WebSVN – gelsvn – Diff – /trunk/src/CGLA/ArithVec.h


#ifndef __CGLA_ARITHVEC_H__
#define __CGLA_ARITHVEC_H__
 
#include <iostream>
#include "CGLA.h"
 
#include <numeric>
 
namespace CGLA 
{
 
  /** \brief Template representing generic arithmetic vectors.  
 
			The three parameters to the template are
 
      T - the scalar type (i.e. float, int, double etc.)
 
      V - the name of the vector type. This template is always (and
      only) used as ancestor of concrete types, and the name of the
      class _inheriting_ _from_ this class is used as the V argument.
 
      N - The final argument is the dimension N. For instance, N=3 for a
      3D vector.
 
      This class template contains all functions that are assumed to be
      the same for any arithmetic vector - regardless of dimension or
      the type of scalars used for coordinates.
 
      The template contains no virtual functions which is important
      since they add overhead.
  */
 
  template <class T, class V, unsigned int N> 
    class ArithVec
    {
 
    protected:
 
      /// The actual contents of the vector.
      T data[N];
 
    protected:
 
      //----------------------------------------------------------------------
      // Constructors
      //----------------------------------------------------------------------
 
      /// Construct uninitialized vector
      ArithVec() 
	{
	}
 
      /// Construct a vector where all coordinates are identical
      explicit ArithVec(T _a)
	{
	  std::fill_n(data, N, _a);
	}
 
      /// Construct a 2D vector 
      ArithVec(T _a, T _b)
	{
	  assert(N==2);
	  data[0] = _a;
	  data[1] = _b;
	}
 
      /// Construct a 3D vector
      ArithVec(T _a, T _b, T _c)
	{
	  assert(N==3);
	  data[0] = _a;
	  data[1] = _b;
	  data[2] = _c;
	}
 
      /// Construct a 4D vector
      ArithVec(T _a, T _b, T _c, T _d)
	{
	  assert(N==4);
	  data[0] = _a;
	  data[1] = _b;
	  data[2] = _c;
	  data[3] = _d;
	}
 
 
    public:
 
      /// For convenience we define a more meaningful name for the scalar type
      typedef T ScalarType;
	
      /// A more meaningful name for vector type
      typedef V VectorType;
 
      /// Return dimension of vector
      static unsigned int get_dim() {return N;}
	
      /// Set all coordinates of a 2D vector.
      void set(T _a, T _b)
	{
	  assert(N==2);
	  data[0] = _a;
	  data[1] = _b;
	}
 
      /// Set all coordinates of a 3D vector.
      void set(T _a, T _b, T _c)
	{
	  assert(N==3);
	  data[0] = _a;
	  data[1] = _b;
	  data[2] = _c;
	}
 
      /// Set all coordinates of a 4D vector.
      void set(T _a, T _b, T _c, T _d)
	{
	  assert(N==4);
	  data[0] = _a;
	  data[1] = _b;
	  data[2] = _c;
	  data[3] = _d;
	}
 
      /// Const index operator
      const T& operator [] ( unsigned int i ) const
	{
	  assert(i<N);
	  return data[i];
	}
 
      /// Non-const index operator
      T& operator [] ( unsigned int i ) 
	{
	  assert(i<N);
	  return data[i];
	}
 
      /** Get a pointer to first element in data array.
	  This function may be useful when interfacing with some other API 
	  such as OpenGL (TM) */
      T* get() {return &data[0];}
 
      /** Get a const pointer to first element in data array.
	  This function may be useful when interfacing with some other API 
	  such as OpenGL (TM). */
      const T* get() const {return &data[0];}
 
      //----------------------------------------------------------------------
      // Comparison operators
      //----------------------------------------------------------------------
 
      /// Equality operator
      bool operator==(const V& v) const 
	{
	  return std::inner_product(data, &data[N], v.get(), true,
				    std::logical_and<bool>(), std::equal_to<T>());
	}
 
#define for_all_i(expr) for(unsigned int i=0;i<N;i++) {expr;}
      /// Equality wrt scalar. True if all coords are equal to scalar
      bool operator==(T k) const 
	{ 
	  for_all_i(if (data[i] != k) return false)
	    return true;
	}
#undef for_all_i  
 
