Introduction

COIN-OR BONMIN (Basic Open-source Nonlinear Mixed Integer programming) is an open-source solver for mixed-integer nonlinear programming (MINLPs), implementing branch-and-bound, branch-and-cut, and outer approximation algorithms. The code has been developed as part of a collaboration between Carnegie Mellon University and IBM Research. The COIN-OR project leader for BONMIN is Pierre Bonami.

BONMIN can handle mixed-integer nonlinear programming models which functions should be twice continuously differentiable. The BONMIN link in GAMS supports continuous, binary, and integer variables, special ordered sets, branching priorities, but no semi-continuous or semi-integer variables.

BONMIN implements six different algorithms for solving MINLPs:

• B-BB (default): a simple branch-and-bound algorithm based on solving a continuous nonlinear program at each node of the search tree and branching on integer variables [123] ; this algorithm is similar to the one implemented in the solver SBB
• B-OA: an outer-approximation based decomposition algorithm based on iterating solving and improving of a MIP relaxation and solving NLP subproblems [74, 87] ; this algorithm is similar to the one implemented in the solver DICOPT
• B-QG: an outer-approximation based branch-and-cut algorithm based on solving a continuous linear program at each node of the search tree, improving the linear program by outer approximation, and branching on integer variables [199] .
• B-Hyb: a branch-and-bound algorithm which is a hybrid of B-BB and B-QG and is based on solving either a continuous nonlinear or a continuous linear program at each node of the search tree, improving the linear program by outer approximation, and branching on integer variables [45]
• B-ECP: a Kelley's outer-approximation based branch-and-cut algorithm inspired by the settings used in the solver FilMINT [1]
• B-iFP: an iterated feasibility pump algorithm [46]

The algorithms are exact when the problem is convex, otherwise they are heuristics.

For convex MINLPs, experiments on a reasonably large test set of problems have shown that B-Hyb is the algorithm of choice (it solved most of the problems in 3 hours of computing time). Nevertheless, there are cases where B-OA (especially when used with CPLEX as MIP subproblem solver) is much faster than B-Hyb and others where B-BB is interesting. B-QG and B-ECP corresponds mainly to a specific parameter setting of B-Hyb but they can be faster in some cases. B-iFP is more tailored at finding quickly good solutions to very hard convex MINLP. For nonconvex MINLPs, it is strongly recommended to use B-BB (the outer-approximation algorithms have not been tailored to treat nonconvex problems). Although even B-BB is only a heuristic for such problems, several options are available to try and improve the quality of the solutions it provides.

NLPs are solved in BONMIN by IPOPT and IPOPTH, which can use MUMPS [14, 15] (currently the default) or MKL PARDISO [224, 225] (only Linux and Windows) as linear solver. In the commerically licensed GAMS/BONMINH version, also the linear solvers MA27, MA57, HSL_MA86, and HSL_MA97 from the Harwell Subroutines Library (HSL) are available in IPOPT. In this case, the default linear solver in IPOPT is MA27.

For more information on BONMIN we refer to [46, 43, 47, 45] and the BONMIN web site. Most of the BONMIN documentation in this section is taken from the BONMIN manual [44] .

Usage

The following statement can be used inside your GAMS program to specify using BONMIN:

Option MINLP = BONMIN;    { or Option MIQCP = BONMIN; }

This statement should appear before the Solve statement. If BONMIN was specified as the default solver during GAMS installation, the above statement is not necessary.

To use BONMINH, one should use the statement

Option MINLP = BONMINH;   { or Option MIQCP = BONMINH; }

GAMS/BONMIN currently does not support the GAMS Branch-and-Cut-and-Heuristic (BCH) Facility. If you need to use GAMS/BONMIN with BCH, please consider to use a GAMS system of version ≤ 23.3.

Specification of Options

A BONMIN options file contains both IPOPT and BONMIN options, for clarity all BONMIN options should be preceded with the prefix bonmin.. The scheme to name option files is the same as for all other GAMS solvers. The format of the option file is the same as for IPOPT.

The most important option in BONMIN is the choice of the solution algorithm. This can be set by using the option named algorithm which can be set to B-BB, B-OA, B-QG, B-Hyb, B-ECP, or B-iFP (its default value is B-BB). Depending on the value of this option, certain other options may be available or not, cf. Section List of all BONMIN Options.

An example of a bonmin.opt file is the following:

bonmin.algorithm       B-Hyb
bonmin.oa_log_level    4
print_level            6

This sets the algorithm to be used to the hybrid algorithm, the level of outer approximation related output to 4, and sets the print level for IPOPT to 6.

GAMS/BONMIN understands currently the following GAMS parameters: reslim (time limit), iterlim (iteration limit), nodlim (node limit), cutoff, optca (absolute gap tolerance), and optcr (relative gap tolerance). Further, the option threads can be used to control the number of threads used in the linear algebra routines of IPOPT and MIP solves of CPLEX.

Passing options to local search based heuristics and OA generators

Several parts of the algorithms in BONMIN are based on solving a simplified version of the problem with another instance of BONMIN: Outer Approximation Decomposition (called in B-Hyb at the root node) and Feasibility Pump for MINLP (called in B-Hyb or B-BB at the root node), RINS, RENS, Local Branching.

In all these cases, one can pass options to the sub-algorithm used through the option file. The basic principle is that the bonmin. prefix is replaced with a prefix that identifies the sub-algorithm used:

• oa_decomposition. to pass options to Outer Approximation Decomposition,
• pump_for_minlp. to pass options to Feasibility Pump for MINLP,
• rins. to pass options to RINS,
• rens. to pass options to RENS,
• local_branch. to pass options to Local Branching.

For example, to run a maximum of 60 seconds of feasibility pump (FP) for MINLP until 6 solutions are found at the beginning of the hybrid algorithm, one sets the following options:

bonmin.algorithm              B-Hyb
bonmin.pump_for_minlp         yes   # tells to run FP for MINLP
pump_for_minlp.time_limit     60    # set a time limit for the pump
pump_for_minlp.solution_limit 6     # set a solution limit

Note that the actual solution and time limit will be the minimum of the global limits set for BONMIN.

A slightly more complicated set of options may be used when using RINS. Say for example that one wants to run RINS inside B-BB. Each time RINS is called one wants to solve the small-size MINLP generated using B-QG (one may run any algorithm available in BONMIN for solving an MINLP) and wants to stop as soon as B-QG found one solution. To achieve this, one sets the following options

bonmin.algorithm      B-BB
bonmin.heuristic_rins yes
rins.algorithm        B-QG
rins.solution_limit   1

This example shows that it is possible to set any option used in the sub-algorithm to be different than the one used for the main algorithm.

In the context of outer-approximation (OA) and feasibility pump for MINLP, a standard MILP solver is used. Several options are available for configuring this MILP solver. BONMIN allows a choice of different MILP solvers through the option milp_solver. Values for this option are: Cbc_D, which uses CBC with its default settings, Cbc_Par, which uses a version of CBC that can be parameterized by the user, and Cplex, which uses CPLEX with its default settings. The options that can be set in Cbc_Par are the number of strong-branching candidates, the number of branches before pseudo costs are to be trusted, and the frequency of the various cut generators, cf. Section List of all BONMIN Options for details. To use the Cplex option, a valid CPLEX licence (standalone or GAMS/CPLEX) is required.

Getting good solutions to nonconvex problems

To solve a problem with nonconvex constraints, one should only use the branch-and-bound algorithm B-BB.

A few options have been designed in BONMIN specifically to treat problems that do not have a convex continuous relaxation. In such problems, the solutions obtained from IPOPT are not necessarily globally optimal, but are only locally optimal. Also the outer-approximation constraints are not necessarily valid inequalities for the problem. No specific heuristic method for treating nonconvex problems is implemented within the OA framework. But for the pure branch-and-bound B-BB, a few options have been implemented while having in mind that lower bounds provided by IPOPT should not be trusted and with the goal of trying to get good solutions. Such options are at an experimental stage.

First, in the context of nonconvex problems, IPOPT may find different local optima when started from different starting points. The two options num_resolve_at_root and num_resolve_at_node allow for solving the root node or each node of the tree, respectively, with a user-specified number of different randomly-chosen starting points, saving the best solution found. Note that the function to generate a random starting point is very naïve: it chooses a random point (uniformly) between the bounds provided for the variable. In particular if there are some functions that can not be evaluated at some points of the domain, it may pick such points, and so it is not robust in that respect.

Secondly, since the solution given by IPOPT does not truly give a lower bound, the fathoming rule can be changed to continue branching even if the solution value to the current node is worse than the best-known solution. This is achieved by setting allowable_gap, allowable_fraction_gap, and cutoff_decr to negative values.

IPOPT options changed by BONMIN

IPOPT has a very large number of options, see Section List of IPOPT Options to get a complete description. To use IPOPT more efficiently in the context of MINLP, BONMIN changes some IPOPT options from their default values, which may help to improve IPOPT's warm-starting capabilities and its ability to prove quickly that a subproblem is infeasible. These are settings that IPOPT does not use for ordinary NLP problems. Note that options set by the user in an option file will override these settings.

• mu_strategy and mu_oracle are set, respectively, to adaptive and probing by default. These are strategies in IPOPT for updating the barrier parameter. They were found to be more efficient in the context of MINLP.
• gamma_phi and gamma_theta are set to 1E-8 and 1E-4, respectively. This has the effect of reducing the size of the filter in the line search performed by IPOPT.
• required_infeasibility_reduction is set to 0.1. This increases the required infeasibility reduction when IPOPT enters the restoration phase and should thus help to detect infeasible problems faster.
• expect_infeasible_problem is set to yes, which enables some heuristics to detect infeasible problems faster.
• warm_start_init_point is set to yes when a full primal/dual starting point is available (generally for all the optimizations after the continuous relaxation has been solved).
• print_level is set to 0 by default to turn off IPOPT output (except for the root node, which print level is controlled by the BONMIN option nlp_log_at_root).
• bound_relax_factor is set to 1E-10. All of the bounds of the problem are relaxed by this factor. This may cause some trouble when constraint functions can only be evaluated within their bounds. In such cases, this option should be set to 0.

List of all BONMIN Options

The following tables give lists of all options together with their types, default values, and availability in each of the main algorithms. The column labeled Cbc_Par indicates the options that can be used to parametrize the MILP subsolver in the context of OA and FP.

Algorithm choice

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
algorithm	string	B-BB	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)

Branch-and-bound options

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
allowable_fraction_gap	real	GAMS optcr	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
allowable_gap	real	GAMS optca	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
clocktype	string	wall	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
cutoff	real	GAMS cutoff	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
cutoff_decr	real	1e-05	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
enable_dynamic_nlp	string	no	\(\surd\)	–	–	–	–	–	–
integer_tolerance	real	1e-06	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
iteration_limit	integer	GAMS iterlim	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
nlp_failure_behavior	string	stop	\(\surd\)	–	–	–	–	–	–
node_comparison	string	best-bound	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
node_limit	integer	GAMS nodlim	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
num_cut_passes	integer	1	–	–	\(\surd\)	\(\surd\)	\(\surd\)	–	–
num_cut_passes_at_root	integer	20	–	–	\(\surd\)	\(\surd\)	\(\surd\)	–	–
number_before_trust	integer	8	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
number_strong_branch	integer	20	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
random_generator_seed	integer	0	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
read_solution_file	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
solution_limit	integer	∞	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
time_limit	real	GAMS reslim	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
tree_search_strategy	string	probed-dive	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
variable_selection	string	strong-branching	\(\surd\)	–	\(\surd\)	\(\surd\)	\(\surd\)	–	–

ECP cuts generation

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
ecp_abs_tol	real	1e-06	–	–	\(\surd\)	\(\surd\)	–	–	–
ecp_max_rounds	integer	5	–	–	\(\surd\)	\(\surd\)	–	–	–
ecp_probability_factor	real	10	–	–	\(\surd\)	\(\surd\)	–	–	–
ecp_rel_tol	real	0	–	–	\(\surd\)	\(\surd\)	–	–	–
filmint_ecp_cuts	integer	0	–	–	\(\surd\)	\(\surd\)	–	–	–

Feasibility checker using OA cuts

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
feas_check_cut_types	string	outer-approx	–	–	\(\surd\)	\(\surd\)	\(\surd\)	–	–
feas_check_discard_policy	string	detect-cycles	–	–	\(\surd\)	\(\surd\)	\(\surd\)	–	–
generate_benders_after_so_many_oa	integer	5000	–	–	\(\surd\)	\(\surd\)	\(\surd\)	–	–

MILP Solver

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
cpx_parallel_strategy	integer	0	–	–	–	–	–	–	\(\surd\)
milp_solver	string	Cbc_D	–	–	–	–	–	–	\(\surd\)
milp_strategy	string	solve_to_optimality	–	–	–	–	–	–	\(\surd\)
number_cpx_threads	integer	GAMS threads	–	–	–	–	–	–	\(\surd\)

