CORE_Array.h

Go to the documentation of this file.

#ifndef CORE_Array_H
#define CORE_Array_H


#include "CORE_Object.h"
#include "CORE_List.h"
#include "CORE_ListPointers.h"
#include "CORE_Exception.h"
#include "CORE_Integer.h"

#include "types.h"
#include <vector>

template <class T>
class CORE_Array : public CORE_Object {

    
private:
    // values of the array
    T* mValues;

    // size of the array
    tUIndex mSize; 

    // memory size of the array
    tUIndex mCapacity;


    //inidate if the values has been allocated within this class
    tBoolean mIsPrivateAllocated;
    

    // CONSTRUCTORS
public:
    CORE_Array() {
        mCapacity=0;
        mSize=0;
        mValues=null;
        mIsPrivateAllocated=false;
    }
    CORE_Array(const CORE_Array<T>& c) {
        mCapacity=0;
        mSize=0;
        mValues=null;
        mIsPrivateAllocated=false;
        copy(c);
    }
    CORE_Array(const tUIndex& n) {
        mCapacity=0;
        mSize=0;
        mValues=null;
        mIsPrivateAllocated=false;
        setSize(n);
    }
   
  

 
    // DESTRUCTORS
    virtual ~CORE_Array() {
        desallocate();
    }
  
 

    // -----------------------
    // shared pointer operator
    // ------------------------
public:
    void getSharedPointer(boost::shared_ptr<CORE_Array<T> >& p){
        SP::CORE_Object r;
        CORE_Object::getSharedPointer(r);
        p=boost::dynamic_pointer_cast<CORE_Array<T> >(r);       
    };
    void getSharedPointer( boost::shared_ptr<const CORE_Array<T> >& p) const{           
        SPC::CORE_Object r;
        CORE_Object::getSharedPointer(r);               
        p=boost::dynamic_pointer_cast<const CORE_Array<T> >(r);                         
    }; 
private:
    inline boost::shared_ptr<CORE_Array<T> > getThis() {
        boost::shared_ptr<CORE_Array<T> > p;
        getSharedPointer(p);
        return p;                               
    }; 
    inline  boost::shared_ptr<const CORE_Array<T> > getThis() const {                                   
        boost::shared_ptr<const CORE_Array<T> > p;
        getSharedPointer(p);
        return p;       
    };

    // ----------------
    // New constructors
    // ----------------
public:
    static inline boost::shared_ptr<CORE_Array<T> > New() {
        boost::shared_ptr<CORE_Array<T> > p(new CORE_Array<T>(),
                                            CORE_Object::Delete());
        p->setThis(p);
        return p;
    };  

    
    //Builder of array
    //================
private:
    
    void desallocate();
    
    void allocate(const tUIndex& cap);

public:

    void reserve(const tUIndex& cap) {
        if (mCapacity<cap) allocate(cap);
    }
    
    virtual void fitToSize();
    
    // ---------------------------
    // Accessor & basic operators
    // ---------------------------
public:
    inline const T& operator[](const tUIndex& i) const { 
        if (i>=mCapacity)
            throw CORE_Exception("common/core",
                                 "CORE_Array<T>["+CORE_Integer::toString(i)+"]",
                                 "index out of bounds [0,"+CORE_Integer::toString(mCapacity)+"[");
        return mValues[i];
    };
    inline T& operator[](const tUIndex& i)  { 
        if (i>=mCapacity)
            throw CORE_Exception("common/core",
                                 "CORE_Array<T>["+CORE_Integer::toString(i)+"]",
                                 "index out of bounds [0,"+CORE_Integer::toString(mCapacity)+"[");
        return mValues[i];
    };
    
    
    //copy operators
    //===============
    
   
    template<class Q>
    inline CORE_Array<T>& operator=(const Q& f) {
        initArray(f);
        return (*this);
    };
    
   
    
