---

vector2d.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 AMOD_MATH_LIB_INCVECTOR2d_H
#define AMOD_MATH_LIB_INCVECTOR2d_H

#include <math.h>
#include "global.H"
#include "point3d.H"

template <class V>
class _vec2d
{
protected :
    Greal _x, _y;

public:

    _vec2d()                   : _x(0)   , _y(0)    {} 
    _vec2d(Greal x, Greal y) : _x(x)   , _y(y)    {}

    V       operator + (const V &v)    const { return V(_x+v._x, _y+v._y); }
    V       operator - (const V &v)    const { return V(_x-v._x, _y-v._y); }
    Greal  operator * (const V &v)    const { return _x*v._x+_y*v._y;         }
    V       operator - ()              const { return V(-_x, -_y);         }

    V       operator * (Greal s)      const { return V(_x*s, _y*s); }
    V       operator / (Greal s)      const { return V(_x/s, _y/s); }

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

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

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

    Greal  dist       (const V &v)    const { return (*this-v).length();     }
    Greal  distSqrd   (const V &v)    const { return (*this-v).lengthSqrd(); }

    bool     isEqual   (const V &v, Greal epsSqrd = epsNorSqrdMath()) const
                                             { return distSqrd(v)<=epsSqrd;}
    bool     isExactNull()             const { return _x == 0 && _y == 0; }
    bool     isParallel(const V&)      const;
    
    void     operator +=(const V &v)         { _x += v._x; _y += v._y;       }
    void     operator -=(const V &v)         { _x -= v._x; _y -= v._y;       }
    void     operator *=(Greal s)           { _x *= s; _y *= s; }
    void     operator /=(Greal s)           { _x /= s; _y /= s; }
    bool     operator ==(const V &v)   const { return v._x == _x && v._y == _y;}
    bool     operator !=(const V &v)   const { return v._x != _x || v._y != _y;}

    Greal   angle      (const V&)     const;
    bool     isNull     (Greal epsSqrdMath = epsNorSqrdMath()) const 
                                       { return lengthSqrd() <= epsSqrdMath; }

}; // class _vec2d<V>

template <class V>
inline Greal 
det(const _vec2d<V> &v1, const _vec2d<V> &v2) { return v1[0]*v2[1]-v1[1]*v2[0];}

//************************************************************
//***            Inlines for _vec2d<V>                     *** 
//************************************************************

template <class V>
inline ostream &
operator <<(ostream &os, const _vec2d<V> &v) 
{ 
   return os << "{" << v[0] << " " << v[1] << "}";
}


template <class V>
inline istream &
operator>>(istream &is, _vec2d<V> &v) 
{ 
   char dummy;
   return is >> dummy >> v[0] >> v[1] >> dummy; 
}

template<class V>
inline V 
_vec2d<V>::normalize() const 
{ 
    const Greal l = length(); 
    return (l > gEpsZeroMath ? V(_x/l, _y/l) : V(0,0));
}

template<class V>
inline Greal 
_vec2d<V>::angle(const V& v) const
{
    const V v1 =   normalize();
    const V v2 = v.normalize();

    if (v1.isNull() || v2.isNull()) 
        return 0;

    const Greal cross = det(v1, v2);  // Cross product
    const Greal dot   = v1 * v2;      // Dot   product

    if (fabs(dot) < epsNorMath())
    {
        return cross > 0 ? M_PI_2 : 1.5*M_PI;
    } 
    else 
    {
        Greal angle = atan(cross/dot);
        if (dot < 0)
            angle = angle - M_PI;

        return angle >= 0 ? angle : angle + M_PI * 2;
    }
}


//************************************************************
//***     inlines for class vec2d                          *** 
//************************************************************

template<class V>
inline bool 
_vec2d<V>::isParallel(const V &v) const 
{ 
    const V a =   normalize();
    const V b = v.normalize();

    if (a.isExactNull() || b.isExactNull())
        return false;

    return (a-b).lengthSqrd() <= epsNorSqrdMath() || 
           (a+b).lengthSqrd() <= epsNorSqrdMath();
}
#endif

---