vector.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_MATH_VECTOR_H
#define ARCHON_MATH_VECTOR_H

#include <cmath>
#include <algorithm>
#include <iostream>

#include <archon/math/functions.H>

namespace Archon
{
  namespace Math
  {
    template<typename T, int N>
    struct BasicVector
    {
      typedef T ElementType;
      static const unsigned size = N;

      BasicVector() {}
      BasicVector(const T v[]) { set(v); }

      static const BasicVector &zero();

      T &operator[](int i) { return a[i]; }
      const T &operator[](int i) const { return a[i]; }

      T squareSum() const;
      T length() const { return sqrt(squareSum()); }
      T min() const;
      T max() const;

      BasicVector operator+(const BasicVector &) const;
      BasicVector operator-(const BasicVector &) const;
      BasicVector operator*(T) const;
      BasicVector operator/(T) const;
      BasicVector operator-() const;

      BasicVector &operator+=(const BasicVector &);
      BasicVector &operator-=(const BasicVector &);
      BasicVector &operator*=(T);
      BasicVector &operator/=(T);

      bool operator==(const BasicVector &) const;
      bool operator!=(const BasicVector &) const;

      void set(const T []);
      void negate();
      void normalize() { *this /= length(); }

    private:
      T a[N];

      static BasicVector makeZero();
    };

    template<typename T>
    struct BasicVector<T, 2>
    {
      BasicVector() {}
      BasicVector(const T v[]) { set(v); }
 
      static const BasicVector &zero();

      T &operator[](int i) { return a[i]; }
      const T &operator[](int i) const { return a[i]; }

      T squareSum() const;
      T length() const { return sqrt(squareSum()); }
      T min() const;
      T max() const;

      BasicVector operator+(const BasicVector &) const;
      BasicVector operator-(const BasicVector &) const;
      BasicVector operator*(T) const;
      BasicVector operator/(T) const;
      BasicVector operator-() const;

      BasicVector &operator+=(const BasicVector &);
      BasicVector &operator-=(const BasicVector &);
      BasicVector &operator*=(T);
      BasicVector &operator/=(T);

      bool operator==(const BasicVector &) const;
      bool operator!=(const BasicVector &) const;

      void set(const T []);
      void negate();
      void normalize() { *this /= length(); }


      // Special Vector2 ops.:

      void set(T v0, T v1) { a[0] = v0; a[1] = v1; }

      BasicVector(T v0, T v1) { set(v0, v1); }
      explicit BasicVector(const BasicVector<T, 3> &v) { set(v[0], v[1]); }

      // In range [0;2pi)
      T angle() const { return angle(a[0], a[1]); }

      // Perpendicular vector
      BasicVector perp() const { return BasicVector(-a[1], a[0]); }

    private:
      T a[2];

      static BasicVector makeZero();
    };

    template<typename T>
    struct BasicVector<T, 3>
    {
      BasicVector() {}
      BasicVector(const T v[]) { set(v); }

      static const BasicVector &zero();

      T &operator[](int i) { return a[i]; }
      const T &operator[](int i) const { return a[i]; }

      T squareSum() const;
      T length() const { return sqrt(squareSum()); }
      T min() const;
      T max() const;

      BasicVector operator+(const BasicVector &) const;
      BasicVector operator-(const BasicVector &) const;
      BasicVector operator*(T) const;
      BasicVector operator/(T) const;
      BasicVector operator-() const;

      BasicVector &operator+=(const BasicVector &);
      BasicVector &operator-=(const BasicVector &);
      BasicVector &operator*=(T);
      BasicVector &operator/=(T);

      bool operator==(const BasicVector &) const;
      bool operator!=(const BasicVector &) const;

      void set(const T []);
      void negate();
      void normalize() { *this /= length(); }


      // Special Vector3 ops.:

      void set(T v0, T v1, T v2) { a[0] = v0; a[1] = v1; a[2] = v2; }

      BasicVector(T v0, T v1, T v2) { set(v0, v1, v2); }
      explicit BasicVector(const BasicVector<T, 2> &v) { set(v[0], v[1], 0); }

      BasicVector &operator*=(const BasicVector &v)
      {
        set(a[1]*v[2] - a[2]*v[1], a[2]*v[0] - a[0]*v[2], a[0]*v[1] - a[1]*v[0]);
        return *this;
      }

      BasicVector operator*(const BasicVector &v) const
      {
        BasicVector w(*this);
        return w *= v;
      }

    private:
      T a[3];

      static BasicVector makeZero();
    };




    template<typename T, int N>
    BasicVector<T, N> BasicVector<T, N>::makeZero()
    {
      BasicVector z;
      for(int i=0; i<N; ++i) z[i] = 0;
      return z;
    }

