BlockMatrix.cpp

Go to the documentation of this file.

//-- Implementation

template <class TRing>
int BlockMatrix<TRing>::refit(const int number,const int multipleTo) 
{       
        assert(number>0);
        assert(multipleTo>0);

        int result    = number;
        int remainder = number % multipleTo;
        if (remainder !=0 )
                result += (multipleTo-remainder);
        return result;
}

template <class TRing>
BlockMatrix<TRing>::BlockMatrix(int             _rowBlockSize, 
                                int             _colBlockSize, 
                                int             _rows, 
                                int             _cols,  
                                const TRing*    _ring, 
                                string          _name  ):       rows(_rows),
                                                                cols(_cols),
                                                                rowBlockSize(_rowBlockSize),
                                                                colBlockSize(_colBlockSize),
                                                                ring(_ring),
                                                                name(_name),
                                                                extendedRowNum( refit(rows,_rowBlockSize) ),
                                                                extendedColNum( refit(cols,_colBlockSize) )
        
{

        assert (rows>0);
        assert (cols>0);
        
        assert (_rowBlockSize>0);
        assert (_colBlockSize>0);

        data            = NULL;
        
        data = new TNum[ getBlockNum() * getBlockSize() ];
        assert( data != NULL );
        
        fillZero();
}


template <class TRing>
BlockMatrix<TRing>::BlockMatrix(const BlockMatrix& mat ):       rows(mat.rows),
                                                                cols(mat.cols),
                                                                rowBlockSize(mat.rowBlockSize),
                                                                colBlockSize(mat.colBlockSize),
                                                                ring(mat.ring),
                                                                name(mat.name),
                                                                extendedRowNum(mat.extendedRowNum ),
                                                                extendedColNum(mat.extendedColNum )
        {

                data    = NULL;
                
                data = new TNum[ getBlockNum() * getBlockSize() ];
                #ifdef SAFE
                        assert (getBlockNum() * getBlockSize() ==getSize() );
                #endif
                assert( data != NULL );

                std::copy(mat.data, mat.data+getSize(), data);
                //for (size_t   dataPos = 0; dataPos < getSize(); dataPos++)
                //      data[dataPos] = mat.data[ dataPos ];
        }






template <class TRing>
BlockMatrix<TRing>::~BlockMatrix()
{
        if ( data!=NULL )
                delete[] data;
};



template <class TRing> 
void  BlockMatrix<TRing>::checkBounds(int row, int col) const
{
        if (row<0  || row>=rows || col<0  || col>=cols)
                        {
                                std::cerr << "BlockMatrix: bound error !" << std::endl;
                                std::cerr << "row " << row << " rows " << rows << std::endl;
                                std::cerr << "col " << col << " cols " << cols << std::endl;    
                                exit(0);
                        }
}


template <class TRing> 
void  BlockMatrix<TRing>::checkBlockBounds(int _blockNr, int _blockPos) const
{
        if (  _blockNr<0  || _blockNr >= getBlockNum() || _blockPos<0  || _blockPos>=getBlockSize())
                        {
                                std::cerr << "BlockMatrix: block bound error !" << std::endl;
                                std::cerr << "_blockNr " << _blockNr << " blocks " << getBlockNum() << std::endl;
                                std::cerr << " blockPos " << _blockPos << " blockSize " << getBlockSize() << std::endl; 
                                exit(0);
                        }
}




template <class TRing>
void BlockMatrix<TRing>::fillZero()
{               
        //assert( ((long)TNum::Zero) == 0 );
        //memset(data ,0x00, getSize()*sizeof(TNum) );
        std::fill(data, data+getSize(), TNum::Zero);
}



template <class TRing>
void BlockMatrix<TRing>::randomInit(long * _randomSeed )
{
        for (size_t     dataPos = 0; dataPos < getSize(); dataPos++)
        {
                data[ dataPos ] = ring->ConvertScalar( random( _randomSeed, ring->getCharacteristic()-1)   );
        }
}


