local_matrix.hpp

Go to the documentation of this file.

#ifndef PARALUTION_LOCAL_MATRIX_HPP_
#define PARALUTION_LOCAL_MATRIX_HPP_

#include "operator.hpp"
#include "base_matrix.hpp"
#include "backend_manager.hpp"

namespace paralution {

template <typename ValueType>
class LocalVector;

// Local Matrix
template <typename ValueType>
class LocalMatrix : public Operator<ValueType> {

public:

  LocalMatrix();
  virtual ~LocalMatrix();

  virtual void info(void) const;

  unsigned int get_format(void) const;

  virtual int get_nrow(void) const;
  virtual int get_ncol(void) const;
  virtual int get_nnz(void) const;

  //  and false if there is something wrong with the strcture or some of values are NaN
  bool Check(void) const;

  void AllocateCSR(const std::string name, const int nnz, const int nrow, const int ncol);
  void AllocateBCSR(void) {};
  void AllocateMCSR(const std::string name, const int nnz, const int nrow, const int ncol);
  void AllocateCOO(const std::string name, const int nnz, const int nrow, const int ncol);
  void AllocateDIA(const std::string name, const int nnz, const int nrow, const int ncol, const int ndiag);
  void AllocateELL(const std::string name, const int nnz, const int nrow, const int ncol, const int max_row);
  void AllocateHYB(const std::string name, const int ell_nnz, const int coo_nnz, const int ell_max_row,
                   const int nrow, const int ncol);
  void AllocateDENSE(const std::string name, const int nrow, const int ncol);

  void SetDataPtrCOO(int **row, int **col, ValueType **val,
                     std::string name, const int nnz, const int nrow, const int ncol);
  void LeaveDataPtrCOO(int **row, int **col, ValueType **val);

  void SetDataPtrCSR(int **row_offset, int **col, ValueType **val,
                     std::string name, const int nnz, const int nrow, const int ncol);
  void LeaveDataPtrCSR(int **row_offset, int **col, ValueType **val);

  void SetDataPtrELL(int **col, ValueType **val,
                     std::string name, 
                     const int nnz, const int nrow, const int ncol, const int max_row);
  void LeaveDataPtrELL(int **col, ValueType **val, int &max_row);

  void SetDataPtrDIA(int **offset, ValueType **val,
                     std::string name, 
                     const int nnz, const int nrow, const int ncol, const int num_diag);
  void LeaveDataPtrDIA(int **offset, ValueType **val, int &num_diag);

  void SetDataPtrDENSE(ValueType **val, std::string name, const int nrow, const int ncol);
  void LeaveDataPtrDENSE(ValueType **val);

  void Clear(void);

  void Zeros(void);

  void Assemble(const int *i, const int *j, const ValueType *v, int size, 
                std::string name, const int n=0, const int m=0);

  void AssembleUpdate(const ValueType *v);

  void Scale(const ValueType alpha);
  void ScaleDiagonal(const ValueType alpha);
  void ScaleOffDiagonal(const ValueType alpha);
 
  void AddScalar(const ValueType alpha);
  void AddScalarDiagonal(const ValueType alpha);
  void AddScalarOffDiagonal(const ValueType alpha);

  void ExtractSubMatrix(const int row_offset,
                        const int col_offset,
                        const int row_size,
                        const int col_size,
                        LocalMatrix<ValueType> *mat) const;

  void ExtractSubMatrices(const int row_num_blocks,
                          const int col_num_blocks,
                          const int *row_offset,
                          const int *col_offset,
                          LocalMatrix<ValueType> ***mat) const;

  void ExtractDiagonal(LocalVector<ValueType> *vec_diag) const;

  void ExtractInverseDiagonal(LocalVector<ValueType> *vec_inv_diag) const;

  void ExtractU(LocalMatrix<ValueType> *U, const bool diag) const;
  void ExtractL(LocalMatrix<ValueType> *L, const bool diag) const;

  void Permute(const LocalVector<int> &permutation);

  void PermuteBackward(const LocalVector<int> &permutation);

  void CMK(LocalVector<int> *permutation) const;
  void RCMK(LocalVector<int> *permutation) const;

  void MultiColoring(int &num_colors,
                     int **size_colors,
                     LocalVector<int> *permutation) const;

  void MaximalIndependentSet(int &size,
                             LocalVector<int> *permutation) const;

  void ZeroBlockPermutation(int &size,
                            LocalVector<int> *permutation) const;

  void ILU0Factorize(void);
  void LUFactorize(void);

  void ILUTFactorize(const double t, const int maxrow);

  void ILUpFactorize(const int p, const bool level=true);   
  void LUAnalyse(void);
  void LUAnalyseClear(void);
  void LUSolve(const LocalVector<ValueType> &in, LocalVector<ValueType> *out) const; 

  void ICFactorize(LocalVector<ValueType> *inv_diag);

