monolish_crs.hpp

Go to the documentation of this file.

#pragma once
#include <exception>
#include <omp.h>
#include <stdexcept>
#include <string>
#include <vector>
 
#if USE_SXAT
#undef _HAS_CPP17
#endif
#include <random>
#if USE_SXAT
#define _HAS_CPP17 1
#endif
 
namespace monolish {
template <typename Float> class vector;
template <typename TYPE, typename Float> class view1D;
namespace matrix {
template <typename Float> class Dense;
template <typename Float> class COO;
 
template <typename Float> class CRS {
private:
  size_t rowN;
 
  size_t colN;
 
  size_t nnz;
 
  mutable bool gpu_status = false;
 
  size_t structure_hash;
 
public:
  std::vector<Float> val;
 
  std::vector<int> col_ind;
 
  std::vector<int> row_ptr;
 
  CRS() {}
 
  CRS(const size_t M, const size_t N, const size_t NNZ);
 
  CRS(const size_t M, const size_t N, const size_t NNZ, const int *rowptr,
      const int *colind, const Float *value);
 
  CRS(const size_t M, const size_t N, const size_t NNZ, const int *rowptr,
      const int *colind, const Float *value, const size_t origin);
 
  CRS(const size_t M, const size_t N, const std::vector<int> &rowptr,
      const std::vector<int> &colind, const std::vector<Float> &value);
 
  CRS(const size_t M, const size_t N, const std::vector<int> &rowptr,
      const std::vector<int> &colind, const vector<Float> &value);
 
  void convert(COO<Float> &coo);
 
  void convert(CRS<Float> &crs);
 
  CRS(COO<Float> &coo) { convert(coo); }
 
  CRS(const CRS<Float> &mat);
 
  CRS(const CRS<Float> &mat, Float value);
 
  void set_ptr(const size_t M, const size_t N, const std::vector<int> &rowptr,
               const std::vector<int> &colind, const std::vector<Float> &value);
 
  void print_all(bool force_cpu = false) const;
 
  [[nodiscard]] size_t get_row() const { return rowN; }
 
  [[nodiscard]] size_t get_col() const { return colN; }
 
  [[nodiscard]] size_t get_nnz() const { return nnz; }
 
  [[nodiscard]] std::string type() const { return "CRS"; }
 
  void compute_hash();
 
  [[nodiscard]] size_t get_hash() const { return structure_hash; }
 
  // communication
  // ///////////////////////////////////////////////////////////////////////////
  void send() const;
 
  void recv();
 
  void nonfree_recv();
 
  void device_free() const;
 
  [[nodiscard]] bool get_device_mem_stat() const { return gpu_status; }
 
  ~CRS() {
    if (get_device_mem_stat()) {
      device_free();
    }
  }
 
 
  void diag(vector<Float> &vec) const;
  void diag(view1D<vector<Float>, Float> &vec) const;
  void diag(view1D<matrix::Dense<Float>, Float> &vec) const;
 
  void row(const size_t r, vector<Float> &vec) const;
  void row(const size_t r, view1D<vector<Float>, Float> &vec) const;
  void row(const size_t r, view1D<matrix::Dense<Float>, Float> &vec) const;
 
  void col(const size_t c, vector<Float> &vec) const;
  void col(const size_t c, view1D<vector<Float>, Float> &vec) const;
  void col(const size_t c, view1D<matrix::Dense<Float>, Float> &vec) const;
 
 
  void diag_add(const Float alpha);
 
  void diag_sub(const Float alpha);
 
  void diag_mul(const Float alpha);
 
  void diag_div(const Float alpha);
 
  void diag_add(const vector<Float> &vec);
  void diag_add(const view1D<vector<Float>, Float> &vec);
  void diag_add(const view1D<matrix::Dense<Float>, Float> &vec);
 
  void diag_sub(const vector<Float> &vec);
  void diag_sub(const view1D<vector<Float>, Float> &vec);
  void diag_sub(const view1D<matrix::Dense<Float>, Float> &vec);
 
  void diag_mul(const vector<Float> &vec);
  void diag_mul(const view1D<vector<Float>, Float> &vec);
  void diag_mul(const view1D<matrix::Dense<Float>, Float> &vec);
 
  void diag_div(const vector<Float> &vec);
  void diag_div(const view1D<vector<Float>, Float> &vec);
  void diag_div(const view1D<matrix::Dense<Float>, Float> &vec);
 
 
  void transpose();
 
  void transpose(const CRS &B);
 
  /*
   * @brief Memory data space required by the matrix
   * @note
   * - # of computation: 3
   * - Multi-threading: false
   * - GPU acceleration: false
   **/
  [[nodiscard]] double get_data_size() const {
    return (get_nnz() * sizeof(Float) + (get_row() + 1) * sizeof(int) +
            get_nnz() * sizeof(int)) /
           1.0e+9;
  }
 
  void fill(Float value);
 
  void operator=(const CRS<Float> &mat);
 
  [[nodiscard]] bool equal(const CRS<Float> &mat,
                           bool compare_cpu_and_device = false) const;
 
  [[nodiscard]] bool operator==(const CRS<Float> &mat) const;
 
  [[nodiscard]] bool operator!=(const CRS<Float> &mat) const;
};
} // namespace matrix
} // namespace monolish