MILP cutting planes in hybrid algorithm

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
2mir_cuts	integer	0	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
Gomory_cuts	integer	-5	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
clique_cuts	integer	-5	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
cover_cuts	integer	0	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
flow_cover_cuts	integer	-5	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
lift_and_project_cuts	integer	0	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
mir_cuts	integer	-5	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
reduce_and_split_cuts	integer	0	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)

NLP interface

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
solvefinal	string	yes	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
warm_start	string	none	\(\surd\)	–	–	–	–	–	–

NLP solution robustness

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
max_consecutive_failures	integer	10	\(\surd\)	–	–	–	–	–	–
max_random_point_radius	real	100000	\(\surd\)	–	–	–	–	–	–
num_iterations_suspect	integer	-1	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
num_retry_unsolved_random_point	integer	0	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
random_point_perturbation_interval	real	1	\(\surd\)	–	–	–	–	–	–
random_point_type	string	Jon	\(\surd\)	–	–	–	–	–	–
resolve_on_small_infeasibility	real	0	\(\surd\)	–	–	–	–	–	–

NLP solves in hybrid algorithm (B-Hyb)

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
nlp_solve_frequency	integer	10	–	–	–	\(\surd\)	–	–	–
nlp_solve_max_depth	integer	10	–	–	–	\(\surd\)	–	–	–
nlp_solves_per_depth	real	1e+100	–	–	–	\(\surd\)	–	–	–

Nonconvex problems

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
coeff_var_threshold	real	0.1	\(\surd\)	–	–	–	–	–	–
dynamic_def_cutoff_decr	string	no	\(\surd\)	–	–	–	–	–	–
first_perc_for_cutoff_decr	real	-0.02	\(\surd\)	–	–	–	–	–	–
max_consecutive_infeasible	integer	0	\(\surd\)	–	–	–	–	–	–
num_resolve_at_infeasibles	integer	0	\(\surd\)	–	–	–	–	–	–
num_resolve_at_node	integer	0	\(\surd\)	–	–	–	–	–	–
num_resolve_at_root	integer	0	\(\surd\)	–	–	–	–	–	–
second_perc_for_cutoff_decr	real	-0.05	\(\surd\)	–	–	–	–	–	–

Outer Approximation Decomposition (B-OA)

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
oa_decomposition	string	no	–	–	\(\surd\)	\(\surd\)	\(\surd\)	–	–

Outer Approximation cuts generation

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
add_only_violated_oa	string	no	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
oa_cuts_scope	string	global	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
oa_rhs_relax	real	1e-08	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
tiny_element	real	1e-08	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
very_tiny_element	real	1e-17	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)

Output and Loglevel

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
bb_log_interval	integer	100	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
bb_log_level	integer	1	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
fp_log_frequency	real	100	–	–	\(\surd\)	\(\surd\)	–	–	–
fp_log_level	integer	1	–	–	\(\surd\)	\(\surd\)	–	–	–
lp_log_level	integer	0	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
milp_log_level	integer	0	–	–	–	–	–	–	\(\surd\)
nlp_log_at_root	integer	5	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
nlp_log_level	integer	1	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
oa_cuts_log_level	integer	0	–	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
oa_log_frequency	real	100	\(\surd\)	–	–	\(\surd\)	\(\surd\)	–	–
oa_log_level	integer	1	\(\surd\)	–	–	\(\surd\)	\(\surd\)	–	–
print_funceval_statistics	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
solvetrace	string		\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
solvetracenodefreq	integer	100	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
solvetracetimefreq	real	5	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)

Primal Heuristics

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
feasibility_pump_objective_norm	integer	1	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
fp_pass_infeasible	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)
heuristic_RINS	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
heuristic_dive_MIP_fractional	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
heuristic_dive_MIP_vectorLength	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
heuristic_dive_fractional	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
heuristic_dive_vectorLength	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
heuristic_feasibility_pump	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
pump_for_minlp	string	no	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–

Strong branching setup

Option	Type	Default	B-BB	B-OA	B-QG	B-Hyb	B-Ecp	B-iFP	Cbc_Par
candidate_sort_criterion	string	best-ps-cost	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
maxmin_crit_have_sol	real	0.1	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
maxmin_crit_no_sol	real	0.7	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
min_number_strong_branch	integer	0	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
number_before_trust_list	integer	0	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
number_look_ahead	integer	0	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–	–
number_strong_branch_root	integer	∞	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
setup_pseudo_frac	real	0.5	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–
trust_strong_branching_for_pseudo_cost	string	yes	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	\(\surd\)	–

Ipopt Barrier Parameter Update

Option	Type	Default
adaptive_mu_globalization	string	obj-constr-filter
adaptive_mu_kkt_norm_type	string	2-norm-squared
adaptive_mu_kkterror_red_fact	real	0.9999
adaptive_mu_kkterror_red_iters	integer	4
adaptive_mu_monotone_init_factor	real	0.8
adaptive_mu_restore_previous_iterate	string	no
barrier_tol_factor	real	10
filter_margin_fact	real	1e-05
filter_max_margin	real	1
fixed_mu_oracle	string	average_compl
mu_allow_fast_monotone_decrease	string	yes
mu_init	real	0.1
mu_linear_decrease_factor	real	0.2
mu_max	real	100000
mu_max_fact	real	1000
mu_min	real	1e-11
mu_oracle	string	quality-function
mu_strategy	string	monotone
mu_superlinear_decrease_power	real	1.5
quality_function_balancing_term	string	none
quality_function_centrality	string	none
quality_function_max_section_steps	integer	8
quality_function_norm_type	string	2-norm-squared
quality_function_section_qf_tol	real	0
quality_function_section_sigma_tol	real	0.01
sigma_max	real	100
sigma_min	real	1e-06
tau_min	real	0.99

Ipopt Convergence

Option	Type	Default
acceptable_compl_inf_tol	real	0.01
acceptable_constr_viol_tol	real	0.01
acceptable_dual_inf_tol	real	1e+10
acceptable_iter	integer	15
acceptable_obj_change_tol	real	1e+20
acceptable_tol	real	1e-06
compl_inf_tol	real	0.0001
constr_viol_tol	real	0.0001
diverging_iterates_tol	real	1e+20
dual_inf_tol	real	1
max_cpu_time	real	1e+06
max_iter	integer	3000
mu_target	real	0
s_max	real	100
tol	real	1e-08

Ipopt Hessian Approximation

Option	Type	Default
hessian_approximation	string	exact
hessian_approximation_space	string	nonlinear-variables
limited_memory_aug_solver	string	sherman-morrison
limited_memory_init_val	real	1
limited_memory_init_val_max	real	1e+08
limited_memory_init_val_min	real	1e-08
limited_memory_initialization	string	scalar1
limited_memory_max_history	integer	6
limited_memory_max_skipping	integer	2
limited_memory_special_for_resto	string	no
limited_memory_update_type	string	bfgs

Ipopt Initialization

Option	Type	Default
bound_frac	real	0.01
bound_mult_init_method	string	constant
bound_mult_init_val	real	1
bound_push	real	0.01
constr_mult_init_max	real	1000
least_square_init_duals	string	no
least_square_init_primal	string	no
slack_bound_frac	real	0.01
slack_bound_push	real	0.01

Ipopt Line Search

Option	Type	Default
accept_after_max_steps	integer	-1
accept_every_trial_step	string	no
alpha_for_y	string	primal
alpha_for_y_tol	real	10
alpha_min_frac	real	0.05
alpha_red_factor	real	0.5
constraint_violation_norm_type	string	1-norm
corrector_compl_avrg_red_fact	real	1
corrector_type	string	none
delta	real	1
eta_phi	real	1e-08
filter_reset_trigger	integer	5
gamma_phi	real	1e-08
gamma_theta	real	1e-05
kappa_sigma	real	1e+10
kappa_soc	real	0.99
line_search_method	string	filter
max_filter_resets	integer	5
max_soc	integer	4
nu_inc	real	0.0001
nu_init	real	1e-06
obj_max_inc	real	5
recalc_y	string	no
recalc_y_feas_tol	real	1e-06
rho	real	0.1
s_phi	real	2.3
s_theta	real	1.1
skip_corr_if_neg_curv	string	yes
skip_corr_in_monotone_mode	string	yes
slack_move	real	1.81899e-12
soc_method	integer	0
theta_max_fact	real	10000
theta_min_fact	real	0.0001
tiny_step_tol	real	2.22045e-15
tiny_step_y_tol	real	0.01
watchdog_shortened_iter_trigger	integer	10
watchdog_trial_iter_max	integer	3

Ipopt Linear Solver

Option	Type	Default
linear_scaling_on_demand	string	yes
linear_solver	string	ma27, if BonminH, otherwise mumps
linear_system_scaling	string	mc19, if BonminH, otherwise none

Ipopt MA27 Linear Solver

Option	Type	Default
ma27_ignore_singularity	string	no
ma27_la_init_factor	real	5
ma27_liw_init_factor	real	5
ma27_meminc_factor	real	2
ma27_pivtol	real	1e-08
ma27_pivtolmax	real	0.0001
ma27_skip_inertia_check	string	no

Ipopt MA28 Linear Solver

Option	Type	Default
ma28_pivtol	real	0.01

Ipopt MA57 Linear Solver

Option	Type	Default
ma57_automatic_scaling	string	no
ma57_block_size	integer	16
ma57_node_amalgamation	integer	16
ma57_pivot_order	integer	5
ma57_pivtol	real	1e-08
ma57_pivtolmax	real	0.0001
ma57_pre_alloc	real	1.05
ma57_small_pivot_flag	integer	0

Ipopt MA77 Linear Solver

Option	Type	Default
ma77_buffer_lpage	integer	4096
ma77_buffer_npage	integer	1600
ma77_file_size	integer	2097152
ma77_maxstore	integer	0
ma77_nemin	integer	8
ma77_order	string	amd
ma77_print_level	integer	-1
ma77_small	real	1e-20
ma77_static	real	0
ma77_u	real	1e-08
ma77_umax	real	0.0001

Ipopt MA86 Linear Solver

Option	Type	Default
ma86_nemin	integer	32
ma86_order	string	amd
ma86_print_level	integer	-1
ma86_scaling	string	mc64
ma86_small	real	1e-20
ma86_static	real	0
ma86_u	real	1e-08
ma86_umax	real	0.0001

Ipopt MA97 Linear Solver

Option	Type	Default
ma97_nemin	integer	8
ma97_order	string	auto
ma97_print_level	integer	0
ma97_scaling	string	dynamic
ma97_scaling1	string	mc64
ma97_scaling2	string	mc64
ma97_scaling3	string	mc64
ma97_small	real	1e-20
ma97_solve_blas3	string	no
ma97_switch1	string	od_hd_reuse
ma97_switch2	string	never
ma97_switch3	string	never
ma97_u	real	1e-08
ma97_umax	real	0.0001

Ipopt Mumps Linear Solver

Option	Type	Default
mumps_dep_tol	real	0
mumps_mem_percent	integer	1000
mumps_permuting_scaling	integer	7
mumps_pivot_order	integer	7
mumps_pivtol	real	1e-06
mumps_pivtolmax	real	0.1
mumps_scaling	integer	77

Ipopt NLP

Option	Type	Default
bound_relax_factor	real	1e-08
check_derivatives_for_naninf	string	no
dependency_detection_with_rhs	string	no
dependency_detector	string	none
fixed_variable_treatment	string	make_parameter
honor_original_bounds	string	yes
jac_c_constant	string	no
jac_d_constant	string	no
kappa_d	real	1e-05

Ipopt NLP Scaling

Option	Type	Default
nlp_scaling_constr_target_gradient	real	0
nlp_scaling_max_gradient	real	100
nlp_scaling_method	string	gradient-based
nlp_scaling_min_value	real	1e-08
nlp_scaling_obj_target_gradient	real	0

Ipopt Output

Option	Type	Default
inf_pr_output	string	original
print_eval_error	string	yes
print_frequency_iter	integer	1
print_frequency_time	real	0
print_info_string	string	no
print_level	integer	5
print_timing_statistics	string	no
replace_bounds	string	no

Ipopt Pardiso Linear Solver

Option	Type	Default
pardiso_matching_strategy	string	complete+2x2
pardiso_max_iterative_refinement_steps	integer	1
pardiso_msglvl	integer	0
pardiso_order	string	metis
pardiso_redo_symbolic_fact_only_if_inertia_wrong	string	no
pardiso_repeated_perturbation_means_singular	string	no
pardiso_skip_inertia_check	string	no

Ipopt Restoration Phase

Option	Type	Default
bound_mult_reset_threshold	real	1000
constr_mult_reset_threshold	real	0
evaluate_orig_obj_at_resto_trial	string	yes
expect_infeasible_problem	string	no
expect_infeasible_problem_ctol	real	0.001
expect_infeasible_problem_ytol	real	1e+08
max_resto_iter	integer	3000000
max_soft_resto_iters	integer	10
required_infeasibility_reduction	real	0.9
resto_failure_feasibility_threshold	real	0
resto_penalty_parameter	real	1000
resto_proximity_weight	real	1
soft_resto_pderror_reduction_factor	real	0.9999
start_with_resto	string	no

