SM_PackedBlockGeneralMatrix.h

#ifndef SM_PackedBlockGeneralMatrix_H
#define SM_PackedBlockGeneralMatrix_H
 
//base classes
#include "SM_PackedBlockMatrix.h"
 
 
template<typename T,tUCInt P>
class SM_PackedBlockGeneralMatrix : public SM_PackedBlockMatrix<T,P> {
 
public:
  
 
private :
 
    //type class
    typedef SM_PackedBlockMatrix<T,P>  SuperClass;
    typedef SM_PackedBlockGeneralMatrix<T,P> SelfClass;
    
    //single attributes
    //-----------------
    
    
    //multiple attributes
    //------------------
 
     //values of superior blocks of the matrix
    std::valarray<T> mBlocksValues;
   
 
    
    //single associations
    //-------------------
 
 
    //multiple associations
    //---------------------
 
    
   
protected:
    // CONSTRUCTORS 
    SM_PackedBlockGeneralMatrix(void) {
      
    }
    
    // DESTRUCTORS 
    virtual ~SM_PackedBlockGeneralMatrix(void) {
    }
   
    
public : 
 
    //Instance building
    //=================
 
   
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        mem+=mBlocksValues.size()*sizeof(T);
        return mem;
    }
 
    
    inline static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),
                                             SM_Object::Delete());
    }
 
    
public:
   
    //SET & GET
    //=========
 
    virtual void reset() final{
        memset(&mBlocksValues[0],0,mBlocksValues.size()*sizeof(T));
        
    }
    virtual void setSize(const tIndex& nRowBlocks,const tIndex& nColBlocks) final {
        SuperClass::setSize(nRowBlocks,nColBlocks);
        
        //number of elements of the sup block values
        tIndex s=nRowBlocks*nColBlocks*SM_PackedBlockMatrix<T,P>::BLOCK_SIZE;
        if (s!=mBlocksValues.size()) {
            try {
                mBlocksValues.resize(s);
                memset(&mBlocksValues[0],0,sizeof(T)*s);
            } catch (std::exception& e) {
                throw CORE_Exception("stochmagnet/operators/dipolar",
                                     "SM_PackedBlockGeneralMatrix::setSize("+std::to_string(nRowBlocks)+","+std::to_string(nColBlocks)+")",
                                     "not enough size to allocate "+std::to_string(s)+" elements for  matrix : memory size needed:  "+std::to_string((sizeof(T)*s)/(1024*1024*1024))+" Go");
            }
        }
        
    }
 
    virtual void setValue(const tIndex& i,const tIndex& j,const T& v) final {
        (*this)(i,j)=v;
    }
   
    virtual const T& getValue(const tIndex& i,const tIndex& j) const final {
        return (*this)(i,j);
    }
    virtual T& getValue(const tIndex& i,const tIndex& j)  final {
        return (*this)(i,j);
    }
    
public:
    
    inline std::valarray<T>& getBlocksValues() {
        return mBlocksValues;
    }
 
    inline const std::valarray<T>& getBlocksValues() const {
        return mBlocksValues;
    }
   
    
    
    //OPERATORS
    //==========
public:
    inline const T& operator()(tIndex i,tIndex j) const {
        //indices of the block : ib=i/P jb=j/P
        //index of the block index= ib x nColBlocks + jb
        //index of the element (ib x nColBlocks + jb) + getPackedIndex(i%P,j%P)
        return mBlocksValues[SM_PackedBlockMatrix<T,P>::GetPackedIndex(i%P,j%P)+(i/P)*this->getColumnBlocksNumber()+(j/P)];
    }
    
    inline T& operator()(tIndex i,tIndex j) {
        return mBlocksValues[SM_PackedBlockMatrix<T,P>::GetPackedIndex(i%P,j%P)+(i/P)*this->getColumnBlocksNumber()+(j/P)];
    }
  
 
   
   
private:
 
 
    
public:
  
    virtual void vectorProduct(const T* vX,T* vY) const;
    
public:
    
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<SuperClass::toString()<<"\n";
        //print matrix 6 first blocks
        ret<<"blocks values:"<<functions_array::toString(mBlocksValues)<<"\n";
        return ret.str();
    }
  
};
 
#include "SM_PackedBlockGeneralMatrix.hpp"
 
#endif