vec.h

Go to the documentation of this file.

/*
* $Id: vec.h,v 1.5 2003/09/15 17:15:31 jmk Exp $
*/
///////////////////////////////////////////////////////////////////////////
//              _____________  ______________________    __   __  _____
//             /  ________  |  |   ___   ________   /   |  \ /  \   |
//            |  |       |  |_ |  |_ |  |       /  /    \__  |      |
//            |  |  ___  |  || |  || |  |      /  /        | |      |
//            |  | |   \ |  || |  || |  |     /  /      \__/ \__/ __|__
//            |  | |_@  ||  || |  || |  |    /  /          Institute
//            |  |___/  ||  ||_|  || |  |   /  /_____________________
//             \_______/  \______/ | |__|  /___________________________
//                        |  |__|  |
//                         \______/
//                    University of Utah       
//                           2002
///////////////////////////////////////////////////////////////////////////

// vec.h


#ifndef GUTZ_VEC_BASE_H
#define GUTZ_VEC_BASE_H

// using alloc policies declared in this file...
#include "mathExt.h"
#include <assert.h>

namespace gutz {

/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
/// a vector templated in type and dimension, plus delete policy, but 
///  you can ignore this in 99% of normal use
/// a generic vector, with constructors up to length 10
/// bridges the gap between vectors and arrays, very similar to 
/// an array1 but, supports smaller 1D arrays that are used like
/// N Dimensional vectors.
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

template<class T, int V_DIM>
class vec {
public:

  //typedef typename T Type;
   enum THE_DIM {
      DIM = V_DIM
   };

   vec() : v(new T[V_DIM]) {}
   vec(const vec &vee);
   /// the last value in a constructor gets replicated to the
   /// end of the vec if there are more values in the vector
   /// than specified by the constructor.
   vec(T v1);
   vec(T v1, T v2); 
   vec(T v1, T v2, T v3);
   vec(T v1, T v2, T v3, T v4);
   vec(T v1, T v2, T v3, T v4, T v5);
   vec(T v1, T v2, T v3, T v4, T v5, T v6);
   vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7);
   vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8);
   vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9);
   vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10);
   /// copy data array, will depend on AllocPolicy used...
   /// when numVals == -1 you indicate that the "vee" array
   /// is at least as big as the dimension of this vec
   vec(T *vee, int numVals=-1);

   virtual ~vec() { if(v) delete[] v; }

   ///////////////////////////////////////
   /// Public data Member
   T *v;
   ///////////////////////////////////////

   /// element accessor
   T &operator[](int i)            { return v[i]; }
   const T operator[](int i) const { return v[i]; }

   //// these are all the same, preference/symantics really :)
   int len()  { return DIM; }
   int dim()  { return DIM; }
   int size() { return DIM; }

   /// assignment =
   vec &operator=(const vec &v)
   { for(int i=0; i<DIM; ++i) this->v[i] = v.v[i]; return *this;}
   //vec &operator=(const T& val)
   //{ for(int i=0; i<DIM; ++i) this->v[i] = val; return *this;}
   /// +=
   vec &operator+=(const T& v)
   { for(int i=0; i<DIM; ++i) this->v[i] += v; return *this;}
   vec &operator+=(const vec &v)
   { for(int i=0; i<DIM; ++i) this->v[i] += v.v[i]; return *this;}
   /// -=
   vec &operator-=(const T& v)
   { for(int i=0; i<DIM; ++i) this->v[i] -= v; return *this;}
   vec &operator-=(const vec &v)
   { for(int i=0; i<DIM; ++i) this->v[i] += v.v[i]; return *this;}
   /// *=
   vec &operator*=(const T& v)
   { for(int i=0; i<DIM; ++i) this->v[i] *= v; return *this;}
   vec &operator*=(const vec &v)
   { for(int i=0; i<DIM; ++i) this->v[i] *= v.v[i]; return *this;}
   /// /=
   vec &operator/=(const T& v)
   { for(int i=0; i<DIM; ++i) this->v[i] /= v; return *this;}
   vec &operator/=(const vec &v)
   { for(int i=0; i<DIM; ++i) this->v[i] /= v.v[i]; return *this;}

   /// negate -
   vec operator-() const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = -this->v[i];
      return vec(vee, true);
   }
   /// subtract
   vec operator-(const T& v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] - v;
      return vec(vee, true);
   }
   vec operator-(const vec &v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] - v.v[i];
      return vec(vee, true);
   }
   /// add
   vec operator+(const T& v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] + v;
      return vec(vee, true);
   }
   vec operator+(const vec &v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] + v.v[i];
      return vec(vee, true);
   }
   /// multiply
   vec operator*(const T& v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] * v;
      return vec<T,DIM>(vee, true);
   }
   vec operator*(const vec &v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] * v.v[i];
      return vec(vee, true);
   }
   /// divide
   vec operator/(const T& v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] / v;
      return vec(vee, true);
   }
   vec operator/(const vec &v) const
   {
      T *vee = new T[DIM];
      for(int i=0; i<DIM; ++i) vee[i] = this->v[i] / v.v[i];
      return vec(vee, true);
   }

   /// comparison ops ===================
   /// equal
   bool operator==(const vec &v) const
   {
      for(int i=0; i<DIM; ++i)
         if(this->v[i] != v[i]) return false;
      return true;
   }
   bool operator==(T val) const
   {
      for(int i=0; i<DIM; ++i)
         if(this->v[i] != val) return false;
      return true;
   }
   /// not equal
   bool operator!=(const vec &v) const
   { return !(operator==(v)); }
   /// less
   bool operator< (const vec &v) const
   {    
      for(int i=0; i<DIM; ++i)
         if(this->v[i] >= v.v[i]) return false;
      return true;
   }
   /// less equal
   bool operator<=(const vec &v) const
   {
      for(int i=0; i<DIM; ++i)
         if(this->v[i] > v.v[i]) return false;
      return true;
   }
   /// greater
   bool operator> (const vec &v) const
   { return !(operator<=(v)); }
   /// greater equal
   bool operator>=(const vec &v) const
   { return !(operator<(v)); }

   /// other ops ===========================
   /// L1 norm
   T normL1() const
   {
      T tmp = 0;
      for(int i=0; i<DIM; ++i)
         tmp += this->v[i];
      return tmp;
   }
   /// L2 norm squared
   T norm2() const
   {
      T tmp=0;
      for(int i=0; i<DIM; ++i)
         tmp += this->v[i] * this->v[i];
      return tmp;
   }
   /// L2 norm
   T norm() const 
   {
      return T(sqrt(norm2()));
   }
   /// Normalize, side-effect op, normalizes this vector!
   T normalize()
   {
      T tmp = norm();
      (*this) *= 1.0/tmp;
      return tmp;
   }

   /// dot product
   T dot(const vec &v)
   {
      return ((*this) * v).normL1;
   }
   /// abs of all elements
   vec abs()
   {
      T *tmp = new T[DIM];
      for(int i=0; i<DIM; ++i)
         tmp[i] = g_abs(this->v[i]);
      return vec(tmp,true);
   }