template <class TRing>
 inline tBlockPos       BlockMatrix<TRing>::computeBlockPos(const int row, const int col) const
{
        int currRowBlock = row / getRowBlockSize();
        int currColBlock = col / getColBlockSize();

        int currBlock = currRowBlock*getBlocksPerRow() + currColBlock;

        
        int currSubMatrixRow = row % getRowBlockSize();
        int currSubMatrixCol = col % getColBlockSize();

        int currBlockPos = currSubMatrixRow*colBlockSize + currSubMatrixCol;

        #ifdef SAFE
                checkBlockBounds(currBlock,currBlockPos);
        #endif

        return tBlockPos(currBlock,currBlockPos);
}


template <class TRing>
 inline tPos    BlockMatrix<TRing>::computeNormalPos(const int _blockNr, const int _blockPos) const
{

        // x-coordinate of the block
        int currColBlock = _blockNr % getBlocksPerRow();

        // y-coordinate of the block
        int currRowBlock = _blockNr / getBlocksPerRow();
        
        // top-left- col coordinate of the block
        int col=currColBlock*getColBlockSize();

        // top-left- row coordinate of the block
        int row=currRowBlock*getRowBlockSize();

        // final col number
        col += _blockPos % colBlockSize;

        // final row number
        row += _blockPos / colBlockSize;

        #ifdef SAFE
                checkBounds(row,col);
        #endif

        return tPos(row,col);
}



template <class TRing>
inline void     BlockMatrix<TRing>::setVal(const int row, const int col, const TNum z)
{
        #ifdef SAFE
                checkBounds(row,col);
        #endif
        
        tBlockPos blockPos = computeBlockPos(row,col);

        data[ blockPos.blockNr*getBlockSize() + blockPos.blockPos ] =  z;
}





template <class TRing>
inline typename TRing::ElementType      BlockMatrix<TRing>::getVal(const int _row, const int _col) const
{
        #ifdef SAFE
                checkBounds(_row,_col);
        #endif
        tBlockPos blockPos = computeBlockPos(_row,_col);

        return data[ blockPos.blockNr*getBlockSize() + blockPos.blockPos ];
}


template <class TRing>
inline const typename TRing::ElementType&       BlockMatrix<TRing>::getConstValRef(const int _row,const int _col) const
{
        #ifdef SAFE
                checkBounds(_row,_col);
        #endif
        tBlockPos blockPos = computeBlockPos(_row,_col);

        return data[  blockPos.blockNr*getBlockSize() + blockPos.blockPos ];
}


template <class TRing>
inline typename TRing::ElementType &    BlockMatrix<TRing>::getValRef(const int _row,const int _col) 
{
        #ifdef SAFE
                checkBounds(_row,_col);
        #endif
        tBlockPos blockPos = computeBlockPos(_row,_col);
        return  data[ blockPos.blockNr*getBlockSize() + blockPos.blockPos ];
}


template <class TRing>
inline  typename TRing::ElementType *   BlockMatrix<TRing>::getBlockValAddr(const int _blockNr, const int _blockPos) 
{
        #ifdef SAFE
                checkBlockBounds(_blockNr,_blockPos);
        #endif
        return &(data[ _blockNr*getBlockSize() + _blockPos ]);
}

template <class TRing>
inline  typename TRing::ElementType     BlockMatrix<TRing>::getBlockVal(const int _blockNr, const int _blockPos)
{
        #ifdef SAFE
                checkBlockBounds(_blockNr,_blockPos);
        #endif
        return data[ _blockNr*getBlockSize() + _blockPos ];
}

template <class TRing>
inline  void    BlockMatrix<TRing>::setBlockVal(const int _blockNr, const int _blockPos,const TNum z)
{
        #ifdef SAFE
                checkBlockBounds(_blockNr,_blockPos);
        #endif
        data[ _blockNr*getBlockSize() + _blockPos ] = z;
}