    template<typename T, int N>
    inline const BasicVector<T, N> &BasicVector<T, N>::zero()
    {
      static BasicVector z = makeZero();
      return z;
    }

    template<typename T, int N>
    inline BasicVector<T, N> operator*(T f, const BasicVector<T, N> &v)
    {
      BasicVector<T, N> w = v; return w *= f;
    }

    template<typename T, int N>
    inline BasicVector<T, N> normalize(const BasicVector<T, N> &v)
    {
      BasicVector<T, N> w = v; w.normalize(); return w;
    }

    template<typename T, int N>
    inline T squareDist(BasicVector<T, N> v, const BasicVector<T, N> &w)
    {
      v -= w;
      return v.squareSum();
    }

    template<typename T, int N>
    inline T dist(BasicVector<T, N> v, const BasicVector<T, N> &w)
    {
      return sqrt(squareDist(v, w));
    }

    template<typename T, int N>
    inline T dot(const BasicVector<T, N> &v, const BasicVector<T, N> &w)
    {
      T s = 0;
      for(int i=0; i<N; ++i) s += v[i] * w[i];
      return s;
    }

    template<typename T, int N>
    std::ostream &operator<<(std::ostream &o, const BasicVector<T, N> &v)
    {
      o << "[";
      if(N > 0)
      {
        o << v[0];
        for(int i=1; i<N; ++i) o << ", " << v[i];
      }
      o << "]";
      return o;
    }

    template<typename T, int N>
    inline T BasicVector<T, N>::squareSum() const
    {
      T s = 0;
      for(int i=0; i<N; ++i) s += sq(a[i]);
      return s;
    }

    template<typename T, int N>
    inline T BasicVector<T, N>::min() const
    {
      T v = a[0];
      for(int i=1; i<N; ++i) if(a[i] < v) v = a[i];
      return v;
    }

    template<typename T, int N>
    inline T BasicVector<T, N>::max() const
    {
      T v = a[0];
      for(int i=1; i<N; ++i) if(a[i] > v) v = a[i];
      return v;
    }

    template<typename T, int N>
    inline BasicVector<T, N> BasicVector<T, N>::operator+(const BasicVector<T, N> &v) const
    {
      BasicVector w(*this);
      return w += v;
    }

    template<typename T, int N>
    inline BasicVector<T, N> BasicVector<T, N>::operator-(const BasicVector<T, N> &v) const
    {
      BasicVector w(*this);
      return w -= v;
    }

    template<typename T, int N>
    inline BasicVector<T, N> BasicVector<T, N>::operator*(T f) const
    {
      BasicVector v(*this);
      return v *= f;
    }

    template<typename T, int N>
    inline BasicVector<T, N> BasicVector<T, N>::operator/(T f) const
    {
      BasicVector v(*this);
      return v /= f;
    }

    template<typename T, int N>
    inline BasicVector<T, N> BasicVector<T, N>::operator-() const
    {
      BasicVector v(*this);
      v.negate();
      return v;
    }

    template<typename T, int N>
    inline BasicVector<T, N> &BasicVector<T, N>::operator+=(const BasicVector<T, N> &v)
    {
      for(int i=0; i<N; ++i) a[i] += v.a[i];
      return *this;
    }

    template<typename T, int N>
    inline BasicVector<T, N> &BasicVector<T, N>::operator-=(const BasicVector<T, N> &v)
    {
      for(int i=0; i<N; ++i) a[i] -= v.a[i];
      return *this;
    }

    template<typename T, int N>
    inline BasicVector<T, N> &BasicVector<T, N>::operator*=(T f)
    {
      for(int i=0; i<N; ++i) a[i] *= f;
      return *this;
    }

    template<typename T, int N>
    inline BasicVector<T, N> &BasicVector<T, N>::operator/=(T f)
    {
      for(int i=0; i<N; ++i) a[i] /= f;
      return *this;
    }

    template<typename T, int N>
    inline bool BasicVector<T, N>::operator==(const BasicVector<T, N> &v) const
    {
      for(int i=0; i<N; ++i) if(a[i] != v.a[i]) return false;
      return true;
    }

    template<typename T, int N>
    inline bool BasicVector<T, N>::operator!=(const BasicVector<T, N> &v) const
    {
      for(int i=0; i<N; ++i) if(a[i] != v.a[i]) return true;
      return false;
    }

    template<typename T, int N>
    inline void BasicVector<T, N>::set(const T v[])
    {
      for(int i=0; i<N; ++i) a[i] = v[i];
    }

    template<typename T, int N>
    inline void BasicVector<T, N>::negate()
    {
      for(int i=0; i<N; ++i) a[i] = -a[i];
    }




    template<typename T>
    BasicVector<T, 2> BasicVector<T, 2>::makeZero()
    {
      BasicVector z;
      for(int i=0; i<2; ++i) z[i] = 0;
      return z;
    }

