/home/brandes/workspace/LAMA/src/lama/storage/DenseStorage.hpp

Go to the documentation of this file.

#ifndef LAMA_DENSESTORAGE_HPP_
#define LAMA_DENSESTORAGE_HPP_

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

// base classes
#include <lama/storage/CRTPMatrixStorage.hpp>

// others
#include <lama/LAMAArray.hpp>
#include <lama/HostReadAccess.hpp>
#include <lama/HostWriteAccess.hpp>
#include <lama/Scalar.hpp>

#include <lama/openmp/OpenMPDenseUtils.hpp>

namespace lama
{

template<typename T> class DenseStorage;

template<typename T>
class LAMA_DLL_IMPORTEXPORT DenseStorageView : public CRTPMatrixStorage<DenseStorageView<T>, T>
{
public:

    typedef T ValueType;  

    static const char* typeName();

    DenseStorageView( LAMAArray<ValueType>& data, 
                     const IndexType numRows, 
                     const IndexType numColumns,
                     bool initializedData = true );

    virtual ~DenseStorageView();

    virtual DenseStorageView<ValueType>* copy() const;

    virtual DenseStorageView<ValueType>* create() const;

    void check( const char* msg ) const;

    virtual void assign( const _MatrixStorage& other );

    virtual Scalar::ScalarType getValueType() const;

    virtual MatrixStorageFormat getFormat() const;

    void setIdentity( const IndexType size );

    void setIdentity();

    void setZero();

    template<typename OtherValueType>
    void setCSRDataImpl( const IndexType numRows,
                         const IndexType numColumns,
                         const IndexType numValues,
                         const LAMAArray<IndexType>& ia,
                         const LAMAArray<IndexType>& ja,
                         const LAMAArray<OtherValueType>& values,
                         const ContextPtr loc );

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

    ValueType getValue( IndexType i, IndexType j ) const;

    void prefetch( const ContextPtr location ) const;

    void wait() const;

    LAMAArray<ValueType>& getData();

    const LAMAArray<ValueType>& getData() const;

    virtual IndexType getNumValues() const;

    virtual void clear()
    {
        mNumRows = 0;
        mNumColumns = 0;
        mData.clear();
    }

    virtual void purge()
    {
        mNumRows = 0;
        mNumColumns = 0;
        mData.purge();
    }

    template<typename OtherValueType>
    void buildCSR( LAMAArray<IndexType>& ia,
                   LAMAArray<IndexType>* ja,
                   LAMAArray<OtherValueType>* values,
                   const ContextPtr /* loc */ ) const;

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

    virtual void invert( const MatrixStorage<ValueType>& other );

    virtual void matrixTimesVector(
        LAMAArrayView<ValueType> result,
        const ValueType alpha, const LAMAArrayConstView<ValueType> x,
        const ValueType beta, const LAMAArrayConstView<ValueType> y ) const;

    virtual void matrixTimesMatrix( const ValueType alpha,
                                    const MatrixStorage<ValueType>& a,
                                    const MatrixStorage<ValueType>& b,
                                    const ValueType beta,
                                    const MatrixStorage<ValueType>& c );

    virtual ValueType maxDiffNorm ( const MatrixStorage<ValueType>& other );

    virtual ValueType maxDiffNormImpl ( const DenseStorageView<ValueType>& other );

    template<typename OtherType>
    void getRowImpl( LAMAArray<OtherType>& row, const IndexType i ) const;

    template<typename OtherType>
    void getDiagonalImpl( LAMAArray<OtherType>& diagonal ) const;

    template<typename OtherType>
    void setDiagonalImpl( const LAMAArray<OtherType>& diagonal );

    void setDiagonalImpl( const Scalar scalar );

    /******************************************************************
    *  Scaling of elements in a matrix                                *
    ******************************************************************/

    template<typename OtherType>
    void scaleImpl( const LAMAArray<OtherType>& values );

    virtual void scaleImpl( const Scalar value );

    virtual size_t getMemoryUsageImpl() const;

    void swap( DenseStorageView<ValueType>& other );

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

    using MatrixStorage<ValueType>::mNumRows;
    using MatrixStorage<ValueType>::mNumColumns;
    using MatrixStorage<ValueType>::mDiagonalProperty;
    using MatrixStorage<ValueType>::prefetch;
    using MatrixStorage<ValueType>::assign;
    using MatrixStorage<ValueType>::mContext;
    using MatrixStorage<ValueType>::getTypeName;

    void print() const;

protected:

    LAMAArray<ValueType>& mData;   

    LAMA_LOG_DECL_STATIC_LOGGER( logger );  

private:

    DenseStorageView();   // disable the default constructor

    virtual bool checkDiagonalProperty() const;

    template<typename OtherType>
    void assignDenseStorageImpl( const DenseStorageView<OtherType>& otherDenseStorage );

    void matrixTimesMatrixDense( const ValueType alpha,
                                 const DenseStorageView<ValueType>& a,
                                 const DenseStorageView<ValueType>& b,
                                 const ValueType beta,
                                 const DenseStorageView<ValueType>& c );

    void invertDense( const DenseStorageView<ValueType>& other );
};

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

template<typename T>
class LAMA_DLL_IMPORTEXPORT DenseStorage : public DenseStorageView<T>
{
public:

    typedef T ValueType;  

    static const char* typeName();

    DenseStorage();

    DenseStorage( const IndexType numRows, const IndexType numColumns );

    DenseStorage( const LAMAArray<ValueType>& data, const IndexType numRows, const IndexType numColumns );

    DenseStorage( const DenseStorage<ValueType>& other );

    explicit DenseStorage( const _MatrixStorage& other );

    DenseStorage( const _MatrixStorage& other, const ContextPtr context );

    const char* getTypeName() const;

    DenseStorage<ValueType>& operator=( const _MatrixStorage& other);

    DenseStorage<ValueType>& operator=( const DenseStorage<ValueType>& other);

    virtual ~DenseStorage();

    using MatrixStorage<ValueType>::mNumRows;
    using MatrixStorage<ValueType>::mNumColumns;
    using MatrixStorage<ValueType>::assign;

    using DenseStorageView<ValueType>::mData;

private:

    LAMAArray<ValueType> mDataArray;   

};

}

#endif // LAMA_DENSESTORAGE_HPP_