Ipopt Step Calculation

Option	Type	Default
fast_step_computation	string	no
first_hessian_perturbation	real	0.0001
jacobian_regularization_exponent	real	0.25
jacobian_regularization_value	real	1e-08
max_hessian_perturbation	real	1e+20
max_refinement_steps	integer	10
mehrotra_algorithm	string	no
min_hessian_perturbation	real	1e-20
min_refinement_steps	integer	1
neg_curv_test_reg	string	yes
neg_curv_test_tol	real	0
perturb_always_cd	string	no
perturb_dec_fact	real	0.333333
perturb_inc_fact	real	8
perturb_inc_fact_first	real	100
residual_improvement_factor	real	1
residual_ratio_max	real	1e-10
residual_ratio_singular	real	1e-05

Ipopt Warm Start

Option	Type	Default
warm_start_bound_frac	real	0.001
warm_start_bound_push	real	0.001
warm_start_init_point	string	no
warm_start_mult_bound_push	real	0.001
warm_start_mult_init_max	real	1e+06
warm_start_slack_bound_frac	real	0.001
warm_start_slack_bound_push	real	0.001

Detailed Options Description

In the following we give a detailed description of all BONMIN options.

2mir_cuts: Frequency (in terms of nodes) for generating 2-MIR cuts in branch-and-cut ↵

If \(k > 0\), cuts are generated every \(k\) nodes, if \(-99 < k < 0\) cuts are generated every \(-k\) nodes but Cbc may decide to stop generating cuts, if not enough are generated at the root node, if \(k=-99\) generate cuts only at the root node, if \(k=0\) or \(100\) do not generate cuts.

Range: {-100, ..., ∞}

Default: 0

accept_after_max_steps: Accept a trial point after maximal this number of steps. ↵

Even if it does not satisfy line search conditions.

Range: {-1, ..., ∞}

Default: -1

accept_every_trial_step: Always accept the first trial step. ↵

Setting this option to "yes" essentially disables the line search and makes the algorithm take aggressive steps, without global convergence guarantees.

value	meaning
no	don't arbitrarily accept the full step
yes	always accept the full step

Default: no

acceptable_compl_inf_tol: "Acceptance" threshold for the complementarity conditions. ↵

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.

Range: (0, ∞]

Default: 0.01

acceptable_constr_viol_tol: "Acceptance" threshold for the constraint violation. ↵

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.

Range: (0, ∞]

Default: 0.01

acceptable_dual_inf_tol: "Acceptance" threshold for the dual infeasibility. ↵

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.

Range: (0, ∞]

Default: 1e+10

acceptable_iter: Number of "acceptable" iterates before triggering termination. ↵

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.

Range: {0, ..., ∞}

Default: 15

acceptable_obj_change_tol: "Acceptance" stopping criterion based on objective function change. ↵

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.

Range: [0, ∞]

Default: 1e+20

acceptable_tol: "Acceptable" convergence tolerance (relative). ↵

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.

Range: (0, ∞]

Default: 1e-06

adaptive_mu_globalization: Globalization strategy for the adaptive mu selection mode. ↵

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".)

value	meaning
kkt-error	nonmonotone decrease of kkt-error
obj-constr-filter	2-dim filter for objective and constraint violation
never-monotone-mode	disables globalization

Default: obj-constr-filter

adaptive_mu_kkt_norm_type: Norm used for the KKT error in the adaptive mu globalization strategies. ↵

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.

value	meaning
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

Default: 2-norm-squared

adaptive_mu_kkterror_red_fact: Sufficient decrease factor for "kkt-error" globalization strategy. ↵

For the "kkt-error" based globalization strategy, the error must decrease by this factor to be deemed sufficient decrease.

Range: (0, 1)

Default: 0.9999

adaptive_mu_kkterror_red_iters: Maximum number of iterations requiring sufficient progress. ↵

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.

Range: {0, ..., ∞}

Default: 4

adaptive_mu_monotone_init_factor: Determines the initial value of the barrier parameter when switching to the monotone mode. ↵

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".

Range: (0, ∞]

Default: 0.8

adaptive_mu_restore_previous_iterate: Indicates if the previous iterate should be restored if the monotone mode is entered. ↵

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).

value	meaning
no	don't restore accepted iterate
yes	restore accepted iterate

Default: no

add_only_violated_oa: Do we add all OA cuts or only the ones violated by current point? ↵

value	meaning
no	Add all cuts
yes	Add only violated cuts

Default: no

algorithm: Choice of the algorithm. ↵

This will preset some of the options of bonmin depending on the algorithm choice.

value	meaning
B-BB	simple branch-and-bound algorithm,
B-OA	OA Decomposition algorithm,
B-QG	Quesada and Grossmann branch-and-cut algorithm,
B-Hyb	hybrid outer approximation based branch-and-cut,
B-Ecp	ECP cuts based branch-and-cut a la FilMINT.
B-iFP	Iterated Feasibility Pump for MINLP.

Default: B-BB

allowable_fraction_gap: Specify the value of relative gap under which the algorithm stops. ↵

Stop the tree search when the gap between the objective value of the best known solution and the best bound on the objective of any solution is less than this fraction of the absolute value of the best known solution value.

Range: [-1e+20, 1e+20]

Default: GAMS optcr

allowable_gap: Specify the value of absolute gap under which the algorithm stops. ↵

Stop the tree search when the gap between the objective value of the best known solution and the best bound on the objective of any solution is less than this.

Range: [-1e+20, 1e+20]

Default: GAMS optca

alpha_for_y: Method to determine the step size for constraint multipliers. ↵

This option determines how the step size (alpha_y) will be calculated when updating the constraint multipliers.

value	meaning
primal	use primal step size
bound-mult	use step size for the bound multipliers (good for LPs)
min	use the min of primal and bound multipliers
max	use the max of primal and bound multipliers
full	take a full step of size one
min-dual-infeas	choose step size minimizing new dual infeasibility
safer-min-dual-infeas	like "min_dual_infeas", but safeguarded by "min" and "max"
primal-and-full	use the primal step size, and full step if delta_x ≤ alpha_for_y_tol
dual-and-full	use the dual step size, and full step if delta_x ≤ alpha_for_y_tol
acceptor	Call LSAcceptor to get step size for y

Default: primal

alpha_for_y_tol: Tolerance for switching to full equality multiplier steps. ↵

This is only relevant if "alpha_for_y" is chosen "primal-and-full" or "dual-and-full". The step size for the equality constraint multipliers is taken to be one if the max-norm of the primal step is less than this tolerance.

Range: [0, ∞]

Default: 10

alpha_min_frac: Safety factor for the minimal step size (before switching to restoration phase). ↵

(This is gamma_alpha in Eqn. (20) in the implementation paper.)

Range: (0, 1)

Default: 0.05

alpha_red_factor: Fractional reduction of the trial step size in the backtracking line search. ↵

At every step of the backtracking line search, the trial step size is reduced by this factor.

Range: (0, 1)

Default: 0.5

barrier_tol_factor: Factor for mu in barrier stop test. ↵

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).

Range: (0, ∞]

Default: 10

bb_log_interval: Interval at which node level output is printed. ↵

Set the interval (in terms of number of nodes) at which a log on node resolutions (consisting of lower and upper bounds) is given.

Range: {0, ..., ∞}

Default: 100

bb_log_level: specify main branch-and-bound log level. ↵

Set the level of output of the branch-and-bound : 0 - none, 1 - minimal, 2 - normal low, 3 - normal high

Range: {0, ..., 5}

Default: 1

bound_frac: Desired minimum relative distance from the initial point to bound. ↵

Determines how much the initial point might have to be modified in order to be sufficiently inside the bounds (together with "bound_push"). (This is kappa_2 in Section 3.6 of implementation paper.)

Range: (0, 0.5]

Default: 0.01

bound_mult_init_method: Initialization method for bound multipliers ↵

This option defines how the iterates for the bound multipliers are initialized. If "constant" is chosen, then all bound multipliers are initialized to the value of "bound_mult_init_val". If "mu-based" is chosen, the each value is initialized to the the value of "mu_init" divided by the corresponding slack variable. This latter option might be useful if the starting point is close to the optimal solution.

value	meaning
constant	set all bound multipliers to the value of bound_mult_init_val
mu-based	initialize to mu_init/x_slack

Default: constant

bound_mult_init_val: Initial value for the bound multipliers. ↵

All dual variables corresponding to bound constraints are initialized to this value.

Range: (0, ∞]

Default: 1

bound_mult_reset_threshold: Threshold for resetting bound multipliers after the restoration phase. ↵

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.

Range: [0, ∞]

Default: 1000

bound_push: Desired minimum absolute distance from the initial point to bound. ↵

Determines how much the initial point might have to be modified in order to be sufficiently inside the bounds (together with "bound_frac"). (This is kappa_1 in Section 3.6 of implementation paper.)

Range: (0, ∞]

Default: 0.01

bound_relax_factor: Factor for initial relaxation of the bounds. ↵

Before start of the optimization, the bounds given by the user are relaxed. This option sets the factor for this relaxation. If it is set to zero, then then bounds relaxation is disabled. (See Eqn.(35) in implementation paper.)

Range: [0, ∞]

Default: 1e-10

candidate_sort_criterion: Choice of the criterion to choose candidates in strong-branching ↵

value	meaning
best-ps-cost	Sort by decreasing pseudo-cost
worst-ps-cost	Sort by increasing pseudo-cost
most-fractional	Sort by decreasing integer infeasibility
least-fractional	Sort by increasing integer infeasibility

Default: best-ps-cost

check_derivatives_for_naninf: Indicates whether it is desired to check for Nan/Inf in derivative matrices ↵

Activating this option will cause an error if an invalid number is detected in the constraint Jacobians or the Lagrangian Hessian. If this is not activated, the test is skipped, and the algorithm might proceed with invalid numbers and fail. If test is activated and an invalid number is detected, the matrix is written to output with print_level corresponding to J_MORE_DETAILED; so beware of large output!

value	meaning
no	Don't check (faster).
yes	Check Jacobians and Hessian for Nan and Inf.

Default: no

clique_cuts: Frequency (in terms of nodes) for generating clique cuts in branch-and-cut ↵

See option 2mir_cuts for a detailed description.

Range: {-100, ..., ∞}

Default: -5

clocktype: Type of clock to use for time_limit ↵

value	meaning
cpu	CPU time
wall	Wall-clock time

Default: wall

coeff_var_threshold: Coefficient of variation threshold (for dynamic definition of cutoff_decr). ↵

Range: [0, ∞]

Default: 0.1

compl_inf_tol: Desired threshold for the complementarity conditions. ↵

Absolute tolerance on the complementarity. Successful termination requires that the max-norm of the (unscaled) complementarity is less than this threshold.

Range: (0, ∞]

Default: 0.0001

constr_mult_init_max: Maximum allowed least-square guess of constraint multipliers. ↵

Determines how large the initial least-square guesses of the constraint multipliers are allowed to be (in max-norm). If the guess is larger than this value, it is discarded and all constraint multipliers are set to zero. This options is also used when initializing the restoration phase. By default, "resto.constr_mult_init_max" (the one used in RestoIterateInitializer) is set to zero.

Range: [0, ∞]

Default: 1000

constr_mult_reset_threshold: Threshold for resetting equality and inequality multipliers after restoration phase. ↵

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.

Range: [0, ∞]

Default: 0

constr_viol_tol: Desired threshold for the constraint violation. ↵

Absolute tolerance on the constraint violation. Successful termination requires that the max-norm of the (unscaled) constraint violation is less than this threshold.

Range: (0, ∞]

Default: 0.0001

constraint_violation_norm_type: Norm to be used for the constraint violation in the line search. ↵

Determines which norm should be used when the algorithm computes the constraint violation in the line search.

value	meaning
1-norm	use the 1-norm
2-norm	use the 2-norm
max-norm	use the infinity norm

Default: 1-norm

corrector_compl_avrg_red_fact: Complementarity tolerance factor for accepting corrector step. ↵

This option determines the factor by which complementarity is allowed to increase for a corrector step to be accepted. Changing this option is experimental.

Range: (0, ∞]

Default: 1

corrector_type: The type of corrector steps that should be taken. ↵

If "mu_strategy" is "adaptive", this option determines what kind of corrector steps should be tried. Changing this option is experimental.

value	meaning
none	no corrector
affine	corrector step towards mu=0
primal-dual	corrector step towards current mu

Default: none

cover_cuts: Frequency (in terms of nodes) for generating cover cuts in branch-and-cut ↵

See option 2mir_cuts for a detailed description.

Range: {-100, ..., ∞}

Default: 0

cpx_parallel_strategy: Strategy of parallel search mode in CPLEX. ↵

-1 = opportunistic, 0 = automatic, 1 = deterministic (refer to CPLEX documentation)

Range: {-1, ..., 1}

Default: 0

cutoff: Specify cutoff value. ↵

