lemon-0.x: comparison src/lemon/xy.h

equal deleted inserted replaced

-:38884f02f37c
+:3bbf6b88ea58
 /// The class \ref lemon::xy "xy" implements
 ///a two dimensional vector with the usual
 /// operations.
 ///
 /// The class \ref lemon::BoundingBox "BoundingBox" can be used to determine
-/// the rectangular bounding box a set of \ref lemon::xy "xy"'s.
+/// the rectangular bounding box of a set of \ref lemon::xy "xy"'s.
 ///
 ///\author Attila Bernath
 namespace lemon {
 ///Conversion constructor
 template<class TT> xy(const xy<TT> &p) : x(p.x), y(p.y) {}
 ///Gives back the square of the norm of the vector
 T normSquare() const {
-	return x*x+y*y;
+return x*x+y*y;
 }
 ///Increments the left hand side by u
 xy<T>& operator +=(const xy<T>& u) {
-	x += u.x;
+x += u.x;
-	y += u.y;
+y += u.y;
-	return *this;
+return *this;
 }
 ///Decrements the left hand side by u
 xy<T>& operator -=(const xy<T>& u) {
-	x -= u.x;
+x -= u.x;
-	y -= u.y;
+y -= u.y;
-	return *this;
+return *this;
 }
 ///Multiplying the left hand side with a scalar
 xy<T>& operator *=(const T &u) {
-	x *= u;
+x *= u;
-	y *= u;
+y *= u;
-	return *this;
+return *this;
 }
 ///Dividing the left hand side by a scalar
 xy<T>& operator /=(const T &u) {
-	x /= u;
+x /= u;
-	y /= u;
+y /= u;
-	return *this;
+return *this;
 }
 ///Returns the scalar product of two vectors
 T operator *(const xy<T>& u) const {
-	return x*u.x+y*u.y;
+return x*u.x+y*u.y;
 }
 ///Returns the sum of two vectors
 xy<T> operator+(const xy<T> &u) const {
-	xy<T> b=*this;
+xy<T> b=*this;
-	return b+=u;
+return b+=u;
 }
 ///Returns the neg of the vectors
 xy<T> operator-() const {
-	xy<T> b=*this;
+xy<T> b=*this;
-	b.x=-b.x; b.y=-b.y;
+b.x=-b.x; b.y=-b.y;
-	return b;
+return b;
 }
 ///Returns the difference of two vectors
 xy<T> operator-(const xy<T> &u) const {
-	xy<T> b=*this;
+xy<T> b=*this;
-	return b-=u;
+return b-=u;
 }
 ///Returns a vector multiplied by a scalar
 xy<T> operator*(const T &u) const {
-	xy<T> b=*this;
+xy<T> b=*this;
-	return b*=u;
+return b*=u;
 }
 ///Returns a vector divided by a scalar
 xy<T> operator/(const T &u) const {
-	xy<T> b=*this;
+xy<T> b=*this;
-	return b/=u;
+return b/=u;
 }
 ///Testing equality
 bool operator==(const xy<T> &u) const {
-	return (x==u.x) && (y==u.y);
+return (x==u.x) && (y==u.y);
 }
 ///Testing inequality
 bool operator!=(xy u) const {
-	return  (x!=u.x) || (y!=u.y);
+return  (x!=u.x) || (y!=u.y);
 }
 };
 ///Returns a vector multiplied by a scalar
 class BoundingBox {
 xy<T> bottom_left, top_right;
 bool _empty;
 public:
-///Default constructor: an empty bounding box
+///Default constructor: creates an empty bounding box
 BoundingBox() { _empty = true; }
 ///Constructing the instance from one point
 BoundingBox(xy<T> a) { bottom_left=top_right=a; _empty = false; }
-///Is there any point added
+///Were any points added?
 bool empty() const {
-	return _empty;
+return _empty;
 }
 ///Makes the BoundingBox empty
 void clear() {
-	_empty=1;
+_empty=1;
 }
 ///Gives back the bottom left corner (if the bounding box is empty, then the return value is not defined)
 xy<T> bottomLeft() const {
-	return bottom_left;
+return bottom_left;
 }
 ///Gives back the top right corner (if the bounding box is empty, then the return value is not defined)
 xy<T> topRight() const {
-	return top_right;
+return top_right;
 }
 ///Gives back the bottom right corner (if the bounding box is empty, then the return value is not defined)
 xy<T> bottomRight() const {
-	return xy<T>(top_right.x,bottom_left.y);
+return xy<T>(top_right.x,bottom_left.y);
 }
 ///Gives back the top left corner (if the bounding box is empty, then the return value is not defined)
 xy<T> topLeft() const {
-	return xy<T>(bottom_left.x,top_right.y);
+return xy<T>(bottom_left.x,top_right.y);
 }
 ///Gives back the bottom of the box (if the bounding box is empty, then the return value is not defined)
 T bottom() const {
-	return bottom_left.y;
+return bottom_left.y;
 }
 ///Gives back the top of the box (if the bounding box is empty, then the return value is not defined)
 T top() const {
-	return top_right.y;
+return top_right.y;
 }
 ///Gives back the left side of the box (if the bounding box is empty, then the return value is not defined)
 T left() const {
-	return bottom_left.x;
+return bottom_left.x;
 }
 ///Gives back the right side of the box (if the bounding box is empty, then the return value is not defined)
 T right() const {
-	return top_right.x;
+return top_right.x;
 }
 ///Gives back the height of the box (if the bounding box is empty, then the return value is not defined)
 T height() const {
-	return top_right.y-bottom_left.y;
+return top_right.y-bottom_left.y;
 }
 ///Gives back the width of the box (if the bounding box is empty, then the return value is not defined)
 T width() const {
-	return top_right.x-bottom_left.x;
+return top_right.x-bottom_left.x;
 }
 ///Checks whether a point is inside a bounding box
 bool inside(const xy<T>& u){
-	if (_empty)
+if (_empty)
-	  return false;
+return false;
-	else{
+else{
-	  return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
+return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
-		  (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
+(u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
-	}
+}
 }
 ///Increments a bounding box with a point
 BoundingBox& operator +=(const xy<T>& u){
-	if (_empty){
+if (_empty){
-	  bottom_left=top_right=u;
+bottom_left=top_right=u;
-	  _empty = false;
+_empty = false;
-	}
+}
-	else{
+else{
-	  if (bottom_left.x > u.x) bottom_left.x = u.x;
+if (bottom_left.x > u.x) bottom_left.x = u.x;
-	  if (bottom_left.y > u.y) bottom_left.y = u.y;
+if (bottom_left.y > u.y) bottom_left.y = u.y;
-	  if (top_right.x < u.x) top_right.x = u.x;
+if (top_right.x < u.x) top_right.x = u.x;
-	  if (top_right.y < u.y) top_right.y = u.y;
+if (top_right.y < u.y) top_right.y = u.y;
-	}
+}
-	return *this;
+return *this;
 }
 ///Sums a bounding box and a point
 BoundingBox operator +(const xy<T>& u){
-	BoundingBox b = *this;
+BoundingBox b = *this;
-	return b += u;
+return b += u;
 }
 ///Increments a bounding box with an other bounding box
 BoundingBox& operator +=(const BoundingBox &u){
-	if ( !u.empty() ){
+if ( !u.empty() ){
-	  *this += u.bottomLeft();
+*this += u.bottomLeft();
-	  *this += u.topRight();
+*this += u.topRight();
-	}
+}
-	return *this;
+return *this;
 }
 ///Sums two bounding boxes
 BoundingBox operator +(const BoundingBox& u){
-	BoundingBox b = *this;
+BoundingBox b = *this;
-	return b += u;
+return b += u;
 }
 };//class Boundingbox

changeset 1429	4283998fb2be
parent 1420	e37cca875667