mthVector.h

Go to the documentation of this file.

/******************************************************************************

  Copyright 2015 Scientific Computation Research Center,
      Rensselaer Polytechnic Institute. All rights reserved.

  This work is open source software, licensed under the terms of the
  BSD license as described in the LICENSE file in the top-level directory.

*******************************************************************************/

#ifndef MTH_VECTOR_H
#define MTH_VECTOR_H

#include "canArray.h"
#include <cmath>
#include <ostream>

namespace mth {

template <class T, unsigned N=0>
class Vector : public can::Array<T,N>
{
  public:
    Vector() {}
    Vector(unsigned n) {(void)n;}
    Vector(T const* v)
    {
      for (unsigned i=0; i < N; ++i)
        (*this)[i] = v[i];
    }
    T& operator()(unsigned i) {return (*this)[i];}
    T const& operator()(unsigned i) const {return (*this)[i];}
    Vector<T,N>& operator+=(Vector<T,N> const& b)
    {
      for (unsigned i=0; i < N; ++i)
        (*this)[i] += b[i];
      return (*this);
    }
    Vector<T,N> operator+(Vector<T,N> const& b) const
    {
      Vector<T,N> r;
      for (unsigned i=0; i < N; ++i)
        r[i] = (*this)[i] + b[i];
      return r;
    }
    Vector<T,N>& operator-=(Vector<T,N> const& b)
    {
      for (unsigned i=0; i < N; ++i)
        (*this)[i] -= b[i];
      return (*this);
    }
    Vector<T,N> operator-(Vector<T,N> const& b) const
    {
      Vector<T,N> r;
      for (unsigned i=0; i < N; ++i)
        r[i] = (*this)[i] - b[i];
      return r;
    }
    Vector<T,N> operator*(T const& s) const
    {
      Vector<T,N> r;
       for (unsigned i=0; i < N; ++i)
         r[i] = (*this)[i] * s;
       return r;
    }
    Vector<T,N> operator/(T const& s) const
    {
      Vector<T,N> r;
       for (unsigned i=0; i < N; ++i)
         r[i] = (*this)[i] / s;
       return r;
    }
    T operator*(Vector<T,N> const& b) const
    {
      T r = (T)0.0;
      for (unsigned i=0; i < N; ++i)
        r += (*this)[i] * b[i];
      return r;
    }
    T getLength() const {return sqrt((*this)*(*this));}
    Vector<T,N> normalize() const {return (*this)/getLength();}
    void zero()
    {
      for (unsigned i=0; i < N; ++i)
        (*this)[i] = (T)0.0;
    }
};

template <class T>
class Vector<T,0> : public can::Array<T,0>
{
  public:
    Vector() {}
    Vector(unsigned n) : can::Array<T>(n) {}
    T& operator()(unsigned i) {return (*this)[i];}
    T const& operator()(unsigned i) const {return (*this)[i];}
    Vector<T,0>& operator+=(Vector<T,0> const& b)
    {
      for (unsigned i=0; i < this->sz; ++i)
        (*this)[i] += b[i];
      return *this;
    }
    Vector<T,0>& operator-=(Vector<T,0> const& b)
    {
      for (unsigned i=0; i < this->sz; ++i)
        (*this)[i] -= b[i];
      return *this;
    }
    Vector<T,0>& operator*=(T const& s)
    {
      for (unsigned i=0; i < this->sz; ++i)
        (*this)[i] *= s;
      return *this;
    }
    Vector<T,0>& operator/=(T const& s)
    {
      for (unsigned i=0; i < this->sz; ++i)
        (*this)[i] *= s;
      return *this;
    }
    T getLength() const {return sqrt((*this)*(*this));}
    void zero()
    {
      for (unsigned i=0; i < this->sz; ++i)
        (*this)[i] = (T)0.0;
    }
    double operator*(Vector<T,0> const& b)
    {
      double s = 0;
      for (unsigned i=0; i < this->sz; ++i)
        s += (*this)[i] * b[i];
      return s;
    }
};

template <class T>
class Vector3 : public Vector<T,3>
{
  public:
    Vector3() {}
    Vector3(Vector<T,3> const& other) : Vector<T,3>(other) {};
    Vector3(T const& a, T const& b, T const& c)
    {
      (*this)[0] = a;
      (*this)[1] = b;
      (*this)[2] = c;
    }
    Vector3(T const* abc)
    {
      (*this)[0] = abc[0];
      (*this)[1] = abc[1];
      (*this)[2] = abc[2];
    }
    void toArray(T* abc) const
    {
      abc[0] = (*this)[0];
      abc[1] = (*this)[1];
      abc[2] = (*this)[2];
    }
    void fromArray(T const* abc)
    {
      (*this)[0] = abc[0];
      (*this)[1] = abc[1];
      (*this)[2] = abc[2];
    }
    T& x() {return (*this[0]);}
    T& y() {return (*this[1]);}
    T& z() {return (*this[2]);}
    T const& x() const {return (*this)[0];}
    T const& y() const {return (*this)[1];}
    T const& z() const {return (*this)[2];}
};

}

template <class T, unsigned N>
std::ostream& operator<<(std::ostream& s, mth::Vector<T,N> const& a)
{
  for (unsigned i=0; i < a.size(); ++i)
    s << a[i] << ' ';
  s << '\n';
  return s;
}

#endif