Changeset 1426:91eb70983697 in lemon-0.x for src/lemon/xy.h

Timestamp:

05/18/05 11:39:06 (19 years ago)

Author:

Akos Ladanyi

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@1897

Message:

• minor corrections in the docs
• fixed indenting

File:

• src/lemon/xy.h (modified) (4 diffs)

src/lemon/xy.h

@@ -30 +30 @@
 ///
 /// 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
@@ -68 +68 @@
       ///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;
-        y += u.y;
-        return *this;
+        x += u.x;
+        y += u.y;
+        return *this;
       }
   
       ///Decrements the left hand side by u
       xy<T>& operator -=(const xy<T>& u) {
-        x -= u.x;
-        y -= u.y;
-        return *this;
+        x -= u.x;
+        y -= u.y;
+        return *this;
       }
 
       ///Multiplying the left hand side with a scalar
       xy<T>& operator *=(const T &u) {
-        x *= u;
-        y *= u;
-        return *this;
+        x *= u;
+        y *= u;
+        return *this;
       }
 
       ///Dividing the left hand side by a scalar
       xy<T>& operator /=(const T &u) {
-        x /= u;
-        y /= u;
-        return *this;
+        x /= u;
+        y /= u;
+        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;
-        return b+=u;
+        xy<T> b=*this;
+        return b+=u;
       }
 
       ///Returns the neg of the vectors
       xy<T> operator-() const {
-        xy<T> b=*this;
-        b.x=-b.x; b.y=-b.y;
-        return b;
+        xy<T> b=*this;
+        b.x=-b.x; b.y=-b.y;
+        return b;
       }
 
       ///Returns the difference of two vectors
       xy<T> operator-(const xy<T> &u) const {
-        xy<T> b=*this;
-        return b-=u;
+        xy<T> b=*this;
+        return b-=u;
       }
 
       ///Returns a vector multiplied by a scalar
       xy<T> operator*(const T &u) const {
-        xy<T> b=*this;
-        return b*=u;
+        xy<T> b=*this;
+        return b*=u;
       }
 
       ///Returns a vector divided by a scalar
       xy<T> operator/(const T &u) const {
-        xy<T> b=*this;
-        return b/=u;
+        xy<T> b=*this;
+        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);
       }
 
@@ -230 +230 @@
     public:
       
-      ///Default constructor: an empty bounding box
+      ///Default constructor: creates an empty bounding box
       BoundingBox() { _empty = true; }
 
@@ -236 +236 @@
       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)
-          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 );
-        }
+        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& operator +=(const xy<T>& u){
-        if (_empty){
-          bottom_left=top_right=u;
-          _empty = false;
-        }
-        else{
-          if (bottom_left.x > u.x) bottom_left.x = u.x;
-          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.y < u.y) top_right.y = u.y;
-        }
-        return *this;
+        if (_empty){
+          bottom_left=top_right=u;
+          _empty = false;
+        }
+        else{
+          if (bottom_left.x > u.x) bottom_left.x = u.x;
+          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.y < u.y) top_right.y = u.y;
+        }
+        return *this;
       }
   
       ///Sums a bounding box and a point
       BoundingBox operator +(const xy<T>& u){
-        BoundingBox b = *this;
-        return b += u;
+        BoundingBox b = *this;
+        return b += u;
       }
 
       ///Increments a bounding box with an other bounding box
       BoundingBox& operator +=(const BoundingBox &u){
-        if ( !u.empty() ){
-          *this += u.bottomLeft();
-          *this += u.topRight();
-        }
-        return *this;
+        if ( !u.empty() ){
+          *this += u.bottomLeft();
+          *this += u.topRight();
+        }
+        return *this;
       }
   
       ///Sums two bounding boxes
       BoundingBox operator +(const BoundingBox& u){
-        BoundingBox b = *this;
-        return b += u;
+        BoundingBox b = *this;
+        return b += u;
       }