SM_PackedBlockMatrix.h

#ifndef SM_PackedBlockMatrix_H
#define SM_PackedBlockMatrix_H
 
//base classes
#include "CORE_Object.h"
 
 
template<typename T,tUCInt P>
class SM_PackedBlockMatrix : public CORE_Object {
 
public:
    static constexpr tUCInt BLOCK_SIZE=P*(P+1)/2;
 
private :
 
    //type class
    typedef CORE_Object SuperClass;
    typedef SM_PackedBlockMatrix<T,P> SelfClass;
    
    //single attributes
    //-----------------
    
 
    tInteger mRowBlocksNumber;
    tInteger mColumnBlocksNumber;
    
    //single associations
    //-------------------
 
 
    //multiple associations
    //---------------------
 
    
   
protected:
    // CONSTRUCTORS 
    SM_PackedBlockMatrix(void) {
        mRowBlocksNumber=0;
        mColumnBlocksNumber=0;
    }
    
    // DESTRUCTORS 
    virtual ~SM_PackedBlockMatrix(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
   
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        return mem;
    }
 
public:
   
    //SET & GET
    //=========
 
    virtual void reset()=0;
       
    virtual void setSize(const tInteger& nRowBlocks,const tInteger& nColBlocks) {
        mRowBlocksNumber=nRowBlocks;
        mColumnBlocksNumber=nColBlocks;
    }
       
    inline const tInteger& getRowBlocksNumber() const {
        return mRowBlocksNumber;
    }
    inline const tInteger& getColumnBlocksNumber() const {
        return mColumnBlocksNumber;
    }
    virtual void setValue(const tIndex& i,const tIndex& j,const T& v)=0;
    
    virtual const T& getValue(const tIndex& i,const tIndex& j) const=0;
    
    virtual T& getValue(const tIndex& i,const tIndex& j)=0;
    
protected:
    
   
   
    
    
    //OPERATORS
    //==========
 
   
   
protected:
    inline static tIndex GetPackedIndex(const tIndex& i ,const tIndex& j) {
        ASSERT_IN(i<=j);
        tIndex index=j;
        index++;
        index*=j;
        index/=2;
        index+=i;
        return index;
    }
 
    
 
protected:
    inline static void  BlockVectorProduct(const T* B,
                                           const T* X,
                                           T* Y,const T *eY,
                                           const T* Xi,const T* Xj,T* Yi,T* Yj) {
 
        
        //X
        Xj=X;
        //Y
        Yj=Y;
        while (Yj!=eY) {//loop on j column
            //X[i]
            Xi=X;
            //Y[i]
            Yi=Y;
            while (Yi!=Yj) {//loop on i < j
                //Yi+=Bij.Xj
                //Yj+=Bij.Xi
                (*Yi)+=(*B)*(*Xj);
                (*Yj)+=(*B)*(*Xi);
                //next i
                Xi++;
                Yi++;
                B++;
            }
            
            //Yj+=Bjj.Xj
            (*Yj)+=(*B)*(*Xj);
 
            //next j
            B++;
            Yj++;
            Xj++;
        }
       
    }
public:
  
    virtual void vectorProduct(const T* vX,T* vY) const=0;
    
public:
    
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        ret<<"block size:"<<P<<"\n";
        ret<<"Rows number:"<<mRowBlocksNumber<<"\n";
        ret<<"Columns number:"<<mColumnBlocksNumber<<"\n";
        return ret.str();
    }
  
};
 
 
#endif