cutoff should be the value of a feasible solution known by the user (if any). The algorithm will only look for solutions better than cutoff.

Range: [-1e+100, 1e+100]

Default: GAMS cutoff

cutoff_decr: Specify cutoff decrement. ↵

Specify the amount by which cutoff is decremented below a new best upper-bound (usually a small positive value but in non-convex problems it may be a negative value).

Range: [-1e+10, 1e+10]

Default: 1e-05

delta: Multiplier for constraint violation in the switching rule. ↵

(See Eqn. (19) in the implementation paper.)

Range: (0, ∞]

Default: 1

dependency_detection_with_rhs: Indicates if the right hand sides of the constraints should be considered during dependency detection ↵

value	meaning
no	only look at gradients
yes	also consider right hand side

Default: no

dependency_detector: Indicates which linear solver should be used to detect linearly dependent equality constraints. ↵

The default and available choices depend on how Ipopt has been compiled. This is experimental and does not work well.

value	meaning
none	don't check; no extra work at beginning
mumps	use MUMPS
ma28	use MA28

Default: none

diverging_iterates_tol: Threshold for maximal value of primal iterates. ↵

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.

Range: (0, ∞]

Default: 1e+20

dual_inf_tol: Desired threshold for the dual infeasibility. ↵

Absolute tolerance on the dual infeasibility. Successful termination requires that the max-norm of the (unscaled) dual infeasibility is less than this threshold.

Range: (0, ∞]

Default: 1

dynamic_def_cutoff_decr: Do you want to define the parameter cutoff_decr dynamically? ↵

Range: no, yes

Default: no

ecp_abs_tol: Set the absolute termination tolerance for ECP rounds. ↵

Range: [0, ∞]

Default: 1e-06

ecp_max_rounds: Set the maximal number of rounds of ECP cuts. ↵

Range: {0, ..., ∞}

Default: 5

ecp_probability_factor: Factor appearing in formula for skipping ECP cuts. ↵

Choosing -1 disables the skipping.

Range: real

Default: 10

ecp_rel_tol: Set the relative termination tolerance for ECP rounds. ↵

Range: [0, ∞]

Default: 0

enable_dynamic_nlp: Enable dynamic linear and quadratic rows addition in nlp ↵

Range: no, yes

Default: no

eta_phi: Relaxation factor in the Armijo condition. ↵

(See Eqn. (20) in the implementation paper)

Range: (0, 0.5)

Default: 1e-08

evaluate_orig_obj_at_resto_trial: Determines if the original objective function should be evaluated at restoration phase trial points. ↵

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.

value	meaning
no	skip evaluation
yes	evaluate at every trial point

Default: yes

expect_infeasible_problem: Enable heuristics to quickly detect an infeasible problem. ↵

This options is meant to activate heuristics that may speed up the infeasibility determination if you expect that there is a good chance for the problem to be infeasible. In the filter line search procedure, the restoration phase is called more quickly than usually, and more reduction in the constraint violation is enforced before the restoration phase is left. If the problem is square, this option is enabled automatically.

value	meaning
no	the problem probably be feasible
yes	the problem has a good chance to be infeasible

Default: yes

expect_infeasible_problem_ctol: Threshold for disabling "expect_infeasible_problem" option. ↵

If the constraint violation becomes smaller than this threshold, the "expect_infeasible_problem" heuristics in the filter line search are disabled. If the problem is square, this options is set to 0.

Range: [0, ∞]

Default: 0.001

expect_infeasible_problem_ytol: Multiplier threshold for activating "expect_infeasible_problem" option. ↵

If the max norm of the constraint multipliers becomes larger than this value and "expect_infeasible_problem" is chosen, then the restoration phase is entered.

Range: (0, ∞]

Default: 1e+08

fast_step_computation: Indicates if the linear system should be solved quickly. ↵

If set to yes, the algorithm assumes that the linear system that is solved to obtain the search direction, is solved sufficiently well. In that case, no residuals are computed, and the computation of the search direction is a little faster.

value	meaning
no	Verify solution of linear system by computing residuals.
yes	Trust that linear systems are solved well.

Default: no

feas_check_cut_types: Choose the type of cuts generated when an integer feasible solution is found ↵

If it seems too much memory is used should try Benders to use less

value	meaning
outer-approx	Generate a set of Outer Approximations cuts.
Benders	Generate a single Benders cut.

Default: outer-approx

feas_check_discard_policy: How cuts from feasibility checker are discarded ↵

Normally to avoid cycle cuts from feasibility checker should not be discarded in the node where they are generated. However Cbc sometimes does it if no care is taken which can lead to an infinite loop in Bonmin (usually on simple problems). To avoid this one can instruct Cbc to never discard a cut but if we do that for all cuts it can lead to memory problems. The default policy here is to detect cycles and only then impose to Cbc to keep the cut. The two other alternative are to instruct Cbc to keep all cuts or to just ignore the problem and hope for the best

value	meaning
detect-cycles	Detect if a cycle occurs and only in this case force not to discard.
keep-all	Force cuts from feasibility checker not to be discarded (memory hungry but sometimes better).
treated-as-normal	Cuts from memory checker can be discarded as any other cuts (code may cycle then)

Default: detect-cycles

feasibility_pump_objective_norm: Norm of feasibility pump objective function ↵

Range: {1, ..., 2}

Default: 1

filmint_ecp_cuts: Specify the frequency (in terms of nodes) at which some a la filmint ecp cuts are generated. ↵

A frequency of 0 amounts to to never solve the NLP relaxation.

Range: {0, ..., ∞}

Default: 0

filter_margin_fact: Factor determining width of margin for obj-constr-filter adaptive globalization strategy. ↵

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".

Range: (0, 1)

Default: 1e-05

filter_max_margin: Maximum width of margin in obj-constr-filter adaptive globalization strategy. ↵

Range: (0, ∞]

Default: 1

filter_reset_trigger: Number of iterations that trigger the filter reset. ↵

If the filter reset heuristic is active and the number of successive iterations in which the last rejected trial step size was rejected because of the filter, the filter is reset.

Range: {1, ..., ∞}

Default: 5

first_hessian_perturbation: Size of first x-s perturbation tried. ↵

The first value tried for the x-s perturbation in the inertia correction scheme.(This is delta_0 in the implementation paper.)

Range: (0, ∞]

Default: 0.0001

first_perc_for_cutoff_decr: The percentage used when, the coeff of variance is smaller than the threshold, to compute the cutoff_decr dynamically. ↵

Range: real

Default: -0.02

fixed_mu_oracle: Oracle for the barrier parameter when switching to fixed mode. ↵

Determines how the first value of the barrier parameter should be computed when switching to the "monotone mode" in the adaptive strategy. (Only considered if "adaptive" is selected for option "mu_strategy".)

value	meaning
probing	Mehrotra's probing heuristic
loqo	LOQO's centrality rule
quality-function	minimize a quality function
average_compl	base on current average complementarity

Default: average_compl

fixed_variable_treatment: Determines how fixed variables should be handled. ↵

The main difference between those options is that the starting point in the "make_constraint" case still has the fixed variables at their given values, whereas in the case "make_parameter" the functions are always evaluated with the fixed values for those variables. Also, for "relax_bounds", the fixing bound constraints are relaxed (according to" bound_relax_factor"). For both "make_constraints" and "relax_bounds", bound multipliers are computed for the fixed variables.

value	meaning
make_parameter	Remove fixed variable from optimization variables
make_constraint	Add equality constraints fixing variables
relax_bounds	Relax fixing bound constraints

Default: make_parameter

flow_cover_cuts: Frequency (in terms of nodes) for generating flow cover cuts in branch-and-cut ↵

See option 2mir_cuts for a detailed description.

Range: {-100, ..., ∞}

Default: -5

fp_log_frequency: display an update on lower and upper bounds in FP every n seconds ↵

Range: (0, ∞]

Default: 100

fp_log_level: specify FP iterations log level. ↵

Set the level of output of OA decomposition solver : 0 - none, 1 - normal, 2 - verbose

Range: {0, ..., 2}

Default: 1

fp_pass_infeasible: Say whether feasibility pump should claim to converge or not ↵

