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 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 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 InexactSearchDirCalculator::RegisterOptions(
SmartPtr<RegisteredOptions> roptions
)
{
roptions->AddLowerBoundedNumberOption("local_inf_Ac_tol",
"Termination tolerance for local infeasibility (scaled ||Ac||).", 0.0, true, 1e-8, "");
roptions->AddStringOption3("inexact_step_decomposition",
"Determines if the steps should be decomposed into normal and tangential components.", "adaptive", "always",
"always compute the step as two components", "adaptive", "try to use undecomposed steps if possible",
"switch-once", "try to use undecomposed steps, but if decomposition is necessary, always keep it",
"TO BE WRITTEN");
}
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.");
}
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
}
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 OptimalityErrorConvergenceCheck::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddLowerBoundedIntegerOption(
"max_iter",
"Maximum number of iterations.",
0, 3000,
"The algorithm terminates with an error message if the number of "
"iterations exceeded this number.");
roptions->AddLowerBoundedNumberOption(
"max_cpu_time",
"Maximum number of CPU seconds.",
0.0, true, 1e6,
"A limit on CPU seconds that Ipopt can use to solve one problem. If "
"during the convergence check this limit is exceeded, Ipopt will "
"terminate with a corresponding error message.");
roptions->AddLowerBoundedNumberOption(
"dual_inf_tol",
"Desired threshold for the dual infeasibility.",
0.0, true, 1.,
"Absolute tolerance on the dual infeasibility. Successful termination "
"requires that the max-norm of the (unscaled) dual infeasibility is less than this "
"threshold.");
roptions->AddLowerBoundedNumberOption(
"constr_viol_tol",
"Desired threshold for the constraint violation.",
0.0, true, 1e-4,
"Absolute tolerance on the constraint violation. Successful termination "
"requires that the max-norm of the (unscaled) constraint violation is less than this "
"threshold.");
roptions->AddLowerBoundedNumberOption(
"compl_inf_tol",
"Desired threshold for the complementarity conditions.",
0.0, true, 1e-4,
"Absolute tolerance on the complementarity. Successful termination "
"requires that the max-norm of the (unscaled) complementarity is less than this "
"threshold.");
roptions->AddLowerBoundedNumberOption(
"acceptable_tol",
"\"Acceptable\" convergence tolerance (relative).",
0.0, true, 1e-6,
"Determines which (scaled) overall optimality error is considered to be"
" \"acceptable.\" There are two levels of termination criteria. If the "
"usual \"desired\" tolerances (see tol, dual_inf_tol etc) are satisfied "
"at an iteration, the algorithm immediately terminates with a success "
"message. On the other hand, if the algorithm encounters "
"\"acceptable_iter\" many iterations in a row that are considered "
"\"acceptable\", it will terminate before the desired convergence "
"tolerance is met. This is useful in cases where the algorithm might "
"not be able to achieve the \"desired\" level of accuracy.");
roptions->AddLowerBoundedIntegerOption(
"acceptable_iter",
"Number of \"acceptable\" iterates before triggering termination.",
0, 15,
"If the algorithm encounters this many successive \"acceptable\" iterates "
"(see \"acceptable_tol\"), it terminates, assuming that the problem "
"has been solved to best possible accuracy given round-off. If it is "
"set to zero, this heuristic is disabled.");
roptions->AddLowerBoundedNumberOption(
"acceptable_dual_inf_tol",
"\"Acceptance\" threshold for the dual infeasibility.",
0.0, true, 1e10,
"Absolute tolerance on the dual infeasibility. \"Acceptable\" termination "
"requires that the (max-norm of the unscaled) dual infeasibility is less than this "
"threshold; see also acceptable_tol.");
roptions->AddLowerBoundedNumberOption(
"acceptable_constr_viol_tol",
"\"Acceptance\" threshold for the constraint violation.",
0.0, true, 1e-2,
"Absolute tolerance on the constraint violation. \"Acceptable\" termination "
"requires that the max-norm of the (unscaled) constraint violation is less than this "
"threshold; see also acceptable_tol.");
roptions->AddLowerBoundedNumberOption(
"acceptable_compl_inf_tol",
"\"Acceptance\" threshold for the complementarity conditions.",
0.0, true, 1e-2,
"Absolute tolerance on the complementarity. \"Acceptable\" termination "
"requires that the max-norm of the (unscaled) complementarity is less than this "
"threshold; see also acceptable_tol.");
roptions->AddLowerBoundedNumberOption(
"acceptable_obj_change_tol",
"\"Acceptance\" stopping criterion based on objective function change.",
0.0, false, 1e20,
"If the relative change of the objective function (scaled by "
"Max(1,|f(x)|)) is less than this value, this part of the acceptable "
"tolerance termination is satisfied; see also acceptable_tol. This is "
"useful for the quasi-Newton option, which has trouble to bring down "
"the dual infeasibility.");
roptions->AddLowerBoundedNumberOption(
"diverging_iterates_tol",
"Threshold for maximal value of primal iterates.",
0.0, true, 1e20,
"If any component of the primal iterates exceeded this value (in "
"absolute terms), the optimization is aborted with the exit message "
"that the iterates seem to be diverging.");
roptions->AddLowerBoundedNumberOption(
"mu_target",
"Desired value of complementarity.",
0.0, false, 0.0,
"Usually, the barrier parameter is driven to zero and the termination "
"test for complementarity is measured with respect to zero "
"complementarity. However, in some cases it might be desired to have "
"Ipopt solve barrier problem for strictly positive value of the barrier "
"parameter. In this case, the value of \"mu_target\" specifies the "
"final value of the barrier parameter, and the termination tests are "
"then defined with respect to the barrier problem for this value of the "
"barrier parameter.");
}
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 Ma86SolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddIntegerOption(
"ma86_print_level",
"Debug printing level for the linear solver MA86",
-1,
"");
/*
"<0 no printing.\n"
"0 Error and warning messages only.\n"
"=1 Limited diagnostic printing.\n"
">1 Additional diagnostic printing.");
*/
roptions->AddLowerBoundedIntegerOption(
"ma86_nemin",
"Node Amalgamation parameter",
1, 32,
"Two nodes in elimination tree are merged if result has fewer than "
"ma86_nemin variables.");
roptions->AddLowerBoundedNumberOption(
"ma86_small",
"Zero Pivot Threshold",
0.0, false, 1e-20,
"Any pivot less than ma86_small is treated as zero.");
roptions->AddLowerBoundedNumberOption(
"ma86_static",
"Static Pivoting Threshold",
0.0, false, 0.0,
"See MA86 documentation. Either ma86_static=0.0 or "
"ma86_static>ma86_small. ma86_static=0.0 disables static pivoting.");
roptions->AddBoundedNumberOption(
"ma86_u",
"Pivoting Threshold",
0.0, false, 0.5, false, 1e-8,
"See MA86 documentation.");
roptions->AddBoundedNumberOption(
"ma86_umax",
"Maximum Pivoting Threshold",
0.0, false, 0.5, false, 1e-4,
"Maximum value to which u will be increased to improve quality.");
roptions->AddStringOption3(
"ma86_scaling",
"Controls scaling of matrix",
"mc64",
"none", "Do not scale the linear system matrix",
"mc64", "Scale linear system matrix using MC64",
"mc77", "Scale linear system matrix using MC77 [1,3,0]",
"This option controls scaling for the solver HSL_MA86.");
roptions->AddStringOption3(
"ma86_order",
"Controls type of ordering used by HSL_MA86",
#ifdef COINHSL_HAS_METIS
"auto",
#else
"amd",
#endif
"auto", "Try both AMD and MeTiS, pick best",
"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_MA86.");
}
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 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 OptimalityErrorConvergenceCheck::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddLowerBoundedIntegerOption(
"max_iter",
"Maximum number of iterations.",
0, 3000,
"The algorithm terminates with an error message if the number of "
"iterations exceeded this number.");
roptions->AddLowerBoundedNumberOption(
"dual_inf_tol",
"Desired threshold for the dual infeasibility.",
0.0, true, 1e-4,
"Absolute tolerance on the dual infeasibility. Successful termination "
"requires that the max-norm of the (unscaled) dual infeasibility is less than this "
"threshold.");
roptions->AddLowerBoundedNumberOption(
"constr_viol_tol",
"Desired threshold for the constraint violation.",
0.0, true, 1e-4,
"Absolute tolerance on the constraint violation. Successful termination "
"requires that the max-norm of the (unscaled) constraint violation is less than this "
"threshold.");
roptions->AddLowerBoundedNumberOption(
"compl_inf_tol",
"Desired threshold for the complementarity conditions.",
0.0, true, 1e-4,
"Absolute tolerance on the complementarity. Successful termination "
"requires that the max-norm of the (unscaled) complementarity is less than this "
"threshold.");
roptions->AddLowerBoundedNumberOption(
"acceptable_tol",
"\"Acceptable\" convergence tolerance (relative).",
0.0, true, 1e-6,
"Determines which (scaled) overall optimality error is considered to be"
" \"acceptable.\" There are two levels of termination criteria. If the "
"usual \"desired\" tolerances (see tol, dual_inf_tol etc) are satisfied "
"at an iteration, the algorithm immediately terminates with a success "
"message. On the other hand, if the algorithm encounters "
"\"acceptable_iter\" many iterations in a row that are considered "
"\"acceptable\", it will terminate before the desired convergence "
"tolerance is met. This is useful in cases where the algorithm might "
"not be able to achieve the \"desired\" level of accuracy.");
roptions->AddLowerBoundedIntegerOption(
"acceptable_iter",
"Number of \"acceptable\" iterates before triggering termination.",
0, 15,
"If the algorithm encounters this many successive \"acceptable\" iterates "
"(see \"acceptable_tol\"), it terminates, assuming that the problem "
"has been solved to best possible accuracy given round-off. If it is "
"set to zero, this heuristic is disabled.");
roptions->AddLowerBoundedNumberOption(
"acceptable_dual_inf_tol",
"\"Acceptance\" threshold for the dual infeasibility.",
0.0, true, 1e-2,
"Absolute tolerance on the dual infeasibility. \"Acceptable\" termination "
"requires that the (max-norm of the unscaled) dual infeasibility is less than this "
"threshold; see also acceptable_tol.");
roptions->AddLowerBoundedNumberOption(
"acceptable_constr_viol_tol",
"\"Acceptance\" threshold for the constraint violation.",
0.0, true, 1e-2,
"Absolute tolerance on the constraint violation. \"Acceptable\" termination "
"requires that the max-norm of the (unscaled) constraint violation is less than this "
"threshold; see also acceptable_tol.");
roptions->AddLowerBoundedNumberOption(
"acceptable_compl_inf_tol",
"\"Acceptance\" threshold for the complementarity conditions.",
0.0, true, 1e-2,
"Absolute tolerance on the complementarity. \"Acceptable\" termination "
"requires that the max-norm of the (unscaled) complementarity is less than this "
"threshold; see also acceptable_tol.");
roptions->AddLowerBoundedNumberOption(
"diverging_iterates_tol",
"Threshold for maximal value of primal iterates.",
0.0, true, 1e20,
"If any component of the primal iterates exceeded this value (in "
"absolute terms), the optimization is aborted with the exit message "
"that the iterates seem to be diverging.");
}
void
PDPerturbationHandler::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddLowerBoundedNumberOption(
"max_hessian_perturbation",
"Maximum value of regularization parameter for handling negative curvature.",
0, true,
1e20,
"In order to guarantee that the search directions are indeed proper "
"descent directions, Ipopt requires that the inertia of the "
"(augmented) linear system for the step computation has the "
"correct number of negative and positive eigenvalues. The idea "
"is that this guides the algorithm away from maximizers and makes "
"Ipopt more likely converge to first order optimal points that "
"are minimizers. If the inertia is not correct, a multiple of the "
"identity matrix is added to the Hessian of the Lagrangian in the "
"augmented system. This parameter gives the maximum value of the "
"regularization parameter. If a regularization of that size is "
"not enough, the algorithm skips this iteration and goes to the "
"restoration phase. (This is delta_w^max in the implementation paper.)");
roptions->AddLowerBoundedNumberOption(
"min_hessian_perturbation",
"Smallest perturbation of the Hessian block.",
0., false, 1e-20,
"The size of the perturbation of the Hessian block is never selected "
"smaller than this value, unless no perturbation is necessary. (This "
"is delta_w^min in implementation paper.)");
roptions->AddLowerBoundedNumberOption(
"perturb_inc_fact_first",
"Increase factor for x-s perturbation for very first perturbation.",
1., true, 100.,
"The factor by which the perturbation is increased when a trial value "
"was not sufficient - this value is used for the computation of the "
"very first perturbation and allows a different value for for the first "
"perturbation than that used for the remaining perturbations. "
"(This is bar_kappa_w^+ in the implementation paper.)");
roptions->AddLowerBoundedNumberOption(
"perturb_inc_fact",
"Increase factor for x-s perturbation.",
1., true, 8.,
"The factor by which the perturbation is increased when a trial value "
"was not sufficient - this value is used for the computation of "
"all perturbations except for the first. "
"(This is kappa_w^+ in the implementation paper.)");
roptions->AddBoundedNumberOption(
"perturb_dec_fact",
"Decrease factor for x-s perturbation.",
0., true, 1., true, 1./3.,
"The factor by which the perturbation is decreased when a trial value "
"is deduced from the size of the most recent successful perturbation. "
"(This is kappa_w^- in the implementation paper.)");
roptions->AddLowerBoundedNumberOption(
"first_hessian_perturbation",
"Size of first x-s perturbation tried.",
0., true, 1e-4,
"The first value tried for the x-s perturbation in the inertia "
"correction scheme."
"(This is delta_0 in the implementation paper.)");
roptions->AddLowerBoundedNumberOption(
"jacobian_regularization_value",
"Size of the regularization for rank-deficient constraint Jacobians.",
0., false, 1e-8,
"(This is bar delta_c in the implementation paper.)");
roptions->AddLowerBoundedNumberOption(
"jacobian_regularization_exponent",
"Exponent for mu in the regularization for rank-deficient constraint Jacobians.",
0., false, 0.25,
"(This is kappa_c in the implementation paper.)");
}
