Vector.h

/*
    Hyperspace Explorer - vizualizing higher-dimensional geometry
    Copyright (C) 2010  Lene Preuss <lene.preuss@gmail.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/

#ifndef VECTOR_H
#define VECTOR_H 1

#include <cstdarg>
#include <cassert>

#include <iostream>
#include <iomanip>
#include <string>
#include <sstream>

# if (!defined __PI)
#   include <cmath>
    const double pi = 4.*atan (1.);
#   define __PI 3_14
# endif


namespace VecMath {


  template <unsigned D, typename N = double> class Vector {

    public:

      //----------  management  ----------
      Vector<D, N> ();
      Vector<D, N> (const N &x);
      Vector<D, N> (N x0, N x1, ... );

      //----------  access      ----------

      N &operator[] (unsigned i);
      N operator[] (unsigned i) const;

      static unsigned dimension (void);

      //----------  arithmetics ----------

      Vector<D, N> &operator+= (const Vector<D, N> &Y);
      Vector<D, N> &operator-= (const Vector<D, N> &Y);
      Vector<D, N> &operator*= (const N &s);

      const N *data () const;               

      template <typename T> operator const T * () const;
        
      std::string toString() const;
        
    private:

      N _x[D]; 
        
  };

  template <unsigned D, typename N>    
  Vector<D, N> operator-(const Vector<D, N> &v);
  template <unsigned D, typename N>    
  Vector<D, N> operator+(const Vector<D, N> &x, const Vector<D, N> &y);
  template <unsigned D, typename N>    
  Vector<D, N> operator-(const Vector<D, N> &x, const Vector<D, N> &y);
        
  template <unsigned D, typename N>    
  Vector<D, N> operator* (const Vector<D, N> &x, const N &s);
  template <unsigned D, typename N>    
  Vector<D, N> operator* (const N &s, const Vector<D, N> &x);
    
  template <unsigned D, typename N>    
  N operator* (const Vector<D, N> &x, const Vector<D, N> &y);
    
  template <unsigned D, typename N>    
  Vector<D, N> operator/ (const Vector<D, N> &x, const N &s);
    
  template <unsigned D, typename N>    
  Vector<D, N> operator/ (const Vector<D, N> &x, const Vector<D, N> &y);

  template <unsigned D, typename N>
  Vector<D, N> scale (const Vector<D, N> &x, const Vector<D, N> &y);

  template <unsigned D, typename N>    
  bool operator==(const Vector<D, N> &one, const Vector<D, N> &other);
    
  template <unsigned D, typename N>    
  bool operator!=(const Vector<D, N> &one, const Vector<D, N> &other);
    
  template <unsigned D, typename N>    
  bool operator<(const Vector<D, N> &one, const Vector<D, N> &other);

  template <unsigned D, typename N>    
  N sqnorm (const Vector<D, N> &x);

  
  template <unsigned D, typename N>
  std::ostream &operator << (std::ostream &s, const Vector<D, N> &v);

  template <unsigned D, typename N>
  std::istringstream &operator >> (std::istringstream &in, Vector<D, N> &v);

  template <typename N>
  Vector<3, N> vcross (Vector<3, N> a, Vector<3, N> b);

  template <typename N>
  Vector<4, N> vcross (Vector<4, N> a, Vector<4, N> b, Vector<4, N> c);
     
  template <unsigned D, typename N>
  Vector<D, N> vnormalize( const Vector<D, N> &x );
    
  template <typename N> Vector<2, N> makeVector(N const &x0, N const &x1);
    
  template <typename N> 
  Vector<3, N> makeVector(N const &x0, N const &x1, N const &x2);
    
  template <typename N> 
  Vector<4, N> makeVector(N const &x0, N const &x1, N const &x2, N const &x3);
    
  template <typename N> 
  Vector<5, N> makeVector(N const &x0, N const &x1, N const &x2, N const &x3, N const &x4);
    
  template <typename N> 
  Vector<6, N> makeVector(N const &x0, N const &x1, N const &x2, N const &x3, N const &x4,
                          N const &x5);
     
  template <typename N> 
  Vector<7, N> makeVector(N const &x0, N const &x1, N const &x2, N const &x3, N const &x4,
                          N const &x5, N const &x6);

  template <typename N> 
  Vector<8, N> makeVector(N const &x0, N const &x1, N const &x2, N const &x3, N const &x4,
                          N const &x5, N const &x6, N const &x7);
                            
  template <typename N> 
  Vector<9, N> makeVector(N const &x0, N const &x1, N const &x2, N const &x3, N const &x4,
                          N const &x5, N const &x6, N const &x7, N const &x8);
                            
  template <typename N> 
  Vector<10, N> makeVector(N const &x0, N const &x1, N const &x2, N const &x3, N const &x4,
                           N const &x5, N const &x6, N const &x7, N const &x8, N const &x9);

     
}
#endif                                                //  VECTOR_H