value	meaning
no	When master MILP is infeasible just bail out (don't stop all algorithm). This is the option for using in B-Hyb.
yes	Claim convergence, numerically dangerous.

Default: no

gamma_phi: Relaxation factor in the filter margin for the barrier function. ↵

(See Eqn. (18a) in the implementation paper.)

Range: (0, 1)

Default: 1e-08

gamma_theta: Relaxation factor in the filter margin for the constraint violation. ↵

(See Eqn. (18b) in the implementation paper.)

Range: (0, 1)

Default: 0.0001

generate_benders_after_so_many_oa: Specify that after so many oa cuts have been generated Benders cuts should be generated instead. ↵

It seems that sometimes generating too many oa cuts slows down the optimization compared to Benders due to the size of the LP. With this option we specify that after so many OA cuts have been generated we should switch to Benders cuts.

Range: {0, ..., ∞}

Default: 5000

Gomory_cuts: Frequency (in terms of nodes) for generating Gomory cuts in branch-and-cut. ↵

See option 2mir_cuts for a detailed description.

Range: {-100, ..., ∞}

Default: -5

hessian_approximation: Indicates what Hessian information is to be used. ↵

This determines which kind of information for the Hessian of the Lagrangian function is used by the algorithm.

value	meaning
exact	Use second derivatives provided by the NLP.
limited-memory	Perform a limited-memory quasi-Newton approximation

Default: exact

hessian_approximation_space: Indicates in which subspace the Hessian information is to be approximated. ↵

value	meaning
nonlinear-variables	only in space of nonlinear variables.
all-variables	in space of all variables (without slacks)

Default: nonlinear-variables

heuristic_dive_fractional: if yes runs the Dive Fractional heuristic ↵

Range: no, yes

Default: no

heuristic_dive_MIP_fractional: if yes runs the Dive MIP Fractional heuristic ↵

Range: no, yes

Default: no

heuristic_dive_MIP_vectorLength: if yes runs the Dive MIP VectorLength heuristic ↵

Range: no, yes

Default: no

heuristic_dive_vectorLength: if yes runs the Dive VectorLength heuristic ↵

Range: no, yes

Default: no

heuristic_feasibility_pump: whether the heuristic feasibility pump should be used ↵

Range: no, yes

Default: no

heuristic_RINS: if yes runs the RINS heuristic ↵

Range: no, yes

Default: no

honor_original_bounds: Indicates whether final points should be projected into original bounds. ↵

Ipopt might relax the bounds during the optimization (see, e.g., option "bound_relax_factor"). This option determines whether the final point should be projected back into the user-provide original bounds after the optimization.

value	meaning
no	Leave final point unchanged
yes	Project final point back into original bounds

Default: yes

inf_pr_output: Determines what value is printed in the "inf_pr" output column. ↵

Ipopt works with a reformulation of the original problem, where slacks are introduced and the problem might have been scaled. The choice "internal" prints out the constraint violation of this formulation. With "original" the true constraint violation in the original NLP is printed.

value	meaning
internal	max-norm of violation of internal equality constraints
original	maximal constraint violation in original NLP

Default: original

integer_tolerance: Set integer tolerance. ↵

Any number within that value of an integer is considered integer.

Range: (0, ∞]

Default: 1e-06

iteration_limit: Set the cumulative maximum number of iteration in the algorithm used to process nodes continuous relaxations in the branch-and-bound. ↵

value 0 deactivates option.

Range: {0, ..., ∞}

Default: GAMS iterlim

jac_c_constant: Indicates whether all equality constraints are linear ↵

Activating this option will cause Ipopt to ask for the Jacobian of the equality constraints only once from the NLP and reuse this information later.

value	meaning
no	Don't assume that all equality constraints are linear
yes	Assume that equality constraints Jacobian are constant

Default: no

jac_d_constant: Indicates whether all inequality constraints are linear ↵

Activating this option will cause Ipopt to ask for the Jacobian of the inequality constraints only once from the NLP and reuse this information later.

value	meaning
no	Don't assume that all inequality constraints are linear
yes	Assume that equality constraints Jacobian are constant

Default: no

jacobian_regularization_exponent: Exponent for mu in the regularization for rank-deficient constraint Jacobians. ↵

(This is kappa_c in the implementation paper.)

Range: [0, ∞]

Default: 0.25

jacobian_regularization_value: Size of the regularization for rank-deficient constraint Jacobians. ↵

(This is bar delta_c in the implementation paper.)

Range: [0, ∞]

Default: 1e-08

kappa_d: Weight for linear damping term (to handle one-sided bounds). ↵

(see Section 3.7 in implementation paper.)

Range: [0, ∞]

Default: 1e-05

kappa_sigma: Factor limiting the deviation of dual variables from primal estimates. ↵

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.

Range: (0, ∞]

Default: 1e+10

kappa_soc: Factor in the sufficient reduction rule for second order correction. ↵

This option determines how much a second order correction step must reduce the constraint violation so that further correction steps are attempted. (See Step A-5.9 of Algorithm A in the implementation paper.)

Range: (0, ∞]

Default: 0.99

least_square_init_duals: Least square initialization of all dual variables ↵

If set to yes, Ipopt tries to compute least-square multipliers (considering ALL dual variables). If successful, the bound multipliers are possibly corrected to be at least bound_mult_init_val. This might be useful if the user doesn't know anything about the starting point, or for solving an LP or QP. This overwrites option "bound_mult_init_method".

value	meaning
no	use bound_mult_init_val and least-square equality constraint multipliers
yes	overwrite user-provided point with least-square estimates

Default: no

least_square_init_primal: Least square initialization of the primal variables ↵

If set to yes, Ipopt ignores the user provided point and solves a least square problem for the primal variables (x and s), to fit the linearized equality and inequality constraints. This might be useful if the user doesn't know anything about the starting point, or for solving an LP or QP.

value	meaning
no	take user-provided point
yes	overwrite user-provided point with least-square estimates

Default: no

lift_and_project_cuts: Frequency (in terms of nodes) for generating lift-and-project cuts in branch-and-cut ↵

See option 2mir_cuts for a detailed description.

Range: {-100, ..., ∞}

Default: 0

limited_memory_aug_solver: Strategy for solving the augmented system for low-rank Hessian. ↵

value	meaning
sherman-morrison	use Sherman-Morrison formula
extended	use an extended augmented system

Default: sherman-morrison

limited_memory_init_val: Value for B0 in low-rank update. ↵

The starting matrix in the low rank update, B0, is chosen to be this multiple of the identity in the first iteration (when no updates have been performed yet), and is constantly chosen as this value, if "limited_memory_initialization" is "constant".

Range: (0, ∞]

Default: 1

limited_memory_init_val_max: Upper bound on value for B0 in low-rank update. ↵

The starting matrix in the low rank update, B0, is chosen to be this multiple of the identity in the first iteration (when no updates have been performed yet), and is constantly chosen as this value, if "limited_memory_initialization" is "constant".

Range: (0, ∞]

Default: 1e+08

limited_memory_init_val_min: Lower bound on value for B0 in low-rank update. ↵

The starting matrix in the low rank update, B0, is chosen to be this multiple of the identity in the first iteration (when no updates have been performed yet), and is constantly chosen as this value, if "limited_memory_initialization" is "constant".

Range: (0, ∞]

Default: 1e-08

limited_memory_initialization: Initialization strategy for the limited memory quasi-Newton approximation. ↵

Determines how the diagonal Matrix B_0 as the first term in the limited memory approximation should be computed.

value	meaning
scalar1	sigma = s^Ty/s^Ts
scalar2	sigma = y^Ty/s^Ty
scalar3	arithmetic average of scalar1 and scalar2
scalar4	geometric average of scalar1 and scalar2
constant	sigma = limited_memory_init_val

Default: scalar1

limited_memory_max_history: Maximum size of the history for the limited quasi-Newton Hessian approximation. ↵

This option determines the number of most recent iterations that are taken into account for the limited-memory quasi-Newton approximation.

Range: {0, ..., ∞}

Default: 6

limited_memory_max_skipping: Threshold for successive iterations where update is skipped. ↵

If the update is skipped more than this number of successive iterations, we quasi-Newton approximation is reset.

Range: {1, ..., ∞}

Default: 2

limited_memory_special_for_resto: Determines if the quasi-Newton updates should be special during the restoration phase. ↵

Until Nov 2010, Ipopt used a special update during the restoration phase, but it turned out that this does not work well. The new default uses the regular update procedure and it improves results. If for some reason you want to get back to the original update, set this option to "yes".

value	meaning
no	use the same update as in regular iterations
yes	use the a special update during restoration phase

Default: no

limited_memory_update_type: Quasi-Newton update formula for the limited memory approximation. ↵

Determines which update formula is to be used for the limited-memory quasi-Newton approximation.

value	meaning
bfgs	BFGS update (with skipping)
sr1	SR1 (not working well)

Default: bfgs

line_search_method: Globalization method used in backtracking line search ↵

Only the "filter" choice is officially supported. But sometimes, good results might be obtained with the other choices.

value	meaning
filter	Filter method
cg-penalty	Chen-Goldfarb penalty function
penalty	Standard penalty function

Default: filter

linear_scaling_on_demand: Flag indicating that linear scaling is only done if it seems required. ↵

This option is only important if a linear scaling method (e.g., mc19) is used. If you choose "no", then the scaling factors are computed for every linear system from the start. This can be quite expensive. Choosing "yes" means that the algorithm will start the scaling method only when the solutions to the linear system seem not good, and then use it until the end.

value	meaning
no	Always scale the linear system.
yes	Start using linear system scaling if solutions seem not good.

Default: yes

linear_solver: Linear solver used for step computations. ↵

Determines which linear algebra package is to be used for the solution of the augmented linear system (for obtaining the search directions). Note, that MA27, MA57, MA86, and MA97 are only available with a commercially supported GAMS/IpoptH license, or when the user provides a library with HSL code separately. To use HSL_MA77, a HSL library needs to be provided.

value	meaning
ma27	use the Harwell routine MA27
ma57	use the Harwell routine MA57
ma77	use the Harwell routine HSL_MA77
ma86	use the Harwell routine HSL_MA86
ma97	use the Harwell routine HSL_MA97
pardiso	use the Pardiso package
mumps	use MUMPS package

Default: ma27, if BonminH, otherwise mumps

linear_system_scaling: Method for scaling the linear system. ↵

Determines the method used to compute symmetric scaling factors for the augmented system (see also the "linear_scaling_on_demand" option). This scaling is independent of the NLP problem scaling. By default, MC19 is only used if MA27 or MA57 are selected as linear solvers. Note, that MC19 is only available with a commercially supported GAMS/IpoptH license, or when the user provides a library with HSL code separately.

value	meaning
none	no scaling will be performed
mc19	use the Harwell routine MC19
slack-based	use the slack values

Default: mc19, if BonminH, otherwise none

lp_log_level: specify LP log level. ↵

Set the level of output of the linear programming sub-solver in B-Hyb or B-QG : 0 - none, 1 - minimal, 2 - normal low, 3 - normal high, 4 - verbose

Range: {0, ..., 4}

Default: 0

ma27_ignore_singularity: Enables MA27's ability to solve a linear system even if the matrix is singular. ↵

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.

value	meaning
no	Don't have MA27 solve singular systems
yes	Have MA27 solve singular systems

Default: no

ma27_la_init_factor: Real workspace memory for MA27. ↵

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.

Range: [1, ∞]

Default: 5

ma27_liw_init_factor: Integer workspace memory for MA27. ↵

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.

Range: [1, ∞]

Default: 5

ma27_meminc_factor: Increment factor for workspace size for MA27. ↵

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.

Range: [1, ∞]

Default: 2

ma27_pivtol: Pivot tolerance for the linear solver MA27. ↵

A smaller number pivots for sparsity, a larger number pivots for stability. This option is only available if Ipopt has been compiled with MA27.

Range: (0, 1)

Default: 1e-08

ma27_pivtolmax: Maximum pivot tolerance for the linear solver MA27. ↵

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.

Range: (0, 1)

Default: 0.0001

ma27_skip_inertia_check: Always pretend inertia is correct. ↵

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.

value	meaning
no	check inertia
yes	skip inertia check

Default: no

ma28_pivtol: Pivot tolerance for linear solver MA28. ↵

This is used when MA28 tries to find the dependent constraints.

Range: (0, 1]

Default: 0.01

ma57_automatic_scaling: Controls MA57 automatic scaling ↵

This option controls the internal scaling option of MA57. For higher reliability of the MA57 solver, you may want to set this option to yes. This is ICNTL(15) in MA57.

value	meaning
no	Do not scale the linear system matrix
yes	Scale the linear system matrix

Default: no

ma57_block_size: Controls block size used by Level 3 BLAS in MA57BD ↵

This is ICNTL(11) in MA57.

Range: {1, ..., ∞}

Default: 16

ma57_node_amalgamation: Node amalgamation parameter ↵

This is ICNTL(12) in MA57.

Range: {1, ..., ∞}

Default: 16

ma57_pivot_order: Controls pivot order in MA57 ↵

This is ICNTL(6) in MA57.

Range: {0, ..., 5}

Default: 5

ma57_pivtol: Pivot tolerance for the linear solver MA57. ↵

A smaller number pivots for sparsity, a larger number pivots for stability. This option is only available if Ipopt has been compiled with MA57.

Range: (0, 1)

Default: 1e-08

ma57_pivtolmax: Maximum pivot tolerance for the linear solver MA57. ↵

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.

Range: (0, 1)

Default: 0.0001

ma57_pre_alloc: Safety factor for work space memory allocation for the linear solver MA57. ↵

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.

Range: [1, ∞]

Default: 1.05

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. ↵

This is ICNTL(16) in MA57.

Range: {0, ..., 1}

Default: 0

ma77_buffer_lpage: Number of scalars per MA77 buffer page ↵

Number of scalars per an in-core buffer in the out-of-core solver MA77. Must be at most ma77_file_size.

Range: {1, ..., ∞}

Default: 4096

ma77_buffer_npage: Number of pages that make up MA77 buffer ↵

Number of pages of size buffer_lpage that exist in-core for the out-of-core solver MA77.

Range: {1, ..., ∞}

Default: 1600

ma77_file_size: Target size of each temporary file for MA77, scalars per type ↵

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.

Range: {1, ..., ∞}

Default: 2097152

ma77_maxstore: Maximum storage size for MA77 in-core mode ↵

If greater than zero, the maximum size of factors stored in core before out-of-core mode is invoked.

Range: {0, ..., ∞}

Default: 0

ma77_nemin: Node Amalgamation parameter ↵

Two nodes in elimination tree are merged if result has fewer than ma77_nemin variables.

Range: {1, ..., ∞}

Default: 8

ma77_order: Controls type of ordering used by HSL_MA77 ↵

This option controls ordering for the solver HSL_MA77.

value	meaning
amd	Use the HSL_MC68 approximate minimum degree algorithm
metis	Use the MeTiS nested dissection algorithm (if available)

Default: amd

ma77_print_level: Debug printing level for the linear solver MA77 ↵

Range: {-∞, ..., ∞}

Default: -1

ma77_small: Zero Pivot Threshold ↵

Any pivot less than ma77_small is treated as zero.

Range: [0, ∞]

Default: 1e-20

ma77_static: Static Pivoting Threshold ↵

See MA77 documentation. Either ma77_static=0.0 or ma77_static>ma77_small. ma77_static=0.0 disables static pivoting.

Range: [0, ∞]

Default: 0

ma77_u: Pivoting Threshold ↵

See MA77 documentation.

Range: [0, 0.5]

Default: 1e-08

ma77_umax: Maximum Pivoting Threshold ↵

Maximum value to which u will be increased to improve quality.

Range: [0, 0.5]

Default: 0.0001

ma86_nemin: Node Amalgamation parameter ↵

Two nodes in elimination tree are merged if result has fewer than ma86_nemin variables.

Range: {1, ..., ∞}

Default: 32

ma86_order: Controls type of ordering used by HSL_MA86 ↵

This option controls ordering for the solver HSL_MA86.

value	meaning
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)

Default: auto

ma86_print_level: Debug printing level for the linear solver MA86 ↵

Range: {-∞, ..., ∞}

Default: -1

ma86_scaling: Controls scaling of matrix ↵

This option controls scaling for the solver HSL_MA86.

value	meaning
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]

Default: mc64

ma86_small: Zero Pivot Threshold ↵

Any pivot less than ma86_small is treated as zero.

Range: [0, ∞]

Default: 1e-20

ma86_static: Static Pivoting Threshold ↵

See MA86 documentation. Either ma86_static=0.0 or ma86_static>ma86_small. ma86_static=0.0 disables static pivoting.

Range: [0, ∞]

Default: 0

ma86_u: Pivoting Threshold ↵

See MA86 documentation.

Range: [0, 0.5]

Default: 1e-08

ma86_umax: Maximum Pivoting Threshold ↵

Maximum value to which u will be increased to improve quality.

Range: [0, 0.5]

Default: 0.0001

ma97_nemin: Node Amalgamation parameter ↵

Two nodes in elimination tree are merged if result has fewer than ma97_nemin variables.

Range: {1, ..., ∞}

Default: 8

ma97_order: Controls type of ordering used by HSL_MA97 ↵

value	meaning
auto	Use HSL_MA97 heuristic to guess best of AMD and METIS
best	Try both AMD and MeTiS, pick best
amd	Use the HSL_MC68 approximate minimum degree algorithm
metis	Use the MeTiS nested dissection algorithm
matched-auto	Use the HSL_MC80 matching with heuristic choice of AMD or METIS
matched-metis	Use the HSL_MC80 matching based ordering with METIS
matched-amd	Use the HSL_MC80 matching based ordering with AMD

Default: auto

ma97_print_level: Debug printing level for the linear solver MA97 ↵

Range: {-∞, ..., ∞}

Default: 0

