LAP_Vector.h

Go to the documentation of this file.

#ifndef LAP_Vector_H
#define LAP_Vector_H

#include "LAP_Object.h"
#include "LAP_View.h"


template<class T>
class LAP_Vector: public virtual LAP_Object {
    
public:

    //for sorting methods
    static const tFlag ASCENT;
    static const tFlag DESCENT;
private:
    
    
    // capacity of the values
    tLVectorIndex mCapacity;
    
    // values of vector
    T* mValues;

    //view of the vector
    LAP_View mView;
    
    // boolean than indicates if the mValues pointer must be destroyed at reallocation or deleting
    tBoolean mIsVectorReference;
    
    
    
    // METHODS
    
    
protected:
    // CONSTRUCTORS
    
    LAP_Vector() {
        mValues=null;
        mCapacity=0;
        mIsVectorReference=false;
    }
      
  
 
    
    // DESTRUCTORS
    virtual ~LAP_Vector() {
        deleteVector();
    };
    
private:
    void deleteVector() {
        if (!mIsVectorReference) {
            if (mValues!=null) {
                delete[] mValues;
                mValues=null;
                mView.reset();
                mCapacity=0;
            }
            
        }
    }
    
    // -----------------------
    // shared pointer operator
    // ------------------------
public:
    void getSharedPointer(boost::shared_ptr<LAP_Vector<T> >& p){
        SP::CORE_Object r;
        CORE_Object::getSharedPointer(r);
        p=boost::dynamic_pointer_cast<LAP_Vector<T> >(r);       
    };
    void getSharedPointer( boost::shared_ptr<const LAP_Vector<T> >& p) const{           
        SPC::CORE_Object r;
        CORE_Object::getSharedPointer(r);               
        p=boost::dynamic_pointer_cast<const LAP_Vector<T> >(r);                         
    }; 
private:
    inline boost::shared_ptr<LAP_Vector<T> > getThis() {
        boost::shared_ptr<LAP_Vector<T> > p;
        getSharedPointer(p);
        return p;                               
    }; 
    inline  boost::shared_ptr<const LAP_Vector<T> > getThis() const {                                   
        boost::shared_ptr<const LAP_Vector<T> > p;
        getSharedPointer(p);
        return p;       
    };

    //OPERATOR ACCESSORS
    //=================
    
public:
    // operators get the i-th value of the vector without view
    inline const T& operator[](const tLVectorIndex& i) const {
       if (i>=mCapacity)
           throw LAP_Exception("math/linalg/core","LAP_Vector<T>[]","index "+CORE_Integer::toString(i)+" out of bounds [0,"+CORE_Integer::toString(mCapacity)+"[");
       
        return mValues[i];
    };
    // operators get the i-th value of the vector without view
    inline T& operator[](const tLVectorIndex& i)  {
      if (i>=mCapacity)
          throw LAP_Exception("math/linalg/core","LAP_Vector<T>[]","index "+CORE_Integer::toString(i)+" out of bounds [0,"+CORE_Integer::toString(mCapacity)+"[");
      
        return mValues[i];
        
    };
    
    // operators get the i-th element of the view of the vector
    inline T& operator()(const tLVectorIndex& i) {
        return (*this)[mView.getStart()+mView.getIncrement()*i];
    };
    // operators get the i-th element of the view of the vector
    inline const T& operator()(const tLVectorIndex& i) const {
        return (*this)[mView.getStart()+mView.getIncrement()*i];
    };

    
    
    //computation operators
    //=====================
    void add(const T&  s)  {
      tLVectorIndex i,n=getSize();
      const tLVectorIncrement &inc=getIncrement();
      T *ts=&(*this)(0);
      for (i=0;i<n;i++)  {
        *ts+=s;
        ts+=inc;
      }
    }
    
    inline void sub(const T&  s)  {
        tLVectorIndex i,n=getSize();
        const tLVectorIncrement& inc=getIncrement();
        T *ts=&(*this)(0);
        for (i=0;i<n;i++)  {
          *ts-=s;
          ts+=inc;
        }
    };
    
    inline void power(const T&  s)  {
      tLVectorIndex i,n=getSize();
      T *ts=&(*this)(0);
      const tLVectorIncrement& inc=getIncrement();
      if (s==1) return ;
      else if (s==-1) {
        for (i=0;i<n;i++) {
          *ts=(T) 1./(*ts);
          ts+=inc;
        }
      } else if (s==-2) {
        for (i=0;i<n;i++) {
          *ts=(T) 1./((*ts)*(*ts));
          ts+=inc;
        }
      } else if (s==2) {
        for (i=0;i<n;i++) {
          *ts=(T) ((*ts)*(*ts));
          ts+=inc;
        }
      } else {   
        for (i=0;i<n;i++)  {
          *ts=(T) pow((tReal)*ts,(tReal)s);
          ts+=inc;
        }
      }
    };
    
