EMM_Tensors.h

Go to the documentation of this file.

#ifndef EMM_Tensor_H
#define EMM_Tensor_H

#include "CORE_Object.h"
#include "CORE_Integer.h"
#include "CORE_Exception.h"
#include "CORE_MorseArray.h"

DEFINE_SPTR(EMM_Tensors);
class EMM_Tensors : public CORE_Object {
  
  
    SP_OBJECT(EMM_Tensors);
  
    // ATTRIBUTES
  
  
public:
 
    
private:

    tUSInt mDimension;
    CORE_RealMorseArray mValues;
   
    
protected:
    // METHODS
  
    // CONSTRUCTORS 
     
    EMM_Tensors() {
        mDimension=3;
    }
    
   
   
   
    
    
    // DESTRUCTORS 
    
    
    virtual ~EMM_Tensors(void) {
    }
    
   
public:
    
    // CONSTRUCTORS
  
   

    //operator
public:
   
    inline const tReal* operator[](const tUIndex& index) const {
        return mValues[index];
    }
    inline tReal* operator[](const tUIndex& index) {
        return mValues[index];
    }
   
    
   
public:
  
    //NEW

    inline SP::EMM_Tensors NewCopyInstance() const {
        SP::EMM_Tensors p=NewInstance();
        p->copy(*this);
        return p;
    }
    virtual SP::EMM_Tensors NewInstance() const=0;
    
    //SET methods
    
protected:
    virtual void copy(const EMM_Tensors& tensors) {
        mDimension=tensors.getDimension();
        mValues.copy(tensors.getValues());
    }

public:
    virtual void setDimension(const tUSInt& dim)  {
        mDimension=dim;
    }
    
    inline void setTensorsNumber(const tUIndex& n,const tUInteger& nPacks) {
        if (n==0) return;
      
        //set the morse array dimension
        mValues.setSize(n,getTensorSize(),nPacks);
           
    }
  
    inline void setTensorsNumber(const tUIndex& n) {
        setTensorsNumber(n,1);
        //init the indices
        tUSInt p=getTensorSize();
        tUIndex *indices=&mValues.getIndices()[0];
        tUIndex i,index=0;
        for (i=0;i<=n;i++) {
            (*indices)=index;
            //next i
            index+=p;
            indices++;
        }
    }
  
    inline void setUniformTensorsNumber(const tUIndex& n) {
        if (n==0) return;
        tUSInt p=getTensorSize();
        //set the morse array dimension
        mValues.setUniformSize(n,p);
        
    }

    inline void reset() {
        mValues.reset();
    }
    inline void init(const tUIndex& index,
                     const tReal& v) {
       
        tReal *vs=mValues[index];
        tUSInt n=getTensorSize();
        if (v==0.) memset(vs,0,n*sizeof(tReal));
        else {
            for (tUSInt i=0;i<n;i++) {
                *vs=v;
                vs++;
            }
        }
    }
    inline void init(const tUIndex& index,
                     const vector<tReal>& v) {
        tReal *vs=mValues[index];
        tUSInt i,n=getTensorSize();
        tUSInt nv=v.size();
        tUSInt m=(nv<n)?nv:n;
        vector<tReal>::const_iterator iv=v.begin();
        for (i=0;i<m;i++) {
            *vs=*iv;
            vs++;
            iv++;
        }
        if (m<n) memset(vs,0,(n-m)*sizeof(tReal));
        
       
    }
    inline void init(const tUIndex& index,
                     const tUSInt& nv,
                     const tReal* v) {
        tReal *vs=mValues[index];
        tUSInt i,n=getTensorSize();
        tUSInt m=(nv<n)?nv:n;
        const tReal *iv=v;
        for (i=0;i<m;i++) {
            *vs=*iv;
            vs++;
            iv++;
        }
        if (m<n) memset(vs,0,(n-m)*sizeof(tReal));
        
       
    }

    
    // GET methods 
public:
  
    virtual tULLInt getMemorySize() const {
        return mValues.getMemorySize();
    }
    inline const tUSInt& getDimension() const {
        return mDimension;
    }
    virtual tUSInt getTensorSize() const=0;

    inline const tUIndex& getTensorsNumber() const {
        return mValues.getSize();
    }
    
    inline const CORE_RealMorseArray& getValues() const {
        return mValues;
    }
    inline CORE_RealMorseArray& getValues()  {
        return mValues;
    }
  

    
    inline tBoolean isUniform() const {
        return mValues.isUniform();
    }

    inline tBoolean isNull(const tUIndex& i) const {
        return (mValues.getSize(i)==0);
    }
    inline tBoolean isNotNull(const tUIndex& i) const {
        return (mValues.getSize(i)!=0);
    }
    inline tBoolean saveToFile(const tString& fn) const {
        return mValues.saveToFile(fn);
    }
    inline tBoolean loadFromFile(const tString& fn)  {
        return mValues.loadFromFile(fn);
    }
   
    
    
    // STRING representation
    //=======================
    
    virtual tString toString() const {
        return getIdentityString()+":"+mValues.toString();
    }
   
};

#endif