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 RestoConvergenceCheck::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddBoundedNumberOption(
"required_infeasibility_reduction",
"Required reduction of infeasibility before leaving restoration phase.",
0.0, false, 1.0, true,
0.9,
"The restoration phase algorithm is performed, until a point is found "
"that is acceptable to the filter and the infeasibility has been "
"reduced by at least the fraction given by this option.");
roptions->AddLowerBoundedIntegerOption(
"max_resto_iter",
"Maximum number of successive iterations in restoration phase.",
0, 3000000,
"The algorithm terminates with an error message if the number of "
"iterations successively taken in the restoration phase exceeds this "
"number.");
}
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 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
}
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.)");
}