/ray/src/lib/numerics/2d/vector2.h

Go to the documentation of this file.

/*
 * lib/numerics/2d/vector2.h
 * 
 * 2d vector template. 
 * 
 * Copyright (c) 2004 by Wolfgang Wieser ] wwieser (a) gmx <*> de [ 
 * 
 * This file may be distributed and/or modified under the terms of the 
 * GNU General Public License version 2 as published by the Free Software 
 * Foundation. (See COPYING.GPL for details.)
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * 
 */

#ifndef _LIB_NUMERICS_2D_VECTOR2_H_
#define _LIB_NUMERICS_2D_VECTOR2_H_ 1

#include <lib/numerics/num_math.h>

namespace NUM  // numerics
{

// As defined in omatrix.h which we may NOT include. 
template<typename T>class OMatrix;


template<typename T=dbl>class Vector2
{
    public:
        enum { X=0, Y=1 };
        
        static const Vector2<T> UX,UY,Null;
        
    private:
        T v[2];
        
    public:
        inline Vector2() {}
        inline Vector2(T x,T y)
            {  v[0]=x;  v[1]=y;  }
        inline Vector2(const Vector2 &a)
            {  v[0]=a.v[0];  v[1]=a.v[1];  }
        inline Vector2(const T *a)
            {  v[0]=a[0];  v[1]=a[1];  }
        inline ~Vector2() {}
        
        inline T &operator[](int i)  {  return(v[i]);  }
        inline const T &operator[](int i) const  {  return(v[i]);  }
        
        inline operator T *()  {  return(v);  }
        inline operator const T *() const  {  return(v);  }
        
        inline int dim() const
            {  return(2);  }
        
        inline Vector2 &operator=(const Vector2 &a)
            {  v[0]=a.v[0];  v[1]=a.v[1];  return(*this);  }
        
        inline Vector2 &promote(T a)
            {  v[0]=a;  v[1]=a;  return(*this);  }
        
        inline T len2() const
            {  return(v[0]*v[0] + v[1]*v[1]);  }
        inline T len() const
            {  return(hypot(v[0],v[1]));  }
        
        inline T norm1() const
            {  return(fabs(v[0])+fabs(v[1]));  }
        
        inline T max() const
            {  return(v[0]>v[1] ? v[0] : v[1]);  }
        inline T min() const
            {  return(v[0]<v[1] ? v[0] : v[1]);  }
        
        inline Vector2 &operator+=(const Vector2 &a)
            {  v[0]+=a.v[0];  v[1]+=a.v[1];  return(*this);  }
        inline Vector2 &operator-=(const Vector2 &a)
            {  v[0]-=a.v[0];  v[1]-=a.v[1];  return(*this);  }
        
        inline Vector2 &AddScaled(const Vector2 &a,T f)
            {  v[0]+=a.v[0]*f;  v[1]+=a.v[1]*f;  return(*this);  }
        
        inline Vector2 &operator*=(T a)
            {  v[0]*=a;  v[1]*=a;  return(*this);  }
        inline Vector2 &operator/=(T a)
            {  v[0]/=a;  v[1]/=a;  return(*this);  }
        
        inline T normalize()
            {  T l=len(),f=1.0/l;  v[0]*=f; v[1]*=f; return(l);  }
        inline T normalize(T wl)
            {  T l=len(),f=wl/l;  v[0]*=f; v[1]*=f; return(l);  }
        
        inline Vector2 &neg()
            {  v[0]=-v[0];  v[1]=-v[1];  return(*this);  }
        
        inline bool IsNull(T epsilon) const
            {  return(fabs(v[0])<epsilon && fabs(v[1])<epsilon);  }
};

template<typename T>inline Vector2<T> operator+(
    const Vector2<T> &a,const Vector2<T> &b)
    {  return(Vector2<T>(a[0]+b[0],a[1]+b[1]));  }
template<typename T>inline Vector2<T> operator-(
    const Vector2<T> &a,const Vector2<T> &b)
    {  return(Vector2<T>(a[0]-b[0],a[1]-b[1]));  }

template<typename T>inline Vector2<T> operator*(const Vector2<T> &a,T b)
    {  return(Vector2<T>(a[0]*b,a[1]*b));  }
template<typename T>inline Vector2<T> operator*(T b,const Vector2<T> &a)
    {  return(Vector2<T>(b*a[0],b*a[1]));  }

template<typename T>inline Vector2<T> operator/(const Vector2<T> &a,T b)
    {  return(Vector2<T>(a[0]/b,a[1]/b));  }

template<typename T>inline T len2(const Vector2<T> &v)
    {  return(v[0]*v[0] + v[1]*v[1]);  }
template<typename T>inline T len(const Vector2<T> &v)
    {  return(hypot(v[0],v[1]));  }

template<typename T>inline T dist2(const Vector2<T> &a,const Vector2<T> &b)
    {  return(sqr(a[0]-b[0])+sqr(a[1]-b[1]));  }
template<typename T>inline T dist(const Vector2<T> &a,const Vector2<T> &b)
    {  return(hypot(a[0]-b[0],a[1]-b[1]));  }

template<typename T>inline Vector2<T> normalize(const Vector2<T> &v)
    {  T f=1.0/v.len();  return(Vector2<T>(v[0]*f,v[1]*f));  }
template<typename T>inline Vector2<T> normalize(const Vector2<T> &v,T l)
    {  T f=l/v.len();  return(Vector2<T>(v[0]*f,v[1]*f));  }

template<typename T>inline T dot(const Vector2<T> &a,const Vector2<T> &b)
    {  return(a[0]*b[0] + a[1]*b[1]);  }

template<typename T>inline T angle(const Vector2<T> &a,const Vector2<T> &b)
    {  return(acos(dot(a,b)/sqrt(a.len2()*b.len2())));  }

template<typename T>inline bool equal(const Vector2<T> &a,const Vector2<T> &b,
    T epsilon)
    {  return(fabs(a[0]-b[0])<epsilon && fabs(a[1]-b[1])<epsilon);  }

template<typename T>inline Vector2<T> LinComb(
    const Vector2<T> &va,T ca,const Vector2<T> &vb)
    {  return(Vector2<T>( ca*va[0] + vb[0], ca*va[1] + vb[1] ));  }

template<typename T>inline Vector2<T> LinComb(
    const Vector2<T> &va,T ca,const Vector2<T> &vb,T cb)
    {  return(Vector2<T>( ca*va[0] + cb*vb[0], ca*va[1] + cb*vb[1] ));  }

template<typename T>inline Vector2<T> LinComb(
    const Vector2<T> &va,T ca,const Vector2<T> &vb,T cb,const Vector2<T> &vc)
    {  return(Vector2<T>(
        ca*va[0] + cb*vb[0] + vc[0],
        ca*va[1] + cb*vb[1] + vc[1] ));  }

template<typename T>inline Vector2<T> LinComb(
    const Vector2<T> &va,T ca,const Vector2<T> &vb,T cb,
    const Vector2<T> &vc,T cc)
    {  return(Vector2<T>(
        ca*va[0] + cb*vb[0] + cc*vc[0],
        ca*va[1] + cb*vb[1] + cc*vc[1] ));  }

template<typename T>inline Vector2<T> average(
    const Vector2<T> &a,const Vector2<T> &b)
    {  return(Vector2<T>(0.5*(a[0]+b[0]),0.5*(a[1]+b[1])));  }

}  // end of namespace NUM

#endif  /* _LIB_NUMERICS_2D_VECTOR2_H_ */

---