MatrixOperations.h

Go to the documentation of this file.

#ifndef included_MatrixOperations_H_
#define included_MatrixOperations_H_
 
#include "AMP/utils/typeid.h"
#include "AMP/vectors/Scalar.h"
 
namespace AMP::IO {
class RestartManager;
}
 
namespace AMP::LinearAlgebra {
 
class Vector;
class MatrixData;
 
class MatrixOperations
{
public:
    virtual ~MatrixOperations() {}
 
    virtual void
    mult( std::shared_ptr<const Vector> x, MatrixData const &A, std::shared_ptr<Vector> y ) = 0;
 
    virtual void multTranspose( std::shared_ptr<const Vector> in,
                                MatrixData const &A,
                                std::shared_ptr<Vector> out ) = 0;
 
    virtual void scale( AMP::Scalar alpha, MatrixData &A ) = 0;
 
    virtual void scale( AMP::Scalar alpha, std::shared_ptr<const Vector> D, MatrixData &A ) = 0;
 
    virtual void scaleInv( AMP::Scalar alpha, std::shared_ptr<const Vector> D, MatrixData &A ) = 0;
 
    virtual void matMatMult( std::shared_ptr<MatrixData> A,
                             std::shared_ptr<MatrixData> B,
                             std::shared_ptr<MatrixData> C ) = 0;
 
    virtual void axpy( AMP::Scalar alpha, const MatrixData &X, MatrixData &Y ) = 0;
 
    virtual void setScalar( AMP::Scalar alpha, MatrixData &A ) = 0;
 
    virtual void zero( MatrixData &A ) = 0;
 
    virtual void setDiagonal( std::shared_ptr<const Vector> in, MatrixData &A ) = 0;
 
    virtual void extractDiagonal( MatrixData const &A, std::shared_ptr<Vector> buf ) = 0;
 
    virtual void getRowSums( MatrixData const &A, std::shared_ptr<Vector> buf );
 
    virtual void getRowSumsAbsolute( MatrixData const &A,
                                     std::shared_ptr<Vector> buf,
                                     const bool remove_zeros = false );
 
    virtual void setIdentity( MatrixData &A ) = 0;
 
    virtual AMP::Scalar LinfNorm( const MatrixData &X ) const = 0;
 
    virtual void copy( const MatrixData &x, MatrixData &y ) = 0;
 
    virtual void copyCast( const MatrixData &x, MatrixData &y );
 
    virtual std::string type() const { return "MatrixOperations"; }
 
    uint64_t getID() const;
 
public: // Write/read restart data
    virtual void registerChildObjects( AMP::IO::RestartManager *manager ) const;
 
    virtual void writeRestart( int64_t fid ) const;
 
 
protected:
    MatrixOperations();
 
protected:
    uint64_t d_hash = 0;
};
 
} // namespace AMP::LinearAlgebra
 
#endif // included_MatrixOperations_H_