/Users/jab/Documents/Teaching/02585/GEL2_and_demos/GEL/src/LinAlg/Vector.h

Go to the documentation of this file.

#if !defined(VECTOR_H__HAA_AGUST_2001)
#define VECTOR_H__HAA_AGUST_2001

#include <cassert>
#include <iostream>
#include <cmath>
#include "CGLA/Vec2f.h"
#include "CGLA/Vec3f.h"

namespace LinAlg
{
        template <class T> class CMatrixType;  

        template <class T>
        class CVectorType  
        {

                friend class CMatrixType<T>;

        private:

                int nElems;

                T*Data;

                void SetScalar(const T& Scalar) 
                {
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        *Itt=Scalar;
                                        ++Itt;
                                }
                }; 

                void CleanUp(void)  {if(Data!=NULL) delete [] Data;};

                void Allocate(void) { Data= new T[nElems];};


        public:



                CVectorType<T>():nElems(0),Data(NULL) {};

                explicit CVectorType<T>(const int Length): nElems(Length) {Allocate();}

                CVectorType<T>(const int Length,const T& Scalar): nElems(Length) {Allocate();SetScalar(Scalar);}

                CVectorType<T>(const CVectorType<T>& Rhs): nElems(Rhs.nElems)
                {
                        Allocate();
                        memcpy(Data,Rhs.Data,nElems*sizeof(T));
                }

                template <class TT, class V, unsigned int N> 
                CVectorType<T>(const CGLA::ArithVec<TT,V,N>& Rhs):nElems(N)
                {
                        Allocate(); 
                        for(int i=0;i<N;++i)
                                Data[i]=Rhs[i];
                }

                virtual ~CVectorType<T>(){ CleanUp();};


                CVectorType<T>& operator=(const T& Rhs) {SetScalar(Rhs);return *this;}

                template <class TT, class V, unsigned int N> 
                CVectorType<T>& operator=(const CGLA::ArithVec<TT,V,N>& Rhs)
                {
                        Resize(N);
                        for(int i=0;i<N;++i)
                                Data[i]=Rhs[i];
                }


                CVectorType<T>& operator=(const CVectorType<T>& Rhs)
                {
                        Resize(Rhs.nElems);
                        memcpy(Data,Rhs.Data,nElems*sizeof(T));
                        return *this;
                }



                const int Length(void) const {return nElems;}
                void Resize(const int Length)
                {
                        if(Length!=nElems)
                                {
                                        CleanUp();
                                        nElems=Length;
                                        Data= new T[nElems];
                                }
                }

                const T& get(const int i)const 
                {
                        assert(i>=0);
                        assert(i<nElems);

                        return Data[i];
                }

                void set(const int i,const T& val)
                {
                        assert(i>=0);
                        assert(i<nElems);

                        Data[i]=val;
                }

                T& operator[](const int i) 
                {
                        assert(i>=0);
                        assert(i<nElems);
                
                        return Data[i];
                }

                const T& operator[](const int i) const 
                {
                        assert(i>=0);
                        assert(i<nElems);
                
                        return Data[i];
                }


                CVectorType<T> operator+(const CVectorType<T>& Rhs) const {CVectorType<T>Ret(*this); return Ret+=Rhs;};
                CVectorType<T> operator-(const CVectorType<T>& Rhs) const {CVectorType<T>Ret(*this); return Ret-=Rhs;};
                CVectorType<T> operator+(const T& Rhs) const {CVectorType<T>Ret(*this); return Ret+=Rhs;};
                CVectorType<T> operator-(const T& Rhs) const {CVectorType<T>Ret(*this); return Ret-=Rhs;};
                CVectorType<T> operator*(const T& Rhs) const {CVectorType<T>Ret(*this); return Ret*=Rhs;};
                CVectorType<T> operator/(const T& Rhs) const {CVectorType<T>Ret(*this); return Ret/=Rhs;};