      /// Inequality operator
      bool operator!=(const V& v) const 
	{
	  return std::inner_product(data, &data[N], v.get(), false,
				    std::logical_or<bool>(), std::not_equal_to<T>());
	}
 
      /// Inequality wrt scalar. True if any coord not equal to scalar
      bool operator!=(T k) const 
	{ 
	  return !(*this==k);
	}
 
 
      //----------------------------------------------------------------------
      // Comparison functions ... of geometric significance 
      //----------------------------------------------------------------------
 
      /** Compare all coordinates against other vector. ( < )
	  Similar to testing whether we are on one side of three planes. */
      bool  all_l  (const V& v) const
	{
	  return std::inner_product(data, &data[N], v.get(), true, 
				    std::logical_and<bool>(), std::less<T>());
	}
 
      /** Compare all coordinates against other vector. ( <= )
	  Similar to testing whether we are on one side of three planes. */
      bool  all_le (const V& v) const
	{
	  return std::inner_product(data, &data[N], v.get(), true, 
				    std::logical_and<bool>(), std::less_equal<T>());
	}
 
      /** Compare all coordinates against other vector. ( > )
	  Similar to testing whether we are on one side of three planes. */
      bool  all_g  (const V& v) const
	{
	  return std::inner_product(data, &data[N], v.get(), true, 
				    std::logical_and<bool>(), std::greater<T>());
	}
 
      /** Compare all coordinates against other vector. ( >= )
	  Similar to testing whether we are on one side of three planes. */
      bool  all_ge (const V& v) const
	{
	  return std::inner_product(data, &data[N], v.get(), true, 
				    std::logical_and<bool>(), std::greater_equal<T>());
	}
 
 
      //----------------------------------------------------------------------
      // Assignment operators
      //----------------------------------------------------------------------
 
      /// Assignment multiplication with scalar.
      const V& operator *=(T k) 
	{ 
	  std::transform(data, &data[N], data, std::bind2nd(std::multiplies<T>(), k));
	  return static_cast<const V&>(*this);
	}
 
      /// Assignment division with scalar.
      const V& operator /=(T k)
	{ 
	  std::transform(data, &data[N], data, std::bind2nd(std::divides<T>(), k));
	  return static_cast<const V&>(*this);
	}
 
      /// Assignment addition with scalar. Adds scalar to each coordinate.
      const V& operator +=(T k) 
	{
	  std::transform(data, &data[N], data, std::bind2nd(std::plus<T>(), k));
	  return  static_cast<const V&>(*this);
	}
 
      /// Assignment subtraction with scalar. Subtracts scalar from each coord.
      const V& operator -=(T k) 
	{ 
	  std::transform(data, &data[N], data, std::bind2nd(std::minus<T>(), k));
	  return  static_cast<const V&>(*this);
	}
 
      /** Assignment multiplication with vector. 
	  Multiply each coord independently. */
      const V& operator *=(const V& v) 
	{ 
	  std::transform(data, &data[N], v.get(), data, std::multiplies<T>());
	  return  static_cast<const V&>(*this);
	}
 
      /// Assigment division with vector. Each coord divided independently.
      const V& operator /=(const V& v)
	{
	  std::transform(data, &data[N], v.get(), data, std::divides<T>());
	  return  static_cast<const V&>(*this);
	}
 
      /// Assignmment addition with vector.
      const V& operator +=(const V& v) 
	{
	  std::transform(data, &data[N], v.get(), data, std::plus<T>());
	  return  static_cast<const V&>(*this);
	}
		
      /// Assignment subtraction with vector.
      const V& operator -=(const V& v) 
	{ 
	  std::transform(data, &data[N], v.get(), data, std::minus<T>());
	  return  static_cast<const V&>(*this);
	}
 
 
      //----------------------------------------------------------------------
      // Unary operators on vectors
      //----------------------------------------------------------------------
 