ma97_scaling: Specifies strategy for scaling in HSL_MA97 linear solver ↵

value	meaning
none	Do not scale the linear system matrix
mc30	Scale all linear system matrices using MC30
mc64	Scale all linear system matrices using MC64
mc77	Scale all linear system matrices using MC77 [1,3,0]
dynamic	Dynamically select scaling according to rules specified by ma97_scalingX and ma97_switchX options.

Default: dynamic

ma97_scaling1: First scaling. ↵

If ma97_scaling=dynamic, this scaling is used according to the trigger ma97_switch1. If ma97_switch2 is triggered it is disabled.

value	meaning
none	No scaling
mc30	Scale linear system matrix using MC30
mc64	Scale linear system matrix using MC64
mc77	Scale linear system matrix using MC77 [1,3,0]

Default: mc64

ma97_scaling2: Second scaling. ↵

If ma97_scaling=dynamic, this scaling is used according to the trigger ma97_switch2. If ma97_switch3 is triggered it is disabled.

value	meaning
none	No scaling
mc30	Scale linear system matrix using MC30
mc64	Scale linear system matrix using MC64
mc77	Scale linear system matrix using MC77 [1,3,0]

Default: mc64

ma97_scaling3: Third scaling. ↵

If ma97_scaling=dynamic, this scaling is used according to the trigger ma97_switch3.

value	meaning
none	No scaling
mc30	Scale linear system matrix using MC30
mc64	Scale linear system matrix using MC64
mc77	Scale linear system matrix using MC77 [1,3,0]

Default: mc64

ma97_small: Zero Pivot Threshold ↵

Any pivot less than ma97_small is treated as zero.

Range: [0, ∞]

Default: 1e-20

ma97_solve_blas3: Controls if blas2 or blas3 routines are used for solve ↵

value	meaning
no	Use BLAS2 (faster, some implementations bit incompatible)
yes	Use BLAS3 (slower)

Default: no

ma97_switch1: First switch, determine when ma97_scaling1 is enabled. ↵

If ma97_scaling=dynamic, ma97_scaling1 is enabled according to this condition. If ma97_switch2 occurs this option is henceforth ignored.

value	meaning
never	Scaling is never enabled.
at_start	Scaling to be used from the very start.
at_start_reuse	Scaling to be used on first iteration, then reused thereafter.
on_demand	Scaling to be used after Ipopt request improved solution (i.e. iterative refinement has failed).
on_demand_reuse	As on_demand, but reuse scaling from previous itr
high_delay	Scaling to be used after more than 0.05*n delays are present
high_delay_reuse	Scaling to be used only when previous itr created more that 0.05*n additional delays, otherwise reuse scaling from previous itr
od_hd	Combination of on_demand and high_delay
od_hd_reuse	Combination of on_demand_reuse and high_delay_reuse

Default: od_hd_reuse

ma97_switch2: Second switch, determine when ma97_scaling2 is enabled. ↵

If ma97_scaling=dynamic, ma97_scaling2 is enabled according to this condition. If ma97_switch3 occurs this option is henceforth ignored.

value	meaning
never	Scaling is never enabled.
at_start	Scaling to be used from the very start.
at_start_reuse	Scaling to be used on first iteration, then reused thereafter.
on_demand	Scaling to be used after Ipopt request improved solution (i.e. iterative refinement has failed).
on_demand_reuse	As on_demand, but reuse scaling from previous itr
high_delay	Scaling to be used after more than 0.05*n delays are present
high_delay_reuse	Scaling to be used only when previous itr created more that 0.05*n additional delays, otherwise reuse scaling from previous itr
od_hd	Combination of on_demand and high_delay
od_hd_reuse	Combination of on_demand_reuse and high_delay_reuse

Default: never

ma97_switch3: Third switch, determine when ma97_scaling3 is enabled. ↵

If ma97_scaling=dynamic, ma97_scaling3 is enabled according to this condition.

value	meaning
never	Scaling is never enabled.
at_start	Scaling to be used from the very start.
at_start_reuse	Scaling to be used on first iteration, then reused thereafter.
on_demand	Scaling to be used after Ipopt request improved solution (i.e. iterative refinement has failed).
on_demand_reuse	As on_demand, but reuse scaling from previous itr
high_delay	Scaling to be used after more than 0.05*n delays are present
high_delay_reuse	Scaling to be used only when previous itr created more that 0.05*n additional delays, otherwise reuse scaling from previous itr
od_hd	Combination of on_demand and high_delay
od_hd_reuse	Combination of on_demand_reuse and high_delay_reuse

Default: never

ma97_u: Pivoting Threshold ↵

See MA97 documentation.

Range: [0, 0.5]

Default: 1e-08

ma97_umax: Maximum Pivoting Threshold ↵

See MA97 documentation.

Range: [0, 0.5]

Default: 0.0001

max_consecutive_failures: (temporarily removed) Number \(n\) of consecutive unsolved problems before aborting a branch of the tree. ↵

When \(n > 0\), continue exploring a branch of the tree until \(n\) consecutive problems in the branch are unsolved (we call unsolved a problem for which Ipopt can not guarantee optimality within the specified tolerances).

Range: {0, ..., ∞}

Default: 10

max_consecutive_infeasible: Number of consecutive infeasible subproblems before aborting a branch. ↵

Will continue exploring a branch of the tree until "max_consecutive_infeasible"consecutive problems are locally infeasible by the NLP sub-solver.

Range: {0, ..., ∞}

Default: 0

max_cpu_time: Maximum number of CPU seconds. ↵

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.

Range: (0, ∞]

Default: 1e+06

max_filter_resets: Maximal allowed number of filter resets ↵

A positive number enables a heuristic that resets the filter, whenever in more than "filter_reset_trigger" successive iterations the last rejected trial steps size was rejected because of the filter. This option determine the maximal number of resets that are allowed to take place.

Range: {0, ..., ∞}

Default: 5

max_hessian_perturbation: Maximum value of regularization parameter for handling negative curvature. ↵

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.)

Range: (0, ∞]

Default: 1e+20

max_iter: Maximum number of iterations. ↵

The algorithm terminates with an error message if the number of iterations exceeded this number.

Range: {0, ..., ∞}

Default: 3000

max_random_point_radius: Set max value r for coordinate of a random point. ↵

When picking a random point, coordinate i will be in the interval [min(max(l,-r),u-r), max(min(u,r),l+r)] (where l is the lower bound for the variable and u is its upper bound)

Range: (0, ∞]

Default: 100000

max_refinement_steps: Maximum number of iterative refinement steps per linear system solve. ↵

Iterative refinement (on the full unsymmetric system) is performed for each right hand side. This option determines the maximum number of iterative refinement steps.

Range: {0, ..., ∞}

Default: 10

max_resto_iter: Maximum number of successive iterations in restoration phase. ↵

The algorithm terminates with an error message if the number of iterations successively taken in the restoration phase exceeds this number.

Range: {0, ..., ∞}

Default: 3000000

max_soc: Maximum number of second order correction trial steps at each iteration. ↵

Choosing 0 disables the second order corrections. (This is p^{max} of Step A-5.9 of Algorithm A in the implementation paper.)

Range: {0, ..., ∞}

Default: 4

max_soft_resto_iters: Maximum number of iterations performed successively in soft restoration phase. ↵

If the soft restoration phase is performed for more than so many iterations in a row, the regular restoration phase is called.

Range: {0, ..., ∞}

Default: 10

maxmin_crit_have_sol: Weight towards minimum in of lower and upper branching estimates when a solution has been found. ↵

Range: [0, 1]

Default: 0.1

maxmin_crit_no_sol: Weight towards minimum in of lower and upper branching estimates when no solution has been found yet. ↵

Range: [0, 1]

Default: 0.7

mehrotra_algorithm: Indicates if we want to do Mehrotra's 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".

value	meaning
no	Do the usual Ipopt algorithm.
yes	Do Mehrotra's predictor-corrector algorithm.

Default: no

milp_log_level: specify MILP solver log level. ↵

Set the level of output of the MILP subsolver in OA : 0 - none, 1 - minimal, 2 - normal low, 3 - normal high

Range: {0, ..., 4}

Default: 0

milp_solver: Choose the subsolver to solve MILP sub-problems in OA decompositions. ↵

To use Cplex, a valid license is required.

value	meaning
Cbc_D	Coin Branch and Cut with its default
Cbc_Par	Coin Branch and Cut with passed parameters
Cplex	IBM Cplex

Default: Cbc_D

milp_strategy: Choose a strategy for MILPs. ↵

value	meaning
find_good_sol	Stop sub milps when a solution improving the incumbent is found
solve_to_optimality	Solve MILPs to optimality

Default: solve_to_optimality

min_hessian_perturbation: Smallest perturbation of the Hessian block. ↵

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.)

Range: [0, ∞]

Default: 1e-20

min_number_strong_branch: Sets minimum number of variables for strong branching (overriding trust) ↵

Range: {0, ..., ∞}

Default: 0

min_refinement_steps: Minimum number of iterative refinement steps per linear system solve. ↵

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.)

Range: {0, ..., ∞}

Default: 1

mir_cuts: Frequency (in terms of nodes) for generating MIR cuts in branch-and-cut ↵

See option 2mir_cuts for a detailed description.

Range: {-100, ..., ∞}

Default: -5

mu_allow_fast_monotone_decrease: Allow skipping of barrier problem if barrier test is already 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.

value	meaning
no	Take at least one iteration per barrier problem
yes	Allow fast decrease of mu if barrier test it met

Default: yes

mu_init: Initial value for the barrier parameter. ↵

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")

Range: (0, ∞]

Default: 0.1

mu_linear_decrease_factor: Determines linear decrease rate of barrier parameter. ↵

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.

Range: (0, 1)

Default: 0.2

mu_max: Maximum value for barrier parameter. ↵

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".)

Range: (0, ∞]

Default: 100000

mu_max_fact: Factor for initialization of maximum value for barrier parameter. ↵

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".)

Range: (0, ∞]

Default: 1000

mu_min: Minimum value for barrier parameter. ↵

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".)

Range: (0, ∞]

Default: 1e-11

mu_oracle: Oracle for a new barrier parameter in the adaptive strategy. ↵

Determines how a new barrier parameter is computed in each "free-mode" iteration of the adaptive barrier parameter strategy. (Only considered if "adaptive" is selected for option "mu_strategy").

value	meaning
probing	Mehrotra's probing heuristic
loqo	LOQO's centrality rule
quality-function	minimize a quality function

Default: probing

mu_strategy: Update strategy for barrier parameter. ↵

Determines which barrier parameter update strategy is to be used.

value	meaning
monotone	use the monotone (Fiacco-McCormick) strategy
adaptive	use the adaptive update strategy

Default: adaptive

mu_superlinear_decrease_power: Determines superlinear decrease rate of barrier parameter. ↵

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.

Range: (1, 2)

Default: 1.5

mu_target: Desired value of complementarity. ↵

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.

Range: [0, ∞]

Default: 0

mumps_dep_tol: Pivot threshold for detection of linearly dependent constraints in MUMPS. ↵

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.

Range: real

Default: 0

mumps_mem_percent: Percentage increase in the estimated working space for MUMPS. ↵

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.

Range: {0, ..., ∞}

Default: 1000

mumps_permuting_scaling: Controls permuting and scaling in MUMPS ↵

This is ICNTL(6) in MUMPS.

Range: {0, ..., 7}

Default: 7

mumps_pivot_order: Controls pivot order in MUMPS ↵

This is ICNTL(7) in MUMPS.

Range: {0, ..., 7}

Default: 7

mumps_pivtol: Pivot tolerance for the linear solver MUMPS. ↵

A smaller number pivots for sparsity, a larger number pivots for stability. This option is only available if Ipopt has been compiled with MUMPS.

Range: [0, 1]

Default: 1e-06

mumps_pivtolmax: Maximum pivot tolerance for the linear solver MUMPS. ↵

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.

Range: [0, 1]

Default: 0.1

mumps_scaling: Controls scaling in MUMPS ↵

This is ICNTL(8) in MUMPS.

Range: {-2, ..., 77}

Default: 77

neg_curv_test_reg: Whether to do the curvature test with the primal regularization (see Zavala and Chiang, 2014). ↵

value	meaning
yes	use primal regularization with the inertia-free curvature test
no	use original IPOPT approach, in which the primal regularization is ignored

Default: yes

neg_curv_test_tol: Tolerance for heuristic to ignore wrong inertia. ↵

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.

Range: [0, ∞]

Default: 0

nlp_failure_behavior: Set the behavior when an NLP or a series of NLP are unsolved by Ipopt (we call unsolved an NLP for which Ipopt is not able to guarantee optimality within the specified tolerances). ↵

If set to "fathom", the algorithm will fathom the node when Ipopt fails to find a solution to the nlp at that node within the specified tolerances. The algorithm then becomes a heuristic, and the user will be warned that the solution might not be optimal.

value	meaning
stop	Stop when failure happens.
fathom	Continue when failure happens.

Default: stop

