/home/brandes/workspace/LAMA/src/lama/matrix/DenseMatrix.hpp

Go to the documentation of this file.

#ifndef LAMA_DENSEMATRIX_HPP_
#define LAMA_DENSEMATRIX_HPP_

#include <boost/lexical_cast.hpp>
#include <boost/shared_ptr.hpp>

#include <lama/config.hpp>

#include <lama/matrix/CRTPMatrix.hpp>
#include <lama/matrix/SparseMatrix.hpp>

#include <lama/storage/DenseStorage.hpp>

namespace lama
{

template<typename T> class DenseVector;   // forward declaration

template<typename T>
class LAMA_DLL_IMPORTEXPORT DenseMatrix: public CRTPMatrix<DenseMatrix<T>, T >
{

public:

    typedef T ValueType;

    typedef boost::shared_ptr<DenseStorage<T> > DenseStoragePtr;

    static const char* typeName();

    DenseMatrix();

    DenseMatrix( const IndexType numRows, const IndexType numColumns );

    DenseMatrix( DistributionPtr rowDist, DistributionPtr colDist );

    explicit DenseMatrix( DistributionPtr dist );

    DenseMatrix( const DenseMatrix<ValueType>& other );

    DenseMatrix( const Matrix& other );

    DenseMatrix( const Matrix& other, DistributionPtr distribution, DistributionPtr colDistribution );

    DenseMatrix( const DenseMatrix<ValueType>& matrix, DistributionPtr distribution, DistributionPtr colDistribution );

    DenseMatrix( const _MatrixStorage& localData, DistributionPtr rowDist, DistributionPtr colDist );

    template<typename OtherValueType>
    DenseMatrix(
        const IndexType numRows,
        const IndexType numColumns,
        const IndexType numNoneZeros,
        const IndexType* const ia,
        const IndexType* const ja,
        const OtherValueType* const values );

    DenseMatrix( const Expression<Expression<Scalar,Expression<Matrix,Matrix,Times>,Times>,Expression<Scalar,Matrix,Times>,Plus> expression );

    DenseMatrix( const Expression<Matrix, Matrix, Times> expression );

    DenseMatrix( const Expression<Scalar,Expression<Matrix,Matrix,Times>,Times> expression );

    DenseMatrix( const Expression<Scalar,Matrix,Times> expression );

    DenseMatrix( const std::string& filename );

    virtual ~DenseMatrix();

    DenseMatrix& operator=( const DenseMatrix& matrix );

    DenseMatrix& operator=( const Matrix& matrix );

    DenseMatrix& operator=( const Expression<Scalar,Matrix,Times> expression );

    DenseMatrix& operator=( const Expression<Matrix,Matrix,Times> expression );

    DenseMatrix& operator=( const Expression<Scalar,Expression<Matrix,Matrix,Times>,Times> expression );

    DenseMatrix& operator=( const Expression<Expression<Scalar,Expression<Matrix,Matrix,Times>,Times>,Expression<Scalar,Matrix,Times>,Plus> expression );

    const char* getTypeName() const;

    Matrix::MatrixKind getMatrixKind() const { return Matrix::DENSE; }

    virtual void setContext( const ContextPtr context );

    using CRTPMatrix<DenseMatrix<T>, T >::setContext;   // setContext( localContext, haloContext )

    virtual ContextPtr getContextPtr() const { return mData[0]->getContextPtr(); }

    virtual void setIdentity();

    template<typename OtherValueType>
    void setRawDenseData( const IndexType numRows,
                          const IndexType numColumns,
                          const OtherValueType values[],
                          const OtherValueType eps = 0.0 ); 
 
    virtual void buildCSRData( LAMAArray<IndexType>& rowIA,
                               LAMAArray<IndexType>& rowJA,
                               _LAMAArray& rowValues ) const;

    virtual void setCSRData( const LAMAArray<IndexType>& rowIA,
                             const LAMAArray<IndexType>& rowJA,
                             const _LAMAArray& rowValues,
                             DistributionPtr rowDistribution,
                             DistributionPtr colDistribution );

