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

Go to the documentation of this file.

#ifndef LAMA_MATRIX_HPP_
#define LAMA_MATRIX_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/Printable.hpp>
#include <lama/Distributed.hpp>

// others
#include <lama/LAMATypes.hpp>
#include <lama/Scalar.hpp>
#include <lama/Vector.hpp>
#include <lama/Context.hpp>

#include <lama/distribution/Distribution.hpp>

// logging
#include <logging/logging.hpp>

namespace lama
{

// Forward declaration

class _MatrixStorage;

typedef boost::shared_ptr<class Matrix> MatrixPtr;

class LAMA_DLL_IMPORTEXPORT Matrix : public Printable,
    public Distributed
{

public:

    typedef const Matrix& ExpressionMemberType;

    Matrix( DistributionPtr rowDistribution, DistributionPtr colDistribution );

    Matrix( const IndexType numRows, const IndexType numColumns );

    Matrix( DistributionPtr distribution );

    explicit Matrix( const IndexType size );

    Matrix();

    Matrix( const Matrix& other, DistributionPtr rowDistribution, DistributionPtr colDistribution );

    Matrix( const Matrix& other );

    virtual ~Matrix();

    virtual const char* getTypeName() const = 0;

    std::auto_ptr<_LAMAArray> createArray() const;

    virtual void clear() = 0;

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

    virtual void allocate( DistributionPtr rowDistribution, DistributionPtr colDistribution ) = 0;

    virtual void setIdentity() = 0;

    virtual void assign( const Matrix& other ) = 0;

    virtual void assign( const _MatrixStorage& other ) = 0;

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

    virtual void buildLocalStorage( _MatrixStorage& storage ) const = 0;

    virtual void redistribute( DistributionPtr rowDistribution , DistributionPtr colDistribution ) = 0;

    virtual void getRow( Vector& row, const IndexType globalRowIndex ) const = 0;

    virtual void getDiagonal( Vector& diagonal ) const = 0;

    virtual void setDiagonal( const Vector& diagonal ) = 0;

    virtual void setDiagonal( const Scalar scalar ) = 0;

    virtual void scale( const Vector& scaling ) = 0;

    virtual void scale( const Scalar scaling ) = 0;

    Scalar operator()( IndexType i, IndexType j ) const;

    virtual Scalar getValue( IndexType i, IndexType j ) const = 0;

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

    inline IndexType getNumRows() const;

    inline IndexType getNumColumns() const;

    virtual IndexType getNumValues() const = 0;

    /* Returns the sparsity rate (#nnz/(#rows*#columns)) of the whole matrix */

    double getSparsityRate() const;

    virtual void matrixTimesVector(
        Vector& result, const Scalar alpha, const Vector& x,
        const Scalar beta, const Vector& y ) const = 0;

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

    virtual void matrixTimesMatrix(
        Matrix& result, const Scalar alpha, const Matrix& B,
        const Scalar beta, const Matrix& C ) const = 0;

    virtual void matrix2CSRGraph( IndexType* xadj, IndexType* adjncy, IndexType* vwgt, CommunicatorPtr comm,
                                  const IndexType* globalRowIndices = NULL, IndexType* vtxdist = NULL ) const;

    virtual IndexType getLocalNumValues() const = 0;

    virtual IndexType getLocalNumRows() const = 0;

    virtual IndexType getLocalNumColumns() const = 0;

    inline const Distribution& getColDistribution() const;

    inline DistributionPtr getColDistributionPtr() const;

    virtual void setContext( const ContextPtr context ) = 0;

    virtual void setContext( const ContextPtr localContext, const ContextPtr haloContext);

    virtual ContextPtr getContextPtr() const = 0;

    const Context& getContext() const { return *getContextPtr(); }

    typedef enum
    {
        ASYNCHRONOUS,
        SYNCHRONOUS
    } SyncKind;

    typedef enum
    {
        DENSE,   
        SPARSE   
    } MatrixKind;

    virtual MatrixKind getMatrixKind() const = 0;

    inline SyncKind getCommunicationKind() const;

    inline SyncKind getComputeKind() const;

    void setCommunicationKind( SyncKind communicationKind );

    virtual void setComputeKind( SyncKind computeKind );

    void inheritAttributes( const Matrix& other );

    virtual void prefetch() const = 0;

    virtual void wait() const = 0;

    Matrix& operator=( const Matrix& other );

    Matrix& operator=( Expression<Scalar, Matrix, Times> exp );

    Matrix& operator=( Expression<Matrix, Matrix, Times> exp );

    Matrix& operator=( Expression<Scalar, Expression<Matrix, Matrix, Times>, Times> exp );

    Matrix& operator=( Expression< Expression< Scalar, Expression< Matrix, Matrix, Times>, Times>,
                       Expression< Scalar, Matrix, Times>, Plus> exp );

    virtual void invert( const Matrix& other ) = 0;

    virtual Scalar maxDiffNorm( const Matrix& other ) const =0;

    virtual std::auto_ptr<Matrix> create() const = 0;

    std::auto_ptr<Matrix> create( const IndexType numRows, const IndexType numColumns ) const;

    std::auto_ptr<Matrix> create( const IndexType size ) const;

    std::auto_ptr<Matrix> create( DistributionPtr rowDistribution, DistributionPtr colDistribution ) const;

    std::auto_ptr<Matrix> create( DistributionPtr distribution ) const;

    VectorPtr createDenseVector( DistributionPtr distribution, const Scalar value ) const;

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

    virtual Scalar::ScalarType getValueType() const = 0;

    virtual bool hasDiagonalProperty() const = 0;

    virtual void resetDiagonalProperty() = 0;

    virtual size_t getMemoryUsage() const = 0;

protected:

    void setReplicatedMatrix( const IndexType numRows, const IndexType numColumns );

    void setDistributedMatrix( DistributionPtr distribution, DistributionPtr colDistribution );

    DistributionPtr mColDistribution;

    //TODO: remove mNumRows and mNumColumns, this value is stored in the distribution
    IndexType mNumRows;
    IndexType mNumColumns;

protected:

    void checkSettings();   // check valid member variables

    void swapMatrix( Matrix& other );  // swap member variables of Matrix

    LAMA_LOG_DECL_STATIC_LOGGER( logger );

private:

    void setDefaultKind();  // set default values for communication and compute kind

    SyncKind mCommunicationKind;
    SyncKind mComputeKind;
};

/* ======================================================================== */
/*             Inline methods                                               */
/* ======================================================================== */

inline IndexType Matrix::getNumRows() const
{
    //return getDistributionPtr().get()->getGlobalSize();
    return mNumRows;
}

inline IndexType Matrix::getNumColumns() const
{
    //return getColDistributionPtr().get()->getGlobalSize();
    return mNumColumns;
}

inline Matrix::SyncKind Matrix::getCommunicationKind() const
{
    return mCommunicationKind;
}

inline Matrix::SyncKind Matrix::getComputeKind() const
{
    return mComputeKind;
}

inline const Distribution& Matrix::getColDistribution() const
{
    LAMA_ASSERT_ERROR( mColDistribution, "NULL column distribution for Matrix" );
    return *mColDistribution;
}

inline DistributionPtr Matrix::getColDistributionPtr() const
{
    LAMA_ASSERT_ERROR( mColDistribution, "NULL column distribution for Matrix" );
    return mColDistribution;
}

inline std::ostream& operator<<( std::ostream& stream, const Matrix::SyncKind& kind )
{
    switch ( kind )
    {
        case Matrix::SYNCHRONOUS:
        {
            stream << "SYNCHRONOUS";
            break;
        }
        case Matrix::ASYNCHRONOUS:
        {
            stream << "ASYNCHRONOUS";
            break;
        }
        default:
        {
            stream << "<unknown sync kind>";
            break;
        }
    }

    return stream;
}

}

#endif // LAMA_MATRIX_HPP_