    inline void multiplyBy(const LAP_Vector<T>&  s)  {
      tLVectorIndex i,n=getSize();
      if (s.getSize()!=n) throw LAP_Exception("math/linalg/core",
                                              "*= operator",
                                              "incompatible vector dimension");
      const T *vs=&s(0);
      T *ts=&(*this)(0);
      const tLVectorIncrement& incs=s.getIncrement();
      const tLVectorIncrement& inc=getIncrement();
      for (i=0;i<n;i++) {
        *ts*=*vs;
        vs+=incs;
        ts+=inc;
      }
    };
    inline LAP_Vector<T>& divideBy(const LAP_Vector<T>&  s)  {
      tLVectorIndex i,n=getSize();
      if (s.getSize()!=n) throw LAP_Exception("math/linalg/core",
                                              "/= operator",
                                              "incompatible vector dimension");
      
      const T *vs=&s(0);
      T *ts=&(*this)(0);
      const tLVectorIncrement& incs=s.getIncrement();
      const tLVectorIncrement& inc=getIncrement();
      for (i=0;i<n;i++) {
        *ts/=*vs;
        vs+=incs;
        ts+=inc;
      }
      return (*this);
    };
    
  
    //SET methods
    //===========
    // copy method
    
    virtual void copy(const vector<T>& s) {
      tLVectorIndex i,n=s.size();
      setSize(n);
      T *ts=mValues;
      for (i=0;i<n;i++) {
        *ts=s[i];
        ts++;
      }
    }
    
    inline void setIsValuesReferenced(const tBoolean& isReferenced) {
        mIsVectorReference=isReferenced;
    }
    /* \brief set the values to values of size n
     * if isReferenced is true the vector is not destroyed with the class
     * otherwise it is destroyed
     */
    inline void setValues(const tLVectorIndex& n,
                          T*& values,
                          const tBoolean& isReferenced) {
        //delete the old values
        deleteVector();
        //make the pointer to the new values
        mValues=values;
        //set the capacity of the vector to n
        mCapacity=n;
        //set the the values pointer is referenced by another object
        mIsVectorReference=isReferenced;
        
        //update the view
        mView.setView(0,n,1);
    };
    inline void setValues(const tLVectorIndex& n,const T* values) {
        setValues(n,1,values);
    }
    inline void setValues(const tLVectorIndex& n,const tLVectorIncrement& incv,const T* values) {
        
        if (n>0) {
            if (n!=mCapacity) {
                deleteVector();
                try {
                    mValues=new T[n+1];
                } catch (std::exception e) {
                    throw LAP_Exception("math/linalg/core","LAP_Vector<T>::setValues()",
                                        "memory allocation over flow for size "+CORE_Integer::toString(n));
                }
                if (mValues==null) throw LAP_Exception("math/linalg/core","LAP_Vector<T>::setValues()",
                                                       "memory allocation over flowfor size "+CORE_Integer::toString(n));
            }

            T *pValues=&mValues[0];
            const T *vs=values;
            for (tLVectorIndex i=0;i<n;i++) {
                *pValues=*vs;
                pValues++;
                vs+=incv;
            }
            *pValues=0;
            
            mCapacity=n+1;
            mIsVectorReference=false;
            mView.setView(0,n,1);
        } else {
            deleteVector();
            mValues=null;
            mCapacity=0;
            mView.reset();
        }
    }
    inline tBoolean setView(SP::LAP_View v) {
        return setView(v->getStart(),v->getEnd(),v->getIncrement());
    }
    
    inline tBoolean setView(const tLVectorIndex& start,const tLVectorIndex& end,const tLVectorIndex& increment) {
        if (increment==0) return false;
        if (end<start) return false;
        if (end-increment>=mCapacity) return false; 
        mView.setView(start,end,increment);
        return true;
    }
    
    inline void resetView() {
        setView(0,mCapacity-1,1);
    }
    
    inline void setSize(const tLVectorIndex& n) {
        if (getSize()!=n) {
            if (!setView(0,n,1)) {
                //resize the vector
                resize(n);
                //re-set the view
                setView(0,n,1);
            }
        }
    }
   
    
private:
    inline void resize(const tLVectorIndex& n) {
        if (n!=mCapacity) {
            T *newVector=null;
            //reallocate the new vector of size n
            try {
               newVector=new T[n+1];
               if (newVector==null) throw LAP_Exception("math/linalg/core","LAP_Vector<T>::resize()",
                                                        "memory allocation over flow for size "+CORE_Integer::toString(n));
            } catch(std::exception e) {
                throw LAP_Exception("math/linalg/core","LAP_Vector<T>::resize()",
                                    "memory allocation over flow for size "+CORE_Integer::toString(n));
            }
            
            //copy the old values taking into account the view
            tLVectorIndex oldSize=mView.getSize();
            tLVectorIndex k=0,i,dim=(oldSize<n)?oldSize:n;

            const tLVectorIncrement& inc=getIncrement();
            //copy the old values
            i=mView.getStart();
            for (k=0;k<dim;k++) {
                newVector[k]=mValues[i];
                i+=inc;
            }
            for (i=dim;i<=n;i++) {
                newVector[i]=(T) 0;
            }
            
            //delete the old vector
            deleteVector();
            //reallocate the new vector
            mValues=newVector;
            mIsVectorReference=false;
            //update the capacity
            mCapacity=n+1;
            //update the view
            mView.setView(0,n,1);
        }
    };
public:
    inline void fit() {
        resize(mView.getSize());
    }; 
 