    void setCSRDataLocal( const LAMAArray<IndexType>& rowIA,
                             const LAMAArray<IndexType>& rowJA,
                             const _LAMAArray& rowValues ) const;

    virtual void clear();

    virtual void allocate( const IndexType numRows, const IndexType numColumns );

    virtual void allocate( DistributionPtr rowDistribution, DistributionPtr colDistribution );

    virtual void assign( const Matrix& other );

    void swap( DenseMatrix<ValueType>& other );

    void assignSparse( const _SparseMatrix& other );

    void assign( const _MatrixStorage& storage );

    void assign( const _MatrixStorage& storage, DistributionPtr rowDist, DistributionPtr colDist );

    void assignLocal( const _MatrixStorage& other );

    virtual void buildLocalStorage( _MatrixStorage& storage ) const;

    void redistribute( DistributionPtr rowDistribution , DistributionPtr colDistribution );

    virtual void getDiagonal( Vector& diagonal ) const;
    virtual void getRow( Vector& row, const IndexType globalRowIndex ) const;
    virtual void setDiagonal( const Vector& diagonal );
    virtual void setDiagonal( const Scalar diagonalValue );
    virtual void scale( const Vector& values );
    virtual void scale( const Scalar value );

    Scalar getValue(lama::IndexType i, lama::IndexType j) const;

    void matrixTimesScalar( const Matrix& other, const Scalar alpha);

    void  matrixTimesVectorImpl( DenseVector<ValueType>& denseResult,
                                 const ValueType alphaValue,
                                 const DenseVector<ValueType>& denseX,
                                 const ValueType betaValue,
                                 const DenseVector<ValueType>& denseY ) const;

    /******************************************************************
    *   invert                                                        *
    ******************************************************************/

    virtual void invert( const Matrix& other );

    void invert() { this->invert( *this );  }

    Scalar maxDiffNorm( const Matrix& other ) const;

    ValueType maxDiffNormImpl( const DenseMatrix<ValueType>& other ) const;

    void matrixTimesMatrix( Matrix& result, const Scalar alpha, const Matrix& x,const Scalar beta, const Matrix& y) const;

    virtual void prefetch() const;
    void prefetch(lama::ContextPtr loc) const;
    void wait() const;

    const DenseStorage<ValueType>& getLocalStorage() const;

    DenseStorage<ValueType>& getLocalStorage();

    virtual IndexType getLocalNumValues() const;
    virtual IndexType getLocalNumRows() const;
    virtual IndexType getLocalNumColumns() const;

    //todo: no instantiation of these functions --> implement or delete
    //IndexType getNumLocalChunks( ) const;
    //IndexType getNumTotalChunks( ) const;

    virtual IndexType getNumValues() const;

    std::vector<DenseStoragePtr>& getCyclicLocalValues( );

    const std::vector<DenseStoragePtr>& getCyclicLocalValues( ) const;

    virtual bool hasDiagonalProperty() const;

    virtual void resetDiagonalProperty();

    virtual void writeAt( std::ostream& stream ) const;

    virtual Scalar::ScalarType getValueType() const;

    void writeToFile( const std::string& fileName,
                      const File::FileType fileType = File::BINARY,
                      const File::DataType dataType = File::INTERNAL,
                      const File::IndexDataType indexDataTypeIA = File::INT,
                      const File::IndexDataType indexDataTypeJA = File::INT ) const;
    virtual std::auto_ptr<Matrix> create() const;

    virtual std::auto_ptr<Matrix> copy() const;

    virtual size_t getMemoryUsage() const;

    std::vector<boost::shared_ptr<DenseStorage<ValueType> > > mData;

    using CRTPMatrix<DenseMatrix<T>, T >::getNumRows;
    using CRTPMatrix<DenseMatrix<T>, T >::getNumColumns;

    using CRTPMatrix<DenseMatrix<T>, T >::getDistribution;
    using CRTPMatrix<DenseMatrix<T>, T >::getDistributionPtr;
    using CRTPMatrix<DenseMatrix<T>, T >::getColDistribution;
    using CRTPMatrix<DenseMatrix<T>, T >::getColDistributionPtr;