nlp_log_at_root: specify a different log level for root relaxation. ↵

Range: {0, ..., 12}

Default: 5

nlp_log_level: specify NLP solver interface log level (independent from ipopt print_level). ↵

Set the level of output of the OsiTMINLPInterface : 0 - none, 1 - normal, 2 - verbose

Range: {0, ..., 2}

Default: 1

nlp_scaling_constr_target_gradient: Target value for constraint function gradient size. ↵

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.

Range: [0, ∞]

Default: 0

nlp_scaling_max_gradient: Maximum gradient after NLP scaling. ↵

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".

Range: (0, ∞]

Default: 100

nlp_scaling_method: Select the technique used for scaling the NLP. ↵

Selects the technique used for scaling the problem internally before it is solved. For user-scaling, the parameters come from the NLP. If you are using AMPL, they can be specified through suffixes ("scaling_factor")

value	meaning
none	no problem scaling will be performed
gradient-based	scale the problem so the maximum gradient at the starting point is scaling_max_gradient
equilibration-based	scale the problem so that first derivatives are of order 1 at random points (only available with MC19)

Default: gradient-based

nlp_scaling_min_value: Minimum value of gradient-based scaling values. ↵

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".

Range: [0, ∞]

Default: 1e-08

nlp_scaling_obj_target_gradient: Target value for objective function gradient size. ↵

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.

Range: [0, ∞]

Default: 0

nlp_solve_frequency: Specify the frequency (in terms of nodes) at which NLP relaxations are solved in B-Hyb. ↵

A frequency of 0 amounts to to never solve the NLP relaxation.

Range: {0, ..., ∞}

Default: 10

nlp_solve_max_depth: Set maximum depth in the tree at which NLP relaxations are solved in B-Hyb. ↵

A depth of 0 amounts to to never solve the NLP relaxation.

Range: {0, ..., ∞}

Default: 10

nlp_solves_per_depth: Set average number of nodes in the tree at which NLP relaxations are solved in B-Hyb for each depth. ↵

Range: [0, ∞]

Default: 1e+100

node_comparison: Choose the node selection strategy. ↵

Choose the strategy for selecting the next node to be processed.

value	meaning
best-bound	choose node with the smallest bound,
depth-first	Perform depth first search,
breadth-first	Perform breadth first search,
dynamic	Cbc dynamic strategy (starts with a depth first search and turn to best bound after 3 integer feasible solutions have been found).
best-guess	choose node with smallest guessed integer solution

Default: best-bound

node_limit: Set the maximum number of nodes explored in the branch-and-bound search. ↵

Range: {0, ..., ∞}

Default: GAMS nodlim

nu_inc: Increment of the penalty parameter. ↵

Range: (0, ∞]

Default: 0.0001

nu_init: Initial value of the penalty parameter. ↵

Range: (0, ∞]

Default: 1e-06

num_cut_passes: Set the maximum number of cut passes at regular nodes of the branch-and-cut. ↵

Range: {0, ..., ∞}

Default: 1

num_cut_passes_at_root: Set the maximum number of cut passes at regular nodes of the branch-and-cut. ↵

Range: {0, ..., ∞}

Default: 20

num_iterations_suspect: Number of iterations over which a node is considered "suspect" (for debugging purposes only, see detailed documentation). ↵

When the number of iterations to solve a node is above this number, the subproblem at this node is considered to be suspect and it will be written into a file (set to -1 to deactivate this).

Range: {-1, ..., ∞}

Default: -1

num_resolve_at_infeasibles: Number \(k\) of tries to resolve an infeasible node (other than the root) of the tree with different starting point. ↵

The algorithm will solve all the infeasible nodes with \(k\) different random starting points and will keep the best local optimum found.

Range: {0, ..., ∞}

Default: 0

num_resolve_at_node: Number \(k\) of tries to resolve a node (other than the root) of the tree with different starting point. ↵

The algorithm will solve all the nodes with \(k\) different random starting points and will keep the best local optimum found.

Range: {0, ..., ∞}

Default: 0

num_resolve_at_root: Number \(k\) of tries to resolve the root node with different starting points. ↵

The algorithm will solve the root node with \(k\) random starting points and will keep the best local optimum found.

Range: {0, ..., ∞}

Default: 0

num_retry_unsolved_random_point: Number \(k\) of times that the algorithm will try to resolve an unsolved NLP with a random starting point (we call unsolved an NLP for which Ipopt is not able to guarantee optimality within the specified tolerances). ↵

When Ipopt fails to solve a continuous NLP sub-problem, if \(k > 0\), the algorithm will try again to solve the failed NLP with \(k\) new randomly chosen starting points or until the problem is solved with success.

Range: {0, ..., ∞}

Default: 0

number_before_trust: Set the number of branches on a variable before its pseudo costs are to be believed in dynamic strong branching. ↵

A value of 0 disables pseudo costs.

Range: {0, ..., ∞}

Default: 8

number_before_trust_list: Set the number of branches on a variable before its pseudo costs are to be believed during setup of strong branching candidate list. ↵

The default value is that of "number_before_trust"

Range: {-1, ..., ∞}

Default: 0

number_cpx_threads: Set number of threads to use with cplex. ↵

(refer to CPLEX documentation)

Range: {0, ..., ∞}

Default: GAMS threads

number_look_ahead: Sets limit of look-ahead strong-branching trials ↵

Range: {0, ..., ∞}

Default: 0

number_strong_branch: Choose the maximum number of variables considered for strong branching. ↵

Set the number of variables on which to do strong branching.

Range: {0, ..., ∞}

Default: 20

number_strong_branch_root: Maximum number of variables considered for strong branching in root node. ↵

Range: {0, ..., ∞}

Default: ∞

oa_cuts_log_level: level of log when generating OA cuts. ↵

0: outputs nothing, 1: when a cut is generated, its violation and index of row from which it originates, 2: always output violation of the cut. 3: output generated cuts incidence vectors.

Range: {0, ..., ∞}

Default: 0

oa_cuts_scope: Specify if OA cuts added are to be set globally or locally valid ↵

value	meaning
local	Cuts are treated as locally valid
global	Cuts are treated as globally valid

Default: global

oa_decomposition: If yes do initial OA decomposition ↵

Range: no, yes

Default: no

oa_log_frequency: display an update on lower and upper bounds in OA every n seconds ↵

Range: (0, ∞]

Default: 100

oa_log_level: specify OA iterations log level. ↵

Set the level of output of OA decomposition solver : 0 - none, 1 - normal, 2 - verbose

Range: {0, ..., 2}

Default: 1

oa_rhs_relax: Value by which to relax OA cut ↵

RHS of OA constraints will be relaxed by this amount times the absolute value of the initial rhs if it is ≥ 1 (otherwise by this amount).

Range: [-0, ∞]

Default: 1e-08

obj_max_inc: Determines the upper bound on the acceptable increase of barrier objective function. ↵

Trial points are rejected if they lead to an increase in the barrier objective function by more than obj_max_inc orders of magnitude.

Range: (1, ∞]

Default: 5

pardiso_matching_strategy: Matching strategy to be used by Pardiso ↵

This is IPAR(13) in Pardiso manual.

value	meaning
complete	Match complete (IPAR(13)=1)
complete+2x2	Match complete+2x2 (IPAR(13)=2)
constraints	Match constraints (IPAR(13)=3)

Default: complete+2x2

pardiso_max_iterative_refinement_steps: Limit on number of iterative refinement steps. ↵

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.

Range: {-∞, ..., ∞}

Default: 1

pardiso_msglvl: Pardiso message level ↵

This determines the amount of analysis output from the Pardiso solver. This is MSGLVL in the Pardiso manual.

Range: {0, ..., ∞}

Default: 0

pardiso_order: Controls the fill-in reduction ordering algorithm for the input matrix. ↵

value	meaning
amd	minimum degree algorithm
one	undocumented
metis	MeTiS nested dissection algorithm
pmetis	parallel (OpenMP) version of MeTiS nested dissection algorithm

Default: metis

pardiso_redo_symbolic_fact_only_if_inertia_wrong: Toggle for handling case when elements were perturbed by Pardiso. ↵

value	meaning
no	Always redo symbolic factorization when elements were perturbed
yes	Only redo symbolic factorization when elements were perturbed if also the inertia was wrong

Default: no

pardiso_repeated_perturbation_means_singular: Interpretation of perturbed elements. ↵

value	meaning
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

Default: no

pardiso_skip_inertia_check: Always pretend inertia is correct. ↵

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.

value	meaning
no	check inertia
yes	skip inertia check

Default: no

perturb_always_cd: Active permanent perturbation of constraint linearization. ↵

This options makes the delta_c and delta_d perturbation be used for the computation of every search direction. Usually, it is only used when the iteration matrix is singular.

value	meaning
no	perturbation only used when required
yes	always use perturbation

Default: no

perturb_dec_fact: Decrease factor for x-s perturbation. ↵

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.)

Range: (0, 1)

Default: 0.333333

perturb_inc_fact: Increase factor for x-s perturbation. ↵

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.)

Range: (1, ∞]

Default: 8

perturb_inc_fact_first: Increase factor for x-s perturbation for very first perturbation. ↵

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.)

Range: (1, ∞]

Default: 100

print_eval_error: Switch to enable printing information about function evaluation errors into the GAMS listing file. ↵

Range: no, yes

Default: yes

print_frequency_iter: Determines at which iteration frequency the summarizing iteration output line should be printed. ↵

Summarizing iteration output is printed every print_frequency_iter iterations, if at least print_frequency_time seconds have passed since last output.

Range: {1, ..., ∞}

Default: 1

print_frequency_time: Determines at which time frequency the summarizing iteration output line should be printed. ↵

Summarizing iteration output is printed if at least print_frequency_time seconds have passed since last output and the iteration number is a multiple of print_frequency_iter.

Range: [0, ∞]

Default: 0.5

print_funceval_statistics: Switch to enable printing statistics on number of evaluations of GAMS functions/gradients/Hessian. ↵

Range: no, yes

Default: no

print_info_string: Enables printing of additional info string at end of iteration output. ↵

This string contains some insider information about the current iteration. For details, look for "Diagnostic Tags" in the Ipopt documentation.

value	meaning
no	don't print string
yes	print string at end of each iteration output

Default: no

print_level: Output verbosity level. ↵

Sets the default verbosity level for console output. The larger this value the more detailed is the output.

Range: {0, ..., 12}

Default: 0

print_timing_statistics: Switch to print timing statistics. ↵

If selected, the program will print the CPU usage (user time) for selected tasks.

value	meaning
no	don't print statistics
yes	print all timing statistics

Default: no

pump_for_minlp: whether to run the feasibility pump heuristic for MINLP ↵

Range: no, yes

Default: no

quality_function_balancing_term: The balancing term included in the quality function for centrality. ↵

This determines whether a term is added to the quality function that penalizes situations where the complementarity is much smaller than dual and primal infeasibilities. (Only used if option "mu_oracle" is set to "quality-function".)

value	meaning
none	no balancing term is added
cubic	Max(0,Max(dual_inf,primal_inf)-compl)^3

Default: none

quality_function_centrality: The penalty term for centrality that is included in quality function. ↵

This determines whether a term is added to the quality function to penalize deviation from centrality with respect to complementarity. The complementarity measure here is the xi in the Loqo update rule. (Only used if option "mu_oracle" is set to "quality-function".)

value	meaning
none	no penalty term is added
log	complementarity * the log of the centrality measure
reciprocal	complementarity * the reciprocal of the centrality measure
cubed-reciprocal	complementarity * the reciprocal of the centrality measure cubed

Default: none

quality_function_max_section_steps: Maximum number of search steps during direct search procedure determining the optimal centering parameter. ↵

The golden section search is performed for the quality function based mu oracle. (Only used if option "mu_oracle" is set to "quality-function".)

Range: {0, ..., ∞}

Default: 8

quality_function_norm_type: Norm used for components of the quality function. ↵

(Only used if option "mu_oracle" is set to "quality-function".)

value	meaning
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

Default: 2-norm-squared

quality_function_section_qf_tol: Tolerance for the golden section search procedure determining the optimal centering parameter (in the function value space). ↵

The golden section search is performed for the quality function based mu oracle. (Only used if option "mu_oracle" is set to "quality-function".)

Range: [0, 1)

Default: 0

quality_function_section_sigma_tol: Tolerance for the section search procedure determining the optimal centering parameter (in sigma space). ↵

The golden section search is performed for the quality function based mu oracle. (Only used if option "mu_oracle" is set to "quality-function".)

Range: [0, 1)

Default: 0.01

random_generator_seed: Set seed for random number generator (a value of -1 sets seeds to time since Epoch). ↵

Range: {-1, ..., ∞}

Default: 0

random_point_perturbation_interval: Amount by which starting point is perturbed when choosing to pick random point by perturbing starting point ↵

Range: (0, ∞]

Default: 1

random_point_type: method to choose a random starting point ↵

value	meaning
Jon	Choose random point uniformly between the bounds
Andreas	perturb the starting point of the problem within a prescribed interval
Claudia	perturb the starting point using the perturbation radius suffix information

