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

Go to the documentation of this file.

#ifndef LAMA_SPARSE_MATRIX_HPP_
#define LAMA_SPARSE_MATRIX_HPP_

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

// base classes
#include <lama/matrix/Matrix.hpp>

// others
#include <lama/storage/MatrixStorage.hpp>

#include <lama/DenseVector.hpp>

namespace lama

{

// forward declarations

class Vector;
template<typename> class DenseMatrix;

class LAMA_DLL_IMPORTEXPORT _SparseMatrix: public Matrix
{
public:

    virtual const _MatrixStorage& getLocalStorage() const = 0;

    virtual const _MatrixStorage& getHaloStorage() const = 0;

    virtual const Halo& getHalo() const = 0;

    _SparseMatrix() : Matrix() 
    {}

    _SparseMatrix(const IndexType numRows, const IndexType numColumns) :

        Matrix( numRows, numColumns )
    {}

    _SparseMatrix( DistributionPtr rowDistribution, DistributionPtr colDistribution) :

        Matrix( rowDistribution, colDistribution )
    {}

    _SparseMatrix( DistributionPtr distribution ) :

        Matrix( distribution )
    {}

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

template<typename T>
class LAMA_DLL_IMPORTEXPORT SparseMatrix: public _SparseMatrix
{

    friend class SpecializedJacobi;

public:

    typedef T ValueType;

    static const char* typeName();

    virtual const char* getTypeName() const { return typeName(); }

    const MatrixStorage<ValueType>& getLocalStorage() const { return *mLocalData; };

    const MatrixStorage<ValueType>& getHaloStorage() const { return *mHaloData; };

    SparseMatrix( boost::shared_ptr<MatrixStorage<T> > storage );

    SparseMatrix( boost::shared_ptr<MatrixStorage<T> > storage,
                  DistributionPtr rowDist );

    SparseMatrix( boost::shared_ptr<MatrixStorage<T> > storage,
                  DistributionPtr rowDist, DistributionPtr colDist );

    SparseMatrix( boost::shared_ptr<MatrixStorage<T> > localData,
                  boost::shared_ptr<MatrixStorage<T> > haloData,
                  const Halo& halo,
                  DistributionPtr rowDist, DistributionPtr colDist );

    SparseMatrix( const Matrix& matrix, const bool transposeFlag = false );

    SparseMatrix( const Matrix& other, DistributionPtr rowDist, DistributionPtr colDist );

    SparseMatrix( const SparseMatrix<ValueType>& other );

    virtual void invert( const Matrix& other );

    virtual void setContext( const ContextPtr context )
    {
        setContext( context, context );
    }

    virtual void setContext( const ContextPtr localContext, const ContextPtr haloContext ) 
    {
        mLocalData->setContext( localContext );
        mHaloData->setContext( haloContext );
    }

    virtual ContextPtr getContextPtr() const { return mLocalData->getContextPtr(); }

    virtual const Context& getContext() const { return mLocalData->getContext(); }

    template<typename OtherValueType>
    void setRawDenseData( const IndexType numRows,
                          const IndexType numColumns,
                          const OtherValueType values[],
                          const OtherValueType eps = 0.0 );

    virtual void clear();

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

    virtual void allocate( DistributionPtr distribution, DistributionPtr colDistribution );

    virtual void setIdentity();

    virtual void assign( const Matrix& other );

    void assign( const _SparseMatrix& matrix );

    void assign( const _MatrixStorage& other );

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

    virtual void buildLocalStorage( _MatrixStorage& storage ) const;

    void swap( SparseMatrix<ValueType>& other );

    virtual ~SparseMatrix();

    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 scalar );

    virtual void scale( const Vector& scaling );

    virtual void scale( const Scalar scaling );

    //TODO: implement or delete
    //void setLocal( const MatrixStorage<ValueType>& newLocalData );

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

    void matrixTimesVectorImpl(
        DenseVector<ValueType>& result,
        const ValueType alpha,
        const DenseVector<ValueType>& x,
        const ValueType beta,
        const DenseVector<ValueType>& y ) const;

    virtual void matrixTimesVectorNImpl(
        DenseMatrix<ValueType>& result,
        const ValueType alpha,
        const DenseMatrix<ValueType>& x, 
        const ValueType beta,
        const DenseMatrix<ValueType>& y ) const;

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

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

    Scalar maxDiffNorm( const Matrix& other ) const;

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

    IndexType getLocalNumValues() const;

    /* Getter routine for the local number of rows and columns */

    IndexType getLocalNumRows() const;

    IndexType getLocalNumColumns() const;

    /* Getter routine returning the total num values of the whole distributed matrix */

    virtual IndexType getNumValues() const;

    /* Getter routine returning the num values of the local partition (local + halo) of the matrix */

    IndexType getPartitialNumValues() const;

    Scalar getValue( IndexType i, IndexType j ) const;

    const Halo& getHalo() const;

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

    virtual void prefetch() const;

    virtual void wait() const;

    virtual void setComputeKind( SyncKind computeKind );

    virtual bool hasDiagonalProperty() const;

    virtual void resetDiagonalProperty();

    virtual Scalar::ScalarType getValueType() const;

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

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

    void redistribute( DistributionPtr rowDistribution , DistributionPtr colDistribution );

    void assignTranspose ( const Matrix& matrix );

    virtual size_t getMemoryUsage() 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;

    void readFromFile( const std::string& filename );

    SparseMatrix& operator=( const SparseMatrix& matrix );

    SparseMatrix& operator=( const Matrix& matrix );

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

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

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

protected:

    void checkSettings();

    boost::shared_ptr<MatrixStorage<ValueType> > mLocalData; 

    boost::shared_ptr<MatrixStorage<ValueType> > mHaloData;  

    Halo mHalo; 

    void matrixTimesMatrixImpl( const ValueType alpha,
                                const SparseMatrix<ValueType>& A,
                                const SparseMatrix<ValueType>& B,
                                const ValueType beta,
                                const SparseMatrix<ValueType>& C ) ;
private:

    SparseMatrix();

    LAMA_LOG_DECL_STATIC_LOGGER( logger );

    void set( const MatrixStorage<ValueType>& otherLocalData, DistributionPtr otherDist );

    void assignTransposeImpl ( const SparseMatrix<ValueType>& matrix );

    //TODO: not implemented --> implement or delete
    //void computeHalo( const MatrixStorage<T>& localData, const Distribution& rowDistribution );

    void getLocalRow( DenseVector<ValueType>& row, const IndexType iLocal ) const;

    mutable LAMAArray<ValueType> mTemp; 

    mutable LAMAArray<ValueType> mTempSendValues; 
};

/* ------------------------------------------------------------------------- */

template<typename ValueType>
template<typename OtherValueType>
void SparseMatrix<ValueType>::setRawDenseData( const IndexType numRows,
                                               const IndexType numColumns,
                                               const OtherValueType values[],
                                               const OtherValueType eps )
{
    Matrix::setReplicatedMatrix( numRows, numColumns );  // sets global distributions

    mLocalData->setRawDenseData( numRows, numColumns, values, eps );
    mHaloData->allocate( numRows, 0 );
    mHalo = Halo();
}

}

#endif // LAMA_SPARSE_MATRIX_HPP_