    const std::vector<PartitionId>& getOwners() const { return mOwners; }

protected:

    using CRTPMatrix<DenseMatrix<T>, T >::mNumRows;
    using CRTPMatrix<DenseMatrix<T>, T >::mNumColumns;

    std::vector<PartitionId> mOwners;

private:

    void allocateData();
    
    /***************************************************************************
    *  Static Methods for dense storage                                        *
    ***************************************************************************/

    static void joinColumnData( DenseStorage<ValueType>& result,
                                const std::vector<boost::shared_ptr< DenseStorage<ValueType> > >& chunks,
                                const std::vector<IndexType>& columnOwners);

    static void splitColumnData( std::vector<boost::shared_ptr< DenseStorage<ValueType> > >& chunks,
                                 const DenseStorage<ValueType>& columnData,
                                 const PartitionId numChunks,
                                 const std::vector<IndexType>& columnOwners );


    static void localize( DenseStorage<ValueType>& local,
                          const DenseStorage<ValueType>& global,
                          const Distribution& rowDistribution );

    template<typename otherT>
    void copyDenseMatrix( const DenseMatrix<otherT>& other );

    template<typename OtherT>
    void getDiagonalImpl( DenseVector<OtherT>& diagonal ) const;

    void redistributeRows( DistributionPtr rowDistribution );

    void splitColumns( DistributionPtr colDistribution );

    void getRow( DenseVector<ValueType>& row, const IndexType i ) const;

    mutable LAMAArray<ValueType> mSendValues;
    mutable LAMAArray<ValueType> mReceiveValues;

    //todo: no implementation: implement or delete
    //void initChunks();  // common initialization for constructors

    LAMA_LOG_DECL_STATIC_LOGGER(logger);

    void computeOwners();

    void invertCyclic();
};

/*  template methods implementations */

template<typename ValueType>
template<typename OtherValueType>
void DenseMatrix<ValueType>::copyDenseMatrix( const DenseMatrix<OtherValueType>& other )
{
    // check for valid pointer, might be dynamic cast went wrong somewhere else

    LAMA_ASSERT_ERROR( &other, "NULL matrix in assignment operator" );

    LAMA_LOG_INFO( logger, "copy dense, this = " << this << ", other = " << &other );

    // inherit size and distributions

    Matrix::setDistributedMatrix( other.getDistributionPtr(), other.getColDistributionPtr() );

    mData.resize( other.mData.size() );

    IndexType n = static_cast<IndexType> ( other.mData.size() );

    for( IndexType i = 0; i < n; ++i )
    {
        LAMA_LOG_DEBUG( logger, "copy block " << i << " of " << n 
                        << " = " << *other.mData[i] );

        mData[i].reset( new DenseStorage<ValueType>( *other.mData[i] ) );
    }

    mOwners = other.getOwners();
}

template<typename ValueType>
template<typename OtherValueType>
void DenseMatrix<ValueType>::setRawDenseData( const IndexType numRows,
                                              const IndexType numColumns,
                                              const OtherValueType values[],
                                              const OtherValueType eps )
{
    allocate( numRows, numColumns );
    mData[0]->setRawDenseData( numRows, numColumns, values, eps );
}

template<typename ValueType>
template<typename OtherValueType>
DenseMatrix<ValueType>::DenseMatrix(
        const IndexType numRows,
        const IndexType numColumns,
        const IndexType numNoneZeros,
        const IndexType* const ia,
        const IndexType* const ja,
        const OtherValueType* const values )

   : CRTPMatrix<DenseMatrix<ValueType>, ValueType >( numRows, numColumns )
{
    mData.resize(1);
    mData[0].reset( new DenseStorage<ValueType>( mNumRows, mNumColumns) );
    mData[0]->setCSRData(numNoneZeros,ia,ja,values);
    computeOwners();
}

} // namespace lama

#endif // LAMA_DENSEMATRIX_HPP_