protected:
   /// do not copy data, just pointer (always shallow copy)
   /// the "vee" array MUST be at least as long as this array
   /// and created using NEW.  The array will be deleted with
   /// this class. Not public cuz it's a little confusing.
   vec(T *vee, bool noCpy);
};

/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
/// typedefs
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

/// there are specific classes for vectors 2-4

typedef vec<float, 5>  vec5f;
typedef vec<float, 6>  vec6f;
typedef vec<float, 7>  vec7f;
typedef vec<float, 8>  vec8f;
typedef vec<float, 9>  vec9f;
typedef vec<float, 10> vec10f;

typedef vec<double, 5>  vec5d;
typedef vec<double, 6>  vec6d;
typedef vec<double, 7>  vec7d;
typedef vec<double, 8>  vec8d;
typedef vec<double, 9>  vec9d;
typedef vec<double, 10> vec10d;


/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
/// auxillary ops
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

///////////////////////////////////////
/// side-effect min (no temporary created) alters the first vec
/// in parameter list to be the min (for each element) of the 
/// two vectors
template<class T, int D> inline
vec<T,D> vs_min(vec<T,D> &v1, const vec<T,D> &v2)
{
   for(int i=0; i<D; ++i)
   {
      v1[i] = v1[i] < v2[i] ? v1[i] : v2[i];
   }
   return v1;
}

///////////////////////////////////////
/// side-effect max (no temporary created) alters the first vec
/// in parameter list to be the max (for each element) of the 
/// two vectors
template<class T, int D> inline
vec<T,D> vs_max(vec<T,D> &v1, const vec<T,D> &v2)
{
   for(int i=0; i<D; ++i)
   {
      v1[i] = v1[i] > v2[i] ? v1[i] : v2[i];
   }
   return v1;
}

///////////////////////////////////////
/// <<
template<class T, int D>
std::ostream&
operator<<(std::ostream &os, const vec<T,D> &v)
{
   for(int i=0; i<D; ++i)
      os << v[i] << " ";
   return os;
}

