C++ SmartPtr::AddLowerBoundedNumberOption方法代码示例

 void MinC_1NrmRestorationPhase::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->AddLowerBoundedNumberOption(
     "bound_mult_reset_threshold",
     "Threshold for resetting bound multipliers after the restoration phase.",
     0.0, false,
     1e3,
     "After returning from the restoration phase, the bound multipliers are "
     "updated with a Newton step for complementarity.  Here, the "
     "change in the primal variables during the entire restoration "
     "phase is taken to be the corresponding primal Newton step. "
     "However, if after the update the largest bound multiplier "
     "exceeds the threshold specified by this option, the multipliers "
     "are all reset to 1.");
   roptions->AddLowerBoundedNumberOption(
     "constr_mult_reset_threshold",
     "Threshold for resetting equality and inequality multipliers after restoration phase.",
     0.0, false,
     0e3,
     "After returning from the restoration phase, the constraint multipliers "
     "are recomputed by a least square estimate.  This option triggers when "
     "those least-square estimates should be ignored.");
   roptions->AddLowerBoundedNumberOption(
     "resto_failure_feasibility_threshold",
     "Threshold for primal infeasibility to declare failure of restoration phase.",
     0.0, false,
     0e3,
     "If the restoration phase is terminated because of the \"acceptable\" "
     "termination criteria and the primal infeasibility is smaller than this "
     "value, the restoration phase is declared to have failed.  The default "
     "value is 1e2*tol, where tol is the general termination tolerance.");
 }

