CORE_Vector.h

Go to the documentation of this file.

#ifndef CORE_Vector_H
#define CORE_Vector_H
#include "CORE_List.h"
#include "types.h"
#include <vector>
#include "CORE_SharedPointersList.h"
#include "CORE_String.h"
#include "CORE_Exception.h"

using namespace std;



template <class T>
class CORE_Vector : public CORE_Object, public CORE_List {
   
 
private:
    vector<T> mVector; 

  
    // CONSTRUCTORS
public:
    CORE_Vector();  

    CORE_Vector(const tUIndex& n);   

    CORE_Vector(const CORE_Vector<T>& v);  
 
 

 
 
    // DESTRUCTORS
public:
    virtual ~CORE_Vector(); 
  
  
public:
    // NEW operators 
    static inline boost::shared_ptr<CORE_Vector<T> > New(const boost::shared_ptr<CORE_Vector<T> >& v ) {
        boost::shared_ptr<CORE_Vector<T> > p(new CORE_Vector<T>(),CORE_Object::Delete()); 
        p->setThis(p);
        p->copy(v);
        return p;
    };  
    static inline boost::shared_ptr<CORE_Vector<T> > New(const CORE_Vector<T>& v ) {
        boost::shared_ptr<CORE_Vector<T> > p(new CORE_Vector<T>(),CORE_Object::Delete()); 
        p->setThis(p);
        p->copy(v);
        return p;
    }; 
    static inline boost::shared_ptr<CORE_Vector<T> > New(const CORE_Vector<T>* v ) {
        boost::shared_ptr<CORE_Vector<T> > p(new CORE_Vector<T>(),CORE_Object::Delete()); 
        p->setThis(p);
        if (v!=null) p->copy(*v);
        return p;
    };
    static inline boost::shared_ptr<CORE_Vector<T> > New() {
        boost::shared_ptr<CORE_Vector<T> > p(new CORE_Vector<T>(),CORE_Object::Delete()); 
        p->setThis(p);
        return p;
    };
    static inline boost::shared_ptr<CORE_Vector<T> > New(const tUIndex& dim) {
        boost::shared_ptr<CORE_Vector<T> > p(new CORE_Vector<T>(),CORE_Object::Delete()); 
        p->setThis(p);
        p->setSize(dim);
        return p;
    };
    // OPERATORS
public:
    void getSharedPointer(boost::shared_ptr<CORE_Vector<T> >& p){
        SP::CORE_Object r;
        CORE_Object::getSharedPointer(r);
        p=boost::dynamic_pointer_cast<CORE_Vector<T> >(r);      
    };
    void getSharedPointer( boost::shared_ptr<const CORE_Vector<T> >& p) const{          
        SPC::CORE_Object r;
        CORE_Object::getSharedPointer(r);               
        p=boost::dynamic_pointer_cast<const CORE_Vector<T> >(r);                                
    }; 
private:   
    inline boost::shared_ptr<CORE_Vector<T> > getThis() {
        boost::shared_ptr<CORE_Vector<T> > p;
        getSharedPointer(p);
        return p;                               
    }; 
    inline  boost::shared_ptr<const CORE_Vector<T> > getThis() const {                                  
        boost::shared_ptr<const CORE_Vector<T> > p;
        getSharedPointer(p);
        return p;       
    };
public:

    //ACCESSOR Operators
    //==================
    inline const T& operator[](const tUIndex& i) const { 
        ASSERT_IN(i<mVector.size());
        return mVector[i];
    };
   
    inline T& operator[](const tUIndex& i)  {
        ASSERT_IN(i<mVector.size());
        return mVector[i];
    };

    // = Operators
    //============
    
    inline CORE_Vector<T>& operator=(const T& v)  {
        return initValues(v);
    };
  
    // arithmetic operators
    //=====================
    
    inline CORE_Vector& operator+=(const T& v)  {
        typename vector<T>::iterator iterator;
        for (iterator=mVector.begin();iterator<mVector.end();iterator++) 
            *iterator+=v;
        return *this;
    };
    inline CORE_Vector& operator-=(const T& v)  {
        typename vector<T>::iterator iterator;
        for (iterator=mVector.begin();iterator<mVector.end();iterator++) 
            *iterator-=v;
        return *this;
    };
    inline CORE_Vector& operator*=(const T& v)  {
        typename vector<T>::iterator iterator;
        for (iterator=mVector.begin();iterator<mVector.end();iterator++) 
            *iterator*=v;
        return *this;
    };
    inline CORE_Vector& operator/=(const T& v)  {
        if (v==0) throw CORE_Exception("common/core","CORE_Vector/=","division y zero");
        typename vector<T>::iterator iterator;
        for (iterator=mVector.begin();iterator<mVector.end();iterator++) 
            *iterator/=v;

        return *this;
    };

