Provided by: librheolef-dev_6.6-1build2_amd64 bug


       solver_option_type - options for direct or interative solvers


       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.


       class solver_option_type {
         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()),
            tol           (std::numeric_limits<Float>::epsilon()),
            max_iter      (100000),
            n_refinement  (2),
            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&);