Vector.h

Go to the documentation of this file.

#ifndef Protium_Vector_h_
#define Protium_Vector_h_

#include "Protium/Allocation/SmallObject.h"
#include "Protium/Design/Assert.h"

#include <vector>
#include <cmath>

namespace Protium{

    namespace LinearAlgebra{

        template<typename T, int n>
        class Vector;

        template<typename T, int n>
        struct SubVector{
            Vector<T, n-1> Of(const Vector<T,n>& other, const int& i=0){
                Vector<T,n-1> temp;
                int index=0;
                for(int j=0; j<n;j++ ){
                    if(j!=i)
                        temp[index++] = T(other.At(j) );
                }
                return temp;
            }
        };

        template<typename T>
        struct SubVector<T,2>{
            Vector<T, 1> Of(const Vector<T,2>& other, const int& i=0){
                Vector<T,1> temp;
                if(i==0)
                    temp[0] = T(other.At(1) );
                else
                    temp[0] = T(other.At(0) );
                return temp;
            }
        };

        template<typename T>
        struct SubVector<T,1>{
            Vector<T, 0> Of(const Vector<T,1>& other, const int& i=0){
                PROTIUM_STATIC_ASSERT(false, ERROR_NO_SUBVECTOR_OF_LENGTH_0() );
            }
        };

        template <typename T, int n=3>
        class Vector : public Protium::Allocation::DefaultSmallObject {

            std::vector<T> fComponents;

        public:

            void Init(){
                PROTIUM_STATIC_ASSERT(n>0, ERROR_NO_SUBVECTOR_OF_LENGTH_0 );
                fComponents.clear();
                for(int i=0; i<n;i++)fComponents.push_back( T(1) );
            }

            Vector<T,n>(const T& amplitude=1) : Protium::Allocation::DefaultSmallObject() {
                
                Init();

                this->Normalize( amplitude );
            }

            Vector<T,n>(const T* input) : Protium::Allocation::DefaultSmallObject(){
                Init();
                for(int i=0; i<n; i++)
                    fComponents[i] = T(input[i]);
            }

            Vector<T,n>(const std::vector<T>& vec) : Protium::Allocation::DefaultSmallObject(){
                Init();
                for(int i=0; i<n;i++)
                    fComponents[i] = T(vec[i] );
            }

            Vector<T,n>(const Vector<T,n>& other) : Protium::Allocation::DefaultSmallObject(){
                Init();
                for(int i=0; i<n; i++){
                    fComponents[i] =  T( other.At(i) );
                }
            }

            virtual ~Vector(){
                fComponents.clear();
            }

            static int NDimensions() {
                return n;
            }

            virtual T Norm() const {
              return sqrt( (*this)*(*this) );
            }

            virtual T Normalize(const T& norm){
                T old_norm = this->Norm();
                if(old_norm == norm) return norm;
                if(old_norm ==0) return 0;
                for(int i=0 ;i<n; i++ )
                    fComponents[i] *= (norm/old_norm);
                return this->Norm();
            }

            Vector<T,n-1> GetSubVector(const int& i){
                SubVector<T,n> helper;
                return helper.Of( (*this), i ); 
            }
            
            T& operator[](const int& index){
                return fComponents[index];
            }

            const T& At(const int& index) const{
                return fComponents.at(index);
            }

            Vector<T,n>& operator+=(const Vector<T,n>& rhs) {
                //PROTIUM_STATIC_ASSERT(n == m,"Vector Dimensions Must Match");
                for(int i=0; i<n;i++)
                     (*this)[i]  += rhs.At(i);
                return *this;
            }

            Vector<T,n>& operator*=(const T& rhs) {
                //PROTIUM_STATIC_ASSERT(n == m,"Vector Dimensions Must Match");
                for(int i=0; i<n;i++)
                     (*this)[i] *=rhs;
                return *this;
            }

            Vector<T,n>& operator-=(const Vector<T,n>& rhs) {
                //PROTIUM_STATIC_ASSERT(n == m,"Vector Dimensions Must Match");
                for(int i=0; i<n;i++)
                     (*this)[i] -=rhs.At(i);
                return *this;
            }

            const Vector<T,n> operator+(const Vector<T,n>& rhs) const {
                return Vector<T,n>(*this) += rhs;
            }

            const Vector<T,n> operator-(const Vector<T,n>& rhs) const {
                return Vector<T,n>(*this) -= rhs;
            }

            const T operator*(const Vector<T,n>& rhs) const {
                T ret=0;
                //PROTIUM_STATIC_ASSERT(n == m,"Vector Dimensions Must Match");
                for(int i=0; i<n;i++){
                    ret+= (this->At(i)) * (rhs.At(i) );
                }

                return ret;
            }

            const Vector<T,n> operator*(const T& rhs) const {
                return Vector<T,n>(*this) *=rhs;
            }

            Vector<T,n>& operator=( const Vector<T,n>& rhs ){
                for(int i=0; i<n;i++) fComponents.at(i) = T(rhs.At(i) );
                return *this;
            }

            bool operator==( const Vector<T,n> &rhs) const {
                bool ret=true;
                //PROTIUM_STATIC_ASSERT(n == m,"Vector Dimensions Must Match");
                for(int i=0; i<n;i++)
                    ret &= ( this->At(i) == rhs.At(i) );
                return ret;
            }

            bool operator!=( const Vector<T,n> &rhs) const {
                return !(*this == rhs);
            }

            static Vector<T,n> UnitVector(int dim=0){
                Vector<T,n> vec;
                for(int i=0;i<n;i++)
                    if(i==dim)
                        vec[i]=T(1);
                    else
                        vec[i]=T(0);
                return vec;
            }

        };

        typedef Vector<double, 2> TwoVector;
        typedef Vector<double, 3> ThreeVector;
        typedef Vector<double, 4> FourVector;
        typedef Vector<double, 5> FiveVector;
        typedef Vector<double, 6> SixVector;
        typedef Vector<double, 7> SevenVector;
        typedef Vector<double, 8> EightVector;
        typedef Vector<double, 9> NineVector;
        typedef Vector<double, 10> TenVector;
        typedef Vector<double, 11> ElevenVector;
        typedef Vector<double, 12> TwelveVector;
        typedef Vector<double, 13> ThirteenVector;
        typedef Vector<double, 14> FourteenVector;
        typedef Vector<double, 15> FifteenVector;
    }
}


#endif //File Guardian