    inline void init(const T& v) {
        tLVectorIndex i;
        const tLVectorIndex& n=mView.getEnd();
        const tLVectorIncrement& inc=mView.getIncrement();
        for (i=mView.getStart();i<n;i+=inc) (*this)[i]=v;
    };
    
    inline void removeValues(const tLVectorIndex& index,const tLVectorIndex&  n) {
        // get the number of elements
        tLVectorIndex s=mView.getSize();

        //get the max element to erase
        int nElementsToErase=n;
        int maxElementsToErase=s-index;
        if ( ((int)n)>maxElementsToErase) nElementsToErase=maxElementsToErase;
        if (nElementsToErase==0) return;
        
        //get the increment of the view
        const tLVectorIncrement& inc=mView.getIncrement();
        
        //first index to remove
        tLVectorIndex i0=mView.getStart()+index*inc;
        //after last index to remove
        tLVectorIndex i1=i0+n*inc;

        //pointer to first element to erase
        T* v1=&mValues[i0];
        //pointer to element to copy to v1
        T *v2=&mValues[i1];
        int i=0;
        while (i1<mCapacity) {
            *v1=*v2;
            v1+=inc;
            v2+=inc;
            i++;
            i1+=inc;
        }
        
        mView.setView(mView.getStart(),mView.getStart()+(s-nElementsToErase)*inc,inc);
    };
    
     
    inline void set(const tLVectorIndex& i,const T& v) {
        (*this)(i)=v;
    };

  
    virtual void add(const tLVectorIndex& i,const T& v) {
        (*this)(i)+=v;
    };

   
    void merge(const T &alpha,const LAP_Vector<T>& x,
               const T &beta,const LAP_Vector<T>& y);
    
    // GET methods
    // ===========
    
public:
    
    virtual const T* getValues() const {
        return mValues;
    };
    
    virtual T* getValues()  {
        return mValues;
    };

    virtual tLVectorIndex getNullValuesNumber(const tReal& eps) const=0;
    
    virtual const T& get(const tLVectorIndex & i) const {
        return (*this)(i);
    };

    inline tLVectorIndex getSize() const {
        return mView.getSize();
    }
    inline tLVectorIndex getCapacity() const {
        return mCapacity;
    }
    inline const tLVectorIncrement& getIncrement() const {
        return mView.getIncrement();
    }
    inline const tLVectorIndex& getStart() const {
        return mView.getStart();
    }
    T sum() const;
    
    inline static void max(const LAP_Vector<T>& x,LAP_Vector<T>& y) {
        
        // take the min dimension
        tLVectorIndex dimx=x.getSize();
        tLVectorIndex dimy=y.getSize();
        const tLVectorIncrement& incx=x.getIncrement();
        const tLVectorIncrement& incy=y.getIncrement();
        
        // dim=min(dimx,dimy)
        tLVectorIndex i,dim=(dimx>dimy)?dimy:dimx;

        //get the first element form start
        const T *ptr_x=&x(0);
        T *ptr_y=&y(0);
        for (i=0;i<dim;i++) {
            *ptr_y=(*ptr_x>*ptr_y)?*ptr_x:*ptr_y;
            ptr_x+=incx;
            ptr_y+=incy;
        }
    }
    
    inline void max(LAP_Vector<T>& y) {
        max(*this,y);
    }

    T maxValue(tLVectorIndex& i) const ;
    T minValue(tLVectorIndex& i) const;
    
    tLVectorIndex indexMin() const;

    inline tReal distance2(const LAP_Vector<T>& a) const {
      return LAP_Vector<T>::distance2(*this,a);
    }
    static tReal  distance2(const LAP_Vector<T>& a, const LAP_Vector<T>& b);

    
    
    //----------
    // sorting
    // ---------

    void quickSort();

 private:
    void quickSort(T* v,
                   const tLVectorIncrement& incv,
                   const tLVectorIndex& from,
                   const tLVectorIndex& left);
    
 public:
    void sort(const tFlag& order);

    
    inline void sort() {
        sort(ASCENT);
    };

    inline tBoolean compare(const T& a,const T& b,const tFlag& order) {
        if (order==DESCENT) {
            return (a>=b);
        } else {
            return (a<=b);
        }
    }
    void reverse();
 
};

#include "LAP_Vector.hpp"

#endif