                CVectorType<T>& operator+=(const CVectorType<T>& Rhs)
                {
                        assert(nElems==Rhs.nElems);

                        T* IttRhs=Rhs.Data;
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        (*Itt)+=(*IttRhs);
                                        ++Itt;
                                        ++IttRhs;
                                }
                        return *this; 
                }

                CVectorType<T>& operator-=(const CVectorType<T>& Rhs)
                {
                        assert(nElems==Rhs.nElems);

                        T* IttRhs=Rhs.Data;
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        (*Itt)-=(*IttRhs);
                                        ++Itt;
                                        ++IttRhs;
                                }
                        return *this; 
                }

                CVectorType<T>& operator+=(const T& Rhs)
                {
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        (*Itt)+=Rhs;
                                        ++Itt;
                                }
                        return *this; 
                }

                CVectorType<T>& operator-=(const T& Rhs)
                {
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        (*Itt)-=Rhs;
                                        ++Itt;
                                }
                        return *this; 
                }

                CVectorType<T>& operator*=(const T& Rhs)
                {
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        (*Itt)*=Rhs;
                                        ++Itt;
                                }
                        return *this; 
                }

                CVectorType<T>& operator/=(const T& Rhs)
                {
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        (*Itt)/=Rhs;
                                        ++Itt;
                                }
                        return *this; 
                }

                T operator*(const CVectorType<T>& Rhs) const
                {
                        assert(nElems==Rhs.nElems);
                        T Ret=0;

                        T* IttRhs=Rhs.Data;
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        Ret+=(*Itt)*(*IttRhs);
                                        ++Itt;
                                        ++IttRhs;
                                }
                        return Ret; 
                }

                CVectorType<T> operator*(const CMatrixType<T>& Rhs) const
                {
                        assert(nElems==Rhs.Rows());
                        CVectorType<T> Ret(Rhs.Cols(),0);

                        T* ThisItt=Data;
                        const T* RhsItt=Rhs.Data;
                        const T* Stop=&(Rhs.Data[Rhs.nElems]);
                        T* RetItt;

                        while(RhsItt!=Stop)
                                {
                                        RetItt=Ret.Data;
                                        for(int cCol=Rhs.Cols()-1;cCol>=0;--cCol)
                                                {
                                                        (*RetItt)+=(*ThisItt)*(*RhsItt);
                                                        ++RetItt;
                                                        ++RhsItt;
                                                }
                                        ++ThisItt;
                                }
                        return Ret;
                }


                const T Norm(void) const {return sqrt((*this)*(*this));}
                const T NormMax(void) const
                {
                        T Ret=0;
                        T Abs;
                        const T* Itt=Data;
                        const T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        Abs=(*Itt)>0?(*Itt):-(*Itt);
                                        if(Ret<Abs)
                                                Ret=Abs;

                                        ++Itt;
                                }
                        return Ret;
                }

                const T Sum(void) const
                {
                        T Ret=0;
                        const T* Itt=Data;
                        const T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        Ret+=(*Itt);
                                        ++Itt;
                                }
                }



                void ElemSqr(void)
                {
                        T* Itt=Data;
                        T* Stop=&(Data[nElems]);
                        while(Itt!=Stop)
                                {
                                        (*Itt)*=(*Itt);
                                        ++Itt;
                                }
                }


        };


        template<class T>
        inline CVectorType<T> operator+(const T& Lhs,const CVectorType<T>&Rhs ) 
        {
                return Rhs+Lhs;
        }

        template<class T>
        inline CVectorType<T> operator*(const T& Lhs,const CVectorType<T>&Rhs ) 
        {
                return Rhs*Lhs;
        }

        template <class T>
        std::ostream& operator<<(std::ostream &s, const CVectorType<T> &a)
        {
                int nElems=a.Length();
        
                for (int cElem=0; cElem<nElems; cElem++)
                        {
                                s << a[cElem] << " ";
                        }
                s << "\n";
        
                return s;
        }


        template <class T>
        std::istream& operator>>(std::istream &s, CVectorType<T> &a)
        {
                int nElems;

                s >> nElems;

                if ( nElems!=a.Length())
                        a.Resize(nElems);


                for (int cElem=0; cElem<a.Length();cElem++)
                        {
                                s >>  a[cElem];
                        }

                return s;
        }

        typedef CVectorType<double> CVector;
}
#endif // !defined(VECTOR_H__HAA_AGUST_2001)