    //COPY Methods
    // ===========
     
    template<class Q> void copy(const CORE_Vector<Q>& u) {
        mVector.resize(u.getSize());
        typename vector<T>::const_iterator iu=u.begin();
        typename vector<T>::iterator iterator=mVector.begin();
        while (iterator!=mVector.end()) {
            *iterator=(T) (*iu);
            //next iter
            iu++;
            iterator++;
        }
    }
    template<class Q>
    void copy(const  boost::shared_ptr<CORE_Vector<Q> >& array) {
        copy(array.get());
    }

    template<class Q>
    void copy(const  vector<Q>& u) {
        setValues(u);
    }
    
    // SET Methods
    //==================  
    inline void clear(){
        setSize(0);
        mVector.clear();
    };
    inline void setSize(const tUIndex& n){
        mVector.resize(n);
    };
    inline void reserve(const tUIndex& n){
        mVector.reserve(n);
    };
 
    inline CORE_Vector<T>&  initValues(const T& v) {
        typename vector<T>::iterator iterator;
        for (iterator=mVector.begin();iterator<mVector.end();iterator++) 
            *iterator=v;
        return *this;
    };
    
    CORE_Vector<T>& initValues(const tUIndex& from,const tString& v);
   
    
    inline void setValue(const tUIndex& i,const T& v) {
        (*this)[i]=v;
    }; 
    inline void set(const tUIndex& i,const T& v) {
        (*this)[i]=v;
    };
     
   
    
    template<class Q> void setValues(const vector<Q>& u) {
        tUIndex n=u.size();
        typename vector<Q>::const_iterator iu=u.begin();
        mVector.resize(n);
        typename vector<T>::iterator iterator;
        for (iterator=mVector.begin();iterator!=mVector.end();iterator++) {
            *iterator=(T) (*iu);
            iu++;
        }
    } 
    template<class Q> void setValues(const Q* u,const tUIndex& n) {
        mVector.resize(n);
        const Q* iu=u;
        typename vector<T>::iterator iterator;
        for (iterator=mVector.begin();iterator!=mVector.end();iterator++) {
            *iterator=(T) (*iu);
            iu++;
        }
    }
    // GET methods
    // ============
       
  
    typename vector<T>::const_iterator begin() const {
        return mVector.begin();
    };
    typename vector<T>::iterator begin()  {
        return mVector.begin();
    };
    typename vector<T>::const_iterator end() const {
        return mVector.end();
    };
    typename vector<T>::iterator end()  {
        return mVector.end();
    };


  
    inline T& getLastElement() {
        ASSERT_IN(mVector.size()>0);
        return mVector[mVector.size()-1];
    };
    inline const T& getLastElement() const {
        ASSERT_IN(mVector.size()>0);
        return mVector[mVector.size()-1];
    };
    
    inline const T& getValue(const tUIndex& i) const {return (*this)[i];};

    inline const T& get(const tUIndex& i) const {
        return (*this)[i];
    }; 

    inline T& get(const tUIndex& i) {
        return (*this)[i];
    };
  
    inline tUIndex getSize() const {return mVector.size();};
    
    inline tUIndex size() const {return mVector.size();};
 
 
    inline const vector<T>& getValues() const {return mVector;};
    inline vector<T>& getValues()  {return mVector;};
 
    inline vector<T>& getVector() {
        return mVector;
    };
    inline const vector<T>& getVector() const{
        return mVector;
    };
    
    //ARITHMETHIC Methods
    //===================
    inline void divideBy(const tReal& v) {
        (*this)/=v;
    }
    
    inline void multiplyBy(const tReal& v) {
        (*this)*=v;
    }
    inline void add(const CORE_Vector<T>& u,const CORE_Vector<T>& v) {
        tUIndex n=mVector.size();
        tUIndex p=v.getSize();
        tUIndex i,dim=(n<p)?n:p;
        typename vector<T>::const_iterator iu=u.begin();
        typename vector<T>::const_iterator iv=v.begin();
        typename vector<T>::iterator it=mVector.begin();
        for (i=0;i<dim;i++) {
            (*it)=(*iu)+(*iv);
            it++;
            iu++;
            iv++;
        }
    };
    
