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

equal deleted inserted replaced

-:aca570b2a406
+:1e12486dfca4
 /// @{
 /// A simple two dimensional vector (plainvector) implementation
 /// A simple two dimensional vector (plainvector) implementation
-///with the usual vector
+/// with the usual vector operations.
-/// operators.
-///
 template<typename T>
 class Point {
 public:
 typedef T Value;
-///First co-ordinate
+///First coordinate
 T x;
-///Second co-ordinate
+///Second coordinate
 T y;
 ///Default constructor
 Point() {}
 ///Construct an instance from coordinates
 Point(T a, T b) : x(a), y(b) { }
 ///The dimension of the vector.
-///This class give back always 2.
+///This function always returns 2.
 ///
 int size() const { return 2; }
 ///Subscripting operator
 ///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
+///Increment the left hand side by \c u
 Point<T>& operator +=(const Point<T>& u) {
 x += u.x;
 y += u.y;
 return *this;
 }
-///Decrement the left hand side by u
+///Decrement the left hand side by \c u
 Point<T>& operator -=(const Point<T>& u) {
 x -= u.x;
 y -= u.y;
 return *this;
 }
 Point<T> operator+(const Point<T> &u) const {
 Point<T> b=*this;
 return b+=u;
 }
-///Return the neg of the vectors
+///Return the negative of the vector
 Point<T> operator-() const {
 Point<T> b=*this;
 b.x=-b.x; b.y=-b.y;
 return b;
 }
 return  (x!=u.x) || (y!=u.y);
 }
 };
-///Return an Point
+///Return a Point
-///Return an Point
+///Return a Point.
 ///\relates Point
 template <typename T>
 inline Point<T> makePoint(const T& x, const T& y) {
 return Point<T>(x, y);
 }
 ///Construct an instance from one point
 BoundingBox(Point<T> a) { bottom_left=top_right=a; _empty = false; }
 ///Construct an instance from two points
-///Construct an instance from two points
+///Construct an instance from two points.
-///\warning The coordinates of the bottom-left corner must be no more
+///\param a The bottom left corner.
-///than those of the top-right one
+///\param b The top right corner.
+///\warning The coordinates of the bottom left corner must be no more
+///than those of the top right one.
 BoundingBox(Point<T> a,Point<T> b)
 {
 	bottom_left=a;
 	top_right=b;
 	_empty = false;
 }
 ///Construct an instance from four numbers
-///Construct an instance from four numbers
+///Construct an instance from four numbers.
-///\warning The coordinates of the bottom-left corner must be no more
+///\param l The left side of the box.
-///than those of the top-right one
+///\param b The bottom of the box.
+///\param r The right side of the box.
+///\param t The top of the box.
+///\warning The left side must be no more than the right side and
+///bottom must be no more than the top.
 BoundingBox(T l,T b,T r,T t)
 {
 	bottom_left=Point<T>(l,b);
 	top_right=Point<T>(r,t);
 	_empty = false;
 }
-///Were any points added?
+///Return \c true if the bounding box is empty.
+///Return \c true if the bounding box is empty (i.e. return \c false
+///if at least one point was added to the box or the coordinates of
+///the box were set).
+///
+///The coordinates of an empty bounding box are not defined.
 bool empty() const {
 return _empty;
 }
 ///Make the BoundingBox empty
 void clear() {
 _empty=1;
 }
-///Give back the bottom left corner
+///Give back the bottom left corner of the box
-///Give back the bottom left corner.
+///Give back the bottom left corner of the box.
 ///If the bounding box is empty, then the return value is not defined.
 Point<T> bottomLeft() const {
 return bottom_left;
 }
-///Set the bottom left corner
+///Set the bottom left corner of the box
-///Set the bottom left corner.
+///Set the bottom left corner of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void bottomLeft(Point<T> p) {
 	bottom_left = p;
 }
-///Give back the top right corner
+///Give back the top right corner of the box
-///Give back the top right corner.
+///Give back the top right corner of the box.
 ///If the bounding box is empty, then the return value is not defined.
 Point<T> topRight() const {
 return top_right;
 }
-///Set the top right corner
+///Set the top right corner of the box
-///Set the top right corner.
+///Set the top right corner of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void topRight(Point<T> p) {
 	top_right = p;
 }
-///Give back the bottom right corner
+///Give back the bottom right corner of the box
-///Give back the bottom right corner.
+///Give back the bottom right corner of the box.
 ///If the bounding box is empty, then the return value is not defined.
 Point<T> bottomRight() const {
 return Point<T>(top_right.x,bottom_left.y);
 }
-///Set the bottom right corner
+///Set the bottom right corner of the box
-///Set the bottom right corner.
+///Set the bottom right corner of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 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 of the box
-///Give back the top left corner.
+///Give back the top left corner of the box.
 ///If the bounding box is empty, then the return value is not defined.
 Point<T> topLeft() const {
 return Point<T>(bottom_left.x,top_right.y);
 }
-///Set the top left corner
+///Set the top left corner of the box
-///Set the top left corner.
+///Set the top left corner of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void topLeft(Point<T> p) {
 	top_right.y = p.y;
 	bottom_left.x = p.x;
 }
 }
 ///Set the bottom of the box
 ///Set the bottom of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void bottom(T t) {
 	bottom_left.y = t;
 }
 ///Give back the top of the box
 }
 ///Set the top of the box
 ///Set the top of the box.
