lemon-0.x: comparison lemon/dim2.h

equal deleted inserted replaced

-:434771fe659a
+:53d7cf520ace
 * express or implied, and with no claim as to its suitability for any
 * purpose.
 *
 */
-#ifndef LEMON_XY_H
+#ifndef LEMON_DIM2_H
-#define LEMON_XY_H
+#define LEMON_DIM2_H
 #include <iostream>
 #include <lemon/bits/utility.h>
 ///\ingroup misc
 ///\file
 ///\brief A simple two dimensional vector and a bounding box implementation
 ///
-/// The class \ref lemon::xy "xy" implements
+/// The class \ref lemon::dim2::Point "dim2::Point" implements
 ///a two dimensional vector with the usual
 /// operations.
 ///
-/// The class \ref lemon::BoundingBox "BoundingBox" can be used to determine
+/// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"
-/// the rectangular bounding box of a set of \ref lemon::xy "xy"'s.
+/// can be used to determine
+/// the rectangular bounding box of a set of
+/// \ref lemon::dim2::Point "dim2::Point"'s.
 ///
 ///\author Attila Bernath
 namespace lemon {
+///Tools for handling two dimensional coordinates
+///This namespace is a storage of several
+///tools for handling two dimensional coordinates
+namespace dim2 {
 /// \addtogroup misc
 /// @{
 /// A simple two dimensional vector (plainvector) implementation
 /// A simple two dimensional vector (plainvector) implementation
 ///with the usual vector
 /// operators.
 ///
-///\note As you might have noticed, this class does not follow the
-///\ref naming_conv "LEMON Coding Style" (it should be called \c Xy
-///according to it). There is a stupid Hungarian proverb, "A kiv&eacute;tel
-///er&otilde;s&iacute;ti a szab&aacute;lyt" ("An exception
-///reinforces a rule", which is
-///actually a mistranslation of the Latin proverb "Exceptio probat regulam").
-///This class is an example for that.
-///\author Attila Bernath
 template<typename T>
-class xy {
+class Point {
 public:
 typedef T Value;
 T x;
 ///Second co-ordinate
 T y;
 ///Default constructor
-xy() {}
+Point() {}
 ///Construct an instance from coordinates
-xy(T a, T b) : x(a), y(b) { }
+Point(T a, T b) : x(a), y(b) { }
 ///Conversion constructor
-template<class TT> xy(const xy<TT> &p) : x(p.x), y(p.y) {}
+template<class TT> Point(const Point<TT> &p) : x(p.x), y(p.y) {}
 ///Give back the square of the norm of the vector
 T normSquare() const {
 return x*x+y*y;
 }
 ///Increment the left hand side by u
-xy<T>& operator +=(const xy<T>& u) {
+Point<T>& operator +=(const Point<T>& u) {
 x += u.x;
 y += u.y;
 return *this;
 }
 ///Decrement the left hand side by u
-xy<T>& operator -=(const xy<T>& u) {
+Point<T>& operator -=(const Point<T>& u) {
 x -= u.x;
 y -= u.y;
 return *this;
 }
 ///Multiply the left hand side with a scalar
-xy<T>& operator *=(const T &u) {
+Point<T>& operator *=(const T &u) {
 x *= u;
 y *= u;
 return *this;
 }
 ///Divide the left hand side by a scalar
-xy<T>& operator /=(const T &u) {
+Point<T>& operator /=(const T &u) {
 x /= u;
 y /= u;
 return *this;
 }
 ///Return the scalar product of two vectors
-T operator *(const xy<T>& u) const {
+T operator *(const Point<T>& u) const {
 return x*u.x+y*u.y;
 }
 ///Return the sum of two vectors
-xy<T> operator+(const xy<T> &u) const {
+Point<T> operator+(const Point<T> &u) const {
-xy<T> b=*this;
+Point<T> b=*this;
 return b+=u;
 }
 ///Return the neg of the vectors
-xy<T> operator-() const {
+Point<T> operator-() const {
-xy<T> b=*this;
+Point<T> b=*this;
 b.x=-b.x; b.y=-b.y;
 return b;
 }
 ///Return the difference of two vectors
-xy<T> operator-(const xy<T> &u) const {
+Point<T> operator-(const Point<T> &u) const {
-xy<T> b=*this;
+Point<T> b=*this;
 return b-=u;
 }
 ///Return a vector multiplied by a scalar
-xy<T> operator*(const T &u) const {
+Point<T> operator*(const T &u) const {
-xy<T> b=*this;
+Point<T> b=*this;
 return b*=u;
 }
 ///Return a vector divided by a scalar
-xy<T> operator/(const T &u) const {
+Point<T> operator/(const T &u) const {
-xy<T> b=*this;
+Point<T> b=*this;
 return b/=u;
 }
 ///Test equality
-bool operator==(const xy<T> &u) const {
+bool operator==(const Point<T> &u) const {
 return (x==u.x) && (y==u.y);
 }
 ///Test inequality
-bool operator!=(xy u) const {
+bool operator!=(Point u) const {
 return  (x!=u.x) || (y!=u.y);
 }
 };
-///Return an xy
+///Return an Point
-///Return an xy
+///Return an Point
-///\relates xy
+///\relates Point
 template <typename T>
-inline xy<T> make_xy(const T& x, const T& y) {
+inline Point<T> make_Point(const T& x, const T& y) {
-return xy<T>(x, y);
+return Point<T>(x, y);
 }
 ///Return a vector multiplied by a scalar
 ///Return a vector multiplied by a scalar
-///\relates xy
+///\relates Point
-template<typename T> xy<T> operator*(const T &u,const xy<T> &x) {
+template<typename T> Point<T> operator*(const T &u,const Point<T> &x) {
 return x*u;
 }
 ///Read a plainvector from a stream
 ///Read a plainvector from a stream
-///\relates xy
+///\relates Point
 ///
 template<typename T>
-inline std::istream& operator>>(std::istream &is, xy<T> &z) {
+inline std::istream& operator>>(std::istream &is, Point<T> &z) {
 char c;
 if (is >> c) {
 if (c != '(') is.putback(c);
 } else {
 is.clear();
 }
 ///Write a plainvector to a stream
 ///Write a plainvector to a stream
-///\relates xy
+///\relates Point
 ///
 template<typename T>
-inline std::ostream& operator<<(std::ostream &os, const xy<T>& z)
+inline std::ostream& operator<<(std::ostream &os, const Point<T>& z)
 {
 os << "(" << z.x << ", " << z.y << ")";
 return os;
 }
 ///Rotate by 90 degrees
 ///Returns its parameter rotated by 90 degrees in positive direction.
-///\relates xy
+///\relates Point
 ///
 template<typename T>
-inline xy<T> rot90(const xy<T> &z)
+inline Point<T> rot90(const Point<T> &z)
 {
-return xy<T>(-z.y,z.x);
+return Point<T>(-z.y,z.x);
 }
 ///Rotate by 180 degrees
 ///Returns its parameter rotated by 180 degrees.
-///\relates xy
+///\relates Point
 ///
 template<typename T>
-inline xy<T> rot180(const xy<T> &z)
+inline Point<T> rot180(const Point<T> &z)
 {
-return xy<T>(-z.x,-z.y);
+return Point<T>(-z.x,-z.y);
 }
 ///Rotate by 270 degrees
 ///Returns its parameter rotated by 90 degrees in negative direction.
-///\relates xy
+///\relates Point
 ///
 template<typename T>
-inline xy<T> rot270(const xy<T> &z)
+inline Point<T> rot270(const Point<T> &z)
 {
-return xy<T>(z.y,-z.x);
+return Point<T>(z.y,-z.x);
 }
 /// A class to calculate or store the bounding box of plainvectors.
 /// A class to calculate or store the bounding box of plainvectors.
 ///
 ///\author Attila Bernath
 template<typename T>
 class BoundingBox {
-xy<T> bottom_left, top_right;
+Point<T> bottom_left, top_right;
 bool _empty;
 public:
 ///Default constructor: creates an empty bounding box
 BoundingBox() { _empty = true; }
 ///Construct an instance from one point
-BoundingBox(xy<T> a) { bottom_left=top_right=a; _empty = false; }
+BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; }
 ///Were any points added?
 bool empty() const {
 return _empty;
 }
 ///Give back the bottom left corner
 ///Give back the bottom left corner.
 ///If the bounding box is empty, then the return value is not defined.
-xy<T> bottomLeft() const {
+Point<T> bottomLeft() const {
 return bottom_left;
 }
 ///Set the bottom left corner
 ///Set the bottom left corner.
 ///It should only bee used for non-empty box.
-void bottomLeft(xy<T> p) {
+void bottomLeft(Point<T> p) {
 	bottom_left = p;
 }
 ///Give back the top right corner
 ///Give back the top right corner.
 ///If the bounding box is empty, then the return value is not defined.
-xy<T> topRight() const {
+Point<T> topRight() const {
 return top_right;
 }
 ///Set the top right corner
 ///Set the top right corner.
 ///It should only bee used for non-empty box.
-void topRight(xy<T> p) {
+void topRight(Point<T> p) {
 	top_right = p;
 }
 ///Give back the bottom right corner
 ///Give back the bottom right corner.
 ///If the bounding box is empty, then the return value is not defined.
-xy<T> bottomRight() const {
+Point<T> bottomRight() const {
-return xy<T>(top_right.x,bottom_left.y);
+return Point<T>(top_right.x,bottom_left.y);
 }
 ///Set the bottom right corner
 ///Set the bottom right corner.
 ///It should only bee used for non-empty box.
-void bottomRight(xy<T> p) {
+void bottomRight(Point<T> p) {
 	top_right.x = p.x;
 	bottom_left.y = p.y;
 }
 ///Give back the top left corner
 ///Give back the top left corner.
 ///If the bounding box is empty, then the return value is not defined.
-xy<T> topLeft() const {
+Point<T> topLeft() const {
-return xy<T>(bottom_left.x,top_right.y);
+return Point<T>(bottom_left.x,top_right.y);
 }
 ///Set the top left corner
 ///Set the top left corner.
 ///It should only bee used for non-empty box.
-void topLeft(xy<T> p) {
+void topLeft(Point<T> p) {
 	top_right.y = p.y;
 	bottom_left.x = p.x;
 }
 ///Give back the bottom of the box
 T width() const {
 return top_right.x-bottom_left.x;
 }
 ///Checks whether a point is inside a bounding box
-bool inside(const xy<T>& u){
+bool inside(const Point<T>& u){
 if (_empty)
 return false;
 else{
 return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
 (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
 }
 }
 ///Increments a bounding box with a point
-BoundingBox& add(const xy<T>& u){
+BoundingBox& add(const Point<T>& u){
 if (_empty){
 bottom_left=top_right=u;
 _empty = false;
 }
 else{
 }
 return *this;
 }
 //       ///Sums a bounding box and a point
-//       BoundingBox operator +(const xy<T>& u){
+//       BoundingBox operator +(const Point<T>& u){
 //         BoundingBox b = *this;
 //         return b += u;
 //       }
 ///Increments a bounding box with another bounding box
 }
 };//class Boundingbox
-///Map of x-coordinates of an xy<>-map
+///Map of x-coordinates of a dim2::Point<>-map
 ///\ingroup maps
 ///
 template<class M>
 class XMap
 inline ConstXMap<M> xMap(const M &m)
 {
 return ConstXMap<M>(m);
 }
-///Map of y-coordinates of an xy<>-map
+///Map of y-coordinates of a dim2::Point<>-map
 ///\ingroup maps
 ///
 template<class M>
 class YMap
 {
 return ConstYMap<M>(m);
 }
-///Map of the \ref xy::normSquare() "normSquare()" of an \ref xy "xy"-map
+///Map of the \ref Point::normSquare() "normSquare()" of an \ref Point "Point"-map
-///Map of the \ref xy::normSquare() "normSquare()" of an \ref xy "xy"-map
+///Map of the \ref Point::normSquare() "normSquare()" of an \ref Point "Point"-map
 ///\ingroup maps
 ///
 template<class M>
 class NormSquareMap
 {
 return NormSquareMap<M>(m);
 }
 /// @}
+} //namespce dim2
 } //namespace lemon
-#endif //LEMON_XY_H
+#endif //LEMON_DIM2_H

changeset 2207	75a29ac69c19
parent 2157	f9171bfc7ebb
child 2212	0ad3835449f8