void InexactLSAcceptor::RegisterOptions(
   SmartPtr<RegisteredOptions> roptions
   )
{
   roptions->AddLowerBoundedNumberOption("nu_update_inf_skip_tol",
      "Lower bound on infeasibility to perform penalty parameter update.", 0.0, true, 1e-9,
      "If the current infeasibility is less than this value, the penalty "
         "parameter update is skipped");
   roptions->AddStringOption2("flexible_penalty_function", "Switch to use Curtis/Nocedal flexible penalty function",
      "yes", "no", "do not use the flexible penalty function procedure", "yes",
      "use the flexible penalty function procedure", "This determines if the flexible penalty function procedure by "
         "Curtis/Nocedal should be used in the line search.  For now, this only "
         "is implemented for the inexact algorithm.");
   roptions->AddLowerBoundedNumberOption("nu_low_init", "Initial value for the lower penalty parameter.", 0.0, true,
      1e-6, "This is the initial value for the lower penalty parameter in the "
         "Curtis/Nocedal flexible penalty function line search procedure.  This "
         "must be smaller or equal to the intial value of the upper penalty "
         "parameter, see option \"nu_init\".");
   roptions->AddLowerBoundedNumberOption("nu_low_fact",
      "Factor in update rule for nu_low in flexible penalty function.", 0.0, true, 1e-4, "");
   roptions->AddBoundedNumberOption("inexact_decomposition_activate_tol",
      "Line search stepsize threshold for activating step decomposition.", 0.0, true, 1.0, false, 1e-3, "");
   roptions->AddBoundedNumberOption("inexact_decomposition_inactivate_tol",
      "Line search stepsize threshold for inactivating step decomposition.", 0.0, true, 1.0, false, 1e-3, "");
}

 void MonotoneMuUpdate::RegisterOptions(const SmartPtr<RegisteredOptions>& roptions)
 {
   roptions->AddLowerBoundedNumberOption(
     "mu_init", "Initial value for the barrier parameter.",
     0.0, true,
     0.1,
     "This option determines the initial value for the barrier parameter "
     "(mu).  It is only relevant in the monotone, Fiacco-McCormick "
     "version of the algorithm. (i.e., if \"mu_strategy\" is chosen "
     "as \"monotone\")");
   roptions->AddLowerBoundedNumberOption(
     "barrier_tol_factor",
     "Factor for mu in barrier stop test.",
     0.0, true,
     10.0,
     "The convergence tolerance for each barrier problem in the monotone mode "
     "is the value of the barrier parameter times \"barrier_tol_factor\". "
     "This option is also used in the adaptive mu strategy during the "
     "monotone mode. (This is kappa_epsilon in implementation paper).");
   roptions->AddBoundedNumberOption(
     "mu_linear_decrease_factor",
     "Determines linear decrease rate of barrier parameter.",
     0.0, true, 1.0, true,
     0.2,
     "For the Fiacco-McCormick update procedure the new barrier parameter mu "
     "is obtained by taking the minimum of mu*\"mu_linear_decrease_factor\" "
     "and mu^\"superlinear_decrease_power\".  (This is kappa_mu in "
     "implementation paper.) This option is also used in the adaptive mu "
     "strategy during the monotone mode.");
   roptions->AddBoundedNumberOption(
     "mu_superlinear_decrease_power",
     "Determines superlinear decrease rate of barrier parameter.",
     1.0, true, 2.0, true,
     1.5,
     "For the Fiacco-McCormick update procedure the new barrier parameter mu "
     "is obtained by taking the minimum of mu*\"mu_linear_decrease_factor\" "
     "and mu^\"superlinear_decrease_power\".  (This is theta_mu in "
     "implementation paper.) This option is also used in the adaptive mu "
     "strategy during the monotone mode.");
   roptions->AddStringOption2(
     "mu_allow_fast_monotone_decrease",
     "Allow skipping of barrier problem if barrier test is already met.",
     "yes",
     "no", "Take at least one iteration per barrier problem",
     "yes", "Allow fast decrease of mu if barrier test it met",
     "If set to \"no\", the algorithm enforces at least one iteration per "
     "barrier problem, even if the barrier test is already met for the "
     "updated barrier parameter.");
   roptions->AddBoundedNumberOption(
     "tau_min",
     "Lower bound on fraction-to-the-boundary parameter tau.",
     0.0, true, 1.0, true,
     0.99,
     "(This is tau_min in the implementation paper.)  This option is also used "
     "in the adaptive mu strategy during the monotone mode.");
 }

 void PDFullSpaceSolver::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->AddLowerBoundedIntegerOption(
     "min_refinement_steps",
     "Minimum number of iterative refinement steps per linear system solve.",
     0, 1,
     "Iterative refinement (on the full unsymmetric system) is performed for "
     "each right hand side.  This option determines the minimum number "
     "of iterative refinements (i.e. at least \"min_refinement_steps\" "
     "iterative refinement steps are enforced per right hand side.)");
   roptions->AddLowerBoundedIntegerOption(
     "max_refinement_steps",
     "Maximum number of iterative refinement steps per linear system solve.",
     0, 10,
     "Iterative refinement (on the full unsymmetric system) is performed for "
     "each right hand side.  This option determines the maximum number "
     "of iterative refinement steps.");
   roptions->AddLowerBoundedNumberOption(
     "residual_ratio_max",
     "Iterative refinement tolerance",
     0.0, true, 1e-10,
     "Iterative refinement is performed until the residual test ratio is "
     "less than this tolerance (or until \"max_refinement_steps\" refinement "
     "steps are performed).");
   roptions->AddLowerBoundedNumberOption(
     "residual_ratio_singular",
     "Threshold for declaring linear system singular after failed iterative refinement.",
     0.0, true, 1e-5,
     "If the residual test ratio is larger than this value after failed "
     "iterative refinement, the algorithm pretends that the linear system is "
     "singular.");
   // ToDo Think about following option - are the correct norms used?
   roptions->AddLowerBoundedNumberOption(
     "residual_improvement_factor",
     "Minimal required reduction of residual test ratio in iterative refinement.",
     0.0, true, 0.999999999,
     "If the improvement of the residual test ratio made by one iterative "
     "refinement step is not better than this factor, iterative refinement "
     "is aborted.");
   roptions->AddLowerBoundedNumberOption(
     "neg_curv_test_tol",
     "Tolerance for heuristic to ignore wrong inertia.",
     0.0, false, 0.0,
     "If nonzero, incorrect inertia in the augmented system is ignored, and "
     "Ipopt tests if the direction is a direction of positive curvature.  This "
     "tolerance is alpha_n in the paper by Zavala and Chiang (2014) and it "
     "determines when the direction is considered to be sufficiently positive. "
     "A value in the range of [1e-12, 1e-11] is recommended.");
   roptions->AddStringOption2(
     "neg_curv_test_reg",
     "Whether to do the curvature test with the primal regularization (see Zavala and Chiang, 2014).",
     "yes", 
     "yes", "use primal regularization with the inertia-free curvature test",
     "no",  "use original IPOPT approach, in which the primal regularization is ignored",
     "");
 }

 void IpoptAlgorithm::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->SetRegisteringCategory("Line Search");
   roptions->AddLowerBoundedNumberOption(
     "kappa_sigma",
     "Factor limiting the deviation of dual variables from primal estimates.",
     0, true, 1e10,
     "If the dual variables deviate from their primal estimates, a correction "
     "is performed. (See Eqn. (16) in the implementation paper.) "
     "Setting the value to less than 1 disables the correction.");
   roptions->AddStringOption2(
     "recalc_y",
     "Tells the algorithm to recalculate the equality and inequality multipliers as least square estimates.",
     "no",
     "no", "use the Newton step to update the multipliers",
     "yes", "use least-square multiplier estimates",
     "This asks the algorithm to recompute the multipliers, whenever the "
     "current infeasibility is less than recalc_y_feas_tol. "
     "Choosing yes might be helpful in the quasi-Newton option.  However, "
     "each recalculation requires an extra factorization of the linear "
     "system.  If a limited memory quasi-Newton option is chosen, this is "
     "used by default.");
   roptions->AddLowerBoundedNumberOption(
     "recalc_y_feas_tol",
     "Feasibility threshold for recomputation of multipliers.",
     0, true, 1e-6,
     "If recalc_y is chosen and the current infeasibility is less than this "
     "value, then the multipliers are recomputed.");
   roptions->SetRegisteringCategory("Step Calculation");
   roptions->AddStringOption2(
     "mehrotra_algorithm",
     "Indicates if we want to do Mehrotra's algorithm.",
     "no",
     "no", "Do the usual Ipopt algorithm.",
     "yes", "Do Mehrotra's predictor-corrector algorithm.",
     "If set to yes, Ipopt runs as Mehrotra's predictor-corrector algorithm. "
     "This works usually very well for LPs and convex QPs.  This "
     "automatically disables the line search, and chooses the (unglobalized) "
     "adaptive mu strategy with the \"probing\" oracle, and uses "
     "\"corrector_type=affine\" without any safeguards; you should not set "
     "any of those options explicitly in addition.  Also, unless "
     "otherwise specified, the values of \"bound_push\", \"bound_frac\", and "
     "\"bound_mult_init_val\" are set more aggressive, and sets "
     "\"alpha_for_y=bound_mult\".");
   roptions->SetRegisteringCategory("");
   roptions->AddStringOption2(
     "sb",
     "",
     "no",
     "no", "",
     "yes", "");
 }

 void PDFullSpaceSolver::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->AddLowerBoundedIntegerOption(
     "min_refinement_steps",
     "Minimum number of iterative refinement steps per linear system solve.",
     0, 1,
     "Iterative refinement (on the full unsymmetric system) is performed for "
     "each right hand side.  This option determines the minimum number "
     "of iterative refinements (i.e. at least \"min_refinement_steps\" "
     "iterative refinement steps are enforced per right hand side.)");
   roptions->AddLowerBoundedIntegerOption(
     "max_refinement_steps",
     "Maximum number of iterative refinement steps per linear system solve.",
     0, 10,
     "Iterative refinement (on the full unsymmetric system) is performed for "
     "each right hand side.  This option determines the maximum number "
     "of iterative refinement steps.");
   roptions->AddLowerBoundedNumberOption(
     "residual_ratio_max",
     "Iterative refinement tolerance",
     0.0, true, 1e-10,
     "Iterative refinement is performed until the residual test ratio is "
     "less than this tolerance (or until \"max_refinement_steps\" refinement "
     "steps are performed).");
   roptions->AddLowerBoundedNumberOption(
     "residual_ratio_singular",
     "Threshold for declaring linear system singular after failed iterative refinement.",
     0.0, true, 1e-5,
     "If the residual test ratio is larger than this value after failed "
     "iterative refinement, the algorithm pretends that the linear system is "
     "singular.");
   // ToDo Think about following option - are the correct norms used?
   roptions->AddLowerBoundedNumberOption(
     "residual_improvement_factor",
     "Minimal required reduction of residual test ratio in iterative refinement.",
     0.0, true, 0.999999999,
     "If the improvement of the residual test ratio made by one iterative "
     "refinement step is not better than this factor, iterative refinement "
     "is aborted.");
   roptions->AddLowerBoundedNumberOption(
     "neg_curv_test_tol",
     "Tolerance for heuristic to ignore wrong inertia.",
     0.0, true, 0.0,
     "If positive, incorrect inertia in the augmented system is ignored, and "
     "we test if the direction is a direction of positive curvature.  This "
     "tolerance determines when the direction is considered to be "
     "sufficiently positive.");
 }

 void IterativeWsmpSolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->AddLowerBoundedIntegerOption(
     "wsmp_max_iter",
     "Maximal number of iterations in iterative WISMP",
     1, 1000,
     "");
   roptions->AddLowerBoundedNumberOption(
     "wsmp_inexact_droptol",
     "Drop tolerance for inexact factorization preconditioner in WISMP.",
     0.0, false, 0.0,
     "DPARM(14) in WISMP");
   roptions->AddLowerBoundedNumberOption(
     "wsmp_inexact_fillin_limit",
     "Fill-in limit for inexact factorization preconditioner in WISMP.",
     0.0, false, 0.0,
     "DPARM(15) in WISMP");
 }

 void Ma27TSolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->AddBoundedNumberOption(
     "ma27_pivtol",
     "Pivot tolerance for the linear solver MA27.",
     0.0, true, 1.0, true, 1e-8,
     "A smaller number pivots for sparsity, a larger number pivots for "
     "stability.  This option is only available if Ipopt has been compiled "
     "with MA27.");
   roptions->AddBoundedNumberOption(
     "ma27_pivtolmax",
     "Maximum pivot tolerance for the linear solver MA27.",
     0.0, true, 1.0, true, 1e-4,
     "Ipopt may increase pivtol as high as pivtolmax to get a more accurate "
     "solution to the linear system.  This option is only available if "
     "Ipopt has been compiled with MA27.");
   roptions->AddLowerBoundedNumberOption(
     "ma27_liw_init_factor",
     "Integer workspace memory for MA27.",
     1.0, false, 5.0,
     "The initial integer workspace memory = liw_init_factor * memory "
     "required by unfactored system. Ipopt will increase the workspace "
     "size by meminc_factor if required.  This option is only available if "
     "Ipopt has been compiled with MA27.");
   roptions->AddLowerBoundedNumberOption(
     "ma27_la_init_factor",
     "Real workspace memory for MA27.",
     1.0, false, 5.0,
     "The initial real workspace memory = la_init_factor * memory "
     "required by unfactored system. Ipopt will increase the workspace"
     " size by meminc_factor if required.  This option is only available if "
     " Ipopt has been compiled with MA27.");
   roptions->AddLowerBoundedNumberOption(
     "ma27_meminc_factor",
     "Increment factor for workspace size for MA27.",
     1.0, false, 10.0,
     "If the integer or real workspace is not large enough, "
     "Ipopt will increase its size by this factor.  This option is only "
     "available if Ipopt has been compiled with MA27.");
 }

 void GradientScaling::RegisterOptions(const SmartPtr<RegisteredOptions>& roptions)
 {
   roptions->AddLowerBoundedNumberOption(
     "nlp_scaling_max_gradient", "Maximum gradient after NLP scaling.",
     0, true, 100.0,
     "This is the gradient scaling cut-off. If the maximum"
     " gradient is above this value, then gradient based scaling"
     " will be performed. Scaling parameters are calculated to"
     " scale the maximum gradient back to this value. (This is g_max in "
     "Section 3.8 of the implementation paper.) Note: This"
     " option is only used if \"nlp_scaling_method\" is chosen as"
     " \"gradient-based\".");
   roptions->AddLowerBoundedNumberOption(
     "nlp_scaling_obj_target_gradient",
     "Target value for objective function gradient size.",
     0, false, 0.,
     "If a positive number is chosen, the scaling factor the objective "
     "function is computed so that the gradient has the max norm of the given "
     "size at the starting point.  This overrides nlp_scaling_max_gradient "
     "for the objective function.");
   roptions->AddLowerBoundedNumberOption(
     "nlp_scaling_constr_target_gradient",
     "Target value for constraint function gradient size.",
     0, false, 0.,
     "If a positive number is chosen, the scaling factor the constraint "
     "functions is computed so that the gradient has the max norm of the given "
     "size at the starting point.  This overrides nlp_scaling_max_gradient "
     "for the constraint functions.");
   roptions->AddLowerBoundedNumberOption(
     "nlp_scaling_min_value",
     "Minimum value of gradient-based scaling values.",
     0, false, 1e-8,
     "This is the lower bound for the scaling factors computed by "
     "gradient-based scaling method.  If some derivatives of some functions "
     "are huge, the scaling factors will otherwise become very small, and "
     "the (unscaled) final constraint violation, for example, might then be "
     "significant.  Note: This option is only used if \"nlp_scaling_method\" "
     "is chosen as \"gradient-based\".");
 }

 void GradientScaling::RegisterOptions(const SmartPtr<RegisteredOptions>& roptions)
 {
   roptions->AddLowerBoundedNumberOption(
     "nlp_scaling_max_gradient", "Maximum gradient after NLP scaling.",
     0, true, 100.0,
     "This is the gradient scaling cut-off. If the maximum"
     " gradient is above this value, then gradient based scaling"
     " will be performed. Scaling parameters are calculated to"
     " scale the maximum gradient back to this value. (This is g_max in "
     "Section 3.8 of the implementation paper.) Note: This"
     " option is only used if \"nlp_scaling_method\" is chosen as"
     " \"gradient-based\".");
 }

 void WarmStartIterateInitializer::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->AddLowerBoundedNumberOption(
     "warm_start_bound_push",
     "same as bound_push for the regular initializer.",
     0.0, true, 1e-3);
   roptions->AddBoundedNumberOption(
     "warm_start_bound_frac",
     "same as bound_frac for the regular initializer.",
     0.0, true, 0.5, false, 1e-3);
   roptions->AddLowerBoundedNumberOption(
     "warm_start_slack_bound_push",
     "same as slack_bound_push for the regular initializer.",
     0.0, true, 1e-3);
   roptions->AddBoundedNumberOption(
     "warm_start_slack_bound_frac",
     "same as slack_bound_frac for the regular initializer.",
     0.0, true, 0.5, false, 1e-3);
   roptions->AddLowerBoundedNumberOption(
     "warm_start_mult_bound_push",
     "same as mult_bound_push for the regular initializer.",
     0.0, true, 1e-3);
   roptions->AddNumberOption(
     "warm_start_mult_init_max",
     "Maximum initial value for the equality multipliers.",
     1e6);
   roptions->AddStringOption2(
     "warm_start_entire_iterate",
     "Tells algorithm whether to use the GetWarmStartIterate method in the NLP.",
     "no",
     "no", "call GetStartingPoint in the NLP",
     "yes", "call GetWarmStartIterate in the NLP",
     "");
   roptions->SetRegisteringCategory("Uncategorized");
   roptions->AddNumberOption(
     "warm_start_target_mu",
     "Unsupported!",
     0e-3);
 }

 void MinC_1NrmRestorationPhase::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
 {
   roptions->AddLowerBoundedNumberOption(
     "bound_mult_reset_threshold",
     "Threshold for resetting bound multipliers after the restoration phase.",
     0.0, false,
     1e3,
     "After returning from the restoration phase, the bound multipliers are "
     "updated with a Newton step for complementarity.  Here, the "
     "change in the primal variables during the entire restoration "
     "phase is taken to be the corresponding primal Newton step. "
     "However, if after the update the largest bound multiplier "
     "exceeds the threshold specified by this option, the multipliers "
     "are all reset to 1.");
   roptions->AddLowerBoundedNumberOption(
     "constr_mult_reset_threshold",
     "Threshold for resetting equality and inequality multipliers after restoration phase.",
     0.0, false,
     0e3,
     "After returning from the restoration phase, the constraint multipliers "
     "are recomputed by a least square estimate.  This option triggers when "
     "those least-square estimates should be ignored.");
 }

 void IpoptData::RegisterOptions(const SmartPtr<RegisteredOptions>& roptions)
 {
   roptions->SetRegisteringCategory("Convergence");
   roptions->AddLowerBoundedNumberOption(
     "tol",
     "Desired convergence tolerance (relative).",
     0.0, true,  1e-8,
     "Determines the convergence tolerance for the algorithm.  The "
     "algorithm terminates successfully, if the (scaled) NLP error "
     "becomes smaller than this value, and if the (absolute) criteria "
     "according to \"dual_inf_tol\", \"primal_inf_tol\", and "
     "\"cmpl_inf_tol\" are met.  (This is epsilon_tol in Eqn. (6) in "
     "implementation paper).  See also \"acceptable_tol\" as a second "
     "termination criterion.  Note, some other algorithmic features also use "
     "this quantity to determine thresholds etc.");
 }

  void Ma27TSolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
  {
    roptions->AddBoundedNumberOption(
      "ma27_pivtol",
      "Pivot tolerance for the linear solver MA27.",
      0.0, true, 1.0, true, 1e-8,
      "A smaller number pivots for sparsity, a larger number pivots for "
      "stability.  This option is only available if Ipopt has been compiled "
      "with MA27.");
    roptions->AddBoundedNumberOption(
      "ma27_pivtolmax",
      "Maximum pivot tolerance for the linear solver MA27.",
      0.0, true, 1.0, true, 1e-4,
      "Ipopt may increase pivtol as high as pivtolmax to get a more accurate "
      "solution to the linear system.  This option is only available if "
      "Ipopt has been compiled with MA27.");
    roptions->AddLowerBoundedNumberOption(
      "ma27_liw_init_factor",
      "Integer workspace memory for MA27.",
      1.0, false, 5.0,
      "The initial integer workspace memory = liw_init_factor * memory "
      "required by unfactored system. Ipopt will increase the workspace "
      "size by meminc_factor if required.  This option is only available if "
      "Ipopt has been compiled with MA27.");
    roptions->AddLowerBoundedNumberOption(
      "ma27_la_init_factor",
      "Real workspace memory for MA27.",
      1.0, false, 5.0,
      "The initial real workspace memory = la_init_factor * memory "
      "required by unfactored system. Ipopt will increase the workspace"
      " size by meminc_factor if required.  This option is only available if "
      " Ipopt has been compiled with MA27.");
    roptions->AddLowerBoundedNumberOption(
      "ma27_meminc_factor",
      "Increment factor for workspace size for MA27.",
      1.0, false, 2.0,
      "If the integer or real workspace is not large enough, "
      "Ipopt will increase its size by this factor.  This option is only "
      "available if Ipopt has been compiled with MA27.");
    roptions->AddStringOption2(
      "ma27_skip_inertia_check",
      "Always pretend inertia is correct.",
      "no",
      "no", "check inertia",
      "yes", "skip inertia check",
      "Setting this option to \"yes\" essentially disables inertia check. "
      "This option makes the algorithm non-robust and easily fail, but it "
      "might give some insight into the necessity of inertia control.");
    roptions->AddStringOption2(
      "ma27_ignore_singularity",
      "Enables MA27's ability to solve a linear system even if the matrix is singular.",
      "no",
      "no", "Don't have MA27 solve singular systems",
      "yes", "Have MA27 solve singular systems",
      "Setting this option to \"yes\" means that Ipopt will call MA27 to "
      "compute solutions for right hand sides, even if MA27 has detected that "
      "the matrix is singular (but is still able to solve the linear system). "
      "In some cases this might be better than using Ipopt's heuristic of "
      "small perturbation of the lower diagonal of the KKT matrix.");

  }

