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"
using namespace std;



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

    int mIterator;
  

  
    // CONSTRUCTORS
public:
    CORE_Vector();  

    CORE_Vector(const int& 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 int& 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:

    inline const T& operator[](int i) const { 
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        return mVector[(int)i];
    };
   
    inline T& operator[](int i)  {
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        return mVector[(int)i];
    };

    
    // SET
   
    inline void setValue(const int& i,const T& v) {
        mVector[i]=v;
    };

    inline void setSize(const int& n){
        mVector.resize(n);
    };
    inline void setCapacity(const int& n){
        mVector.reserve(n);
    };

    inline void initValues(const T& v) {
        int n=mVector.size();
        for(int i=0;i<n;i++) mVector[i]=v;
    }; 
    inline void divideBy(const tReal& v) {
        int dim=getSize();
        for(int i=0;i<dim;i++) mVector[i]/=v;
    }  
    inline void multiplyBy(const tReal& v) {
        int dim=getSize();
        for(int i=0;i<dim;i++) mVector[i]*=v;
    } 
    void addAfterIndex(const int& index,const T& v);
  
    void addAfterIndices(boost::shared_ptr<CORE_Vector<int> >& p_indices,
                         const CORE_SharedPointersList<CORE_Vector<T> >& values);

    inline void add(const CORE_Vector<T>& v) {
        add(1,v);
    }; 
    inline void normalize() {
        tReal n=norm();
        if (n>0) divideBy(n);
    };
    inline void add(const tReal& f,const CORE_Vector<T>& v) {
        int n=mVector.size();
        int p=v.getSize();
        int dim=(n<p)?n:p;
        for(int i=0;i<dim;i++) mVector[i]+=f*v[i];
    };  
 
    inline void sub(const CORE_Vector<T>& v) {
        sub(1,v);
    };
    inline void sub(const CORE_Vector<T>& u,const CORE_Vector<T>& v) {
        int n=mVector.size();
        int p=v.getSize();
        int dim=(n<p)?n:p;
        for(int i=0;i<dim;i++) mVector[i]=u[i]-v[i];
    }; 
    inline void sub(const tReal& f,const CORE_Vector<T>& v) {
        int n=mVector.size();
        int p=v.getSize();
        int dim=(n<p)?n:p;
        for(int i=0;i<dim;i++) mVector[i]-=f*v[i];
    };
    template<class Y> void copy(const CORE_Vector<Y>& array) {
        int n=array.getSize();
        mVector.resize(n);
        for (int i=0;i<n;i++) mVector[i]=(T) array[i];
    } 
    template<class Y> void copy(const CORE_Vector<Y>* array) {
        if (array!=null) copy(*array); 
        else setSize(0);
    } 
    template<class Y> void copy(const  boost::shared_ptr<CORE_Vector<T> >& array) {
        copy(array.get());
    }
    template<class Y> void setValues(const vector<Y>& array) {
        int n=array.size();
        mVector.resize(n);
        for (int i=0;i<n;i++) mVector[i]=(T) array[i];
    } 
    template<class Y> void setValues(const Y* array,const int& n) {
        mVector.resize(n);
        for (int i=0;i<n;i++) mVector[i]=(T) array[i];
    }
  
    tBoolean set(int i,const T& obj);

    tBoolean insert(int i,const T& obj);  

    int insertInOrder(const T& obj,const tBoolean& evenIfEqual);  
    inline int insert(const T& obj){
        return insertInOrder(obj,false);
    };
  
  
    void add(const T& obj) {
        mVector.push_back(obj);
    };
  
    virtual void addInList(const T& obj) {
        add(obj);
    };
  
    void merge(const CORE_Vector<T>& array); 

    inline void sort(const tString& order) {
        sort(mVector,order);
    }; 
 
    static void sort(vector<T>& items,
                     const tString& order);
    tBoolean remove(const T& obj); 
  
    tBoolean removeAtIndex(const int& i);
  
  
    inline tBoolean remove() {
        return remove(size()-1);
    }; 
    inline void clear(){
        setSize(0);
        mVector.clear();
    };

    // GET 
    inline T& getLastElement() {
        ASSERT_IN(mVector.size()>0);
        return mVector[mVector.size()-1];
    };

    inline const T& get(int i) const {
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        return mVector[i];
    }; 

    inline T& get(int i) {
        ASSERT_IN(i>-1);
        ASSERT_IN(i<((int)mVector.size()));
        return mVector[i];
    };
  
    inline int size() const {return mVector.size();};
  
    inline int getSize() const {return mVector.size();}; 

    inline int getDimension() const {return mVector.size();};
  
 
    inline const T& getValue(const int& i) const {return mVector[i];};

    inline const vector<T>& getValues() const {return mVector;};
    inline vector<T>& getValues()  {return mVector;};
 
  
    tBoolean exists(const T& obj) const;

    inline vector<T>& getVector() {
        return mVector;
    };
    inline const vector<T>& getVector() const{
        return mVector;
    };

    static int search(const vector<T>& values,
                      const T& value,const tString& order);

    int search(const T& value,const tString& order) {
        return search(mVector,value,order);
    }
    
    // OTHERS


    void permute(const int& i,const int&j);
  
    void reverse();
  

    inline void begin() {
        mIterator=0;
    };
  
    inline tBoolean hasNext() const {
        return (mIterator<mVector.size());
    };
    inline T& next() {
        T& ret=mVector[mIterator];
        mIterator++;
        return ret;
    };


    // OPERATIONS
    template<class Q>
    inline tReal distance2(const CORE_Vector<Q>& a) const {
        int n=a.getSize();
        int m=getSize();
        int p=(n<m)?n:m;
        tReal d=0;
        tReal t=0;
        for (int i=0;i<p;i++) {
            t=((T)a[i])-mVector[i];
            d+=t*t;
        }
        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>& a) const {
        int n=a.getSize();
        int m=getSize();
        int p=(n<m)?n:m;
        tReal s=0;
        for (int i=0;i<p;i++) 
            s+=((T)a[i])*mVector[i];
        return s;
    };
    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)  {
        int dim_a=a.getSize();
        int dim_b=b.getSize();
        int dim=(dim_a<dim_b)?dim_a:dim_b;
        if (dim==3) {
            res.setSize(3);
            res[0]=a[1]*b[2]-a[2]*b[1];
            res[1]=a[2]*b[0]-a[0]*b[2]; 
            res[2]=a[0]*b[1]-a[1]*b[0];
        } else{
            res.setSize(dim);
            for (int i=0;i<dim;i++) res[i]=0;
        }
    };
    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 {
        int p=getSize();
        tReal d=0;
        for (int i=0;i<p;i++) {
            d+=mVector[i]*mVector[i];
        }
        return d;
    }; 
 
    tReal norm() const {
        return sqrt(norm2());
    };

    virtual tString toString() const {
        int n=getSize();
        tString ret=getIdentityString()+"(";
        for (int i=0;i<n;i++) 
            ret+=CORE_String::toString(mVector[i])+",";
        ret+=")";
        return ret;
    }

  
  
};

