Vector.hpp

Go to the documentation of this file.

//
// This file is part of MorphoGraphX - http://www.MorphoGraphX.org
// Copyright (C) 2012-2015 Richard S. Smith and collaborators.
//
// If you use MorphoGraphX in your work, please cite:
//   http://dx.doi.org/10.7554/eLife.05864
//
// MorphoGraphX is free software, and is licensed under under the terms of the 
// GNU General (GPL) Public License version 2.0, http://www.gnu.org/licenses.
// 
#ifndef VECTOR_HPP
#define VECTOR_HPP
 
#include <Config.hpp>
 
#include <cuda/CudaGlobal.hpp>
#include <StaticAssert.hpp>
 
#include <cassert>
#include <cmath>
#include <cstdarg>
#include <iostream>
#include <math.h>
 
#ifndef __CUDACC__
  #include <QTextStream>
#endif
 
namespace mgx 
{
  template <size_t dim, class T = float> class Vector {
  protected:
    T elems[dim];
  
  public:
    typedef T value_type;
    typedef T& reference_type;
    typedef const T& const_reference_type;
    typedef T* pointer_type;
    typedef const T* const_pointer_type;
    typedef T* iterator;
    typedef const T* const_iterator;
 
    static const size_t numElems = dim; 
// This defeats tr1::has_trivial_copy macro, and it's trivial anyway
//    /**
//     * Copy another vector
//     */
//    CU_HOST_DEVICE
//    Vector(const Vector& vec)
//    {
//      for(size_t i = 0; i < dim; i++)
//        elems[i] = vec[i];
//    }
//  
//    /**
//     * Copy another vector with different number of elements
//     */
//    template <class T1> CU_HOST_DEVICE Vector(const Vector<dim, T1>& vec)
//    {
//      for(size_t i = 0; i < dim; ++i)
//        elems[i] = vec[i];
//    }
  
    template <size_t d1, class T1> CU_HOST_DEVICE explicit Vector(const Vector<d1, T1>& vec)
    {
      if(d1 < dim) {
        for(size_t i = 0; i < d1; ++i)
          elems[i] = vec[i];
        for(size_t i = d1; i < dim; ++i)
          elems[i] = 0;
      } else {
        for(size_t i = 0; i < dim; ++i)
          elems[i] = vec[i];
      }
    }
  
  #ifndef COMPILE_CUDA
 
    template <class Vec> CU_HOST_DEVICE 
    explicit Vector(const Vec& el)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] = T(el[i]);
    }
  #endif
  
    CU_HOST_DEVICE
    explicit Vector(const T& x = T())
    {
      for(size_t i = 0; i < dim; ++i)
        elems[i] = x;
    }
  
    CU_HOST_DEVICE
    explicit Vector(const T& x, const T& y)
    {
      STATIC_ASSERT(dim == 2);
      elems[0] = x;
      elems[1] = y;
    }
  
    CU_HOST_DEVICE
    explicit Vector(const T& x, const T& y, const T& z)
    {
      STATIC_ASSERT(dim == 3);
      elems[0] = x;
      elems[1] = y;
      elems[2] = z;
    }
  
    CU_HOST_DEVICE
    explicit Vector(const T& x, const T& y, const T& z, const T& t)
    {
      STATIC_ASSERT(dim == 4);
      elems[0] = x;
      elems[1] = y;
      elems[2] = z;
      elems[3] = t;
    }
  
    CU_HOST_DEVICE
    Vector(const T& x, const T& y, const T& z, const T& a, const T& b)
    {
      STATIC_ASSERT(dim == 5);
      elems[0] = x;
      elems[1] = y;
      elems[2] = z;
      elems[3] = a;
      elems[4] = b;
    }
  
    CU_HOST_DEVICE
    Vector(const T& x, const T& y, const T& z, const T& a, const T& b, const T& c)
    {
      STATIC_ASSERT(dim == 6);
      elems[0] = x;
      elems[1] = y;
      elems[2] = z;
      elems[3] = a;
      elems[4] = b;
      elems[5] = c;
    }
  
    CU_HOST_DEVICE
    Vector(const T& x, const T& y, const T& z, const T& a, const T& b, const T& c, const T& d)
    {
      STATIC_ASSERT(dim == 7);
      elems[0] = x;
      elems[1] = y;
      elems[2] = z;
      elems[3] = a;
      elems[4] = b;
      elems[5] = c;
      elems[6] = d;
    }
 
    CU_HOST_DEVICE
    Vector(const T& a, const T& b, const T& c, const T& d, const T& e, const T& f, const T& g, const T& h)
    {
      STATIC_ASSERT(dim == 8);
      elems[0] = a;
      elems[1] = b;
      elems[2] = c;
      elems[3] = d;
      elems[4] = e;
      elems[5] = f;
      elems[6] = g;
      elems[7] = h;
    } 
 
    CU_HOST_DEVICE
    Vector(const T& a, const T& b, const T& c, const T& d, const T& e, const T& f, 
                                                             const T& g, const T& h, const T& i)
    {
      STATIC_ASSERT(dim == 9);
      elems[0] = a;
      elems[1] = b;
      elems[2] = c;
      elems[3] = d;
      elems[4] = e;
      elems[5] = f;
      elems[6] = g;
      elems[7] = h;
      elems[8] = i;
    }
 
    CU_HOST_DEVICE
    Vector(const T& a, const T& b, const T& c, const T& d, const T& e, const T& f, const T& g, 
                                                                                                                                                                             const T& h, const T& i, const T& j, const T& k, const T& l)
    {
      STATIC_ASSERT(dim == 12);
      elems[0] = a;
      elems[1] = b;
      elems[2] = c;
      elems[3] = d;
      elems[4] = e;
      elems[5] = f;
      elems[6] = g;
      elems[7] = h;
      elems[8] = i;
      elems[9] = j;
      elems[10] = k;
      elems[11] = l;
    }
 
    CU_HOST_DEVICE
    Vector(const T& a, const T& b, const T& c, const T& d, const T& e, const T& f, 
           const T& g, const T& h, const T& i, const T& j, const T& k, const T& l, 
           const T& m, const T& n, const T& o, const T& p, const T& q, const T& r)
    {
      STATIC_ASSERT(dim == 18);
      elems[0] = a;
      elems[1] = b;
      elems[2] = c;
      elems[3] = d;
      elems[4] = e;
      elems[5] = f;
      elems[6] = g;
      elems[7] = h;
      elems[8] = i;
      elems[9] = j;
      elems[10] = k;
      elems[11] = l;
      elems[12] = m;
      elems[13] = n;
      elems[14] = o;
      elems[15] = p;
      elems[16] = q;
      elems[17] = r;
    } 
 
    CU_HOST_DEVICE
    static size_t size() { return dim; }
  
    CU_HOST_DEVICE
    T* data() { return elems; }
  
    CU_HOST_DEVICE
    iterator begin() { return elems; }
    CU_HOST_DEVICE
    const_iterator begin() const { return elems; }
  
    CU_HOST_DEVICE
    iterator end() { return elems + dim; }
    CU_HOST_DEVICE
    const_iterator end() const { return elems + dim; }
  
    CU_HOST_DEVICE
    const T* c_data() const { return elems; }
  
    CU_HOST_DEVICE
    Vector operator-(void) const
    {
      Vector ans;
      for(size_t i = 0; i < dim; i++)
        ans[i] = -elems[i];
  
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector operator+(const Vector& vec) const
    {
      Vector ans(*this);
      ans += vec;
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector operator-(const Vector& vec) const
    {
      Vector ans(*this);
      ans -= vec;
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector mult(const Vector& vec) const
    {
      Vector ans;
      for(size_t i = 0; i < dim; i++)
        ans[i] = elems[i] * vec.elems[i];
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector operator*(const T& scalar) const
    {
      Vector ans(*this);
      ans *= scalar;
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector operator/(const T& scalar) const
    {
      Vector ans(*this);
      ans /= scalar;
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector operator/(const Vector& vec) const
    {
      Vector ans = *this;
      ans /= vec;
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector& operator/=(const Vector& vec)
    {
      for(size_t i = 0; i < dim; ++i)
        elems[i] /= vec.elems[i];
      return *this;
    }
  
    CU_HOST_DEVICE
    friend Vector operator*(const T& scalar, const Vector& vec)
    {
      Vector ans;
      for(size_t i = 0; i < dim; i++)
        ans[i] = scalar * vec.elems[i];
  
      return ans;
    }
  
    CU_HOST_DEVICE
    T operator*(const Vector& vec) const
    {
      T ans = 0;
      for(size_t i = 0; i < dim; i++)
        ans += elems[i] * vec.elems[i];
  
      return ans;
    }
  
//    CU_HOST_DEVICE
//    Vector& operator=(const Vector& vec)
//    {
//      for(size_t i = 0; i < dim; i++)
//        elems[i] = vec.elems[i];
//  
//      return (*this);
//    }
  
    CU_HOST_DEVICE
    Vector& operator+=(const Vector& vec)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] += vec.elems[i];
      return *this;
    }
  
    CU_HOST_DEVICE
    Vector& operator+=(const T& val)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] += val;
      return *this;
    }
  
    CU_HOST_DEVICE
    Vector& operator-=(const Vector& vec)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] -= vec.elems[i];
      return *this;
    }
  
    CU_HOST_DEVICE
    Vector& operator-=(const T& val)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] -= val;
      return *this;
    }
  
    CU_HOST_DEVICE
    Vector& operator*=(const T& scalar)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] *= scalar;
      return *this;
    }
  
    template <typename T1> CU_HOST_DEVICE 
                                Vector& operator*=(const T1& scalar)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] = (T)(elems[i] * scalar);
      return *this;
    }
  
    CU_HOST_DEVICE
    Vector& operator/=(const T& scalar)
    {
      for(size_t i = 0; i < dim; ++i)
        elems[i] /= scalar;
      return *this;
    }
  
    template <typename T1> CU_HOST_DEVICE 
                  Vector& operator/=(const T1& scalar)
    {
      for(size_t i = 0; i < dim; ++i)
        elems[i] = (T)(elems[i] / scalar);
      return *this;
    }
  
    CU_HOST_DEVICE
    bool operator==(const Vector& vec) const
    {
      for(size_t i = 0; i < dim; i++)
        if(elems[i] != vec.elems[i])
          return false;
  
      return true;
    }
  
    CU_HOST_DEVICE
    bool operator!=(const Vector& vec) const {
      return (!((*this) == vec));
    }
  
    CU_HOST_DEVICE
    T& operator[](size_t idx) {
      return elems[idx];
    }
  
    CU_HOST_DEVICE
    const T& operator[](size_t idx) const {
      return elems[idx];
    }
  
    CU_HOST_DEVICE
    T norm() const
    {
      #ifdef _MSC_VER
                                                  // Incorrect, but stupid compiler can't compile correct code
        return std::sqrt((float)normsq()); 
      #else
        return std::sqrt(normsq());
      #endif
    }
  
    CU_HOST_DEVICE
    T normsq() const
    {
      T ans = 0;
      for(size_t i = 0; i < dim; i++)
        ans += elems[i] * elems[i];
  
      return ans;
    }
  
    CU_HOST_DEVICE
    Vector& normalize(void)
    {
      T sz = norm();
      return ((*this) /= sz);
    }
  
    CU_HOST_DEVICE
    Vector normalized(void) const
    {
      Vector ans(*this);
      return ans.normalize();
    }
  
    bool iszero(void)
    {
      for(size_t i = 0; i < dim; i++)
        if(elems[i] != 0)
          return false;
      return true;
    }
  
    Vector& zero(void)
    {
      for(size_t i = 0; i < dim; i++)
        elems[i] = 0;
      return (*this);
    }
  
    CU_HOST_DEVICE
    void set(const T& x)
    {
      STATIC_ASSERT(dim == 1);
      elems[0] = x;
    }
  
    CU_HOST_DEVICE
    void set(const T& x, const T& y)
    {
      STATIC_ASSERT(dim == 2);
      elems[0] = x;
      elems[1] = y;
    }
  
    CU_HOST_DEVICE
    void set(const T& x, const T& y, const T& z)
    {
      STATIC_ASSERT(dim == 3);
      elems[0] = x;
      elems[1] = y;
      elems[2] = z;
    }
  
    CU_HOST_DEVICE
    void set(const T& x, const T& y, const T& z, const T& t)
    {
      STATIC_ASSERT(dim == 4);
      elems[0] = x;
      elems[1] = y;
      elems[2] = z;
      elems[3] = t;
    }
  
    CU_HOST_DEVICE
    Vector& operator=(const T& value)
    {
      for(size_t i = 0; i < dim; ++i) {
        elems[i] = value;
      }
      return *this;
    }
  
    CU_HOST_DEVICE
    Vector cross(const Vector& other) const
    {
      STATIC_ASSERT(dim == 3);
      return (*this) ^ other;
    }
  
    CU_HOST_DEVICE
    void x(const T& v)
    {
      STATIC_ASSERT(dim > 0);
      elems[0] = v;
    }
    CU_HOST_DEVICE
    void y(const T& v)
    {
      STATIC_ASSERT(dim > 1);
      elems[1] = v;
    }
    CU_HOST_DEVICE
    void z(const T& v)
    {
      STATIC_ASSERT(dim > 2);
      elems[2] = v;
    }
    CU_HOST_DEVICE
    void t(const T& v)
    {
      STATIC_ASSERT(dim > 3);
      elems[3] = v;
    }
    CU_HOST_DEVICE
    T& x()
    {
      STATIC_ASSERT(dim > 0);
      return elems[0];
    }
    CU_HOST_DEVICE
    T& y()
    {
      STATIC_ASSERT(dim > 1);
      return elems[1];
    }
    CU_HOST_DEVICE
    T& z()
    {
      STATIC_ASSERT(dim > 2);
      return elems[2];
    }
    CU_HOST_DEVICE
    T& t()
    {
      STATIC_ASSERT(dim > 3);
      return elems[3];
    }
    CU_HOST_DEVICE
    const T& x() const
    {
      STATIC_ASSERT(dim > 0);
      return elems[0];
    }
    CU_HOST_DEVICE
    const T& y() const
    {
      STATIC_ASSERT(dim > 1);
      return elems[1];
    }
    CU_HOST_DEVICE
    const T& z() const
    {
      STATIC_ASSERT(dim > 2);
      return elems[2];
    }
    CU_HOST_DEVICE
    const T& t() const
    {
      STATIC_ASSERT(dim > 3);
      return elems[3];
    }
  
    CU_HOST_DEVICE
    void i(const T& v)
    {
      STATIC_ASSERT(dim > 0);
      elems[0] = v;
    }
    CU_HOST_DEVICE
    void j(const T& v)
    {
      STATIC_ASSERT(dim > 1);
      elems[1] = v;
    }
    CU_HOST_DEVICE
    void k(const T& v)
    {
      STATIC_ASSERT(dim > 2);
      elems[2] = v;
    }
    CU_HOST_DEVICE
    void l(const T& v)
    {
      STATIC_ASSERT(dim > 3);
      elems[3] = v;
    }
    CU_HOST_DEVICE
    T& i()
    {
      STATIC_ASSERT(dim > 0);
      return elems[0];
    }
    CU_HOST_DEVICE
    T& j()
    {
      STATIC_ASSERT(dim > 1);
      return elems[1];
    }
    CU_HOST_DEVICE
    T& k()
    {
      STATIC_ASSERT(dim > 2);
      return elems[2];
    }
    CU_HOST_DEVICE
    T& l()
    {
      STATIC_ASSERT(dim > 3);
      return elems[3];
    }
    CU_HOST_DEVICE
    const T& i() const
    {
      STATIC_ASSERT(dim > 0);
      return elems[0];
    }
    CU_HOST_DEVICE
    const T& j() const
    {
      STATIC_ASSERT(dim > 1);
      return elems[1];
    }
    CU_HOST_DEVICE
    const T& k() const
    {
      STATIC_ASSERT(dim > 2);
      return elems[2];
    }
    CU_HOST_DEVICE
    const T& l() const
    {
      STATIC_ASSERT(dim > 3);
      return elems[3];
    }
  
    CU_HOST_DEVICE
    Vector<2, T> projectXY(void)
    {
      STATIC_ASSERT(dim > 1);
      return Vector<2, T>(elems[0], elems[1]);
    }
  
    CU_HOST_DEVICE
    bool operator<(const Vector& other) const
    {
      for(size_t i = 0; i < dim; ++i) {
        if(elems[i] < other.elems[i])
          return true;
        if(elems[i] > other.elems[i])
          return false;
      }
      return false;
    }
  
    CU_HOST_DEVICE
    bool operator<=(const Vector& other) const
    {
      for(size_t i = 0; i < dim; ++i) {
        if(elems[i] < other.elems[i])
          return true;
        if(elems[i] > other.elems[i])
          return false;
      }
      return true;
    }
  
    CU_HOST_DEVICE
    bool operator>(const Vector& other) const
    {
      for(size_t i = 0; i < dim; ++i) {
        if(elems[i] > other.elems[i])
          return true;
        if(elems[i] < other.elems[i])
          return false;
      }
      return false;
    }
  
    CU_HOST_DEVICE
    bool operator>=(const Vector& other) const
    {
      for(size_t i = 0; i < dim; ++i) {
        if(elems[i] > other.elems[i])
          return true;
        if(elems[i] < other.elems[i])
          return false;
      }
      return true;
    }
 
    friend std::ostream& operator<<(std::ostream& out, const Vector& vec)
    {
      for(size_t i = 0; i < dim; i++) {
        out << vec.elems[i];
        if(i != (dim - 1))
          out << " ";
      }
      return out;
    }
  
    friend std::istream& operator>>(std::istream& in, Vector& vec)
    {
      in >> vec[0];
      for(size_t i = 1; i < dim && in; i++)
        in >> std::ws >> vec[i];
      return in;
    }
  
  #ifndef __CUDACC__
    friend QTextStream& operator<<(QTextStream& out, const Vector& vec)
    {
      for(size_t i = 0; i < dim; i++) {
        out << vec.elems[i];
        if(i != (dim - 1))
          out << " ";
      }
      return out;
    }
  
    friend QTextStream& operator>>(QTextStream& in, Vector& vec)
    {
      in >> vec[0];
      for(size_t i = 1; i < dim && !in.atEnd(); i++)
        in >> ws >> vec[i];
      return in;
    }
  #endif
  };
  
  template <class T> CU_HOST_DEVICE 
                T operator%(const Vector<2, T>& v1, const Vector<2, T>& v2) 
                {
    return v1 ^ v2;
  }
  
  template <class T> CU_HOST_DEVICE 
                T operator^(const Vector<2, T>& v1, const Vector<2, T>& v2) 
                {
    return ((v1[0] * v2[1]) - (v1[1] * v2[0]));
  }
  
  template <class T> CU_HOST_DEVICE 
                T operator^(const Vector<1, T>&, const Vector<1, T>& ) 
                { 
                                return 0; 
                }
  
  template <class T>
  CU_HOST_DEVICE Vector<3, T> operator%(const Vector<3, T>& v1, const Vector<3, T>& v2)
  {
    return v1 ^ v2;
  }
  
  template <class T> CU_HOST_DEVICE 
                Vector<3, T> operator^(const Vector<3, T>& v1, const Vector<3, T>& v2) {
    Vector<3, T> ans;
    ans[0] = v1[1] * v2[2] - v1[2] * v2[1];
    ans[1] = v1[2] * v2[0] - v1[0] * v2[2];
    ans[2] = v1[0] * v2[1] - v1[1] * v2[0];
    return ans;
  }
  
  template <class T> CU_HOST_DEVICE 
                float angle(const Vector<2, T>& v)
  {
    return atan2(v.y(), v.x());
  }
  
  template <class T> CU_HOST_DEVICE 
                float angle(const Vector<3, T>& v1, const Vector<3, T>& v2)
  {
    float x = v1 * v2;
    float y = norm(v1 ^ v2);
    return atan2(y, x);
  }
  
  template <class T> CU_HOST_DEVICE 
                float angle(const Vector<2, T>& v1, const Vector<2, T>& v2)
  {
    float x = v1 * v2;
    float y = v1 ^ v2;
    return atan2(y, x);
  }
  
  template <class T> CU_HOST_DEVICE 
                float angle(const Vector<1, T>& v1, const Vector<1, T>& v2)
  {
    return (v1 * v2 < 0) ? -1 : 1;
  }
  
  template <class T> CU_HOST_DEVICE 
                float angle(const Vector<3, T>& v1, const Vector<3, T>& v2, const Vector<3, T>& ref)
  {
    float x = v1 * v2;
    Vector<3, T> n = v1 ^ v2;
    float y = norm(n);
    if(n * ref < 0)
      return atan2(-y, x);
    else
      return atan2(y, x);
  }
  
  CU_HOST_DEVICE
  float normalized(float) 
                {
    return 1;
  }
  
  CU_HOST_DEVICE
  float normsq(float s) 
                {
    return s * s;
  }
  
  CU_HOST_DEVICE
  float norm(float s) 
                {
    return (s < 0) ? -s : s;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE T 
                norm(const Vector<dim, T>& v) {
    return v.norm();
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                T normsq(const Vector<dim, T>& v) {
    return v.normsq();
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim, T> normalized(const Vector<dim, T>& v)
  {
    return v.normalized();
  }
  
  using ::fabs;
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim, T> fabs(const Vector<dim, T>& v)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = fabs(v[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim, T> max(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (v1[i] >= v2[i] ? v1[i] : v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim, T> min(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (v1[i] <= v2[i] ? v1[i] : v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T>
  CU_HOST_DEVICE Vector<dim, T> trim(const Vector<dim, T>& v, const Vector<dim, T>& minv, const Vector<dim, T>& maxv)
  {
    Vector<dim, T> result;
    result = max(minv, min(maxv, v));
    return result;
  }
  
  template <size_t dim, typename T>
  CU_HOST_DEVICE Vector<dim, T> multiply(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = v1[i] * v2[i];
    }
    return result;
  }
  
  //  /**
  //   * Return the vector whose components are clipped to min/max
  //   * components.
  //   *
  //   * \relates Vector
  //   */
  //  template <size_t dim, typename T>
  //  CU_HOST_DEVICE
  //  Vector<dim,T> multiply( const Vector<dim,T>& v, const Vector<dim,T>& minv, const Vector<dim,T>& maxv)
  //  {
  //    Vector<dim,T> result;
  //    result = min(minv, max(maxv, v));
  //    return result;
  //  }
  
  template <size_t dim, typename T>
  CU_HOST_DEVICE Vector<dim, T> divide(const Vector<dim, T>& v1, const Vector<dim, T>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = v1[i] / v2[i];
    }
    return result;
  }
  
  template <typename T> CU_HOST_DEVICE 
                Vector<3, T> orthogonal(const Vector<3, T>& v)
  {
    const float ratio = 1 - 1e-8;
    if((std::abs(v.y()) >= ratio * std::abs(v.x())) && (std::abs(v.z()) >= ratio * std::abs(v.x())))
      return Vector<3, T>(0, -v.z(), v.y());
    else if((std::abs(v.x()) >= ratio * std::abs(v.y())) && (std::abs(v.z()) >= ratio * std::abs(v.y())))
      return Vector<3, T>(-v.z(), 0, v.x());
    else
      return Vector<3, T>(-v.y(), v.x(), 0);
  }
  
  /*
   * Transform all components of a vector with a function
   *
   * \relates Vector
   */
  template <size_t dim, typename T, typename T1>
  CU_HOST_DEVICE Vector<dim, T> map(const T& (*fct)(const T1 &), const Vector<dim, T1>& v)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v[i]);
    }
    return result;
  }
  
  /*
   * Transform all components of a vector with a function
   *
   * \relates Vector
   */
  template <size_t dim, typename T, typename T1>
  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(const T1&), const Vector<dim, T1>& v)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T, typename T1> CU_HOST_DEVICE 
                Vector<dim, T> map(T (*fct)(T1), const Vector<dim, T1>& v)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T>
  CU_HOST_DEVICE Vector<dim, T> map(const T& (*fct)(const T &, const T &), const Vector<dim, T>& v1,
                                    const Vector<dim, T>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v1[i], v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T>
  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(const T&, const T&), const Vector<dim, T>& v1, const Vector<dim, T>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v1[i], v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T>
  CU_HOST_DEVICE Vector<dim, T> map(T (*fct)(T, T), const Vector<dim, T>& v1, const Vector<dim, T>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v1[i], v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T, typename T1, typename T2>
  CU_HOST_DEVICE Vector<dim, T> map(const T& (*fct)(const T1 &, const T2 &), const Vector<dim, T1>& v1,
                                    const Vector<dim, T2>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v1[i], v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T, typename T1, typename T2> CU_HOST_DEVICE 
                Vector<dim, T> map(T (*fct)(const T1&, const T2&), const Vector<dim, T1>& v1, 
                                                                                                                                                                                                 const Vector<dim, T2>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v1[i], v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T, typename T1, typename T2> CU_HOST_DEVICE 
  Vector<dim, T> map(T (*fct)(T1, T2), const Vector<dim, T1>& v1, const Vector<dim, T2>& v2)
  {
    Vector<dim, T> result;
    for(size_t i = 0; i < dim; ++i) {
      result[i] = (*fct)(v1[i], v2[i]);
    }
    return result;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
  Vector<dim, T> operator+(const Vector<dim, T>& v, const T& value)
  {
    Vector<dim, T> res;
    for(size_t i = 0; i < dim; ++i)
      res[i] = v[i] + value;
    return res;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim, T> operator+(const T& value, const Vector<dim, T>& v)
  {
    Vector<dim, T> res;
    for(size_t i = 0; i < dim; ++i)
      res[i] = v[i] + value;
    return res;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim, T> operator-(const Vector<dim, T>& v, const T& value)
  {
    Vector<dim, T> res;
    for(size_t i = 0; i < dim; ++i)
      res[i] = v[i] - value;
    return res;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim, T> operator-(const T& value, const Vector<dim, T>& v)
  {
    Vector<dim, T> res;
    for(size_t i = 0; i < dim; ++i)
      res[i] = value - v[i];
    return res;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim + 1, T> homogeneous(const Vector<dim, T>& v)
  {
    Vector<dim + 1, T> res(v);
    res[dim] = T(1);
    return res;
  }
  
  template <size_t dim, typename T> CU_HOST_DEVICE 
                Vector<dim - 1, T> cartesian(const Vector<dim, T>& v)
  {
    Vector<dim - 1, T> res(v);
    res /= v[dim - 1];
    return res;
  }
}
  
#ifndef __CUDACC__
// Add hashes for STL
#include <Common.hpp>
#include <boost/functional/hash.hpp>
  
namespace std 
{
  HASH_NS_ENTER
  template <size_t dim, typename T> struct hash<mgx::Vector<dim, T> > {
    size_t operator()(const mgx::Vector<dim, T>& v) const
    {
      std::size_t seed = 0;
      for(size_t i = 1; i < dim; ++i)
        boost::hash_combine(seed, v[i]);
      return seed;
//
//      boost::hash_combine(seed, 2);
//      static const hash<T> hash_value = hash<T>();
//      size_t acc = hash_value(v[0]);
//      for(size_t i = 1; i < dim; ++i)
//        acc ^= hash_value(v[i]);
//      return acc;
    }
  };
  HASH_NS_EXIT
}
 
#endif
 
#endif