    template<typename T>
    inline const BasicVector<T, 2> &BasicVector<T, 2>::zero()
    {
      static BasicVector z = makeZero();
      return z;
    }

    template<typename T>
    inline BasicVector<T, 2> operator*(T f, const BasicVector<T, 2> &v)
    {
      BasicVector<T, 2> w = v; return w *= f;
    }

    template<typename T>
    inline BasicVector<T, 2> normalize(const BasicVector<T, 2> &v)
    {
      BasicVector<T, 2> w = v; w.normalize(); return w;
    }

    template<typename T>
    inline T squareDist(BasicVector<T, 2> v, const BasicVector<T, 2> &w)
    {
      v -= w;
      return v.squareSum();
    }

    template<typename T>
    inline T dist(BasicVector<T, 2> v, const BasicVector<T, 2> &w)
    {
      return sqrt(squareDist(v, w));
    }

    template<typename T>
    inline T dot(const BasicVector<T, 2> &v, const BasicVector<T, 2> &w)
    {
      T s = 0;
      for(int i=0; i<2; ++i) s += v[i] * w[i];
      return s;
    }

    template<typename T>
    std::ostream &operator<<(std::ostream &o, const BasicVector<T, 2> &v)
    {
      o << "[";
      if(2 > 0)
      {
        o << v[0];
        for(int i=1; i<2; ++i) o << ", " << v[i];
      }
      o << "]";
      return o;
    }

    template<typename T>
    inline T BasicVector<T, 2>::squareSum() const
    {
      T s = 0;
      for(int i=0; i<2; ++i) s += sq(a[i]);
      return s;
    }

    template<typename T>
    inline T BasicVector<T, 2>::min() const
    {
      return std::min(a[0], a[1]);
    }

    template<typename T>
    inline T BasicVector<T, 2>::max() const
    {
      return std::max(a[0], a[1]);
    }

    template<typename T>
    inline BasicVector<T, 2> BasicVector<T, 2>::operator+(const BasicVector<T, 2> &v) const
    {
      BasicVector w(*this);
      return w += v;
    }

    template<typename T>
    inline BasicVector<T, 2> BasicVector<T, 2>::operator-(const BasicVector<T, 2> &v) const
    {
      BasicVector w(*this);
      return w -= v;
    }

    template<typename T>
    inline BasicVector<T, 2> BasicVector<T, 2>::operator*(T f) const
    {
      BasicVector v(*this);
      return v *= f;
    }

    template<typename T>
    inline BasicVector<T, 2> BasicVector<T, 2>::operator/(T f) const
    {
      BasicVector v(*this);
      return v /= f;
    }

    template<typename T>
    inline BasicVector<T, 2> BasicVector<T, 2>::operator-() const
    {
      BasicVector v(*this);
      v.negate();
      return v;
    }

    template<typename T>
    inline BasicVector<T, 2> &BasicVector<T, 2>::operator+=(const BasicVector<T, 2> &v)
    {
      for(int i=0; i<2; ++i) a[i] += v.a[i];
      return *this;
    }

    template<typename T>
    inline BasicVector<T, 2> &BasicVector<T, 2>::operator-=(const BasicVector<T, 2> &v)
    {
      for(int i=0; i<2; ++i) a[i] -= v.a[i];
      return *this;
    }

    template<typename T>
    inline BasicVector<T, 2> &BasicVector<T, 2>::operator*=(T f)
    {
      for(int i=0; i<2; ++i) a[i] *= f;
      return *this;
    }

    template<typename T>
    inline BasicVector<T, 2> &BasicVector<T, 2>::operator/=(T f)
    {
      for(int i=0; i<2; ++i) a[i] /= f;
      return *this;
    }

    template<typename T>
    inline bool BasicVector<T, 2>::operator==(const BasicVector<T, 2> &v) const
    {
      for(int i=0; i<2; ++i) if(a[i] != v.a[i]) return false;
      return true;
    }

    template<typename T>
    inline bool BasicVector<T, 2>::operator!=(const BasicVector<T, 2> &v) const
    {
      for(int i=0; i<2; ++i) if(a[i] != v.a[i]) return true;
      return false;
    }

    template<typename T>
    inline void BasicVector<T, 2>::set(const T v[])
    {
      for(int i=0; i<2; ++i) a[i] = v[i];
    }

    template<typename T>
    inline void BasicVector<T, 2>::negate()
    {
      for(int i=0; i<2; ++i) a[i] = -a[i];
    }




    template<typename T>
    BasicVector<T, 3> BasicVector<T, 3>::makeZero()
    {
      BasicVector z;
      for(int i=0; i<3; ++i) z[i] = 0;
      return z;
    }