#include "CORE_Vector.hpp"

typedef CORE_Vector<tBoolean> CORE_BooleanVector;
typedef CORE_Vector<tCharacter> CORE_CharacterVector;
typedef CORE_Vector<int> CORE_IntVector;
typedef CORE_Vector<tReal> CORE_RealVector;
typedef CORE_Vector<tComplex> CORE_ComplexVector;
typedef CORE_Vector<tFlag> CORE_FlagVector;
typedef CORE_Vector<tShort> CORE_ShortVector;
typedef CORE_Vector<tString> CORE_StringVector;
typedef CORE_Vector<tInteger> CORE_IntegerVector;
typedef CORE_Vector<tRelativeInteger> CORE_RelativeIntegerVector;

//share pointer of primitive type vector
TYPEDEF_SPTR(CORE_BooleanVector);
TYPEDEF_SPTR(CORE_CharacterVector);
TYPEDEF_SPTR(CORE_IntVector);
TYPEDEF_SPTR(CORE_RealVector);
TYPEDEF_SPTR(CORE_ComplexVector);
TYPEDEF_SPTR(CORE_FlagVector);
TYPEDEF_SPTR(CORE_RelativeIntegerVector);
TYPEDEF_SPTR(CORE_IntegerVector);
TYPEDEF_SPTR(CORE_StringVector);
TYPEDEF_SPTR(CORE_ShortVector);


#endif