BlockMatrix.h

Go to the documentation of this file.

#ifndef BLOCKMATRIX_H
#define BLOCKMATRIX_H


//#include <iostream> schon dabei
//#include <fstream> schon dabei
//#include "random.h" schon dabei
//#include <string> schon dabei

#ifndef BLOCKMATRIX_DECLARACION
#define BLOCKMATRIX_DECLARACION

struct tPos;

struct tBlockPos
{
        int blockNr;
        int blockPos;

        tBlockPos(int _blockNr, int _blockPos): blockNr(_blockNr), 
                                                blockPos(_blockPos)
        {}
};




template <class TRing>
class TMatrix;


template <class TRing>
class BlockMatrix
{
        
        

public:
        typedef typename TRing::ElementType TNum;


protected:

        

                int     rows; 
                int             cols; 
        
                int             rowBlockSize; 
                int             colBlockSize;
        
                const TRing*    ring; 
        
        
                TNum*   data;   
                string  name;   
        
                int             extendedRowNum;  
                int             extendedColNum;  

                //int           blocksPerRow; ///< = (genuine col num)/colBlockSize
                //int           blocksPerCol;///< = (genuine row num)/rowBlockSize
public: 

        

                static int refit(int number, int multipleTo) ;


                BlockMatrix(    int             _rowBlockSize, 
                                int             _colBlockSize, 
                                int             _rows, 
                                int             _cols,  
                                const TRing*    _ring, 
                                string          _name = "unnamedMatrix" );
        
                BlockMatrix( const BlockMatrix& mat);
        
                //template <class TMatrix>
                //TMatrix(const TMatrix &mat, const TRing* _ring);
                void    fillZero();
                void    randomInit(long * randomSeed);  
                inline int      getColNum()       const {       return cols;    };
                inline int      getRowNum()       const {       return rows;    };

                inline int      getBlocksPerRow() const {       return extendedRowNum/rowBlockSize;     };
                inline int      getBlocksPerCol() const {       return extendedColNum/colBlockSize;     };


                inline int      getRowBlockSize() const {       return rowBlockSize;    };
                inline int      getColBlockSize() const {       return colBlockSize;    };

                inline int      getBlockNum()     const {       return getBlocksPerRow()*getBlocksPerCol();     };
                inline int      getBlockSize()    const {       return rowBlockSize*colBlockSize;       };

                size_t  getSize()         const {       return extendedRowNum*extendedColNum;   };

                bool    blocksAreSquare() const {       return rowBlockSize==colBlockSize;      };      

                std::string     getName() const {       return name;    };
                void    setName(string _name)   {       name = _name;   };
                void    checkBounds(int row, int col) const;
                void    checkBlockBounds(int _blockNum, int _blockPos) const;
                tBlockPos       computeBlockPos(int _row, int _col) const;
                tPos            computeNormalPos(int _blockNr, int _blockPos) const;
                inline void     setVal(const int row, const int col,const TNum z);
                        TNum    getVal(const int row, const int col) const;
        
                inline  TNum&   getValRef(const int row, const int col);
                const  TNum&    getConstValRef(const int row,const int col) const;      

                inline  void    setBlockVal(const int blockNr,const int blockPos,const TNum z);
                inline  TNum    getBlockVal(const int blockNr,const int blockPos);

                inline  TNum*   getBlockValAddr(const int blockNr, const int blockPos);
                
                bool            isZero();

                template <class TemplateMatrix> bool operator==(const TemplateMatrix& mat) const;

                //TMatrix*      operator*(TMatrix& mat);
        
                BlockMatrix&    operator=(const BlockMatrix& mat);
        
                //TVector<TRing>*       operator*(TVector<TRing>& vec);
                //TNum*         getDiag();
        
                //TVector<TRing>*       getTrace();

                //BlockMatrix*  getTransposed();

                TMatrix<TRing>*         unblock();

                void    outputMatrix(ostream & os) const;
                void    printValue(ostream & os) const;
        virtual ~BlockMatrix();
};



#endif //BLOCKMATRIX_DECLARACION


        #include "BlockMatrix.cpp"

#endif // end BLOCKMATRIX_H