monolish_linearoperator.hpp

Go to the documentation of this file.

 
#pragma once
#include <exception>
#include <functional>
#include <omp.h>
#include <random>
#include <stdexcept>
#include <string>
#include <vector>
 
namespace monolish {
template <typename Float> class vector;
namespace matrix {
template <typename Float> class Dense;
template <typename Float> class COO;
template <typename Float> class CRS;
 
template <typename Float> class LinearOperator {
private:
  size_t rowN;
 
  size_t colN;
 
  bool matvec_init_flag;
 
  bool rmatvec_init_flag;
 
  mutable bool gpu_status = false;
 
  std::function<vector<Float>(const vector<Float> &)> matvec;
 
  std::function<vector<Float>(const vector<Float> &)> rmatvec;
 
public:
  LinearOperator() {}
 
  LinearOperator(const size_t M, const size_t N);
 
  LinearOperator(
      const size_t M, const size_t N,
      const std::function<vector<Float>(const vector<Float> &)> &MATVEC);
 
  LinearOperator(
      const size_t M, const size_t N,
      const std::function<vector<Float>(const vector<Float> &)> &MATVEC,
      const std::function<vector<Float>(const vector<Float> &)> &RMATVEC);
 
  void convert(COO<Float> &coo);
 
  LinearOperator(COO<Float> &coo) { convert(coo); }
 
  void convert(CRS<Float> &crs);
 
  LinearOperator(CRS<Float> &crs) { convert(crs); }
 
  void convert_to_Dense(Dense<Float> &dense) const;
 
  LinearOperator(const LinearOperator<Float> &linearoperator);
 
  size_t get_row() const { return rowN; }
 
  size_t get_col() const { return colN; }
 
  std::function<vector<Float>(const vector<Float> &)> get_matvec() const {
    return matvec;
  }
 
  std::function<vector<Float>(const vector<Float> &)> get_rmatvec() const {
    return rmatvec;
  }
 
  bool get_matvec_init_flag() const { return matvec_init_flag; }
 
  bool get_rmatvec_init_flag() const { return rmatvec_init_flag; }
 
  void
  set_matvec(const std::function<vector<Float>(const vector<Float> &)> &MATVEC);
 
  void set_rmatvec(
      const std::function<vector<Float>(const vector<Float> &)> &RMATVEC);
 
  std::string type() const { return "LinearOperator"; }
 
  void send() const {};
 
  void recv() const {};
 
  void nonfree_recv() const {};
 
  void device_free() const {};
 
  bool get_device_mem_stat() const { return gpu_status; };
 
  void set_device_mem_stat(bool status) {
    gpu_status = status;
    return;
  };
 
  ~LinearOperator() {}
 
  void operator=(const LinearOperator<Float> &mat);
};
} // namespace matrix
} // namespace monolish