monolish_equation.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
 
#include "./monolish_solver.hpp"
#include "common/monolish_common.hpp"
#include <functional>
 
namespace monolish::equation {
 
template <typename MATRIX, typename Float>
class none : public monolish::solver::solver<MATRIX, Float> {
public:
  void create_precond(MATRIX &A);
  void apply_precond(const vector<Float> &r, vector<Float> &z);
  int solve(MATRIX &A, vector<Float> &x, vector<Float> &b);
 
  std::string name() const { return "monolish::equation::none"; }
};
 
template <typename MATRIX, typename Float>
class CG : public monolish::solver::solver<MATRIX, Float> {
private:
  int monolish_CG(MATRIX &A, vector<Float> &x, vector<Float> &b);
 
public:
  int solve(MATRIX &A, vector<Float> &x, vector<Float> &b);
 
  void create_precond(MATRIX &A) {
    throw std::runtime_error("this precond. is not impl.");
  }
 
  void apply_precond(const vector<Float> &r, vector<Float> &z) {
    throw std::runtime_error("this precond. is not impl.");
  }
 
  std::string name() const { return "monolish::equation::CG"; }
};
 
template <typename MATRIX, typename Float>
class BiCGSTAB : public monolish::solver::solver<MATRIX, Float> {
private:
  int monolish_BiCGSTAB(MATRIX &A, vector<Float> &x, vector<Float> &b);
 
public:
  int solve(MATRIX &A, vector<Float> &x, vector<Float> &b);
 
  void create_precond(MATRIX &A) {
    throw std::runtime_error("this precond. is not impl.");
  }
 
  void apply_precond(const vector<Float> &r, vector<Float> &z) {
    throw std::runtime_error("this precond. is not impl.");
  }
 
  std::string name() const { return "monolish::equation::BiCGSTAB"; }
};
 
template <typename MATRIX, typename Float>
class Jacobi : public monolish::solver::solver<MATRIX, Float> {
private:
  int monolish_Jacobi(MATRIX &A, vector<Float> &x, vector<Float> &b);
 
public:
  int solve(MATRIX &A, vector<Float> &x, vector<Float> &b);
  void create_precond(MATRIX &A);
  void apply_precond(const vector<Float> &r, vector<Float> &z);
 
  std::string name() const { return "monolish::equation::Jacobi"; }
};
 
template <typename MATRIX, typename Float>
class LU : public monolish::solver::solver<MATRIX, Float> {
private:
  int lib = 1; // lib is 1
  int mumps_LU(MATRIX &A, vector<double> &x, vector<double> &b);
  int cusolver_LU(MATRIX &A, vector<double> &x, vector<double> &b);
  int singularity;
  int reorder = 3;
 
public:
  void set_reorder(int r) { reorder = r; }
  int get_sigularity() { return singularity; }
  int solve(MATRIX &A, vector<Float> &x, vector<Float> &b);
  int solve(MATRIX &A, vector<Float> &xb);
  void create_precond(MATRIX &A) {
    throw std::runtime_error("this precond. is not impl.");
  }
  void apply_precond(const vector<Float> &r, vector<Float> &z) {
    throw std::runtime_error("this precond. is not impl.");
  }
 
  std::string name() const { return "monolish::equation::LU"; }
};
 
template <typename MATRIX, typename Float>
class QR : public monolish::solver::solver<MATRIX, Float> {
private:
  int lib = 1; // lib is 1
  int cusolver_QR(MATRIX &A, vector<double> &x, vector<double> &b);
  int cusolver_QR(MATRIX &A, vector<float> &x, vector<float> &b);
  int singularity;
  int reorder = 3;
 
public:
  void set_reorder(int r) { reorder = r; }
 
  int get_sigularity() { return singularity; }
 
  int solve(MATRIX &A, vector<Float> &x, vector<Float> &b);
  void create_precond(MATRIX &A) {
    throw std::runtime_error("this precond. is not impl.");
  }
  void apply_precond(const vector<Float> &r, vector<Float> &z) {
    throw std::runtime_error("this precond. is not impl.");
  }
 
  std::string name() const { return "monolish::equation::QR"; }
};
 
template <typename MATRIX, typename Float>
class Cholesky : public monolish::solver::solver<MATRIX, Float> {
private:
  int lib = 1; // lib is 1
  int cusolver_Cholesky(MATRIX &A, vector<float> &x, vector<float> &b);
  int cusolver_Cholesky(MATRIX &A, vector<double> &x, vector<double> &b);
  int singularity;
  int reorder = 3;
 
public:
  void set_reorder(int r) { reorder = r; }
 
  int get_sigularity() { return singularity; }
 
  int solve(MATRIX &A, vector<Float> &x, vector<Float> &b);
  int solve(MATRIX &A, vector<Float> &xb);
 
  void create_precond(matrix::CRS<Float> &A) {
    throw std::runtime_error("this precond. is not impl.");
  }
  void apply_precond(const vector<Float> &r, vector<Float> &z) {
    throw std::runtime_error("this precond. is not impl.");
  }
 
  std::string name() const { return "monolish::equation::Cholesky"; }
};
} // namespace monolish::equation