csr_matrix.hpp

Go to the documentation of this file.

#ifndef PARGEMSLR_CSR_MATRIX_H
#define PARGEMSLR_CSR_MATRIX_H
 
#include <iostream>
 
#include "../utils/utils.hpp"
#include "../vectors/int_vector.hpp"
#include "../vectors/sequential_vector.hpp"
#include "matrix.hpp"
 
#ifdef PARGEMSLR_CUDA
#include "cusparse.h"
#endif
 
namespace pargemslr
{
   
   template <typename T>
   class CsrMatrixClass: public MatrixClass<T>
   {
   private:
      
      /* variables */
      
      IntVectorClass<int>        _i_vec;
      
      IntVectorClass<int>        _j_vec;
      
      SequentialVectorClass<T>   _a_vec;
      
      int                        _nrows;
      
      int                        _ncols;
      
      int                        _nnz;
      
      bool                       _isrowsorted;
      
      bool                       _isholdingdata;
      
      bool                       _iscsr;
      
#ifdef PARGEMSLR_CUDA 
#if (PARGEMSLR_CUDA_VERSION == 11)
 
      cusparseSpMatDescr_t       _cusparse_mat;
#endif
#endif
      
   public:
      
      typename std::conditional<PargemslrIsDoublePrecision<T>::value, 
                                 double, 
                                 float>::type _diagonal_shift;
      
      CsrMatrixClass();
      
      CsrMatrixClass(const CsrMatrixClass<T> &mat);
      
      CsrMatrixClass(CsrMatrixClass<T> &&mat);
      
      CsrMatrixClass<T>& operator= (const CsrMatrixClass<T> &mat);
      
      CsrMatrixClass<T>& operator= (CsrMatrixClass<T> &&mat);
      
      virtual ~CsrMatrixClass();
      
      int            Setup(int nrows, int ncols, int nnz);
      
      int            Setup(int nrows, int ncols, int nnz, int location);
      
      int            Setup(int nrows, int ncols, int nnz, bool setzero);
      
      int            Setup(int nrows, int ncols, int nnz, bool holdvalue, bool setzero);
      
      int            Setup(int nrows, int ncols, int nnz, int location, bool setzero);
      
      int            Setup(int nrows, int ncols, int nnz, int location, bool holdvalue, bool setzero);
      
      int            Setup(int nrows, int ncols, int nnz, int location, bool holdvalue, bool setzero, bool iscsr);
      
      int            PushBack( int col, T v);
      
      int            SubMatrix( int row_start, int col_start, int num_rows, int num_cols, int location, CsrMatrixClass<T> &csrmat_out);
      
      int            SubMatrix( vector_int &row_starts, vector_int &col_starts, vector_int &row_ends, vector_int &col_ends, int location, CsrMatrixClass<T> &csrmat_out);
      
      int            SubMatrix( vector_int &rows, vector_int &cols, int location, CsrMatrixClass<T> &csrmat_out);
      
      int            SubMatrixNoPerm( vector_int &rows, vector_int &cols, vector_int &row_perm, vector_int &col_perm, bool complement, int location, CsrMatrixClass<T> &csrmat_out);
      
      int            GetConnectedComponents(std::vector<vector_int> &comp_indices, int &ncomps);
      
      int            SetupVectorPtrStr(SequentialVectorClass<T> &vec);
      
      virtual int    Clear();
      
      virtual int    GetDataLocation() const;
      
      virtual int    GetNumRowsLocal() const;
      
      virtual int    GetNumColsLocal() const;
      
      virtual long int  GetNumNonzeros() const;
      
      int            SetNumNonzeros();
      
      int*           GetI() const;
      
      int*           GetJ() const;
      
      T*             GetData() const;
      
      IntVectorClass<int>&          GetIVector();
      
      const IntVectorClass<int>&          GetIVector() const;
      
      IntVectorClass<int>&          GetJVector();
      
      const IntVectorClass<int>&          GetJVector() const;
      
      SequentialVectorClass<T>&     GetDataVector();
      
      const SequentialVectorClass<T>&     GetDataVector() const;
      
#ifdef PARGEMSLR_CUDA 
#if (PARGEMSLR_CUDA_VERSION == 11)
 
      cusparseSpMatDescr_t          GetCusparseMat() const;
      
      int                           SetCusparseMat(cusparseSpMatDescr_t cusparse_mat);
#endif
#endif
 
      bool           IsHoldingData() const;
      
      bool&          IsCsr();
      
      const bool&          IsCsr() const;
      
      bool&          IsRowSorted();
      
      const bool&          IsRowSorted() const;
      
      int            SortRow();
      
      virtual int    Eye();
      
      virtual int    Fill(const T &v);
      
      virtual int    MoveData( const int &location);
      
      virtual int    Scale(const T &alpha);
      
      int            GetDiagScale(T &scale);
      
      int            Convert(bool csr);
      
      int            Transpose();
      
      int            Transpose(CsrMatrixClass<T> &AT);
      
      virtual int    MatVec( char trans, const T &alpha, const VectorClass<T> &x, const T &beta, VectorClass<T> &y);
      
      virtual int    MatVec( char trans, const T &alpha, const VectorClass<T> &x, const T &beta, const VectorClass<T> &y, VectorClass<T> &z);
      
      int            MatMat( const T &alpha, const CsrMatrixClass<T> &A, char transa, const CsrMatrixClass<T> &B, char transb, const T &beta);
      
      int            PlotPattern( int *rperm, int *cperm, int conditiona, int conditionb);
      
      int            PlotPatternGnuPlot( const char *datafilename, int *rperm, int *cperm, int conditiona, int conditionb);
      
      int            Plot( int *perm, int conditiona, int conditionb, int width);
      
      int            Laplacian(int nx, int ny, int nz, T alphax, T alphay, T alphaz, T shift, bool rand_perturb = false);
      
      int            Helmholtz(int n, T w);
      
      int            ReadFromMMFile(const char *matfile, int idxin);
      
      template <typename T1>
      int            SetComplexShift(T1 diagonal_shift)
      {
         this->_diagonal_shift = diagonal_shift;
         return PARGEMSLR_SUCCESS;
      }
      
      template <typename T1>
      int            GetComplexShift(T1 &diagonal_shift);
      
      template <typename T1>
      int            GetComplexShift(ComplexValueClass<T1> &diagonal_shift);
      
      int            GetMpiInfo(int &np, int &myid, MPI_Comm &comm) const
      {
         comm = *parallel_log::_lcomm;
         np = 1;
         myid = 0;
         return PARGEMSLR_SUCCESS;
      }
      
      MPI_Comm       GetComm() const
      {
         return *parallel_log::_lcomm;
      }
      
   };
   
   typedef CsrMatrixClass<float>     matrix_csr_float;
   typedef CsrMatrixClass<double>    matrix_csr_double;
   typedef CsrMatrixClass<complexs>  matrix_csr_complexs;
   typedef CsrMatrixClass<complexd>  matrix_csr_complexd;
   template<> struct PargemslrIsComplex<CsrMatrixClass<complexs> > : public std::true_type {};
   template<> struct PargemslrIsComplex<CsrMatrixClass<complexd> > : public std::true_type {};
   
}
 
#endif