vec.inl

Go to the documentation of this file.

/* --------------------------------------------------------------- *\

   file: vec.inl
   date: 030825 22:16:28

   author:

      mathias gumz <gumz at cs.uni-magdeburg.de>

   license:

      see LICENSE.txt

   about:

      generic vector class

\* --------------------------------------------------------------- */


/* --------------------------------------------------------------- *\
    definitions of Vec
\* --------------------------------------------------------------- */
template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::operator=(typename Vec<T, S>::ConstValType& scalar)
{
  return vector::assign(*this, scalar);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::operator=(typename Vec<T, S>::ConstValTypePtr valptr)
{
  return vector::assign(*this, valptr);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::operator=(typename Vec<T, S>::ConstVecType& vec)
{
   return vector::assign(*this, vec);
}





template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::operator+=(typename Vec<T, S>::ConstVecType& vec)
{
  return vector::addOnSpot(*this, vec);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::operator-=(typename Vec<T, S>::ConstVecType& vec)
{
  return vector::subOnSpot(*this, vec);
}


template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::operator*=(typename Vec<T, S>::ConstValType& scalar)
{
  return vector::multOnSpot(*this,scalar);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::operator/=(typename Vec<T, S>::ConstValType& scalar)
{
  return vector::divideOnSpot(*this, scalar);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType Vec<T, S>::operator+(typename Vec<T, S>::ConstVecType& vec) const
{
  return vector::add(*this, vec);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType Vec<T, S>::operator-(typename Vec<T, S>::ConstVecType& vec) const
{
  return vector::sub(*this, vec);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType Vec<T, S>::operator*(typename Vec<T, S>::ConstValType& scalar) const
{
  return vector::mult(*this, scalar);
}

template<typename T, int S> inline
typename Vec<T, S>::VecType Vec<T, S>::operator/(typename Vec<T, S>::ConstValType& scalar) const
{
  return vector::divide(*this, scalar);
}


template<typename T, int S> inline
T Vec<T, S>::norm2() const
{
  T n= Vec<T, S>::ValTrait::zero();
  for(typename Vec<T, S>::ConstValTypePtr pv= begin(); pv != end(); pv++)
      n+= *pv * *pv;
  return n;
}

template<typename T, int S> inline
T Vec<T, S>::norm() const
{
  return sqrt(norm2());
}

template<typename T, int S> inline
typename Vec<T, S>::VecType& Vec<T, S>::normalize()
{
  return operator*=(Vec<T, S>::ValTrait::one()/norm());
}


/* --------------------------------------------------------------- *\
    special stuff only valid for vec3
\* --------------------------------------------------------------- */

template<typename T, int S>
Vec<T, S>::Vec(ConstValType& x, ConstValType& y, ConstValType& z)
{
  STATIC_CHECK(S == 3, Constructor_Is_Only_Valid_For_Vec3);
  val[0]= x; val[1]= y; val[2]= z;
}

/* --------------------------------------------------------------- *\
    functions for vector::
\* --------------------------------------------------------------- */
template<typename T, int S> inline
Vec<T, S>& vector::assign(Vec<T, S>& v, const T& scalar)
{
  for(T* i= v.begin(); i != v.end(); )
    *i++= scalar;
  return v;
}

template<typename T, int S> inline
Vec<T, S>& vector::assign(Vec<T, S>& v, const T* valptr)
{
  for(T* i= v.begin(); i != v.end(); )
    *i++= *valptr++;
  return v;
}

template<typename T, int S> inline
Vec<T, S>& vector::assign(Vec<T, S>& v, const Vec<T, S>& vec)
{
  const T* valptr= vec.begin();
  for(T* i= v.begin(); i != v.end(); )
    *i++= *valptr++;
  return v;
}





template<typename T, int S> inline
Vec<T, S> vector::add(const Vec<T, S>& v, const Vec<T, S>& vec)
{
  Vec<T, S> r(v);
  return vector::addOnSpot(r, vec);
}

template<typename T, int S> inline
Vec<T, S>& vector::addOnSpot(Vec<T, S>& v, const Vec<T, S>& vec)
{
  const T* valptr= vec.begin();
  for(T* i= v.begin(); i != v.end(); )
    *i++ += *valptr++;
  return v;
}

template<typename T, int S> inline
Vec<T, S> vector::sub(const Vec<T, S>& v, const Vec<T, S>& vec)
{
  Vec<T, S> r(v);
  return vector::subOnSpot(r, vec);
}

template<typename T, int S> inline
Vec<T, S>& vector::subOnSpot(Vec<T, S>& v, const Vec<T, S>& vec)
{
  const T* valptr= vec.begin();
  for(T* i= v.begin(); i != v.end(); )
    *i++ -= *valptr++;
  return v;
}


template<typename T, int S> inline
Vec<T, S> vector::mult(const Vec<T, S>& v, const T& scalar)
{
  Vec<T, S> r(v);
  return vector::multOnSpot(r, scalar);
}

template<typename T, int S> inline
Vec<T, S>& vector::multOnSpot(Vec<T, S>& v, const T& scalar)
{
  for(T* i= v.begin(); i != v.end(); )
    *i++ *= scalar;
  return v;
}
template<typename T, int S> inline
Vec<T, S> vector::divide(const Vec<T, S>& v, const T& scalar)
{
  Vec<T, S> r(v);
  return vector::multOnSpot(r, scalar);
}

template<typename T, int S> inline
Vec<T, S>& vector::divideOnSpot(Vec<T, S>& v, const T& scalar)
{
  for(T* i= v.begin(); i != v.end(); )
    *i++ /= scalar;
  return v;
}



/* --------------------------------------------------------------- *\
\* --------------------------------------------------------------- */

/* -- emacs - settings ------------------------------------------- *\
   ;;; Local Variables: ***
   ;;; mode:C++ ***
   ;;; c-basic-offset:2 ***
   ;;; End: ***
\* --------------------------------------------------------------- */
/* -- vim - settings --------------------------------------------- *\
  vim:set ft=cpp ts=2 ss=2:
\* --------------------------------------------------------------- */

---