      /// Negate vector.
      const V operator - () const
	{
	  V v_new;
	  std::transform(data, &data[N], v_new.get(), std::negate<T>());
	  return v_new;
	}
 
      //----------------------------------------------------------------------
      // Binary operators on vectors
      //----------------------------------------------------------------------
 
      /** Multiply vector with vector. Each coord multiplied independently
	  Do not confuse this operation with dot product. */
      const V operator * (const V& v1) const
	{
	  V v_new;
	  std::transform(data, &data[N], v1.get(), v_new.get(), std::multiplies<T>());
	  return v_new;
	}
 
      /// Add two vectors
      const V operator + (const V& v1) const
	{
	  V v_new;
	  std::transform(data, &data[N], v1.get(), v_new.get(), std::plus<T>());
	  return v_new;
	}
 
      /// Subtract two vectors. 
      const V operator - (const V& v1) const
	{
	  V v_new;
	  std::transform(data, &data[N], v1.get(), v_new.get(), std::minus<T>());
	  return v_new;
	}
 
      /// Divide two vectors. Each coord separately
      const V operator / (const V& v1) const
	{
	  V v_new;
	  std::transform(data, &data[N], v1.get(), v_new.get(), std::divides<T>());
	  return v_new;
	}
 
      //----------------------------------------------------------------------
      // Binary operators on vector and scalar
      //----------------------------------------------------------------------
 
      /// Multiply scalar onto vector.
      const V operator * (T k) const
	{
	  V v_new;
	  std::transform(data, &data[N], v_new.get(), std::bind2nd(std::multiplies<T>(), k));
	  return v_new;
	}
  
 
      /// Divide vector by scalar.
      const V operator / (T k) const
	{
	  V v_new;
	  std::transform(data, &data[N], v_new.get(), std::bind2nd(std::divides<T>(), k));
	  return v_new;      
	}
 
 
      /// Return the smallest coordinate of the vector
      const T min_coord() const 
	{
	  return *std::min_element(data, &data[N]);
	}
 
      /// Return the largest coordinate of the vector
      const T max_coord() const
	{
	  return *std::max_element(data, &data[N]);
	}
 
    };
 
  template <class T, class V, unsigned int N> 
    inline std::ostream& operator<<(std::ostream&os, const ArithVec<T,V,N>& v)
    {
      os << "[ ";
      for(unsigned int i=0;i<N;i++) os << v[i] << " ";
      os << "]";
      return os;
    }
 
  /// Get from operator for ArithVec descendants. 
  template <class T,class V, unsigned int N>
    inline std::istream& operator>>(std::istream&is, ArithVec<T,V,N>& v)
    {
      for(unsigned int i=0;i<N;i++) is>>v[i];
      return is;
    }
 
 
  /** Dot product for two vectors. The `*' operator is 
      reserved for coordinatewise	multiplication of vectors. */
  template <class T,class V, unsigned int N>
    inline T dot(const ArithVec<T,V,N>& v0, const ArithVec<T,V,N>& v1)
    {
      return std::inner_product(v0.get(), v0.get() + N, v1.get(), T(0));
    }
 
  /** Compute the sqr length by taking dot product of vector with itself. */
  template <class T,class V, unsigned int N>
    inline T sqr_length(const ArithVec<T,V,N>& v)
    {
      return dot(v,v);
    }
 
  /** Multiply double onto vector. This operator handles the case 
      where the vector is on the righ side of the `*'.
	 
      \note It seems to be optimal to put the binary operators inside the
      ArithVec class template, but the operator functions whose 
      left operand is _not_ a vector cannot be inside, hence they
      are here.
      We need three operators for scalar * vector although they are
      identical, because, if we use a separate template argument for
      the left operand, it will match any type. If we use just T as 
      type for the left operand hoping that other built-in types will
      be automatically converted, we will be disappointed. It seems that 
      a float * ArithVec<float,Vec3f,3> function is not found if the
      left operand is really a double.
  */
 
