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 WsmpSolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddLowerBoundedIntegerOption(
"wsmp_num_threads",
"Number of threads to be used in WSMP",
1, 1,
"This determines on how many processors WSMP is running on. This option "
"is only available if Ipopt has been compiled with WSMP.");
roptions->AddBoundedIntegerOption(
"wsmp_ordering_option",
"Determines how ordering is done in WSMP",
-2, 3, 1,
"This corresponds to the value of WSSMP's IPARM(16). This option is "
"only available if Ipopt has been compiled with WSMP.");
roptions->AddBoundedNumberOption(
"wsmp_pivtol",
"Pivot tolerance for the linear solver WSMP.",
0.0, true, 1.0, true, 1e-4,
"A smaller number pivots for sparsity, a larger number pivots for "
"stability. This option is only available if Ipopt has been compiled "
"with WSMP.");
roptions->AddBoundedNumberOption(
"wsmp_pivtolmax",
"Maximum pivot tolerance for the linear solver WSMP.",
0.0, true, 1.0, true, 1e-1,
"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 WSMP.");
roptions->AddBoundedIntegerOption(
"wsmp_scaling",
"Determines how the matrix is scaled by WSMP.",
0, 3, 0,
"This corresponds to the value of WSSMP's IPARM(10). "
"This option is only available if Ipopt has been compiled "
"with WSMP.");
roptions->AddBoundedNumberOption(
"wsmp_singularity_threshold",
"WSMP's singularity threshold.",
0.0, true, 1.0, true, 1e-18,
"WSMP's DPARM(10) parameter. The smaller this value the less likely "
"a matrix is declared singular. This option is only available if Ipopt "
"has been compiled with WSMP.");
roptions->SetRegisteringCategory("Uncategorized");
roptions->AddLowerBoundedIntegerOption(
"wsmp_write_matrix_iteration",
"Iteration in which the matrices are written to files.",
-1, -1,
"If non-negative, this option determins the iteration in which all "
"matrices given to WSMP are written to files. This option is only "
"available if Ipopt has been compiled with WSMP.");
}
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 MumpsSolverInterface::RegisterOptions(SmartPtr<RegisteredOptions> roptions)
{
roptions->AddBoundedNumberOption(
"mumps_pivtol",
"Pivot tolerance for the linear solver MUMPS.",
0, false, 1, false, 1e-6,
"A smaller number pivots for sparsity, a larger number pivots for "
"stability. This option is only available if Ipopt has been compiled "
"with MUMPS.");
roptions->AddBoundedNumberOption(
"mumps_pivtolmax",
"Maximum pivot tolerance for the linear solver MUMPS.",
0, false, 1, false, 0.1,
"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 MUMPS.");
roptions->AddLowerBoundedIntegerOption(
"mumps_mem_percent",
"Percentage increase in the estimated working space for MUMPS.",
0, 1000,
"In MUMPS when significant extra fill-in is caused by numerical "
"pivoting, larger values of mumps_mem_percent may help use the "
"workspace more efficiently. On the other hand, if memory requirement "
"are too large at the very beginning of the optimization, choosing a "
"much smaller value for this option, such as 5, might reduce memory "
"requirements.");
roptions->AddBoundedIntegerOption(
"mumps_permuting_scaling",
"Controls permuting and scaling in MUMPS",
0, 7, 7,
"This is ICNTL(6) in MUMPS.");
roptions->AddBoundedIntegerOption(
"mumps_pivot_order",
"Controls pivot order in MUMPS",
0, 7, 7,
"This is ICNTL(7) in MUMPS.");
roptions->AddBoundedIntegerOption(
"mumps_scaling",
"Controls scaling in MUMPS",
-2, 77, 77,
"This is ICNTL(8) in MUMPS.");
roptions->AddNumberOption(
"mumps_dep_tol",
"Pivot threshold for detection of linearly dependent constraints in MUMPS.",
0.0,
"When MUMPS is used to determine linearly dependent constraints, this "
"is determines the threshold for a pivot to be considered zero. This "
"is CNTL(3) in MUMPS.");
}
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 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 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 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 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 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 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 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
}