-///It should only bee used for non-empty box.
+///It should only be used for non-empty box.
 void top(T t) {
 	top_right.y = t;
 }
 ///Give back the left side of the box
 }
 ///Set the left side of the box
 ///Set the left side of the box.
-///It should only bee used for non-empty box
+///It should only be used for non-empty box.
 void left(T t) {
 	bottom_left.x = t;
 }
 /// Give back the right side of the box
 }
 ///Set the right side of the box
 ///Set the right side of the box.
-///It should only bee used for non-empty box
+///It should only be used for non-empty box.
 void right(T t) {
 	top_right.x = t;
 }
 ///Give back the height 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 Point<T>& u){
+bool inside(const Point<T>& u) const {
 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
+///Increments a bounding box with a point.
+///
 BoundingBox& add(const Point<T>& u){
 if (_empty){
 bottom_left=top_right=u;
 _empty = false;
 }
 if (top_right.y < u.y) top_right.y = u.y;
 }
 return *this;
 }
-///Increments a bounding to contain another bounding box
+///Increments a bounding box to contain another bounding box
+///Increments a bounding box to contain another bounding box.
+///
 BoundingBox& add(const BoundingBox &u){
 if ( !u.empty() ){
 this->add(u.bottomLeft());
 	  this->add(u.topRight());
 }
 return *this;
 }
 ///Intersection of two bounding boxes
-BoundingBox operator &(const BoundingBox& u){
+///Intersection of two bounding boxes.
+///
+BoundingBox operator&(const BoundingBox& u) const {
 BoundingBox b;
-	b.bottom_left.x=std::max(this->bottom_left.x,u.bottom_left.x);
+if (this->_empty || u._empty) {
-	b.bottom_left.y=std::max(this->bottom_left.y,u.bottom_left.y);
+	  b._empty = true;
-	b.top_right.x=std::min(this->top_right.x,u.top_right.x);
+	} else {
-	b.top_right.y=std::min(this->top_right.y,u.top_right.y);
+	  b.bottom_left.x=std::max(this->bottom_left.x,u.bottom_left.x);
-	b._empty = this->_empty || u._empty ||
+	  b.bottom_left.y=std::max(this->bottom_left.y,u.bottom_left.y);
-	  b.bottom_left.x>top_right.x && b.bottom_left.y>top_right.y;
+	  b.top_right.x=std::min(this->top_right.x,u.top_right.x);
+	  b.top_right.y=std::min(this->top_right.y,u.top_right.y);
+	  b._empty = b.bottom_left.x > b.top_right.x ||
+	             b.bottom_left.y > b.top_right.y;
+	}
 return b;
 }
 };//class Boundingbox
-///Map of x-coordinates of a dim2::Point<>-map
+///Map of x-coordinates of a \ref Point "Point"-map
 ///\ingroup maps
-///Map of x-coordinates of a dim2::Point<>-map
+///Map of x-coordinates of a \ref Point "Point"-map.
 ///
 template<class M>
 class XMap
 {
 M& _map;
 Value operator[](Key k) const {return _map[k].x;}
 };
 ///Returns a \ref ConstXMap class
-///This function just returns an \ref ConstXMap class.
+///This function just returns a \ref ConstXMap class.
 ///
 ///\ingroup maps
 ///\relates ConstXMap
 template<class M>
 inline ConstXMap<M> xMap(const M &m)
 {
 return ConstXMap<M>(m);
 }
-///Map of y-coordinates of a dim2::Point<>-map
+///Map of y-coordinates of a \ref Point "Point"-map
 ///\ingroup maps
-///Map of y-coordinates of a dim2::Point<>-map
+///Map of y-coordinates of a \ref Point "Point"-map.
 ///
 template<class M>
 class YMap
 {
 M& _map;
 YMap(M& map) : _map(map) {}
 Value operator[](Key k) const {return _map[k].y;}
 void set(Key k,Value v) {_map.set(k,typename M::Value(_map[k].x,v));}
 };
-///Returns an \ref YMap class
+///Returns a \ref YMap class
-///This function just returns an \ref YMap class.
+///This function just returns a \ref YMap class.
 ///
 ///\ingroup maps
 ///\relates YMap
 template<class M>
 inline YMap<M> yMap(M &m)
 Value operator[](Key k) const {return _map[k].y;}
 };
 ///Returns a \ref ConstYMap class
-///This function just returns an \ref ConstYMap class.
+///This function just returns a \ref ConstYMap class.
 ///
 ///\ingroup maps
 ///\relates ConstYMap
 template<class M>
 inline ConstYMap<M> yMap(const M &m)
 {
 return ConstYMap<M>(m);
 }
 ///\brief Map of the \ref Point::normSquare() "normSquare()"
-///of an \ref Point "Point"-map
+///of a \ref Point "Point"-map
 ///
 ///Map of the \ref Point::normSquare() "normSquare()"
-///of an \ref Point "Point"-map
+///of a \ref Point "Point"-map.
 ///\ingroup maps
 ///
 template<class M>
 class NormSquareMap
 {
 const M& _map;
 Value operator[](Key k) const {return _map[k].normSquare();}
 };
 ///Returns a \ref NormSquareMap class
-///This function just returns an \ref NormSquareMap class.
+///This function just returns a \ref NormSquareMap class.
 ///
 ///\ingroup maps
 ///\relates NormSquareMap
 template<class M>
 inline NormSquareMap<M> normSquareMap(const M &m)

changeset 2605	852361980706
parent 2553	bfced05fa852