Matrix3D.hpp

Go to the documentation of this file.

template <class TMatrix2D>
Matrix3D< TMatrix2D>::Matrix3D(unsigned int rows, unsigned int cols, unsigned int depth, 
        const typename TMatrix2D::RingType* ring, string name) :        rows_m(rows), 
                                                                        cols_m(cols) ,
                                                                        ring_m(ring),
                                                                        name_m (name)
{
        assert(rows>=0 && cols>=0 && depth>=0);

        matrix2DList_m.resize(depth);

        for (unsigned int i =0; i < depth; i++)
        {
                matrix2DList_m[i] = new TMatrix2D(rows_m, cols_m, ring_m);
        }
}



template <class TMatrix2D>
Matrix3D< TMatrix2D>::Matrix3D( unsigned int rows, unsigned int cols, 
                                const vector< TMatrix2D *> & matlist,
                                const typename TMatrix2D::RingType* ring, string name ): rows_m(rows), 
                                                                                        cols_m(cols) , 
                                                                                        ring_m(ring),
                                                                                        name_m (name)
{
        matrix2DList_m.resize( matlist.size() );
        for (unsigned int k =0; k < matlist.size(); k++)
        {
                assert( matlist[k]!=NULL);
                assert( *(matlist[k])->getColNum == cols_m ) ;
                assert( *(matlist[k])->getRowNum == rows_m ) ;
                assert( *(matlist[k])->getRing == ring_m )   ;
                matrix2DList_m[k] = matlist[k];
        }

}
template <class TMatrix2D>
void Matrix3D< TMatrix2D>::checkDimensions(unsigned int row, unsigned int col, unsigned int depth) const
{
        assert(depth<matrix2DList_m.size() );
        assert(row<rows_m );
        assert(col<cols_m );
}


template <class TMatrix2D>
const typename TMatrix2D::RingType*     Matrix3D< TMatrix2D>::getRing() const
{
        return ring_m;  
}


template <class TMatrix2D>
void    Matrix3D< TMatrix2D>::setName(string name )     
{
        name_m = name; return;  
};

template <class TMatrix2D>
std::string     Matrix3D< TMatrix2D>::getName(string name )     const
{
          return name_m;
};


template <class TMatrix2D>
unsigned int    Matrix3D< TMatrix2D>::getRowNum()       const   
{
        return rows_m;          
};


template <class TMatrix2D>
unsigned int    Matrix3D< TMatrix2D>::getColNum()       const   
{       
        return cols_m;          
};


template <class TMatrix2D>
unsigned int    Matrix3D< TMatrix2D>::getZNum()         const   
{
        return matrix2DList_m.size();           
};


template <class TMatrix2D>
void    Matrix3D< TMatrix2D>::setFrontalMatrix( unsigned int index, TMatrix2D * matrix)
{
        assert( index< matrix2DList_m.size() );
        assert( matrix != NULL );
        assert( ring_m == matrix->getRing() );
        

        assert( matrix->getColNum()==cols_m );
        assert( matrix->getRowNum()==rows_m );

        delete matrix2DList_m[index];

        matrix2DList_m[index]= matrix;
        
}

template <class TMatrix2D>
void    Matrix3D< TMatrix2D>::appendFrontalMatrix(  TMatrix2D * matrix)
{
        assert( matrix != NULL );
        assert( ring_m==matrix->getRing() );

        assert( matrix->getColNum()==cols_m );
        assert( matrix->getRowNum()==rows_m );

        matrix2DList_m.push_back( matrix);
}

/*
template <class TMatrix2D>
TMatrix2D *     Matrix3D< TMatrix2D>::getFrontalMatrix(   unsigned int index) 
{
        assert(index<matrix2DList_m.size() && index>=0);

        return matrix2DList_m[index];
}*/


template <class TMatrix2D>
const TMatrix2D &       Matrix3D< TMatrix2D>::getFrontalMatrixConstRef(   unsigned int index) const
{
        assert(index<matrix2DList_m.size() );

        return *(matrix2DList_m[index]);
}



template <class TMatrix2D>
TMatrix2D &     Matrix3D< TMatrix2D>::getFrontalMatrixRef(   unsigned int index)
{
        assert(index<matrix2DList_m.size() );

        return *(matrix2DList_m[index]);
}


template <class TMatrix2D >
Matrix3D< TMatrix2D >*  Matrix3D< TMatrix2D >::leftMultiply(
const TMatrix2D * mat) const
{
        assert( mat!=0 );
        assert( ring_m==mat->getRing() );

        assert( mat->getColNum()==rows_m );

        Matrix3D* res = new Matrix3D(mat->getRowNum(),cols_m, matrix2DList_m.size(), ring_m);

        for (unsigned int k =0; k < matrix2DList_m.size(); k++)
        {
                res->setFrontalMatrix(k, (*mat)*(*matrix2DList_m[k]) );
        }
        return res;
}


template <class TMatrix2D>
Matrix3D< TMatrix2D >*  Matrix3D< TMatrix2D>::rightMultiply(const TMatrix2D * mat) const
{
        assert( mat!=0 );
        assert( ring_m==mat->getRing() );

        assert( mat->getRowNum()==cols_m );

        Matrix3D* res = new Matrix3D( rows_m,mat->getColNum(), matrix2DList_m.size(), ring_m);

        for (unsigned int k =0; k < matrix2DList_m.size(); k++)
        {
                res->setFrontalMatrix(k, (*matrix2DList_m[k])*(*mat) );
        }
        return res;
}