    //arithmetic operators
    //===================

   
    template<class Q>
    inline CORE_Array<T>& operator+=(const Q& f) {
        tUIndex i;
        T* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)+=(T)f;
            Ts++;
            
        }
        return (*this);
    }
    template<class Q>
    inline CORE_Array<T>& operator-=(const Q& f) {
        tUIndex i;
        T* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)-=(T)f;
            Ts++;
            
        }
        return (*this);
    }
    template<class Q>
    inline CORE_Array<T>& operator*=(const Q& f) {
        tUIndex i;
        T* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)*=(T)f;
            Ts++;
            
        }
        return (*this);
    }

    template<class Q>
    inline CORE_Array<T>& operator/=(const Q& f) {
        if (f==0) throw CORE_Exception("common/core","CORE_Array/=","division by 0");
        tUIndex i;
        T* Ts=&(*this)[0];
        for (i=0;i<mSize;i++) {
            (*Ts)/=(T)f;
            Ts++;
            
        }
        return (*this);
    }



    // SET Methods
    // ==================
    
  

    
    template<class Q>
    void copy(const CORE_Array<Q>& f);

    template<class Q>
    void copy(const CORE_Array<Q>* f) {
        if (f!=null) copy(*f);
    }
  
    
    inline void setSize(const tUIndex& n) {
        if (n>mCapacity) allocate(n); 
        mSize=n;
    }

   
    virtual void clear() {
        desallocate();
        mSize=0;
        mCapacity=0;
        mValues=null;
        mIsPrivateAllocated=false;
    }
   
  
    
    // set the values
    //===============
    template<class Q>
    inline void initArray(const Q& f) {
        if (mSize==0) return;
        if ( fabs((T)f) <=CORE_Object::getEpsilon<T>()) {
            memset(mValues,0,mSize*sizeof(*mValues));
        } else {
            tUIndex i=0;
            T *Ts=&(*this)[0];
            while (i<mSize) {
                *Ts=(T) f;
                Ts++;
                i++;
            }
        }
    }
    template<class Q>
    void initArray(const tUIndex& p,const Q B[]);

    template<class Q>
    inline void initArray(const vector<Q>& B) {
        setValues(B);
    }
    
    template<class Q>
    void initArray(const tUIndex& from,const tUIndex& to,const Q& Bx,const Q& By,const Q& Bz);

    template<class Q>
    void initArray(const tUIndex& from,const tUIndex& to,const tUIndex& p,const tUSInt& inc,const Q B[]);
    
    template<class Q>
    inline void initArray(const tUIndex& from,const tUIndex& to,const tUIndex& p,const Q B[]) {
        initArray(from,to,p,1,B);
    }
    
    void initArray(const tUIndex& from,const tString& values);
    
    inline void initArray(const tString& values) {
        initArray(0,values);
    }


    template<class Q>
    inline tBoolean setValuesByReference(const tUIndex& n,Q* array) {
        //verify Q & T have same size
        if (sizeof(T)!=sizeof(Q)) return false;
        
        desallocate();
        mValues=(T*) array;
        mSize=n;
        mCapacity=n;
        mIsPrivateAllocated=false;
        return true;
    }
    template<class Q>
    inline tBoolean transfertValuesByReference(CORE_Array<Q>& array) {
        //verify Q & T have same size
        if (sizeof(T)!=sizeof(Q)) return false;  

        //desallocate this
        desallocate();
        //copy the values of the array by reference into this
        mValues=array.getValues();
        mSize=array.getSize();
        mCapacity=array.getCapacity();
        mIsPrivateAllocated=true;
        //disable the desallocation of the values of the array
        array.mIsPrivateAllocated=false;
        return true;
    }
    
    template<class Q>
    inline void setValues(const tUIndex& n,const Q* v) {
        setSize(n);
        tUIndex i=0;
        T *Ts=&(*this)[0];
        const Q* cv=v;

        if (sizeof(T)==sizeof(Q)) {
            //copy a block of memory
            memcpy(Ts,v,n*sizeof(T));
        } else {
            //copy each value
            while (i<mSize) {
                *Ts=(T) (*cv);
                Ts++;
                cv++;
                i++;
            }
        }
    }
    template<class Q>
    inline void setValues(const vector<Q>& v) {
        setSize(v.size());
        if (v.size()!=0) {
            tUIndex i=0;
            T *Ts=&(*this)[0];
            typename vector<Q>::const_iterator cv=v.begin();
            while (i<mSize) {
                *Ts=(T) (*cv);
                Ts++;
                cv++;
                i++;
            }
            
        }
    }

    template<class Q>
    inline void setValues(const CORE_Array<Q>& v) {
        copy(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 set(const tReal& alpha,const CORE_Array<Q>& Y) {
        if (alpha==0) {
            initArray(0);
            return;
        }
        if (alpha==1) {
            copy(Y);
            return ;
        }
        tUIndex i,n=Y.getSize();
        //set the size to n
        setSize(n);
        if (n==0) return;
        
        const Q* Ys=&Y[0];
        T* Ts=&(*this)[0];
        for (i=0;i<n;i++) {
            (*Ts)=(T) (alpha * (*Ys) );
            Ts++;
            Ys++;
            
        }
        

    }
    virtual tULLInt getMemorySize() const {
        
        return (mIsPrivateAllocated)?0:mSize*sizeof(T);
            
    }
    
    inline T& get(const tUIndex& i) {
        return (*this)[i];
    }
    inline const T& get(const tUIndex& i) const {
        return (*this)[i];
    }


    inline tString getTypeToString() const {
        return CORE_Object::getTypeName<T>();
    }
    
    //mathematical operations
    //=========================
    template<class Q>
    void add(const tReal& alpha,const CORE_Array<Q>& Y,const tReal& beta) {
        if (alpha==0) {
            if (beta==0) {
                initArray(0);
                return;
            }
            if (beta==1) {
                return;
            }
            (*this)*=beta;
            return;
        }
        
        
        
        if (alpha==1){
            if (beta==0) {
                initArray(Y);
                return ;
            }
            if (beta==1) {
                add(Y);
                return;
            }
        }

        if (beta==1) {
            add(alpha,Y);
            return;
        }
        
        tUIndex j,i,q=Y.getSize();
        if (q==0) return;
        if (mSize==0) return;
        const Q* Ys=null;
        T* Ts=null;
        if (q>mSize) q=mSize;
        Ts=&(*this)[0];
        for (j=0;j<mSize;j+=q) {
            Ys=&Y[0];
            for (i=0;i<q;i++) {
                (*Ts)=(*Ts)*beta+((T) (alpha*(*Ys)));
                Ts++;
                Ys++;
            }
        } 
    }
    
    template<class Q>
    void add(const tReal& alpha,const CORE_Array<Q>& Y) {
        if (alpha==0) return;
        if (alpha==1) {
            add(Y);
            return ;
        }
        tUIndex j,i,q=Y.getSize();
        if (q==0) return;
        if (mSize==0) return;
        const Q* Ys=null;
        T* Ts=null;
        if (q>mSize) q=mSize;
        Ts=&(*this)[0];
        for (j=0;j<mSize;j+=q) {
            Ys=&Y[0];
            for (i=0;i<q;i++) {
                (*Ts)+=(T) (alpha*(*Ys));
                Ts++;
                Ys++;
            }
        } 
    }
    template<class Q>
    void add(const CORE_Array<Q>& Y) {
        tUIndex j,i,q=Y.getSize();
        if (q==0) return;
        if (mSize==0) return;
        const Q* Ys=null;
        T* Ts=null;
        if (q>mSize) q=mSize;
        Ts=&(*this)[0];
        for (j=0;j<mSize;j+=q) {
            Ys=&Y[0];
            for (i=0;i<q;i++) {
                (*Ts)+=(T) (*Ys);
                Ts++;
                Ys++;
            }
        }
      
    }
    
    template<class Q>
    void sub(const tReal& alpha,const CORE_Array<Q>& Y) {
        add(-alpha,Y);
    }
    template<class Q>
    void sub(const CORE_Array<Q>& Y) {
        tUIndex i,j,q=Y.getSize();
        //get the minimum of size
        if (q==0) return;
        if (mSize==0) return;
        const Q* Ys=null;
        T* Ts=null;
        if (q>mSize) q=mSize;
        
        Ts=&(*this)[0];
        for (i=0;i<mSize;i+=q) {
            Ys=&Y[0];
            for (j=0;j<q;j++) {
                (*Ts)-=(T) (*Ys);
                Ts++;
                Ys++;
            }
        }
       

    }
    template<class Q>
    void multiply(const CORE_Array<Q>& Y) {
        tUIndex i,j,q=Y.getSize();
        //get the minimum of size
        if (q==0) return;
        if (mSize==0) return;
        const Q* Ys=null;
        T* Ts=null;
        if (q>mSize) q=mSize;
        
        Ts=&(*this)[0];
        for (i=0;i<mSize;i+=q) {
            Ys=&Y[0];
            for (j=0;j<q;j++) {
                (*Ts)*=(T) (*Ys);
                Ts++;
                Ys++;
            }
        }
    }
    
    inline tReal max(tUIndex& k) const {
        tReal s=0;
        tReal tmp;
        k=0;
        const T* p=&mValues[0];
        for (tUIndex i=0;i<mSize;i++) {
            tmp=fabs(*p);
            if (tmp>s) {
                s=tmp;
                k=i;
            }
            p++;
        }
        return s;
    }
    inline tReal norm2() const {
        tReal s=0;
        const T* p=&mValues[0];
        for (tUIndex i=0;i<mSize;i++) {
            s+=(tReal)((*p)*(*p));
            p++;
        }
        return s;
    }
    inline tReal sum() const {
        tReal s=0;
        const T* p=&mValues[0];
        for (tUIndex i=0;i<mSize;i++) {
            s+=(*p);
            p++;
        }
        return s;
    }
   
    template<class Q>
    inline tReal dot(const CORE_Array<Q>& y) const {
        tReal s=0;
        tReal d;
        tUIndex i,j,q=y.getSize();
        //get the min of dimension
        q=(mSize<q)?mSize:q;
        
        //min dimension is null
        if (q==0) return  0;
        
        const T* px=&mValues[0];
        const Q* py=&y[0];
        
        for (i=0;i<mSize;i++) {
            s+=(*px)*(*py);
            px++;
            py++;
        }
        return s;
    };
    
    inline tReal norm() const{
        return sqrt(norm2());
    };

    
    template<class Q>
    inline tReal distance2(const CORE_Array<Q>& y) const {
        tReal s=0;
        tReal d;
        tUIndex i,j,q=y.getSize();
        if (mSize==0) return y.norm2();
        if (q==0) return  norm2();
        const T* px=&mValues[0];
        const Q* py=null;
        if (q>mSize) q=mSize;
        for (i=0;i<mSize;i+=q) {
            py=&y[0];
            for (j=0;j<q;j++) {
                d=((tReal)(*px))-((tReal)(*py));
                s+=d*d;
                px++;
                py++;
            }
        }
        return s;
    };
    template<class Q>
    inline tReal distanceMax(const CORE_Array<Q>& y,tUIndex& k) const {
        //distance of each points
        tReal d,dmax=0;

        //index of the max distance
        k=0;
        //size of y
        tUIndex i,j,q=y.getSize();

        //if this is empty, return the max of y
        if (mSize==0) return y.max(k);

        //if y is emptyn return the max of this
        if (q==0) return max(k);

        //iteration on values of this
        const T* px=null;
        px=&mValues[0];
        
        //iteration on values of y
        const Q* py=null;

        //compare only the values of this
        if (q>mSize) q=mSize;
       
        for (i=0;i<mSize;i+=q) {//loop on element of This by packs of elements of y for uniform value
            //pack of y
            py=&y[0];
            for (j=0;j<q;j++) {
                //compute teh distance
                d=fabs( ((tReal)(*px))-((tReal)(*py)));
                //take the max
                if (d>dmax) {
                    dmax=d;
                    k=i*q+j;
                }
                //next element of this
                px++;
                //next element of y
                py++;
            }
        }
       
        return dmax;
    };
    
    template<class Q>
    inline tReal distanceMax(const CORE_Array<Q>& y) const {
        tUIndex k;
        return distanceMax(y,k);
    }
    template<class Q>
    inline tReal distance(const CORE_Array<Q>& y) const{
        return sqrt(distance2(y));
    };
  

    
    // GET
    
    
    inline const T& getLastElement() const {
        if (mSize==0) throw CORE_Exception("common/core","CORE_Array::getLastElement()","no element in array");
        return mValues[mSize-1];
    }; 
    inline T& getLastElement()  {
        if (mSize==0) throw CORE_Exception("common/core","CORE_Array::getLastElement()","no element in array");
        return mValues[mSize-1];
    };
   

    inline const T* getValues() const {
        return mValues;
    }
    
    inline  T* getValues() {
        return mValues;
    }
    inline const T* getValues(tUIndex& n) const {
        n=mSize;
        return mValues;
    }
    
    inline  T* getValues(tUIndex& n) {
        n=mSize;
        return mValues;
    }
    inline  T& getValue(const tUIndex& i) {
        return (*this)[i];
    }
    inline  const T& getValue(const tUIndex& i) const {
        return (*this)[i];
    }

    inline void reverse() {
        tUIndex i,p=mSize/2;
        if (p==0) return;
        
        T* vi=&mValues[0];
        T* vf=&mValues[mSize-1];
        for (i=0;i<p;i++) {
            std::swap(*vi,*vf);
            vi++;
            vf--;
        }
    }

    inline void swap(CORE_Array<T>& f) {
        tUIndex i,p=mSize;

        if (p==0) return;
        
        if (f.getSize()!=p) throw CORE_Exception("common/core",
                                                 "CORE_Array::swap()",
                                                 "incompatibe size");
        
        T* vi=&mValues[0];
        T* vf=&f[0];
        for (i=0;i<p;i++) {
            std::swap(*vi,*vf);
            vi++;
            vf++;
        }
    }
protected:
    inline const tUIndex& getCapacity() const {return mCapacity;};
    
public:
    inline const tUIndex& getSize() const {
        return mSize;
    };
    inline tUIndex& getSize()  {
        return mSize;
    }; 
    
    
    
    // -------------
    // PRINT Methods
    // -------------
public:
    virtual tString toString() const; 


 
};

#include "CORE_Array.hpp"

typedef CORE_Array<tBoolean> CORE_BooleanArray;

typedef CORE_Array<tChar> CORE_CharArray;
typedef CORE_Array<tUChar> CORE_UCharArray;

typedef CORE_Array<tSInt> CORE_ShortArray;
typedef CORE_Array<tSInt> CORE_SIntArray;
typedef CORE_Array<tUSInt> CORE_USIntArray;

typedef CORE_Array<tInt> CORE_IntArray;
typedef CORE_Array<tUInt> CORE_UIntArray;

typedef CORE_Array<tLInt> CORE_LIntArray;
typedef CORE_Array<tULInt> CORE_ULIntArray;

typedef CORE_Array<tLLInt> CORE_LLIntArray;
typedef CORE_Array<tULLInt> CORE_ULLIntArray;

typedef CORE_Array<tFloat> CORE_FloatArray;
typedef CORE_Array<tDouble> CORE_DoubleArray;
typedef CORE_Array<tLDouble> CORE_LDoubleArray;

typedef CORE_Array<tDComplex> CORE_DoubleComplexArray;


typedef CORE_Array<tFlag> CORE_FlagArray;
typedef CORE_Array<tInteger> CORE_IntegerArray;
typedef CORE_Array<tUInteger> CORE_UIntegerArray;
typedef CORE_Array<tUIndex> CORE_UIndexArray;
typedef CORE_Array<tIndex> CORE_IndexArray;
typedef CORE_Array<tReal> CORE_RealArray;
typedef CORE_Array<tComplex> CORE_ComplexArray;


TYPEDEF_SPTR(CORE_BooleanArray);

TYPEDEF_SPTR(CORE_CharArray);
TYPEDEF_SPTR(CORE_UCharArray);

TYPEDEF_SPTR(CORE_ShortArray);
TYPEDEF_SPTR(CORE_SIntArray);
TYPEDEF_SPTR(CORE_USIntArray);

TYPEDEF_SPTR(CORE_IntArray);
TYPEDEF_SPTR(CORE_UIntArray);

TYPEDEF_SPTR(CORE_LIntArray);
TYPEDEF_SPTR(CORE_ULIntArray);

TYPEDEF_SPTR(CORE_LLIntArray);
TYPEDEF_SPTR(CORE_ULLIntArray);

TYPEDEF_SPTR(CORE_FloatArray);
TYPEDEF_SPTR(CORE_DoubleArray);
TYPEDEF_SPTR(CORE_LDoubleArray);

TYPEDEF_SPTR(CORE_DoubleComplexArray);

TYPEDEF_SPTR(CORE_FlagArray);
TYPEDEF_SPTR(CORE_IntegerArray);
TYPEDEF_SPTR(CORE_UIntegerArray);
TYPEDEF_SPTR(CORE_UIndexArray);
TYPEDEF_SPTR(CORE_IndexArray);
TYPEDEF_SPTR(CORE_RealArray);
TYPEDEF_SPTR(CORE_ComplexArray);


TYPEDEF_SVPTR(CORE_BooleanArray);

TYPEDEF_SVPTR(CORE_CharArray);
TYPEDEF_SVPTR(CORE_UCharArray);

TYPEDEF_SVPTR(CORE_ShortArray);
TYPEDEF_SVPTR(CORE_SIntArray);
TYPEDEF_SVPTR(CORE_USIntArray);

TYPEDEF_SVPTR(CORE_IntArray);
TYPEDEF_SVPTR(CORE_UIntArray);

TYPEDEF_SVPTR(CORE_LIntArray);
TYPEDEF_SVPTR(CORE_ULIntArray);

TYPEDEF_SVPTR(CORE_LLIntArray);
TYPEDEF_SVPTR(CORE_ULLIntArray);

TYPEDEF_SVPTR(CORE_FloatArray);
TYPEDEF_SVPTR(CORE_DoubleArray);
TYPEDEF_SVPTR(CORE_LDoubleArray);

TYPEDEF_SVPTR(CORE_DoubleComplexArray);

TYPEDEF_SVPTR(CORE_FlagArray);
TYPEDEF_SVPTR(CORE_IntegerArray);
TYPEDEF_SVPTR(CORE_UIntegerArray);
TYPEDEF_SVPTR(CORE_UIndexArray);
TYPEDEF_SVPTR(CORE_IndexArray);
TYPEDEF_SVPTR(CORE_RealArray);
TYPEDEF_SVPTR(CORE_ComplexArray);


#endif