COIN-OR::LEMON - Graph Library

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


Ignore:
Timestamp:
05/18/05 11:39:06 (16 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:
1 edited

Legend:

Unmodified
Added
Removed
  • src/lemon/xy.h

    r1420 r1426  
    3030///
    3131/// The class \ref lemon::BoundingBox "BoundingBox" can be used to determine
    32 /// the rectangular bounding box a set of \ref lemon::xy "xy"'s.
     32/// the rectangular bounding box of a set of \ref lemon::xy "xy"'s.
    3333///
    3434///\author Attila Bernath
     
    6868      ///Gives back the square of the norm of the vector
    6969      T normSquare() const {
    70         return x*x+y*y;
     70        return x*x+y*y;
    7171      }
    7272 
    7373      ///Increments the left hand side by u
    7474      xy<T>& operator +=(const xy<T>& u) {
    75         x += u.x;
    76         y += u.y;
    77         return *this;
     75        x += u.x;
     76        y += u.y;
     77        return *this;
    7878      }
    7979 
    8080      ///Decrements the left hand side by u
    8181      xy<T>& operator -=(const xy<T>& u) {
    82         x -= u.x;
    83         y -= u.y;
    84         return *this;
     82        x -= u.x;
     83        y -= u.y;
     84        return *this;
    8585      }
    8686
    8787      ///Multiplying the left hand side with a scalar
    8888      xy<T>& operator *=(const T &u) {
    89         x *= u;
    90         y *= u;
    91         return *this;
     89        x *= u;
     90        y *= u;
     91        return *this;
    9292      }
    9393
    9494      ///Dividing the left hand side by a scalar
    9595      xy<T>& operator /=(const T &u) {
    96         x /= u;
    97         y /= u;
    98         return *this;
     96        x /= u;
     97        y /= u;
     98        return *this;
    9999      }
    100100 
    101101      ///Returns the scalar product of two vectors
    102102      T operator *(const xy<T>& u) const {
    103         return x*u.x+y*u.y;
     103        return x*u.x+y*u.y;
    104104      }
    105105 
    106106      ///Returns the sum of two vectors
    107107      xy<T> operator+(const xy<T> &u) const {
    108         xy<T> b=*this;
    109         return b+=u;
     108        xy<T> b=*this;
     109        return b+=u;
    110110      }
    111111
    112112      ///Returns the neg of the vectors
    113113      xy<T> operator-() const {
    114         xy<T> b=*this;
    115         b.x=-b.x; b.y=-b.y;
    116         return b;
     114        xy<T> b=*this;
     115        b.x=-b.x; b.y=-b.y;
     116        return b;
    117117      }
    118118
    119119      ///Returns the difference of two vectors
    120120      xy<T> operator-(const xy<T> &u) const {
    121         xy<T> b=*this;
    122         return b-=u;
     121        xy<T> b=*this;
     122        return b-=u;
    123123      }
    124124
    125125      ///Returns a vector multiplied by a scalar
    126126      xy<T> operator*(const T &u) const {
    127         xy<T> b=*this;
    128         return b*=u;
     127        xy<T> b=*this;
     128        return b*=u;
    129129      }
    130130
    131131      ///Returns a vector divided by a scalar
    132132      xy<T> operator/(const T &u) const {
    133         xy<T> b=*this;
    134         return b/=u;
     133        xy<T> b=*this;
     134        return b/=u;
    135135      }
    136136
    137137      ///Testing equality
    138138      bool operator==(const xy<T> &u) const {
    139         return (x==u.x) && (y==u.y);
     139        return (x==u.x) && (y==u.y);
    140140      }
    141141
    142142      ///Testing inequality
    143143      bool operator!=(xy u) const {
    144         return  (x!=u.x) || (y!=u.y);
     144        return  (x!=u.x) || (y!=u.y);
    145145      }
    146146
     
    230230    public:
    231231     
    232       ///Default constructor: an empty bounding box
     232      ///Default constructor: creates an empty bounding box
    233233      BoundingBox() { _empty = true; }
    234234
     
    236236      BoundingBox(xy<T> a) { bottom_left=top_right=a; _empty = false; }
    237237
    238       ///Is there any point added
     238      ///Were any points added?
    239239      bool empty() const {
    240         return _empty;
     240        return _empty;
    241241      }
    242242
    243243      ///Makes the BoundingBox empty
    244244      void clear() {
    245         _empty=1;
     245        _empty=1;
    246246      }
    247247
    248248      ///Gives back the bottom left corner (if the bounding box is empty, then the return value is not defined)
    249249      xy<T> bottomLeft() const {
    250         return bottom_left;
     250        return bottom_left;
    251251      }
    252252
    253253      ///Gives back the top right corner (if the bounding box is empty, then the return value is not defined)
    254254      xy<T> topRight() const {
    255         return top_right;
     255        return top_right;
    256256      }
    257257
    258258      ///Gives back the bottom right corner (if the bounding box is empty, then the return value is not defined)
    259259      xy<T> bottomRight() const {
    260         return xy<T>(top_right.x,bottom_left.y);
     260        return xy<T>(top_right.x,bottom_left.y);
    261261      }
    262262
    263263      ///Gives back the top left corner (if the bounding box is empty, then the return value is not defined)
    264264      xy<T> topLeft() const {
    265         return xy<T>(bottom_left.x,top_right.y);
     265        return xy<T>(bottom_left.x,top_right.y);
    266266      }
    267267
    268268      ///Gives back the bottom of the box (if the bounding box is empty, then the return value is not defined)
    269269      T bottom() const {
    270         return bottom_left.y;
     270        return bottom_left.y;
    271271      }
    272272
    273273      ///Gives back the top of the box (if the bounding box is empty, then the return value is not defined)
    274274      T top() const {
    275         return top_right.y;
     275        return top_right.y;
    276276      }
    277277
    278278      ///Gives back the left side of the box (if the bounding box is empty, then the return value is not defined)
    279279      T left() const {
    280         return bottom_left.x;
     280        return bottom_left.x;
    281281      }
    282282
    283283      ///Gives back the right side of the box (if the bounding box is empty, then the return value is not defined)
    284284      T right() const {
    285         return top_right.x;
     285        return top_right.x;
    286286      }
    287287
    288288      ///Gives back the height of the box (if the bounding box is empty, then the return value is not defined)
    289289      T height() const {
    290         return top_right.y-bottom_left.y;
     290        return top_right.y-bottom_left.y;
    291291      }
    292292
    293293      ///Gives back the width of the box (if the bounding box is empty, then the return value is not defined)
    294294      T width() const {
    295         return top_right.x-bottom_left.x;
     295        return top_right.x-bottom_left.x;
    296296      }
    297297
    298298      ///Checks whether a point is inside a bounding box
    299299      bool inside(const xy<T>& u){
    300         if (_empty)
    301           return false;
    302         else{
    303           return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
    304                   (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
    305         }
     300        if (_empty)
     301          return false;
     302        else{
     303          return ((u.x-bottom_left.x)*(top_right.x-u.x) >= 0 &&
     304              (u.y-bottom_left.y)*(top_right.y-u.y) >= 0 );
     305        }
    306306      }
    307307 
    308308      ///Increments a bounding box with a point
    309309      BoundingBox& operator +=(const xy<T>& u){
    310         if (_empty){
    311           bottom_left=top_right=u;
    312           _empty = false;
    313         }
    314         else{
    315           if (bottom_left.x > u.x) bottom_left.x = u.x;
    316           if (bottom_left.y > u.y) bottom_left.y = u.y;
    317           if (top_right.x < u.x) top_right.x = u.x;
    318           if (top_right.y < u.y) top_right.y = u.y;
    319         }
    320         return *this;
     310        if (_empty){
     311          bottom_left=top_right=u;
     312          _empty = false;
     313        }
     314        else{
     315          if (bottom_left.x > u.x) bottom_left.x = u.x;
     316          if (bottom_left.y > u.y) bottom_left.y = u.y;
     317          if (top_right.x < u.x) top_right.x = u.x;
     318          if (top_right.y < u.y) top_right.y = u.y;
     319        }
     320        return *this;
    321321      }
    322322 
    323323      ///Sums a bounding box and a point
    324324      BoundingBox operator +(const xy<T>& u){
    325         BoundingBox b = *this;
    326         return b += u;
     325        BoundingBox b = *this;
     326        return b += u;
    327327      }
    328328
    329329      ///Increments a bounding box with an other bounding box
    330330      BoundingBox& operator +=(const BoundingBox &u){
    331         if ( !u.empty() ){
    332           *this += u.bottomLeft();
    333           *this += u.topRight();
    334         }
    335         return *this;
     331        if ( !u.empty() ){
     332          *this += u.bottomLeft();
     333          *this += u.topRight();
     334        }
     335        return *this;
    336336      }
    337337 
    338338      ///Sums two bounding boxes
    339339      BoundingBox operator +(const BoundingBox& u){
    340         BoundingBox b = *this;
    341         return b += u;
     340        BoundingBox b = *this;
     341        return b += u;
    342342      }
    343343
Note: See TracChangeset for help on using the changeset viewer.