template <class TRing>
template <class TemplateMatrix >
bool    BlockMatrix<TRing>::operator==(const TemplateMatrix & mat) const
{       
        if ( rows != mat.getRowNum() || cols != mat.getColNum() )
                return false;

        
        for (int row=0; row<rows; row++)
        {
                for (int col=0; col<cols; col++)
                {
                        if ( getVal(row,col) != mat.getVal(row,col) )
                                return false;
                }
        }
        return true;
}



template <class TRing>
BlockMatrix<TRing>&     BlockMatrix<TRing>::operator=(const BlockMatrix<TRing>& mat)
{

        if (this!=&mat)
        {
                ring  = mat.ring ;
                delete [] data;

                
                rows = mat._rows;
                cols = mat.cols;
                rowBlockSize = mat.rowBlockSize;
                colBlockSize = mat.colBlockSize;
                
                name = mat.name;
                extendedRowNum = mat.extendedRowNum;
                extendedColNum = mat.extendedColNum ;


                data            = NULL;
                
                data = new TNum[ getBlockNum() * getBlockSize() ];
                assert( data != NULL );
                assert( getBlockNum() * getBlockSize() == getSize() );
                //for (size_t   dataPos = 0; dataPos < getSize(); dataPos++)
                //      data[dataPos] = mat.data[ dataPos ];
                std::copy(mat.data, mat.data+getSize(), data);
        }
        return *this;
}




template <class TRing>
TMatrix<TRing>*  BlockMatrix<TRing>::unblock()
{

        TMatrix<TRing>* erg = new TMatrix<TRing>(rows,cols, this->ring);


        for (register int row=0;row<rows; row++)
        {
                for (register int col=0; col<cols; col++)
                {
                        erg->setVal(row, col, getVal(row, col) );
                }
        }
        return erg;

        /*int Block=0;

        for (register int h=0; h<blocksPerCol; h++) // j-blocks
        {
                int tmp=blocksize*h;

                for (register int l=0; l<blocksPerRow; l++) // k-blocks
                { 
                        int tmp2    = blocksize*l;

                        int BlockPos = 0;
                        for (int row=tmp; row<tmp+blocksize; row++)
                        {
                                for (int col=tmp2; col<tmp2+blocksize; col++)
                                {
                                        erg->setVal(row,col, getBlockVal(Block,BlockPos) );
                                        BlockPos++;
                                }
                        }
                        Block++;
                }
                
        }*/
}


template <class TRing>
bool   BlockMatrix<TRing>::isZero()
{
        for (size_t  i=0; i<getSize(); i++)
        {
                if (   !(data[i].isZero() )    ) 
                        return false;
        }
        return true;
}


template <class TRing>
void    BlockMatrix<TRing>::printValue(ostream & os) const
{
        
        os << std::endl << "{" ;
        for (int i=0; i<rows; i++)
        {
                if (i>0)
                {
                        os << ", " << std::endl;
                }
                os << "{";
                for (int j=0; j<cols; j++)
                {
                        if (j>0)
                        {
                                os << ", ";
                        }
                        os <<  getVal(i,j);
                        
                }
                os << "}" ;
        }               
        os << std::endl << "} ";
}


template <class TRing>
void BlockMatrix<TRing>::outputMatrix(ostream & os) const
{
        os << std::endl << name << " = " ;
        os  << "{" ;
        for (int i=0; i<rows; i++)
        {
                if (i>0)
                {
                        os << ", " << std::endl;
                }
                os << "{";
                for (int j=0; j<cols; j++)
                {
                        if (j>0)
                        {
                                os << ", ";
                        }
                        os << getVal(i,j);;
                }
                os << "}" ;
        }
        os << std::endl << "};" << std::endl;
}


template <class TRing> 
std::ostream &  operator<<(std::ostream & out, const BlockMatrix<TRing>& z)
{  
        z.outputMatrix(out);
        return out;
}