NAME¶

solver_option_type - options for direct or interative solvers

DESCRIPTION¶

This class implements a set of options for direct or iterative solvers, as implemented by the solver(2). An instance of this class can be supplied to the solver constructor.

IMPLEMENTATION¶

class solver_option_type {
public:


  typedef std::size_t size_type;


  static const long int  decide = -1;    // indicate the solver will try to choose the best method
// data:


  mutable long int   iterative;          // indicate if we want to use iterative solver


  Float              tol;                // tolerance when using iterative methode


  size_type          max_iter;           // maximum number of iteration when using iterative method


  size_type          n_refinement;       // number of iterative refinement, when using direct method (umfpack only support it)


  bool               compute_determinant; // compute also det, when using direct method


  std::string        prefered_library;   // e.g. "umfpack", when available


  size_type          verbose_level;      // 0, 1, 2, 3


  bool               do_check;


  bool               force_seq;          // (still buggy; when using direct) restrict to diagonal blocs per process (e.g. mumps solver)


  size_type          level_of_fill;      // (in development) Level of fill [1:5] for incomplete factorisation


  size_type          amalgamation;       // (in development) Level of amalgamation [10:70] for Kass


  size_type          ooc;                // (in development) out-of-core limit (Mo/percent depending on compilation options)
// allocator with default values:


  solver_option_type ()


   : iterative     (decide),
#if defined(_RHEOLEF_HAVE_QD) || defined(_RHEOLEF_HAVE_FLOAT128)


     tol           (1e6*std::numeric_limits<Float>::epsilon()),
#else


     tol           (std::numeric_limits<Float>::epsilon()),
#endif


     max_iter      (100000),


     n_refinement  (2),


     compute_determinant(false),


     prefered_library(),


     verbose_level (0),


     do_check      (false),


     force_seq     (false),


     level_of_fill (1),


     amalgamation  (10),


     ooc           (20000)


  {


  }


  solver_option_type (const solver_option_type&);


  solver_option_type& operator= (const solver_option_type&);
};

SEE ALSO¶

solver(2)