StrumpackSparseSolverMixedPrecision.hpp

/*
 * STRUMPACK -- STRUctured Matrices PACKage, Copyright (c) 2014, The
 * Regents of the University of California, through Lawrence Berkeley
 * National Laboratory (subject to receipt of any required approvals
 * from the U.S. Dept. of Energy).  All rights reserved.
 *
 * If you have questions about your rights to use or distribute this
 * software, please contact Berkeley Lab's Technology Transfer
 * Department at TTD@lbl.gov.
 *
 * NOTICE. This software is owned by the U.S. Department of Energy. As
 * such, the U.S. Government has been granted for itself and others
 * acting on its behalf a paid-up, nonexclusive, irrevocable,
 * worldwide license in the Software to reproduce, prepare derivative
 * works, and perform publicly and display publicly.  Beginning five
 * (5) years after the date permission to assert copyright is obtained
 * from the U.S. Department of Energy, and subject to any subsequent
 * five (5) year renewals, the U.S. Government is granted for itself
 * and others acting on its behalf a paid-up, nonexclusive,
 * irrevocable, worldwide license in the Software to reproduce,
 * prepare derivative works, distribute copies to the public, perform
 * publicly and display publicly, and to permit others to do so.
 *
 * Developers: Pieter Ghysels, Francois-Henry Rouet, Xiaoye S. Li.
 *             (Lawrence Berkeley National Lab, Computational Research
 *             Division).
 */
#ifndef SPARSE_SOLVER_MIXED_PRECISION_HPP
#define SPARSE_SOLVER_MIXED_PRECISION_HPP
 
#include <new>
#include <memory>
#include <vector>
#include <string>
 
#include "iterative/IterativeSolvers.hpp"
#include "StrumpackOptions.hpp"
#include "StrumpackSparseSolver.hpp"
 
 
namespace strumpack {
 
  template<typename factor_t,typename refine_t,typename integer_t>
  class SparseSolverMixedPrecision {
 
  public:
    SparseSolverMixedPrecision(bool verbose=true, bool root=true);
 
    SparseSolverMixedPrecision(int argc, char* argv[],
                               bool verbose=true, bool root=true);
 
    ~SparseSolverMixedPrecision();
 
    void set_matrix(const CSRMatrix<refine_t,integer_t>& A);
    void set_matrix(const CSRMatrix<factor_t,integer_t>& A);
 
    void update_matrix_values(const CSRMatrix<refine_t,integer_t>& A);
    void update_matrix_values(const CSRMatrix<factor_t,integer_t>& A);
 
    ReturnCode factor();
    ReturnCode reorder(int nx=1, int ny=1, int nz=1);
 
    ReturnCode solve(const DenseMatrix<refine_t>& b,
                     DenseMatrix<refine_t>& x,
                     bool use_initial_guess=false);
    ReturnCode solve(const refine_t* b, refine_t* x,
                     bool use_initial_guess=false);
    ReturnCode solve(int nrhs, const refine_t* b, int ldb,
                     refine_t* x, int ldx,
                     bool use_initial_guess=false);
 
    ReturnCode solve(const DenseMatrix<factor_t>& b,
                     DenseMatrix<factor_t>& x,
                     bool use_initial_guess=false);
    ReturnCode solve(const factor_t* b, factor_t* x,
                     bool use_initial_guess=false);
    ReturnCode solve(int nrhs, const factor_t* b, int ldb,
                     factor_t* x, int ldx,
                     bool use_initial_guess=false);
 
    SPOptions<refine_t>& options() { return opts_; }
    const SPOptions<refine_t>& options() const { return opts_; }
 
    SparseSolver<factor_t,integer_t>& solver() { return solver_; }
    const SparseSolver<factor_t,integer_t>& solver() const { return solver_; }
 
    int Krylov_iterations() const { return Krylov_its_; }
 
  private:
    CSRMatrix<refine_t,integer_t> mat_;
    SparseSolver<factor_t,integer_t> solver_;
    SPOptions<refine_t> opts_;
    int Krylov_its_ = 0;
  };
 
  template<typename factor_t,typename refine_t,typename integer_t>
  using StrumpackSparseSolverMixedPrecision =
    SparseSolverMixedPrecision<factor_t,refine_t,integer_t>;
 
} //end namespace strumpack
 
#endif // STRUMPACK_SPARSE_SOLVER_MIXED_PRECISION_HPP