void
OrigIterationOutput::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
std::string prev_cat = roptions->RegisteringCategory();
roptions->SetRegisteringCategory("Output");
roptions->AddStringOption2(
"print_info_string",
"Enables printing of additional info string at end of iteration output.",
"no",
"no", "don't print string",
"yes", "print string at end of each iteration output",
"This string contains some insider information about the current "
"iteration. For details, look for \"Diagnostic Tags\" in the Ipopt "
"documentation.");
roptions->AddStringOption2(
"inf_pr_output",
"Determines what value is printed in the \"inf_pr\" output column.",
"original",
"internal", "max-norm of violation of internal equality constraints",
"original", "maximal constraint violation in original NLP",
"Ipopt works with a reformulation of the original problem, where slacks "
"are introduced and the problem might have been scaled. The choice "
"\"internal\" prints out the constraint violation of this formulation. "
"With \"original\" the true constraint violation in the original NLP is "
"printed.");
roptions->SetRegisteringCategory(prev_cat);
}
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 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 RestoIpoptNLP::RegisterOptions(
SmartPtr<RegisteredOptions> roptions
)
{
roptions->AddStringOption2("evaluate_orig_obj_at_resto_trial",
"Determines if the original objective function should be evaluated at restoration phase trial points.", "yes",
"no", "skip evaluation", "yes", "evaluate at every trial point",
"Setting this option to \"yes\" makes the restoration phase algorithm "
"evaluate the objective function of the original problem at every trial "
"point encountered during the restoration phase, even if this value is "
"not required. In this way, it is guaranteed that the original "
"objective function can be evaluated without error at all accepted "
"iterates; otherwise the algorithm might fail at a point where the "
"restoration phase accepts an iterate that is good for the restoration "
"phase problem, but not the original problem. On the other hand, if "
"the evaluation of the original objective is expensive, this might be "
"costly.");
roptions->AddLowerBoundedNumberOption("resto_penalty_parameter",
"Penalty parameter in the restoration phase objective function.", 0.0, true, 1e3,
"This is the parameter rho in equation (31a) in the Ipopt "
"implementation paper.");
roptions->AddLowerBoundedNumberOption("resto_proximity_weight",
"Weighting factor for the proximity term in restoration phase objective.", 0.0, false, 1.,
"This determines how the parameter zera in equation (29a) in the "
"implementation paper is computed. zeta here is "
"resto_proximity_weight*sqrt(mu), where mu is the current barrier "
"parameter.");
}
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 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
OrigIterationOutput::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
std::string prev_cat = roptions->RegisteringCategory();
roptions->SetRegisteringCategory("Output");
roptions->AddStringOption2(
"print_info_string",
"Enables printing of additional info string at end of iteration output.",
"no",
"no", "don't print string",
"yes", "print string at end of each iteration output",
"This string contains some insider information about the current iteration.");
roptions->SetRegisteringCategory(prev_cat);
}
void PDSearchDirCalculator::RegisterOptions(const SmartPtr<RegisteredOptions>& roptions)
{
roptions->SetRegisteringCategory("Step Calculation");
roptions->AddStringOption2(
"fast_step_computation",
"Indicates if the linear system should be solved quickly.",
"no",
"no", "Verify solution of linear system by computing residuals.",
"yes", "Trust that linear systems are solved well.",
"If set to yes, the algorithm assumes that the linear system that is "
"solved to obtain the search direction, is solved sufficiently well. "
"In that case, no residuals are computed, and the computation of the "
"search direction is a little faster.");
}
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 AlgorithmBuilder::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->SetRegisteringCategory("Linear Solver");
roptions->AddStringOption9(
"linear_solver",
"Linear solver used for step computations.",
#ifdef COINHSL_HAS_MA27
"ma27",
#else
# ifdef COINHSL_HAS_MA57
"ma57",
# else
# ifdef COINHSL_HAS_MA97
"ma97",
#else
# ifdef COINHSL_HAS_MA86
"ma86",
# else
# ifdef HAVE_PARDISO
"pardiso",
# else
# ifdef HAVE_WSMP
"wsmp",
# else
# ifdef COIN_HAS_MUMPS
"mumps",
# else
# ifdef COINHSL_HAS_MA77
"ma77",
# else
"ma27",
# endif
# endif
# endif
# endif
# endif
# endif
# endif
#endif
"ma27", "use the Harwell routine MA27",
"ma57", "use the Harwell routine MA57",
"ma77", "use the Harwell routine HSL_MA77",
"ma86", "use the Harwell routine HSL_MA86",
"ma97", "use the Harwell routine HSL_MA97",
"pardiso", "use the Pardiso package",
"wsmp", "use WSMP package",
"mumps", "use MUMPS package",
"custom", "use custom linear solver",
"Determines which linear algebra package is to be used for the "
"solution of the augmented linear system (for obtaining the search "
"directions). "
"Note, the code must have been compiled with the linear solver you want "
"to choose. Depending on your Ipopt installation, not all options are "
"available.");
roptions->SetRegisteringCategory("Linear Solver");
roptions->AddStringOption3(
"linear_system_scaling",
"Method for scaling the linear system.",
#ifdef COINHSL_HAS_MC19
"mc19",
#else
"none",
#endif
"none", "no scaling will be performed",
"mc19", "use the Harwell routine MC19",
"slack-based", "use the slack values",
"Determines the method used to compute symmetric scaling "
"factors for the augmented system (see also the "
"\"linear_scaling_on_demand\" option). This scaling is independent "
"of the NLP problem scaling. By default, MC19 is only used if MA27 or "
"MA57 are selected as linear solvers. This value is only available if "
"Ipopt has been compiled with MC19.");
roptions->SetRegisteringCategory("NLP Scaling");
roptions->AddStringOption4(
"nlp_scaling_method",
"Select the technique used for scaling the NLP.",
"gradient-based",
"none", "no problem scaling will be performed",
"user-scaling", "scaling parameters will come from the user",
"gradient-based", "scale the problem so the maximum gradient at the starting point is scaling_max_gradient",
"equilibration-based", "scale the problem so that first derivatives are of order 1 at random points (only available with MC19)",
"Selects the technique used for scaling the problem internally before it is solved."
" For user-scaling, the parameters come from the NLP. If you are using "
"AMPL, they can be specified through suffixes (\"scaling_factor\")");
roptions->SetRegisteringCategory("Barrier Parameter Update");
roptions->AddStringOption2(
"mu_strategy",
"Update strategy for barrier parameter.",
"monotone",
"monotone", "use the monotone (Fiacco-McCormick) strategy",
"adaptive", "use the adaptive update strategy",
"Determines which barrier parameter update strategy is to be used.");
roptions->AddStringOption3(
"mu_oracle",
"Oracle for a new barrier parameter in the adaptive strategy.",
"quality-function",
"probing", "Mehrotra's probing heuristic",
"loqo", "LOQO's centrality rule",
"quality-function", "minimize a quality function",
"Determines how a new barrier parameter is computed in each "
"\"free-mode\" iteration of the adaptive barrier parameter "
"strategy. (Only considered if \"adaptive\" is selected for "
"option \"mu_strategy\").");
roptions->AddStringOption4(
"fixed_mu_oracle",
"Oracle for the barrier parameter when switching to fixed mode.",
"average_compl",
"probing", "Mehrotra's probing heuristic",
"loqo", "LOQO's centrality rule",
"quality-function", "minimize a quality function",
"average_compl", "base on current average complementarity",
"Determines how the first value of the barrier parameter should be "
"computed when switching to the \"monotone mode\" in the adaptive "
"strategy. (Only considered if \"adaptive\" is selected for option "
"\"mu_strategy\".)");
roptions->SetRegisteringCategory("Hessian Approximation");
roptions->AddStringOption2(
"limited_memory_aug_solver",
"Strategy for solving the augmented system for low-rank Hessian.",
"sherman-morrison",
"sherman-morrison", "use Sherman-Morrison formula",
"extended", "use an extended augmented system",
"");
roptions->SetRegisteringCategory("Line Search");
roptions->AddStringOption3(
"line_search_method",
"Globalization method used in backtracking line search",
"filter",
"filter", "Filter method",
"cg-penalty", "Chen-Goldfarb penalty function",
"penalty", "Standard penalty function",
"Only the \"filter\" choice is officially supported. But sometimes, "
"good results might be obtained with the other choices.");
roptions->SetRegisteringCategory("Undocumented");
roptions->AddStringOption2(
"wsmp_iterative",
"Switches to iterative solver in WSMP.",
"no",
"no", "use direct solver",
"yes", "use iterative solver",
"EXPERIMENTAL!");
}
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.");
}
void AdaptiveMuUpdate::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddLowerBoundedNumberOption(
"mu_max_fact",
"Factor for initialization of maximum value for barrier parameter.",
0.0, true, 1e3,
"This option determines the upper bound on the barrier parameter. This "
"upper bound is computed as the average complementarity at the initial "
"point times the value of this option. (Only used if option "
"\"mu_strategy\" is chosen as \"adaptive\".)");
roptions->AddLowerBoundedNumberOption(
"mu_max",
"Maximum value for barrier parameter.",
0.0, true, 1e5,
"This option specifies an upper bound on the barrier parameter in the "
"adaptive mu selection mode. If this option is set, it overwrites the "
"effect of mu_max_fact. (Only used if option "
"\"mu_strategy\" is chosen as \"adaptive\".)");
roptions->AddLowerBoundedNumberOption(
"mu_min",
"Minimum value for barrier parameter.",
0.0, true, 1e-11,
"This option specifies the lower bound on the barrier parameter in the "
"adaptive mu selection mode. By default, it is set to the minimum of 1e-11 and "
"min(\"tol\",\"compl_inf_tol\")/(\"barrier_tol_factor\"+1), which "
"should be a reasonable value. (Only used if option "
"\"mu_strategy\" is chosen as \"adaptive\".)");
std::string prev_cat = roptions->RegisteringCategory();
roptions->SetRegisteringCategory("Undocumented");
roptions->AddLowerBoundedNumberOption(
"adaptive_mu_safeguard_factor",
"",
0.0, false, 0.0);
roptions->SetRegisteringCategory(prev_cat);
roptions->AddStringOption3(
"adaptive_mu_globalization",
"Globalization strategy for the adaptive mu selection mode.",
"obj-constr-filter",
"kkt-error", "nonmonotone decrease of kkt-error",
"obj-constr-filter", "2-dim filter for objective and constraint violation",
"never-monotone-mode", "disables globalization",
"To achieve global convergence of the adaptive version, the algorithm "
"has to switch to the monotone mode (Fiacco-McCormick approach) when "
"convergence does not seem to appear. This option sets the "
"criterion used to decide when to do this switch. (Only used if option "
"\"mu_strategy\" is chosen as \"adaptive\".)");
roptions->AddLowerBoundedIntegerOption(
"adaptive_mu_kkterror_red_iters",
"Maximum number of iterations requiring sufficient progress.",
0, 4,
"For the \"kkt-error\" based globalization strategy, sufficient "
"progress must be made for \"adaptive_mu_kkterror_red_iters\" "
"iterations. If this number of iterations is exceeded, the "
"globalization strategy switches to the monotone mode.");
roptions->AddBoundedNumberOption(
"adaptive_mu_kkterror_red_fact",
"Sufficient decrease factor for \"kkt-error\" globalization strategy.",
0.0, true, 1.0, true,
0.9999,
"For the \"kkt-error\" based globalization strategy, the error "
"must decrease by this factor to be deemed sufficient decrease.");
roptions->AddBoundedNumberOption(
"filter_margin_fact",
"Factor determining width of margin for obj-constr-filter adaptive globalization strategy.",
0.0, true, 1.0, true,
1e-5,
"When using the adaptive globalization strategy, \"obj-constr-filter\", "
"sufficient progress for a filter entry is defined as "
"follows: (new obj) < (filter obj) - filter_margin_fact*(new "
"constr-viol) OR (new constr-viol) < (filter constr-viol) - "
"filter_margin_fact*(new constr-viol). For the description of "
"the \"kkt-error-filter\" option see \"filter_max_margin\".");
roptions->AddLowerBoundedNumberOption(
"filter_max_margin",
"Maximum width of margin in obj-constr-filter adaptive globalization strategy.",
0.0, true,
1.0,
// ToDo Detailed description later
"");
roptions->AddStringOption2(
"adaptive_mu_restore_previous_iterate",
"Indicates if the previous iterate should be restored if the monotone mode is entered.",
"no",
"no", "don't restore accepted iterate",
"yes", "restore accepted iterate",
"When the globalization strategy for the adaptive barrier algorithm "
"switches to the monotone mode, it can either start "
"from the most recent iterate (no), or from the last "
"iterate that was accepted (yes).");
roptions->AddLowerBoundedNumberOption(
"adaptive_mu_monotone_init_factor",
"Determines the initial value of the barrier parameter when switching to the monotone mode.",
0.0, true, 0.8,
"When the globalization strategy for the adaptive barrier algorithm "
"switches to the monotone mode and fixed_mu_oracle is chosen as "
"\"average_compl\", the barrier parameter is set to the "
"current average complementarity times the value of "
"\"adaptive_mu_monotone_init_factor\".");
roptions->AddStringOption4(
"adaptive_mu_kkt_norm_type",
"Norm used for the KKT error in the adaptive mu globalization strategies.",
"2-norm-squared",
"1-norm", "use the 1-norm (abs sum)",
"2-norm-squared", "use the 2-norm squared (sum of squares)",
"max-norm", "use the infinity norm (max)",
"2-norm", "use 2-norm",
"When computing the KKT error for the globalization strategies, the "
"norm to be used is specified with this option. Note, this options is also used "
"in the QualityFunctionMuOracle.");
}
void Ma77SolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddIntegerOption(
"ma77_print_level",
"Debug printing level for the linear solver MA77",
-1,
"");
/*
"<0 no printing.\n"
"0 Error and warning messages only.\n"
"=1 Limited diagnostic printing.\n"
">1 Additional diagnostic printing.");
*/
roptions->AddLowerBoundedIntegerOption(
"ma77_buffer_lpage",
"Number of scalars per MA77 buffer page",
1, 4096,
"Number of scalars per an in-core buffer in the out-of-core solver "
"MA77. Must be at most ma77_file_size.");
roptions->AddLowerBoundedIntegerOption(
"ma77_buffer_npage",
"Number of pages that make up MA77 buffer",
1, 1600,
"Number of pages of size buffer_lpage that exist in-core for the "
"out-of-core solver MA77.");
roptions->AddLowerBoundedIntegerOption(
"ma77_file_size",
"Target size of each temporary file for MA77, scalars per type",
1, 2097152,
"MA77 uses many temporary files, this option controls the size of "
"each one. It is measured in the number of entries (int or double), "
"NOT bytes.");
roptions->AddLowerBoundedIntegerOption(
"ma77_maxstore",
"Maximum storage size for MA77 in-core mode",
0, 0,
"If greater than zero, the maximum size of factors stored in core "
"before out-of-core mode is invoked.");
roptions->AddLowerBoundedIntegerOption(
"ma77_nemin",
"Node Amalgamation parameter",
1, 8,
"Two nodes in elimination tree are merged if result has fewer than "
"ma77_nemin variables.");
roptions->AddLowerBoundedNumberOption(
"ma77_small",
"Zero Pivot Threshold",
0.0, false, 1e-20,
"Any pivot less than ma77_small is treated as zero.");
roptions->AddLowerBoundedNumberOption(
"ma77_static",
"Static Pivoting Threshold",
0.0, false, 0.0,
"See MA77 documentation. Either ma77_static=0.0 or "
"ma77_static>ma77_small. ma77_static=0.0 disables static pivoting.");
roptions->AddBoundedNumberOption(
"ma77_u",
"Pivoting Threshold",
0.0, false, 0.5, false, 1e-8,
"See MA77 documentation.");
roptions->AddBoundedNumberOption(
"ma77_umax",
"Maximum Pivoting Threshold",
0.0, false, 0.5, false, 1e-4,
"Maximum value to which u will be increased to improve quality.");
roptions->AddStringOption2(
"ma77_order",
"Controls type of ordering used by HSL_MA77",
#ifdef COINHSL_HAS_METIS
"metis",
#else
"amd",
#endif
"amd", "Use the HSL_MC68 approximate minimum degree algorithm",
"metis", "Use the MeTiS nested dissection algorithm (if available)",
"This option controls ordering for the solver HSL_MA77.");
}
void CGPenaltyLSAcceptor::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddStringOption2(
"never_use_piecewise_penalty_ls",
"Toggle to switch off the piecewise penalty method",
"no",
"no", "always use the piecewise penalty method",
"yes", "never use the piecewise penalty method",
"");
roptions->AddBoundedNumberOption(
"eta_penalty",
"Relaxation factor in the Armijo condition for the penalty function.",
0.0, true, 0.5, true, 1e-8);
roptions->AddLowerBoundedNumberOption(
"penalty_update_infeasibility_tol",
"Threshold for infeasibility in penalty parameter update test.",
0.0, true, 1e-9,
"If the new constraint violation is smaller than this tolerance, the "
"penalty parameter is not increased.");
roptions->AddLowerBoundedNumberOption(
"eta_min",
"LIFENG WRITES THIS.",
0.0, true, 1e1,
"");
roptions->AddLowerBoundedNumberOption(
"pen_theta_max_fact",
"Determines upper bound for constraint violation in the filter.",
0.0, true, 1e4,
"The algorithmic parameter theta_max is determined as theta_max_fact "
"times the maximum of 1 and the constraint violation at initial point. "
"Any point with a constraint violation larger than theta_max is "
"unacceptable to the filter (see Eqn. (21) in implementation paper).");
roptions->AddLowerBoundedNumberOption(
"penalty_update_compl_tol",
"LIFENG WRITES THIS.",
0.0, true, 1e1,
"");
roptions->AddLowerBoundedNumberOption(
"chi_hat",
"LIFENG WRITES THIS.",
0.0, true, 2.,
"");
roptions->AddLowerBoundedNumberOption(
"chi_tilde",
"LIFENG WRITES THIS.",
0.0, true, 5.,
"");
roptions->AddLowerBoundedNumberOption(
"chi_cup",
"LIFENG WRITES THIS.",
0.0, true, 1.5,
"");
roptions->AddLowerBoundedNumberOption(
"gamma_hat",
"LIFENG WRITES THIS.",
0.0, true, 0.04,
"");
roptions->AddLowerBoundedNumberOption(
"gamma_tilde",
"LIFENG WRITES THIS.",
0.0, true, 4.,
"");
roptions->AddLowerBoundedNumberOption(
"epsilon_c",
"LIFENG WRITES THIS.",
0.0, true, 1e-2,
"");
roptions->AddLowerBoundedNumberOption(
"piecewisepenalty_gamma_obj",
"LIFENG WRITES THIS.",
0.0, true, 1e-13,
"");
roptions->AddLowerBoundedNumberOption(
"piecewisepenalty_gamma_infeasi",
"LIFENG WRITES THIS.",
0.0, true, 1e-13,
"");
roptions->AddLowerBoundedNumberOption(
"min_alpha_primal",
"LIFENG WRITES THIS.",
0.0, true, 1e-13,
"");
roptions->AddLowerBoundedNumberOption(
"theta_min",
"LIFENG WRITES THIS.",
0.0, true, 1e-6,
"");
roptions->AddLowerBoundedNumberOption(
"mult_diverg_feasibility_tol",
"tolerance for deciding if the multipliers are diverging",
0, true, 1e-7,
"");
roptions->AddLowerBoundedNumberOption(
"mult_diverg_y_tol",
"tolerance for deciding if the multipliers are diverging",
0, true, 1e8,
"");
}
void Ma57TSolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddBoundedNumberOption(
"ma57_pivtol",
"Pivot tolerance for the linear solver MA57.",
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 MA57.");
roptions->AddBoundedNumberOption(
"ma57_pivtolmax",
"Maximum pivot tolerance for the linear solver MA57.",
0.0, true, 1.0, true, 1e-4,
"Ipopt may increase pivtol as high as ma57_pivtolmax to get a more "
"accurate solution to the linear system. This option is only available "
"if Ipopt has been compiled with MA57.");
roptions->AddLowerBoundedNumberOption(
"ma57_pre_alloc",
"Safety factor for work space memory allocation for the linear solver MA57.",
1., false, 1.05,
"If 1 is chosen, the suggested amount of work space is used. However, "
"choosing a larger number might avoid reallocation if the suggest values "
"do not suffice. This option is only available if Ipopt has been "
"compiled with MA57.");
roptions->AddBoundedIntegerOption(
"ma57_pivot_order",
"Controls pivot order in MA57",
0, 5, 5,
"This is ICNTL(6) in MA57.");
roptions->AddStringOption2(
"ma57_automatic_scaling",
"Controls MA57 automatic scaling",
"yes",
"no", "Do not scale the linear system matrix",
"yes", "Scale the linear system matrix",
"This option controls the internal scaling option of MA57."
"This is ICNTL(15) in MA57.");
// CET: 04-29-2010
roptions->AddLowerBoundedIntegerOption(
"ma57_block_size",
"Controls block size used by Level 3 BLAS in MA57BD",
1, 16,
"This is ICNTL(11) in MA57.");
roptions->AddLowerBoundedIntegerOption(
"ma57_node_amalgamation",
"Node amalgamation parameter",
1, 16,
"This is ICNTL(12) in MA57.");
roptions->AddBoundedIntegerOption(
"ma57_small_pivot_flag",
"If set to 1, then when small entries defined by CNTL(2) are detected "
"they are removed and the corresponding pivots placed at the end of the "
"factorization. This can be particularly efficient if the matrix is "
"highly rank deficient.",
0, 1, 0,
"This is ICNTL(16) in MA57.");
// CET 04-29-2010
}
void PardisoSolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
// Todo Use keywords instead of integer numbers
roptions->AddStringOption3(
"pardiso_matching_strategy",
"Matching strategy to be used by Pardiso",
"complete+2x2",
"complete", "Match complete (IPAR(13)=1)",
"complete+2x2", "Match complete+2x2 (IPAR(13)=2)",
"constraints", "Match constraints (IPAR(13)=3)",
"This is IPAR(13) in Pardiso manual.");
roptions->AddStringOption2(
"pardiso_redo_symbolic_fact_only_if_inertia_wrong",
"Toggle for handling case when elements were perturbed by Pardiso.",
"no",
"no", "Always redo symbolic factorization when elements were perturbed",
"yes", "Only redo symbolic factorization when elements were perturbed if also the inertia was wrong",
"");
roptions->AddStringOption2(
"pardiso_repeated_perturbation_means_singular",
"Interpretation of perturbed elements.",
"no",
"no", "Don't assume that matrix is singular if elements were perturbed after recent symbolic factorization",
"yes", "Assume that matrix is singular if elements were perturbed after recent symbolic factorization",
"");
//roptions->AddLowerBoundedIntegerOption(
// "pardiso_out_of_core_power",
// "Enables out-of-core variant of Pardiso",
// 0, 0,
// "Setting this option to a positive integer k makes Pardiso work in the "
// "out-of-core variant where the factor is split in 2^k subdomains. This "
// "is IPARM(50) in the Pardiso manual. This option is only available if "
// "Ipopt has been compiled with Pardiso.");
roptions->AddLowerBoundedIntegerOption(
"pardiso_msglvl",
"Pardiso message level",
0, 0,
"This determines the amount of analysis output from the Pardiso solver. "
"This is MSGLVL in the Pardiso manual.");
roptions->AddStringOption2(
"pardiso_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->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
}