template <class TMatrix2D>
void    Matrix3D< TMatrix2D>::setVal(unsigned int row, unsigned int col, unsigned int z, typename TMatrix2D::ElementType val)   
{
        checkDimensions(row,col,z);

        matrix2DList_m[z]->setVal(row,col,val);
}


template <class TMatrix2D>
typename TMatrix2D::ElementType  Matrix3D< TMatrix2D>::getVal(unsigned int row, unsigned int col, unsigned int z)        const
{
        checkDimensions(row,col,z);
        return matrix2DList_m[z]->getVal(row,col);
}


template <class TMatrix2D>
Matrix3D< TMatrix2D>*   Matrix3D< TMatrix2D>::getTransversalForm() const
{
        Matrix3D * transversal3DMat = new Matrix3D(matrix2DList_m.size(), cols_m, rows_m, ring_m );

        for (unsigned int i =0; i < rows_m; i++)
        {
                for (unsigned int j =0; j < cols_m; j++)
                {
                        for (unsigned int k=0 ;k < matrix2DList_m.size(); k++)
                        {
                                transversal3DMat->setVal(k ,   j, i ,  getVal(i , j , k)     );
                        }       
                }
        }
        return transversal3DMat;
}

template <class TMatrix2D>
void  Matrix3D< TMatrix2D>::printTransversalView() const
{

        Matrix3D * transversal3DMat = getTransversalForm();
        
        transversal3DMat->print3DMatrix();
        delete transversal3DMat;
}


template <class TMatrix2D>
void  Matrix3D< TMatrix2D>::print3DMatrix(ostream & os) const
{
        os  << " --3DMatrix " << name_m  << std::endl;
        os <<  "{"   << std::endl;
        for (unsigned int i=0; i<matrix2DList_m.size(); i++)
        {
                if (i>0)
                os  << ",";
                os  << "--k = " << i << std::endl;
                os << *(matrix2DList_m[i]) << std::endl;
                
        }       
        os << "}"   << std::endl;
} 


template <class TMatrix2D>
inline  Matrix3D<TMatrix2D>*            Matrix3D< TMatrix2D>::computeFrontalMatrixBasis(  ) const
{
        
        Matrix3D< TMatrix2D >* frontalMatrixBasis =  new Matrix3D< TMatrix2D >(rows_m, cols_m, 0,  ring_m, "FrontalMatrixBasis" ) ;
        
        
        unsigned int matrixSize = rows_m * cols_m;

        unsigned int matrixCount = getZNum();
        
        TMatrix2D  matricesAsRows(matrixCount, matrixSize, ring_m ,"matricesAsRows" );
        
        for (unsigned int z=0; z < matrixCount ; z++)
        {
                TVector<typename TMatrix2D::RingType> * matrix_i_AsVector = getFrontalMatrixConstRef(z).convertToVector();

                for (unsigned int col=0; col < matrixSize ; col++)
                {
                        matricesAsRows.setVal(z,col, matrix_i_AsVector->getVal(col) );
                }
                delete matrix_i_AsVector;
        }
        

        TMatrix2D * independentMatricesAsRows = matricesAsRows.getRowEchelonForm(); //Funktion gibt es auch in FFPAck, allerdings weiss ich nicht, wie man diese benutzt.

        independentMatricesAsRows->setName("independentMatricesAsRows");
        #ifdef DEBUG
                //std::cerr << "matricesAsRows" << std::endl << matricesAsRows << std::endl;
                //std::cerr << "independentMatricesAsRows" << std::endl << * independentMatricesAsRows << std::endl;
        #endif
        unsigned int independentMatricesCount   = independentMatricesAsRows->getRank();

        // da die RowEchelon-form eventuell nicht korrekt sortiert ist, laufe ueber alle Zeilen der ZeilenstufenFormMatrix;
        for (unsigned int z=0; z < independentMatricesAsRows->getRowNum() ; z++)
        {
                TVector<typename TMatrix2D::RingType> * matrixAsVector = independentMatricesAsRows->getRowAsVector(z);
                if ( matrixAsVector->isNotZero() )
                {
                //      std::cerr << "matrixAsVector " << std::endl << * matrixAsVector << std::endl;
                        TMatrix2D * fm = new TMatrix2D(rows_m, cols_m, ring_m, *(matrixAsVector) );
                //      std::cerr << "fm " << std::endl << * fm << std::endl;
        
                        frontalMatrixBasis->appendFrontalMatrix( fm ) ;
                }
                delete matrixAsVector;
        }
        assert(independentMatricesCount == frontalMatrixBasis->getZNum() );

        delete independentMatricesAsRows;

        return frontalMatrixBasis;
}




template <class TMatrix2D>
void  Matrix3D< TMatrix2D>::print3DMatrix() const
{       
        print3DMatrix(std::cerr);
}


template <class TMatrix2D>
void    Matrix3D< TMatrix2D>::clear()
{
        for (unsigned int i=0; i<matrix2DList_m.size(); i++)
        {
                delete matrix2DList_m[i];
        }
        matrix2DList_m.resize(0);
        
}


template <class TMatrix2D>
Matrix3D< TMatrix2D>::~Matrix3D()
{
        for (unsigned int i=0; i<matrix2DList_m.size(); i++)
        {
                delete matrix2DList_m[i];
        }
}


template <class TMatrix2D>
std::ostream &  operator<<(std::ostream & out, const Matrix3D< TMatrix2D> & z)
{  
        z.print3DMatrix(out);
        return out;
}