Default: Jon

read_solution_file: Read a file with the optimal solution to test if algorithms cuts it. ↵

For Debugging purposes only.

Range: no, yes

Default: no

recalc_y: Tells the algorithm to recalculate the equality and inequality multipliers as least square 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.

value	meaning
no	use the Newton step to update the multipliers
yes	use least-square multiplier estimates

Default: no

recalc_y_feas_tol: Feasibility threshold for recomputation of multipliers. ↵

If recalc_y is chosen and the current infeasibility is less than this value, then the multipliers are recomputed.

Range: (0, ∞]

Default: 1e-06

reduce_and_split_cuts: Frequency (in terms of nodes) for generating reduce-and-split cuts in branch-and-cut ↵

See option 2mir_cuts for a detailed description.

Range: {-100, ..., ∞}

Default: 0

replace_bounds: Indicates if all variable bounds should be replaced by inequality constraints ↵

This option must be set for the inexact algorithm

value	meaning
no	leave bounds on variables
yes	replace variable bounds by inequality constraints

Default: no

required_infeasibility_reduction: Required reduction of infeasibility before leaving restoration phase. ↵

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.

Range: [0, 1)

Default: 0.1

residual_improvement_factor: Minimal required reduction of residual test ratio in iterative refinement. ↵

If the improvement of the residual test ratio made by one iterative refinement step is not better than this factor, iterative refinement is aborted.

Range: (0, ∞]

Default: 1

residual_ratio_max: Iterative refinement tolerance ↵

Iterative refinement is performed until the residual test ratio is less than this tolerance (or until "max_refinement_steps" refinement steps are performed).

Range: (0, ∞]

Default: 1e-10

residual_ratio_singular: Threshold for declaring linear system singular after failed iterative refinement. ↵

If the residual test ratio is larger than this value after failed iterative refinement, the algorithm pretends that the linear system is singular.

Range: (0, ∞]

Default: 1e-05

resolve_on_small_infeasibility: If a locally infeasible problem is infeasible by less than this, resolve it with initial starting point. ↵

Range: [0, ∞]

Default: 0

resto_failure_feasibility_threshold: Threshold for primal infeasibility to declare failure of restoration phase. ↵

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.

Range: [0, ∞]

Default: 0

resto_penalty_parameter: Penalty parameter in the restoration phase objective function. ↵

This is the parameter rho in equation (31a) in the Ipopt implementation paper.

Range: (0, ∞]

Default: 1000

resto_proximity_weight: Weighting factor for the proximity term in restoration phase objective. ↵

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.

Range: [0, ∞]

Default: 1

rho: Value in penalty parameter update formula. ↵

Range: (0, 1)

Default: 0.1

s_max: Scaling threshold for the NLP error. ↵

(See paragraph after Eqn. (6) in the implementation paper.)

Range: (0, ∞]

Default: 100

s_phi: Exponent for linear barrier function model in the switching rule. ↵

(See Eqn. (19) in the implementation paper.)

Range: (1, ∞]

Default: 2.3

s_theta: Exponent for current constraint violation in the switching rule. ↵

(See Eqn. (19) in the implementation paper.)

Range: (1, ∞]

Default: 1.1

second_perc_for_cutoff_decr: The percentage used when, the coeff of variance is greater than the threshold, to compute the cutoff_decr dynamically. ↵

Range: real

Default: -0.05

setup_pseudo_frac: Proportion of strong branching list that has to be taken from most-integer-infeasible list. ↵

Range: [0, 1]

Default: 0.5

sigma_max: Maximum value of the centering parameter. ↵

This is the upper bound for the centering parameter chosen by the quality function based barrier parameter update. (Only used if option "mu_oracle" is set to "quality-function".)

Range: (0, ∞]

Default: 100

sigma_min: Minimum value of the centering parameter. ↵

This is the lower bound for the centering parameter chosen by the quality function based barrier parameter update. (Only used if option "mu_oracle" is set to "quality-function".)

Range: [0, ∞]

Default: 1e-06

skip_corr_if_neg_curv: Skip the corrector step in negative curvature iteration. ↵

The corrector step is not tried if negative curvature has been encountered during the computation of the search direction in the current iteration. This option is only used if "mu_strategy" is "adaptive". Changing this option is experimental.

value	meaning
no	don't skip
yes	skip

Default: yes

skip_corr_in_monotone_mode: Skip the corrector step during monotone barrier parameter mode. ↵

The corrector step is not tried if the algorithm is currently in the monotone mode (see also option "barrier_strategy").This option is only used if "mu_strategy" is "adaptive". Changing this option is experimental.

value	meaning
no	don't skip
yes	skip

Default: yes

slack_bound_frac: Desired minimum relative distance from the initial slack to bound. ↵

Determines how much the initial slack variables might have to be modified in order to be sufficiently inside the inequality bounds (together with "slack_bound_push"). (This is kappa_2 in Section 3.6 of implementation paper.)

Range: (0, 0.5]

Default: 0.01

slack_bound_push: Desired minimum absolute distance from the initial slack to bound. ↵

Determines how much the initial slack variables might have to be modified in order to be sufficiently inside the inequality bounds (together with "slack_bound_frac"). (This is kappa_1 in Section 3.6 of implementation paper.)

Range: (0, ∞]

Default: 0.01

slack_move: Correction size for very small slacks. ↵

Due to numerical issues or the lack of an interior, the slack variables might become very small. If a slack becomes very small compared to machine precision, the corresponding bound is moved slightly. This parameter determines how large the move should be. Its default value is mach_eps^{3/4}. (See also end of Section 3.5 in implementation paper - but actual implementation might be somewhat different.)

Range: [0, ∞]

Default: 1.81899e-12

soc_method: Ways to apply second order correction ↵

This option determins the way to apply second order correction, 0 is the method described in the implementation paper. 1 is the modified way which adds alpha on the rhs of x and s rows.

Range: {0, ..., 1}

Default: 0

soft_resto_pderror_reduction_factor: Required reduction in primal-dual error in the soft restoration phase. ↵

The soft restoration phase attempts to reduce the primal-dual error with regular steps. If the damped primal-dual step (damped only to satisfy the fraction-to-the-boundary rule) is not decreasing the primal-dual error by at least this factor, then the regular restoration phase is called. Choosing "0" here disables the soft restoration phase.

Range: [0, ∞]

Default: 0.9999

solution_limit: Abort after that much integer feasible solution have been found by algorithm ↵

value 0 deactivates option

Range: {0, ..., ∞}

Default: ∞

solvefinal: Switch to disable solving MINLP with discrete variables fixed to solution values after solve. ↵

If enabled, then the dual values from the resolved NLP are made available in GAMS.

Range: no, yes

Default: yes

solvetrace: Name of file for writing solving progress information. ↵

Range: string

Default: empty

solvetracenodefreq: Frequency in number of nodes for writing solving progress information. ↵

giving 0 disables writing of N-lines to trace file

Range: {0, ..., ∞}

Default: 100

solvetracetimefreq: Frequency in seconds for writing solving progress information. ↵

giving 0.0 disables writing of T-lines to trace file

Range: [0, ∞]

Default: 5

start_with_resto: Tells algorithm to switch to restoration phase in first iteration. ↵

Setting this option to "yes" forces the algorithm to switch to the feasibility restoration phase in the first iteration. If the initial point is feasible, the algorithm will abort with a failure.

value	meaning
no	don't force start in restoration phase
yes	force start in restoration phase

Default: no

tau_min: Lower bound on fraction-to-the-boundary parameter tau. ↵

(This is tau_min in the implementation paper.) This option is also used in the adaptive mu strategy during the monotone mode.

Range: (0, 1)

Default: 0.99

theta_max_fact: Determines upper bound for constraint violation in the filter. ↵

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 the implementation paper).

Range: (0, ∞]

Default: 10000

theta_min_fact: Determines constraint violation threshold in the switching rule. ↵

The algorithmic parameter theta_min is determined as theta_min_fact times the maximum of 1 and the constraint violation at initial point. The switching rules treats an iteration as an h-type iteration whenever the current constraint violation is larger than theta_min (see paragraph before Eqn. (19) in the implementation paper).

Range: (0, ∞]

Default: 0.0001

time_limit: Set the global maximum computation time (in secs) for the algorithm. ↵

Range: [0, ∞]

Default: GAMS reslim

tiny_element: Value for tiny element in OA cut ↵

We will remove "cleanly" (by relaxing cut) an element lower than this.

Range: [-0, ∞]

Default: 1e-08

tiny_step_tol: Tolerance for detecting numerically insignificant steps. ↵

If the search direction in the primal variables (x and s) is, in relative terms for each component, less than this value, the algorithm accepts the full step without line search. If this happens repeatedly, the algorithm will terminate with a corresponding exit message. The default value is 10 times machine precision.

Range: [0, ∞]

Default: 2.22045e-15

tiny_step_y_tol: Tolerance for quitting because of numerically insignificant steps. ↵

If the search direction in the primal variables (x and s) is, in relative terms for each component, repeatedly less than tiny_step_tol, and the step in the y variables is smaller than this threshold, the algorithm will terminate.

Range: [0, ∞]

Default: 0.01

tol: Desired convergence tolerance (relative). ↵

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", "constr_viol_tol", and "compl_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.

Range: (0, ∞]

Default: 1e-08

tree_search_strategy: Pick a strategy for traversing the tree ↵

All strategies can be used in conjunction with any of the node comparison functions. Options which affect dfs-dive are max-backtracks-in-dive and max-dive-depth. The dfs-dive won't work in a non-convex problem where objective does not decrease down branches.

value	meaning
top-node	Always pick the top node as sorted by the node comparison function
dive	Dive in the tree if possible, otherwise pick top node as sorted by the tree comparison function.
probed-dive	Dive in the tree exploring two children before continuing the dive at each level.
dfs-dive	Dive in the tree if possible doing a depth first search. Backtrack on leaves or when a prescribed depth is attained or when estimate of best possible integer feasible solution in subtree is worst than cutoff. Once a prescribed limit of backtracks is attained pick top node as sorted by the tree comparison function
dfs-dive-dynamic	Same as dfs-dive but once enough solution are found switch to best-bound and if too many nodes switch to depth-first.

Default: probed-dive

trust_strong_branching_for_pseudo_cost: Whether or not to trust strong branching results for updating pseudo costs. ↵

Range: no, yes

Default: yes

variable_selection: Chooses variable selection strategy ↵

value	meaning
most-fractional	Choose most fractional variable
strong-branching	Perform strong branching
reliability-branching	Use reliability branching
qp-strong-branching	Perform strong branching with QP approximation
lp-strong-branching	Perform strong branching with LP approximation
nlp-strong-branching	Perform strong branching with NLP approximation
osi-simple	Osi method to do simple branching
osi-strong	Osi method to do strong branching
random	Method to choose branching variable randomly

Default: strong-branching

very_tiny_element: Value for very tiny element in OA cut ↵

Algorithm will take the risk of neglecting an element lower than this.

Range: [-0, ∞]

Default: 1e-17

warm_start: Select the warm start method ↵

This will affect the function getWarmStart(), and as a consequence the warm starting in the various algorithms.

value	meaning
none	No warm start, just start NLPs from optimal solution of the root relaxation
fake_basis	builds fake basis, useful for cut management in Cbc (warm start is the same as in none)
optimum	Warm start with direct parent optimum
interior_point	Warm start with an interior point of direct parent

Default: none

warm_start_bound_frac: same as bound_frac for the regular initializer. ↵

Range: (0, 0.5]

Default: 0.001

warm_start_bound_push: same as bound_push for the regular initializer. ↵

Range: (0, ∞]

Default: 0.001

warm_start_init_point: Warm-start for initial point ↵

Indicates whether this optimization should use a warm start initialization, where values of primal and dual variables are given (e.g., from a previous optimization of a related problem.)

value	meaning
no	do not use the warm start initialization
yes	use the warm start initialization

Default: yes

warm_start_mult_bound_push: same as mult_bound_push for the regular initializer. ↵

Range: (0, ∞]

Default: 0.001

warm_start_mult_init_max: Maximum initial value for the equality multipliers. ↵

Range: real

Default: 1e+06

warm_start_slack_bound_frac: same as slack_bound_frac for the regular initializer. ↵

Range: (0, 0.5]

Default: 0.001

warm_start_slack_bound_push: same as slack_bound_push for the regular initializer. ↵

Range: (0, ∞]

Default: 0.001

watchdog_shortened_iter_trigger: Number of shortened iterations that trigger the watchdog. ↵

If the number of successive iterations in which the backtracking line search did not accept the first trial point exceeds this number, the watchdog procedure is activated. Choosing "0" here disables the watchdog procedure.

Range: {0, ..., ∞}

Default: 10

watchdog_trial_iter_max: Maximum number of watchdog iterations. ↵

This option determines the number of trial iterations allowed before the watchdog procedure is aborted and the algorithm returns to the stored point.

Range: {1, ..., ∞}

Default: 3