    inline void add(const tReal& f,const CORE_Vector<T>& v) {
        if (f==0) {
            return;
        }
        tUIndex n=mVector.size();
        tUIndex p=v.getSize();
        tUIndex i,dim=(n<p)?n:p;
        typename vector<T>::const_iterator iv=v.begin();
        typename vector<T>::iterator it=mVector.begin();
        if (f==1) {
            for (i=0;i<dim;i++) {
                (*it)+=(*iv);
                it++;
                iv++;
            }
        } else {
            for (i=0;i<dim;i++) {
                (*it)+=f*(*iv);
                it++;
                iv++;
            }
        }
    };  
    
    
    inline void add(const CORE_Vector<T>& v) {
        add(1,v);
    };
    
    inline void sub(const CORE_Vector<T>& v) {
        sub(-1,v);
    };
    
    inline void sub(const T& f,const CORE_Vector<T>& v) {
        if (f==0) {
            return;
        }
        tUIndex n=mVector.size();
        tUIndex p=v.getSize();
        tUIndex i,dim=(n<p)?n:p;
        typename vector<T>::const_iterator iv=v.begin();
        typename vector<T>::iterator it=mVector.begin();
        if (f==1) {
            for (i=0;i<dim;i++) {
                (*it)-=(*iv);
                it++;
                iv++;
            }
        } else {
            for (i=0;i<dim;i++) {
                (*it)-=f*(*iv);
                it++;
                iv++;
            }
        }
    };
    
    inline void sub(const CORE_Vector<T>& u,const CORE_Vector<T>& v) {
        tUIndex n=mVector.size();
        tUIndex p=v.getSize();
        tUIndex i,dim=(n<p)?n:p;
        typename vector<T>::const_iterator iu=u.begin();
        typename vector<T>::const_iterator iv=v.begin();
        typename vector<T>::iterator it=mVector.begin();
        for (i=0;i<dim;i++) {
            (*it)=(*iu)-(*iv);
            it++;
            iu++;
            iv++;
        }
    };
    // OPERATIONS
    template<class Q>
    inline tReal distance2(const CORE_Vector<Q>& a) const {
        tUIndex n=a.getSize();
        tUIndex m=getSize();
        tUIndex i,p=(n<m)?n:m;
        tReal d=0;
        tReal t=0;
        typename vector<Q>::const_iterator ia=a.begin();
        typename vector<T>::const_iterator it=mVector.begin();
        for (i=0;i<p;i++) {
            t=((T)(*ia))-(*it);
            d+=t*t;
            ia++;
            it++;
        }
        return d;
    }; 
    template<class Q>
    tReal distance(const CORE_Vector<Q>& a) const {
        return sqrt(distance2(a));
    }; 
    template<class Q>
    tReal scalarProduct(const CORE_Vector<Q>& u) const {
        tUIndex n=u.getSize();
        tUIndex m=getSize();
        tUIndex i,p=(n<m)?n:m;
        tReal d=0;
        typename vector<Q>::const_iterator iu=u.begin();
        typename vector<T>::const_iterator it=mVector.begin();
        for (i=0;i<p;i++) {
            d+=((T)(*iu))*(*it);
            iu++;
            it++;
        }
        return d;
    };
    template<class Q>
    tReal scalarProduct(const CORE_Vector<Q>* a) const {
        if (a!=null) return scalarProduct(*a);
        else return 0;
    };
    template<class Q>
    inline static  void crossProduct(const CORE_Vector<Q>& a,
                                     const CORE_Vector<Q>& b,
                                     CORE_Vector<Q>& res)  {
        //get size of vector a
        tUIndex dim_a=a.getSize();
        //get size of vector b
        tUIndex dim_b=b.getSize();
        //take the min size
        tUIndex dim=(dim_a<dim_b)?dim_a:dim_b;
        //set the result size
        res.setSize(dim);

        //test if the size is null
        if (dim==0) return;

        //build iterator
        //typename vector<Q>::const_iterator ia=a.begin();
        //typename vector<Q>::const_iterator ib=b.begin();
        typename vector<T>::iterator it=res.begin();
        
        (*it)=a[1]*b[2]-a[2]*b[1];it++;
        (*it)=a[2]*b[0]-a[0]*b[2];it++;
        (*it)=a[0]*b[1]-a[1]*b[0];it++;
        
       
        
    };
    template<class Q>
    inline void crossProduct(const CORE_Vector<Q>& a,
                             CORE_Vector<Q>& res) const {
        crossProduct(*this,a,res);
    };

    inline void rotX(const tReal& alpha) {
        if (getSize()<3) setSize(3);
        tReal v1=   mVector[1]*cos(alpha) + mVector[2]*sin(alpha);
        mVector[2] = - mVector[1]*sin(alpha) + mVector[2]*cos(alpha);
        mVector[1] =v1;
    };
    