    template<typename T>
    inline const BasicVector<T, 3> &BasicVector<T, 3>::zero()
    {
      static BasicVector z = makeZero();
      return z;
    }

    template<typename T>
    inline BasicVector<T, 3> operator*(T f, const BasicVector<T, 3> &v)
    {
      BasicVector<T, 3> w = v; return w *= f;
    }

    template<typename T>
    inline BasicVector<T, 3> normalize(const BasicVector<T, 3> &v)
    {
      BasicVector<T, 3> w = v; w.normalize(); return w;
    }

    template<typename T>
    inline T squareDist(BasicVector<T, 3> v, const BasicVector<T, 3> &w)
    {
      v -= w;
      return v.squareSum();
    }

    template<typename T>
    inline T dist(BasicVector<T, 3> v, const BasicVector<T, 3> &w)
    {
      return sqrt(squareDist(v, w));
    }

    template<typename T>
    inline T dot(const BasicVector<T, 3> &v, const BasicVector<T, 3> &w)
    {
      T s = 0;
      for(int i=0; i<3; ++i) s += v[i] * w[i];
      return s;
    }

    template<typename T>
    std::ostream &operator<<(std::ostream &o, const BasicVector<T, 3> &v)
    {
      o << "[";
      if(3 > 0)
      {
        o << v[0];
        for(int i=1; i<3; ++i) o << ", " << v[i];
      }
      o << "]";
      return o;
    }

    template<typename T>
    inline T BasicVector<T, 3>::squareSum() const
    {
      T s = 0;
      for(int i=0; i<3; ++i) s += sq(a[i]);
      return s;
    }

    template<typename T>
    inline T BasicVector<T, 3>::min() const
    {
      return std::min(std::min(a[0], a[1]), a[2]);
    }

    template<typename T>
    inline T BasicVector<T, 3>::max() const
    {
      return std::max(std::max(a[0], a[1]), a[2]);
    }

    template<typename T>
    inline BasicVector<T, 3> BasicVector<T, 3>::operator+(const BasicVector<T, 3> &v) const
    {
      BasicVector w(*this);
      return w += v;
    }

    template<typename T>
    inline BasicVector<T, 3> BasicVector<T, 3>::operator-(const BasicVector<T, 3> &v) const
    {
      BasicVector w(*this);
      return w -= v;
    }

    template<typename T>
    inline BasicVector<T, 3> BasicVector<T, 3>::operator*(T f) const
    {
      BasicVector v(*this);
      return v *= f;
    }

    template<typename T>
    inline BasicVector<T, 3> BasicVector<T, 3>::operator/(T f) const
    {
      BasicVector v(*this);
      return v /= f;
    }

    template<typename T>
    inline BasicVector<T, 3> BasicVector<T, 3>::operator-() const
    {
      BasicVector v(*this);
      v.negate();
      return v;
    }

    template<typename T>
    inline BasicVector<T, 3> &BasicVector<T, 3>::operator+=(const BasicVector<T, 3> &v)
    {
      for(int i=0; i<3; ++i) a[i] += v.a[i];
      return *this;
    }

    template<typename T>
    inline BasicVector<T, 3> &BasicVector<T, 3>::operator-=(const BasicVector<T, 3> &v)
    {
      for(int i=0; i<3; ++i) a[i] -= v.a[i];
      return *this;
    }

    template<typename T>
    inline BasicVector<T, 3> &BasicVector<T, 3>::operator*=(T f)
    {
      for(int i=0; i<3; ++i) a[i] *= f;
      return *this;
    }

    template<typename T>
    inline BasicVector<T, 3> &BasicVector<T, 3>::operator/=(T f)
    {
      for(int i=0; i<3; ++i) a[i] /= f;
      return *this;
    }

    template<typename T>
    inline bool BasicVector<T, 3>::operator==(const BasicVector<T, 3> &v) const
    {
      for(int i=0; i<3; ++i) if(a[i] != v.a[i]) return false;
      return true;
    }

    template<typename T>
    inline bool BasicVector<T, 3>::operator!=(const BasicVector<T, 3> &v) const
    {
      for(int i=0; i<3; ++i) if(a[i] != v.a[i]) return true;
      return false;
    }

    template<typename T>
    inline void BasicVector<T, 3>::set(const T v[])
    {
      for(int i=0; i<3; ++i) a[i] = v[i];
    }

    template<typename T>
    inline void BasicVector<T, 3>::negate()
    {
      for(int i=0; i<3; ++i) a[i] = -a[i];
    }



    typedef BasicVector<double, 2> Vector2;
    typedef BasicVector<double, 3> Vector3;
    typedef BasicVector<double, 4> Vector4;
  }
}

#endif // ARCHON_MATH_VECTOR_H

---