AndroMeta/include/AndroMeta/MPLVector.h

Go to the documentation of this file.

/*
 * Copyright 2009-2012 AndroMeta LLC. All rights reserved.
 *
 * AndroMeta LLC retains all intellectual property and proprietary 
 * rights to this software and related documentation and any modifications 
 * thereto.  Any use, reproduction, disclosure, or distribution of this 
 * software and related documentation without an express license agreement 
 * from AndroMeta LLC is strictly prohibited.
 * 
 */

#ifndef ANDROMETA_MPL_VECTOR_H
#define ANDROMETA_MPL_VECTOR_H

#include <AndroMeta/MVar.h>

#include <cmath>

namespace Meta{

  template<typename T, size_t N>
  class MPLVector{
  public:

    MPLVector(){
      
    }
   
    MPLVector(const mvec& v){
      if(v.size() != N){
        throw MError("MPLVector::MPLVector: size mismatch");
      }
      
      for(size_t i = 0; i < N; ++i){
        vc_[i] = v[i];
      }
    }

    MPLVector(const mvar& v){
      if(v.size() != N){
        throw MError("MPLVector::MPLVector: size mismatch");
      }
      
      for(size_t i = 0; i < N; ++i){
        vc_[i] = v[i];
      }
    }
    
    MPLVector<T,N>& operator=(const mvec& v){
      if(v.size() != size()){
        throw MError("MPLVector::operator=: size mismatch");
      }
      
      for(size_t i = 0; i < size(); ++i){
        vc_[i] = v[i];
      }
      
      return *this;
    }

    MPLVector<T,N>& operator=(const mvar& v){
      if(v.size() != size()){
        throw MError("MPLVector::operator=: size mismatch");
      }
      
      for(size_t i = 0; i < size(); ++i){
        vc_[i] = v[i];
      }
      
      return *this;
    }
    
    MPLVector<T,N>& operator=(T x){
      for(size_t i = 0; i < size(); ++i){
        vc_[i] = x;
      }
      
      return *this;
    }
    
    static size_t size(){
      return N;
    }

    T& operator[](size_t i){
      return vc_[i];
    }

    const T& operator[](size_t i) const{
      return vc_[i];
    }
    
    MPLVector<T,N>& operator+=(const MPLVector<T,N>& v){
      for(size_t i = 0; i < N; ++i){
        vc_[i] += v.vc_[i];
      }
      
      return *this;
    }

    MPLVector<T,N>& operator+=(T x){
      for(size_t i = 0; i < N; ++i){
        vc_[i] += x;
      }
      
      return *this;
    }
    
    MPLVector<T,N>& operator-=(const MPLVector<T,N>& v){
      for(size_t i = 0; i < N; ++i){
        vc_[i] -= v.vc_[i];
      }
      
      return *this;
    }

    MPLVector<T,N>& operator-=(T x){
      for(size_t i = 0; i < N; ++i){
        vc_[i] -= x;
      }
      
      return *this;
    }
    
    MPLVector<T,N>& operator*=(const MPLVector<T,N>& v){
      for(size_t i = 0; i < N; ++i){
        vc_[i] *= v.vc_[i];
      }
      
      return *this;
    }
    
    MPLVector<T,N>& operator*=(T x){
      for(size_t i = 0; i < N; ++i){
        vc_[i] *= x;
      }
      
      return *this;
    }
    
    MPLVector<T,N>& operator/=(const MPLVector<T,N>& v){
      for(size_t i = 0; i < N; ++i){
        vc_[i] /= v.vc_[i];
      }
      
      return *this;
    }
    
    MPLVector<T,N>& operator/=(T x){
      for(size_t i = 0; i < N; ++i){
        vc_[i] /= x;
      }
      
      return *this;
    }

    void normalize(){
      T d = 0;
      
      for(size_t i = 0; i < N; ++i){
        d += vc_[i] * vc_[i];
      }
      
      d = sqrt(d);
      
      for(size_t i = 0; i < N; ++i){
        vc_[i] /= d;
      }
    }
    
  private:
    T vc_[N] __attribute__ ((aligned (16)));
  };

  template<typename T, size_t N>
  std::ostream& operator<<(std::ostream& ostr, const MPLVector<T,N>& v){
    ostr << "[";
    for(size_t i = 0; i < N; ++i){
      if(i > 0){
        ostr << ","; 
      }
      ostr << v[i];
    }
    ostr << "]";
    return ostr;
  }
  
  namespace MFunc{
    
    template<typename T, size_t N>
    MPLVector<T,N> crossProduct(const MPLVector<T,N>& u, const MPLVector<T,N>& v){
      MPLVector<T,N> r;
      
      r[0] = u[1]*v[2] - u[2]*v[1];
      r[1] = u[2]*v[0] - u[0]*v[2];
      r[2] = u[0]*v[1] - u[1]*v[0];
      
      return r;
    }
    
    template<typename T, size_t N>
    T dotProduct(const MPLVector<T,N>& u, const MPLVector<T,N>& v){
      T r = 0;
      
      for(size_t i = 0; i < N; ++i){
        r += u[i]*v[i];
      }
      
      return r;
    }
    
    template<typename T, size_t N>
    T mdistance(const MPLVector<T,N>& u, const MPLVector<T,N>& v){
      T d = 0;
      for(size_t i = 0; i < N; ++i){
        T di = u[i] - v[i];
        di *= di;
        d += di;
      }
      return sqrt(d);
    }    
  } // end namespace MFunc
  
  namespace MPLVec{

    typedef MPLVector<int32_t,2> int2;
    typedef MPLVector<int32_t,3> int3;
    typedef MPLVector<int32_t,4> int4;
    typedef MPLVector<int32_t,8> int8;
    typedef MPLVector<int32_t,16> int16;
    
    typedef MPLVector<int64_t,2> long2;
    typedef MPLVector<int64_t,3> long3;
    typedef MPLVector<int64_t,4> long4;
    typedef MPLVector<int64_t,8> long8;
    typedef MPLVector<int64_t,16> long16;

    typedef MPLVector<float,2> float2;
    typedef MPLVector<float,3> float3;
    typedef MPLVector<float,4> float4;
    typedef MPLVector<float,8> float8;
    typedef MPLVector<float,16> float16;

    typedef MPLVector<double,2> double2;
    typedef MPLVector<double,3> double3;
    typedef MPLVector<double,4> double4;
    typedef MPLVector<double,8> double8;
    typedef MPLVector<double,16> double16;

  } // end namespace MPLVec

} // end namespace Meta

#endif // ANDROMETA_MPL_VECTOR_H