---

point2i.H

Go to the documentation of this file.

/*
 * Copyright 2000, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
#ifndef MATH_LIB_INC_POINT2i_H
#define MATH_LIB_INC_POINT2i_H

#include <math.h>
#include "std/config.H"

/*****************************************************************
 * point2i
 *****************************************************************/
typedef const class vec2i cvec2i;
class vec2i {
protected :
    int _x, _y;

public:

    vec2i()                   : _x(0)   , _y(0)    {} 
    vec2i(int x, int y)       : _x(x)   , _y(y)    {}

    vec2i  operator + (cvec2i &v)    const { return vec2i(_x+v._x, _y+v._y); }
    vec2i  operator - (cvec2i &v)    const { return vec2i(_x-v._x, _y-v._y); }
    int    operator * (cvec2i &v)    const { return _x*v._x+_y*v._y;         }
    vec2i  operator - ()             const { return vec2i(-_x, -_y);         }

    int   operator [](int index)  const { return (&_x)[index];     }
    int&  operator [](int index)        { return (&_x)[index];     }

    double   length     ()           const { return sqrt((double)_x*_x+_y*_y);}
    int      lengthSqrd ()           const { return _x*_x+_y*_y;       }

    vec2i    perpend    ()           const { return vec2i(-_y, _x); }

    double   dist       (cvec2i &v)  const { return (*this-v).length();     }
    int      distSqrd   (cvec2i &v)  const { return (*this-v).lengthSqrd(); }

    int      isNull()                const { return _x == 0 && _y == 0; }
    
    void     operator +=(cvec2i &v)        { _x += v._x; _y += v._y;       }
    void     operator -=(cvec2i &v)        { _x -= v._x; _y -= v._y;       }
    int      operator ==(cvec2i& v) const { return v._x == _x && v._y == _y;}
    int      operator !=(cvec2i& v) const { return v._x != _x || v._y != _y;}
};

inline ostream &
operator<<(ostream &os, cvec2i &v)
{ 
   return os << "{ " << v[0] << " " << v[1] << " } "; 
}

inline istream &
operator>>(istream &is, vec2i &v) 
{ 
   char dummy;
   return is >> dummy >> v[0] >> v[1] >> dummy; 
}

typedef ARRAY<vec2i> vec2i_list;

/*****************************************************************
 * point2i
 *****************************************************************/
typedef const class point2i cpoint2i;
class point2i {
protected:
    int _x, _y;

public:

    point2i()                     : _x(0),    _y(0)    {}
    point2i(int xx, int yy)       : _x(xx),   _y(yy)   {}

    const int *data()                  const { return &_x; }
    point2i  operator  %(cpoint2i &p) const { return point2i(_x+p[0],_y+p[1]);}
    point2i  operator  +(cvec2i   &v) const { return point2i(_x+v[0],_y+v[1]);}
    vec2i    operator  -(cpoint2i &p) const { return vec2i  (_x-p[0],_y-p[1]);}
    point2i  operator  -(cvec2i   &v) const { return point2i(_x-v[0],_y-v[1]);}
    point2i  operator  -()            const { return point2i(-_x,   -_y);     }

    int   operator [](int index)    const { return (&_x)[index];     }
    int&  operator [](int index)          { return (&_x)[index];     }

    double   length     () const { return sqrt((double) (_x*_x+_y*_y)); }
    int      lengthSqrd () const { return _x*_x+_y*_y;       }

    int      distSqrd(cpoint2i &p) const { return (_x-p._x) * (_x-p._x) + 
                                                      (_y-p._y) * (_y-p._y);  }
    double   dist    (cpoint2i &p) const { return sqrt((double) distSqrd(p)); }

    void     operator +=(cpoint2i &p)        { _x += p[0]; _y += p[1];     }
    void     operator +=(cvec2i   &v)        { _x += v[0]; _y += v[1];     }
    void     operator -=(cpoint2i &p)        { _x -= p[0]; _y -= p[1];     }
    void     operator -=(cvec2i   &v)        { _x -= v[0]; _y -= v[1];     }

    int      operator ==(cpoint2i &p) const { return _x == p._x && _y == p._y;}
    int      operator !=(cpoint2i &p) const { return _x != p._x || _y != p._y;}
};

inline ostream &
operator<<(ostream &os, cpoint2i &p)
{ 
   return os << "< " << p[0] << " " << p[1] << " > "; 
}

inline istream &
operator>>(istream &is, point2i &p) 
{ 
   char dummy;
   return is >> dummy >> p[0] >> p[1] >> dummy; 
}

typedef ARRAY<point2i> point2i_list;

#endif // MATH_LIB_INC_Point2i_H

/* end of file point2i.H */

---