Matrix.h

Go to the documentation of this file.

#ifndef included_AMP_Matrix
#define included_AMP_Matrix
 
#include "AMP/matrices/MatrixParametersBase.h"
#include "AMP/matrices/data/MatrixData.h"
#include "AMP/matrices/operations/MatrixOperations.h"
#include "AMP/utils/ParameterBase.h"
#include "AMP/utils/enable_shared_from_this.h"
#include "AMP/utils/typeid.h"
#include "AMP/vectors/Vector.h"
#include <memory>
 
 
namespace AMP::LinearAlgebra {
 
 
// commented out for now
// class Matrix : public AMP::enable_shared_from_this<Matrix>
class Matrix
{
public:
    using shared_ptr       = std::shared_ptr<Matrix>;
    using const_shared_ptr = std::shared_ptr<const Matrix>;
 
    explicit Matrix( std::shared_ptr<MatrixParametersBase> params );
 
 
    explicit Matrix( std::shared_ptr<MatrixData> data );
 
    virtual ~Matrix();
 
    virtual std::string type() const = 0;
 
    virtual std::uint16_t mode() const;
 
    virtual void setBackend( AMP::Utilities::Backend );
 
    void mult( std::shared_ptr<const Vector> in, std::shared_ptr<Vector> out );
 
    void multTranspose( std::shared_ptr<const Vector> in, std::shared_ptr<Vector> out );
 
    void scale( AMP::Scalar alpha );
 
    void scale( AMP::Scalar alpha, Vector::const_shared_ptr D );
 
    void scaleInv( AMP::Scalar alpha, Vector::const_shared_ptr D );
 
    void axpy( AMP::Scalar alpha, const Matrix &X );
 
    void setScalar( AMP::Scalar alpha );
 
    void zero();
 
    void setDiagonal( Vector::const_shared_ptr in );
 
    void setIdentity();
 
    AMP::Scalar LinfNorm() const;
 
    static shared_ptr matMatMult( shared_ptr A, shared_ptr B );
 
    static void matMatMult( shared_ptr A, shared_ptr B, shared_ptr C );
 
    void axpy( AMP::Scalar alpha, std::shared_ptr<const Matrix> X );
 
    virtual std::shared_ptr<Matrix> transpose() const;
 
    virtual shared_ptr clone() const = 0;
 
    virtual void copy( std::shared_ptr<const Matrix> X );
 
    void copyCast( std::shared_ptr<const Matrix> X );
 
    virtual Vector::shared_ptr
    extractDiagonal( Vector::shared_ptr buf = Vector::shared_ptr() ) const = 0;
 
    Vector::shared_ptr getRowSums( Vector::shared_ptr buf = Vector::shared_ptr() ) const;
 
    Vector::shared_ptr getRowSumsAbsolute( Vector::shared_ptr buf  = Vector::shared_ptr(),
                                           const bool remove_zeros = false ) const;
 
    virtual Vector::shared_ptr createInputVector() const = 0;
 
    virtual Vector::shared_ptr createOutputVector() const = 0;
 
public:
    template<typename T>
    void
    addValuesByGlobalID( size_t num_rows, size_t num_cols, size_t *rows, size_t *cols, T *values )
    {
        d_matrixData->addValuesByGlobalID( num_rows, num_cols, rows, cols, values );
    }
 
    template<typename T>
    void setValuesByGlobalID(
        size_t num_rows, size_t num_cols, const size_t *rows, const size_t *cols, const T *values )
    {
        d_matrixData->setValuesByGlobalID( num_rows, num_cols, rows, cols, values );
    }
 
    template<typename T = double>
    void
    setRowByGlobalID( size_t row, const std::vector<size_t> &cols, const std::vector<T> &values )
    {
        AMP_ASSERT( cols.size() == values.size() );
        d_matrixData->setValuesByGlobalID<T>( 1, cols.size(), &row, cols.data(), values.data() );
    }
 
    template<typename T>
    void getValuesByGlobalID(
        size_t num_rows, size_t num_cols, const size_t *rows, const size_t *cols, T *values ) const
    {
        d_matrixData->getValuesByGlobalID( num_rows, num_cols, rows, cols, values );
    }
 
    template<typename T = double>
    void getRowByGlobalID( size_t row, std::vector<size_t> &cols, std::vector<T> &values ) const
    {
        d_matrixData->getRowByGlobalID( row, cols, values );
    }
 
 
    size_t numberColumnIDs( size_t row ) const { return d_matrixData->numberColumnIDs( row ); }
 
    std::vector<size_t> getColumnIDs( size_t row ) const
    {
        return d_matrixData->getColumnIDs( row );
    }
 
    void makeConsistent( AMP::LinearAlgebra::ScatterType t )
    {
        return d_matrixData->makeConsistent( t );
    }
 
    size_t numLocalRows() const { return d_matrixData->numLocalRows(); }
 
    size_t numGlobalRows() const { return d_matrixData->numGlobalRows(); }
 
    size_t numLocalColumns() const { return d_matrixData->numLocalColumns(); }
 
    size_t numGlobalColumns() const { return d_matrixData->numGlobalColumns(); }
 
    size_t beginRow() const { return d_matrixData->beginRow(); }
 
    size_t endRow() const { return d_matrixData->endRow(); }
 
    AMP_MPI getComm() const { return d_matrixData->getComm(); }
 
    virtual std::shared_ptr<Discretization::DOFManager> getRightDOFManager() const
    {
        return d_matrixData->getRightDOFManager();
    }
 
    virtual std::shared_ptr<Discretization::DOFManager> getLeftDOFManager() const
    {
        return d_matrixData->getLeftDOFManager();
    }
 
public:
    template<typename T = double>
    void addValueByGlobalID( size_t row, size_t col, T value )
    {
        addValuesByGlobalID( 1, 1, &row, &col, &value );
    }
 
    template<typename T = double>
    void setValueByGlobalID( size_t row, size_t col, T value )
    {
        setValuesByGlobalID( 1, 1, &row, &col, &value );
    }
 
    template<typename T = double>
    T getValueByGlobalID( size_t row, size_t col ) const
    {
        T ans;
        getValuesByGlobalID( 1, 1, &row, &col, &ans );
        return ans;
    }
 
    std::shared_ptr<MatrixData> getMatrixData() { return d_matrixData; }
 
    std::shared_ptr<const MatrixData> getMatrixData() const { return d_matrixData; }
 
    uint64_t getID() const;
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager *manager ) const;
 
    virtual void writeRestart( int64_t fid ) const;
 
    Matrix( int64_t fid, AMP::IO::RestartManager *manager );
 
protected:
    Matrix();
 
    Matrix( const Matrix & );
 
    Matrix &operator=( const Matrix & ) = delete;
 
 
protected:
    virtual void multiply( shared_ptr other_op, shared_ptr &result ) = 0;
 
    std::shared_ptr<MatrixData> d_matrixData;
    std::shared_ptr<MatrixOperations> d_matrixOps;
};
 
inline std::shared_ptr<Matrix> Matrix::transpose() const
{
    AMP_ERROR( "not implemented" );
    return std::shared_ptr<Matrix>();
}
 
std::ostream &operator<<( std::ostream &out, const Matrix &p );
 
inline std::ostream &operator<<( std::ostream &out, std::shared_ptr<const Matrix> p )
{
    return operator<<( out, *p );
}
 
} // namespace AMP::LinearAlgebra
 
#endif