  template<class T, class V, unsigned int N>
    inline const V operator * (double k, const ArithVec<T,V,N>& v) 
    {
      return v * k;
    }
 
  /** Multiply float onto vector. See the note in the documentation
      regarding multiplication of a double onto a vector. */
  template<class T, class V, unsigned int N>
    inline const V operator * (float k, const ArithVec<T,V,N>& v) 
    {
      return v * k;
    }
 
  /** Multiply unsigned int onto vector. See the note in the documentation
      regarding multiplication of a double onto a vector. */
  template<class T, class V, unsigned int N>
    inline const V operator * (int k, const ArithVec<T,V,N>& v) 
    {
      return v * k;
    }
 
  /** Returns the vector containing for each coordinate the smallest
      value from two vectors. */
  template <class T,class V, unsigned int N>
    inline V v_min(const ArithVec<T,V,N>& v0, const ArithVec<T,V,N>& v1)
    {
      V v;
      std::transform(v0.get(), v0.get() + N, v1.get(), v.get(), std::ptr_fun(s_min<T>));
      return v;
    }
 
  /** Returns the vector containing for each coordinate the largest 
      value from two vectors. */
  template <class T,class V, unsigned int N>
    inline V v_max(const ArithVec<T,V,N>& v0, const ArithVec<T,V,N>& v1)
    {
      V v;
      std::transform(v0.get(), v0.get() + N, v1.get(), v.get(), std::ptr_fun(s_max<T>));
      return v;
    }
 
 
}
 
#endif
 

Subversion Repositories gelsvn

(root)/trunk/src/CGLA/ArithVec.h – Rev 45 → 89

Rev 45		Rev 89
1	`#ifndef __CGLA_ARITHVEC_H__`	1	`#ifndef __CGLA_ARITHVEC_H__`
2	`#define __CGLA_ARITHVEC_H__`	2	`#define __CGLA_ARITHVEC_H__`
3		3
4	`#include <iostream>`	4	`#include <iostream>`
5	`#include "CGLA.h"`	5	`#include "CGLA.h"`
6		6
7	`#include <numeric>`	7	`#include <numeric>`
8		8
9	`namespace CGLA`	9	`namespace CGLA`
10	`{`	10	`{`
11		11
12	`/** The ArithVec class template represents a generic arithmetic`	12	`/** \brief Template representing generic arithmetic vectors.`
-		13
13	`vector. The three parameters to the template are`	14	`The three parameters to the template are`
14		15
15	`T - the scalar type (i.e. float, int, double etc.)`	16	`T - the scalar type (i.e. float, int, double etc.)`
16		17
17	`V - the name of the vector type. This template is always (and`	18	`V - the name of the vector type. This template is always (and`
18	`only) used as ancestor of concrete types, and the name of the`	19	`only) used as ancestor of concrete types, and the name of the`
19	`class _inheriting_ _from_ this class is used as the V argument.`	20	`class _inheriting_ _from_ this class is used as the V argument.`
20		21
21	`N - The final argument is the dimension N. For instance, N=3 for a`	22	`N - The final argument is the dimension N. For instance, N=3 for a`
22	`3D vector.`	23	`3D vector.`
23		24
24	`This class template contains all functions that are assumed to be`	25	`This class template contains all functions that are assumed to be`
25	`the same for any arithmetic vector - regardless of dimension or`	26	`the same for any arithmetic vector - regardless of dimension or`
26	`the type of scalars used for coordinates.`	27	`the type of scalars used for coordinates.`
27		28
28	`The template contains no virtual functions which is important`	29	`The template contains no virtual functions which is important`
29	`since they add overhead.`	30	`since they add overhead.`
30	`*/`	31	`*/`
31		32
32	`template <class T, class V, unsigned int N>`	33	`template <class T, class V, unsigned int N>`
33	`class ArithVec`	34	`class ArithVec`
34	`{`	35	`{`
35		36
36	`protected:`	37	`protected:`
37		38
38	`/// The actual contents of the vector.`	39	`/// The actual contents of the vector.`
39	`T data[N];`	40	`T data[N];`