//.........这里部分代码省略.........
      "yes", "skip inertia check",
      "Setting this option to \"yes\" essentially disables inertia check. "
      "This option makes the algorithm non-robust and easily fail, but it "
      "might give some insight into the necessity of inertia control.");
    roptions->AddIntegerOption(
      "pardiso_max_iterative_refinement_steps",
      "Limit on number of iterative refinement steps.",
      // ToDo: Decide how many iterative refinement steps in Pardiso.
      //       For now, we keep the default (0) for Basel Pardiso.
      //       For MKL Pardiso, it seems that setting it to 1 makes it more
      //       robust and just a little bit slower.
      //       Setting it to 1 should decrease the number of iterative refinement
      //       steps by 1 in case that perturbed pivots have been used, and increase
      //       it by 1 otherwise.
#ifdef HAVE_PARDISO_MKL
      1,
#else
      0,
#endif
      "The solver does not perform more than the absolute value of this value steps of iterative refinement and stops the process if a satisfactory level of accuracy of the solution in terms of backward error is achieved. "
      "If negative, the accumulation of the residue uses extended precision real and complex data types. Perturbed pivots result in iterative refinement. "
      "The solver automatically performs two steps of iterative refinements when perturbed pivots are obtained during the numerical factorization and this option is set to 0.");