    inline void rotZ(const tReal& gamma) {
        if (getSize()<2) setSize(2);
        tReal v0 =   mVector[0]*cos(gamma) + mVector[1]*sin(gamma) ;
        mVector[1] =-mVector[0]*sin(gamma) + mVector[1]*cos(gamma) ;
        mVector[0]=v0;
    }
    
    inline tReal norm2() const {
        typename vector<T>::const_iterator it=mVector.begin();
        tReal d=0;
        for (it=mVector.begin();it!=mVector.end();it++) {
            d+=(*it)*(*it);
        }
        return d;
    }; 
 
    tReal norm() const {
        return sqrt(norm2());
    };
  
    inline void normalize() {
        tReal n=norm();
        if (n>0) divideBy(n);
    };
    
    //LIST METHODS
    //============
    
    tBoolean exists(const T& obj) const;
    
    
    virtual void addInList(const T& obj) {
        push_back(obj);
    };
    
    void push_back(const T& obj) {
        mVector.push_back(obj);
    };
    void add(const T& obj) {
        mVector.push_back(obj);
    };
    
    
    tBoolean insert(const tUIndex& i,const T& obj);
      
    tBoolean insertAtIndex(const tUIndex& i,const T& obj) {
        return insert(i,obj);
    }
    
    
    inline tUIndex insert(const T& obj){
        return insertInIncreasingOrder(obj,true);
    };
    
    tUIndex insertInIncreasingOrder(const T& obj,const tBoolean& evenIfEqual);
    
    void addAfterIndex(const tUIndex& index,const T& v);
  
    void addAfterIndices(boost::shared_ptr<CORE_Vector<tUIndex> >& p_indices,
                         const CORE_SharedPointersList<CORE_Vector<T> >& values);

  
  
    
    
    void append(const CORE_Vector<T>& array);
    
    tBoolean remove(const T& obj);
    
    tBoolean remove(const T* obj) {
        if (obj!=null) remove(*obj);
        return false;
    }
    
    tBoolean removeAtIndex(const tUIndex& i);
    
    
    inline tBoolean remove() {
        if (getSize()==0) return false;
        return remove(getSize()-1);
    };
    
    inline void sort(const tFlag& order) {
        sort(mVector,order);
    };
    inline void sort() {
        sort(CORE_List::LT);
    };
    
    
    static void sort(vector<T>& items,
                     const tFlag& order);
   

    static tUIndex search(const vector<T>& values,
                          const T& value,const tFlag& order);
    
    tUIndex search(const T& value,const tFlag& order) {
        return search(mVector,value,order);
    }
    void permute(const tUIndex& i,const tUIndex&j);
  
    void reverse();

  
    
  
 
    virtual tString toString() const {
        tString ret=getIdentityString()+"(";
        typename vector<T>::const_iterator it=mVector.begin();
        for (it=mVector.begin();it!=mVector.end();it++) {
            ret+=CORE_String::toString(*it)+",";
        }
        ret+=")";
        return ret;
    }
    
  
};

#include "CORE_Vector.hpp"

typedef CORE_Vector<tBoolean> CORE_BooleanVector;
typedef CORE_Vector<tChar> CORE_CharVector;
typedef CORE_Vector<tInt> CORE_IntVector;
typedef CORE_Vector<tReal> CORE_RealVector;
typedef CORE_Vector<tComplex> CORE_ComplexVector;
typedef CORE_Vector<tFlag> CORE_FlagVector;
typedef CORE_Vector<tSInt> CORE_ShortVector;
typedef CORE_Vector<tString> CORE_StringVector;
typedef CORE_Vector<tInteger> CORE_IntegerVector;
typedef CORE_Vector<tUInteger> CORE_UIntegerVector;
typedef CORE_Vector<tUIndex> CORE_UIndexVector;

//share pointer of primitive type vector
TYPEDEF_SPTR(CORE_BooleanVector);
TYPEDEF_SPTR(CORE_CharVector);
TYPEDEF_SPTR(CORE_IntVector);
TYPEDEF_SPTR(CORE_RealVector);
TYPEDEF_SPTR(CORE_ComplexVector);
TYPEDEF_SPTR(CORE_FlagVector);
TYPEDEF_SPTR(CORE_UIntegerVector);
TYPEDEF_SPTR(CORE_IntegerVector);
TYPEDEF_SPTR(CORE_StringVector);
TYPEDEF_SPTR(CORE_ShortVector);
TYPEDEF_SPTR(CORE_UIndexVector);

#endif