  void LLAnalyse(void);
  void LLAnalyseClear(void);
  void LLSolve(const LocalVector<ValueType> &in, LocalVector<ValueType> *out) const;
  void LLSolve(const LocalVector<ValueType> &in, const LocalVector<ValueType> &inv_diag,
               LocalVector<ValueType> *out) const;

  void LAnalyse(const bool diag_unit=false);
  void LAnalyseClear(void);
  void LSolve(const LocalVector<ValueType> &in, LocalVector<ValueType> *out) const; 

  void UAnalyse(const bool diag_unit=false);
  void UAnalyseClear(void);
  void USolve(const LocalVector<ValueType> &in, LocalVector<ValueType> *out) const;

  void Householder(const int idx, ValueType &beta, LocalVector<ValueType> *vec) const;
  void QRDecompose(void);
  void QRSolve(const LocalVector<ValueType> &in, LocalVector<ValueType> *out) const;

  void Invert(void);

  void ReadFileMTX(const std::string filename);
  void WriteFileMTX(const std::string filename) const;

  void ReadFileCSR(const std::string filename);
  void WriteFileCSR(const std::string filename) const;
  
  virtual void MoveToAccelerator(void);
  virtual void MoveToAcceleratorAsync(void);
  virtual void MoveToHost(void);
  virtual void MoveToHostAsync(void);
  virtual void Sync(void);

  void CopyFrom(const LocalMatrix<ValueType> &src);

  void CopyFromAsync(const LocalMatrix<ValueType> &src);

  void CloneFrom(const LocalMatrix<ValueType> &src);

  void UpdateValuesCSR(ValueType *val);

  void CopyFromCSR(const int *row_offsets, const int *col, const ValueType *val);

  void CopyToCSR(int *row_offsets, int *col, ValueType *val) const;

  void CopyFromCOO(const int *row, const int *col, const ValueType *val);

  void CopyToCOO(int *row, int *col, ValueType *val) const;

  void CreateFromMap(const LocalVector<int> &map, const int n, const int m);

  void ConvertToCSR(void);
  void ConvertToMCSR(void);
  void ConvertToBCSR(void);
  void ConvertToCOO(void);
  void ConvertToELL(void);
  void ConvertToDIA(void);
  void ConvertToHYB(void);
  void ConvertToDENSE(void);
  void ConvertTo(const unsigned int matrix_format);
  
  virtual void Apply(const LocalVector<ValueType> &in, LocalVector<ValueType> *out) const; 
  virtual void ApplyAdd(const LocalVector<ValueType> &in, const ValueType scalar, 
                        LocalVector<ValueType> *out) const; 

  void SymbolicPower(const int p);

  void MatrixAdd(const LocalMatrix<ValueType> &mat, const ValueType alpha=ValueType(1.0), 
                 const ValueType beta=ValueType(1.0), const bool structure=false);

  void MatrixMult(const LocalMatrix<ValueType> &A, const LocalMatrix<ValueType> &B);

  void DiagonalMatrixMult(const LocalVector<ValueType> &diag);

  void DiagonalMatrixMultL(const LocalVector<ValueType> &diag);

  void DiagonalMatrixMultR(const LocalVector<ValueType> &diag);

  void Gershgorin(ValueType &lambda_min,
                  ValueType &lambda_max) const;

  void Compress(const double drop_off);

  void Transpose(void);

  void Sort(void);

  void ReplaceColumnVector(const int idx, const LocalVector<ValueType> &vec);

  void ReplaceRowVector(const int idx, const LocalVector<ValueType> &vec);

  void ExtractColumnVector(const int idx, LocalVector<ValueType> *vec) const;

  void ExtractRowVector(const int idx, LocalVector<ValueType> *vec) const;

  void AMGConnect(const ValueType eps, LocalVector<int> *connections) const;
  void AMGAggregate(const LocalVector<int> &connections, LocalVector<int> *aggregates) const;
  void AMGSmoothedAggregation(const ValueType relax,
                              const LocalVector<int> &aggregates,
                              const LocalVector<int> &connections,
                                    LocalMatrix<ValueType> *prolong,
                                    LocalMatrix<ValueType> *restrict) const;
  void AMGAggregation(const LocalVector<int> &aggregates,
                            LocalMatrix<ValueType> *prolong,
                            LocalMatrix<ValueType> *restrict) const;

  void FSAI(const int power, const LocalMatrix<ValueType> *pattern);

  void SPAI(void);

protected:

  virtual bool is_host(void) const;
  virtual bool is_accel(void) const;

private:

  BaseMatrix<ValueType> *matrix_;

  HostMatrix<ValueType> *matrix_host_;

  AcceleratorMatrix<ValueType> *matrix_accel_;

  int *assembly_rank;
  int *assembly_irank;
  int *assembly_loop_start;
  int *assembly_loop_end;
  int assembly_threads;

  void free_assembly_data(void);

  friend class LocalVector<ValueType>;

};


}

#endif // PARALUTION_LOCAL_MATRIX_HPP_