#ifdef HAVE_PARDISO_MKL
    roptions->AddStringOption4(
      "pardiso_order",
      "Controls the fill-in reduction ordering algorithm for the input matrix.",
      "metis",
      "amd", "minimum degree algorithm",
      "one", "undocumented",
      "metis", "MeTiS nested dissection algorithm",
      "pmetis", "parallel (OpenMP) version of MeTiS nested dissection algorithm",
      "");
#else
    roptions->AddStringOption6(
      "pardiso_order",
      "Controls the fill-in reduction ordering algorithm for the input matrix.",
      "five",
      "amd", "minimum degree algorithm",
      "one", "undocumented",
      "metis", "MeTiS nested dissection algorithm",
      "pmetis", "parallel (OpenMP) version of MeTiS nested dissection algorithm",
      "four", "undocumented",
      "five", "undocumented"
      "");
#endif
#if !defined(HAVE_PARDISO_OLDINTERFACE) && !defined(HAVE_PARDISO_MKL)
    roptions->AddLowerBoundedIntegerOption(
      "pardiso_max_iter",
      "Maximum number of Krylov-Subspace Iteration",
      1, 500,
      "DPARM(1)");
    roptions->AddBoundedNumberOption(
      "pardiso_iter_relative_tol",
      "Relative Residual Convergence",
      0.0, true, 1.0, true, 1e-6,
      "DPARM(2)");
    roptions->AddLowerBoundedIntegerOption(
      "pardiso_iter_coarse_size",
      "Maximum Size of Coarse Grid Matrix",
      1, 5000,
      "DPARM(3)");
    roptions->AddLowerBoundedIntegerOption(
      "pardiso_iter_max_levels",
      "Maximum Size of Grid Levels",
      1, 10,
      "DPARM(4)");
    roptions->AddBoundedNumberOption(
      "pardiso_iter_dropping_factor",
      "dropping value for incomplete factor",
      0.0, true, 1.0, true, 0.5,
      "DPARM(5)");
    roptions->AddBoundedNumberOption(
      "pardiso_iter_dropping_schur",
      "dropping value for sparsify schur complement factor",
      0.0, true, 1.0, true, 1e-1,
      "DPARM(6)");
    roptions->AddLowerBoundedIntegerOption(
      "pardiso_iter_max_row_fill",
      "max fill for each row",
      1,10000000,
      "DPARM(7)");
    roptions->AddLowerBoundedNumberOption(
      "pardiso_iter_inverse_norm_factor",
      "",
      1, true, 5000000,
      "DPARM(8)");
    roptions->AddStringOption2(
      "pardiso_iterative",
      "Switch on iterative solver in Pardiso library",
      "no",
      "no", "",
      "yes", "",
      "This option is not available for Pardiso < 4.0 or MKL Pardiso");
    roptions->AddLowerBoundedIntegerOption(
      "pardiso_max_droptol_corrections",
      "Maximal number of decreases of drop tolerance during one solve.",
      1, 4,
      "This is relevant only for iterative Pardiso options.");
#endif
  }