CSRMatrixOperationsDefault.h

Go to the documentation of this file.

#ifndef included_CSRMatrixOperationsDefault_H_
#define included_CSRMatrixOperationsDefault_H_
 
#include "AMP/matrices/data/CSRMatrixData.h"
#include "AMP/matrices/data/MatrixData.h"
#include "AMP/matrices/operations/MatrixOperations.h"
#include "AMP/matrices/operations/default/CSRLocalMatrixOperationsDefault.h"
#include "AMP/matrices/operations/default/spgemm/CSRMatrixSpGEMMDefault.h"
#include "AMP/vectors/Vector.h"
 
#include <map>
 
namespace AMP::LinearAlgebra {
 
template<typename Config>
class CSRMatrixOperationsDefault : public MatrixOperations
{
public:
    using allocator_type = typename Config::allocator_type;
    static_assert( std::is_same_v<typename allocator_type::value_type, void> );
 
    using matrixdata_t      = CSRMatrixData<Config>;
    using localmatrixdata_t = typename matrixdata_t::localmatrixdata_t;
 
    using localops_t = CSRLocalMatrixOperationsDefault<Config>;
 
    using gidx_t   = typename Config::gidx_t;
    using lidx_t   = typename Config::lidx_t;
    using scalar_t = typename Config::scalar_t;
 
    CSRMatrixOperationsDefault()
        : d_localops_diag( std::make_shared<localops_t>() ),
          d_localops_offd( std::make_shared<localops_t>() )
    {
    }
 
    void mult( std::shared_ptr<const Vector> x,
               MatrixData const &A,
               std::shared_ptr<Vector> y ) override;
 
    void multTranspose( std::shared_ptr<const Vector> in,
                        MatrixData const &A,
                        std::shared_ptr<Vector> out ) override;
 
    void scale( AMP::Scalar alpha, MatrixData &A ) override;
 
    void scale( AMP::Scalar alpha, std::shared_ptr<const Vector> D, MatrixData &A ) override;
 
    void scaleInv( AMP::Scalar alpha, std::shared_ptr<const Vector> D, MatrixData &A ) override;
 
    void matMatMult( std::shared_ptr<MatrixData> A,
                     std::shared_ptr<MatrixData> B,
                     std::shared_ptr<MatrixData> C ) override;
 
    void axpy( AMP::Scalar alpha, const MatrixData &X, MatrixData &Y ) override;
 
    void setScalar( AMP::Scalar alpha, MatrixData &A ) override;
 
    void zero( MatrixData &A ) override;
 
    void setDiagonal( std::shared_ptr<const Vector> in, MatrixData &A ) override;
 
    void extractDiagonal( MatrixData const &A, std::shared_ptr<Vector> buf ) override;
 
    void getRowSums( MatrixData const &A, std::shared_ptr<Vector> buf ) override;
 
    void getRowSumsAbsolute( MatrixData const &A,
                             std::shared_ptr<Vector> buf,
                             const bool remove_zeros = false ) override;
 
    void setIdentity( MatrixData &A ) override;
 
    AMP::Scalar LinfNorm( const MatrixData &X ) const override;
 
    void copy( const MatrixData &X, MatrixData &Y ) override;
 
    void copyCast( const MatrixData &X, MatrixData &Y ) override;
 
    template<typename ConfigIn>
    static void
    copyCast( CSRMatrixData<typename ConfigIn::template set_alloc_t<Config::allocator>> *X,
              matrixdata_t *Y );
 
    std::string type() const override { return "CSRMatrixOperationsDefault"; }
 
    void writeRestart( int64_t fid ) const override;
 
    CSRMatrixOperationsDefault( int64_t, AMP::IO::RestartManager * )
        : d_localops_diag( std::make_shared<localops_t>() ),
          d_localops_offd( std::make_shared<localops_t>() )
    {
    }
 
protected:
    std::shared_ptr<localops_t> d_localops_diag;
    std::shared_ptr<localops_t> d_localops_offd;
    std::map<std::pair<std::shared_ptr<matrixdata_t>, std::shared_ptr<matrixdata_t>>,
             CSRMatrixSpGEMMDefault<Config>>
        d_SpGEMMHelpers;
};
 
} // namespace AMP::LinearAlgebra
 
#endif