/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
/// implementation of vec_base
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////
/// more operators
template<class T, int D>
vec<T,D> operator+(const T &val, const vec<T,D> &v)
{
   T *vee = new T[D];
   for(int i=0; i<D; ++i) vee[i] = val + v.v[i];
   return vec<T,D>(vee,true);
}

template<class T, int D>
vec<T,D> operator-(const T &val, const vec<T,D> &v)
{
   T *vee = new T[D];
   for(int i=0; i<D; ++i) vee[i] = val - v.v[i];
   return vec<T,D>(vee,true);
}

template<class T, int D>
vec<T,D> operator*(const T &val, const vec<T,D> &v)
{
   T *vee = new T[D];
   for(int i=0; i<D; ++i) vee[i] = val * v.v[i];
   return vec<T,D>(vee,true);
}

template<class T,  int D>
vec<T,D> operator/(const T &val, const vec<T,D> &v)
{
   T *vee = new T[D];
   for(int i=0; i<D; ++i) vee[i] = val / v.v[i];
   return vec<T,D>(vee,true);
}


/////////////////////////////////////////////////////////////////////////
/// constructors 

template<class T, int D>
vec<T,D>::vec(const vec<T,D> &vee)
: v(new T[D])
{
   for(int i=0; i<D; ++i)
   {
      this->v[i] = vee.v[i];
   }
}

template<class T, int D>
vec<T,D>::vec(T *vee, int numVals)
: v(new T[D])
{
   if(numVals == -1)
   {
      for(int i=0; i<D; ++i)
      {
         this->v[i] = vee[i];
      }
   }
   else
   {
      for(int i=0; i<g_min(D,numVals); ++i)
      {
         this->v[i] = vee[i];
      }
   }
}

template<class T, int D>
vec<T,D>::vec(T *vee, bool noCpy)
: v(vee)
{
}


template<class T, int D>
vec<T,D>::vec(T v1)
: v(new T[D])
{
   assert(D >= 1);
   for(int i=0; i<D; ++i)
      v[i] = v1;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2)
: v(new T[D])
{
   assert(D >= 2);
   v[0] = v1; v[1] = v2;
   for(int i=2; i<D; ++i)
      v[i] = v2;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3)
: v(new T[D])
{
   assert(D >= 3);
   v[0] = v1; v[1] = v2; v[2] = v3;
   for(int i=3; i<D; ++i)
      v[i] = v3;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3, T v4)
: v(new T[D])
{
   assert(D >= 4);
   v[0] = v1; v[1] = v2; v[2] = v3; v[3] = v4;
   for(int i=4; i<D; ++i)
      v[i] = v4;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3, T v4, T v5)
: v(new T[D])
{
   assert(D >= 5);
   v[0] = v1; v[1] = v2; v[2] = v3; v[3] = v4; v[4] = v5;
   for(int i=5; i<D; ++i)
      v[i] = v5;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3, T v4, T v5, T v6)
: v(new T[D])
{
   assert(D >= 6);
   v[0] = v1; v[1] = v2; v[2] = v3; v[3] = v4; v[4] = v5; v[5] = v6;
   for(int i=6; i<D; ++i)
      v[i] = v6;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7)
: v(new T[D])
{
   assert(D >= 7);
   v[0] = v1; v[1] = v2; v[2] = v3; v[3] = v4; v[4] = v5; v[5] = v6;
   v[6] = v7;
   for(int i=7; i<D; ++i)
      v[i] = v7;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8)
: v(new T[D])
{
   assert(D >= 8);
   v[0] = v1; v[1] = v2; v[2] = v3; v[3] = v4; v[4] = v5; v[5] = v6;
   v[6] = v7; v[7] = v8;
   for(int i=8; i<D; ++i)
      v[i] = v8;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9)
: v(new T[D])
{
   assert(D >= 9);
   v[0] = v1; v[1] = v2; v[2] = v3; v[3] = v4; v[4] = v5; v[5] = v6;
   v[6] = v7; v[7] = v8; v[8] = v9;
   for(int i=9; i<D; ++i)
      v[i] = v9;
}

template<class T, int D>
vec<T,D>::vec(T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10)
: v(new T[D])
{
   assert(D >= 10);
   v[0] = v1; v[1] = v2; v[2] = v3; v[3] = v4; v[4] = v5; v[5] = v6;
   v[6] = v7; v[7] = v8; v[8] = v9; v[9] = v[10];
   for(int i=10; i<D; ++i)
      v[i] = v10;
}



}//end namespace gutz


#endif

---

Send questions, comments, and bug reports to: