Parameters of the Ipopt interior point optimizer
[x_sol, f_sol, extra] = ipopt(..., params) [x_sol, f_sol, extra] = ipopt(problem)
Parameters are given as fields of the last argument params in the long syntax or as fields of the problem structure in the one argument syntax.
The fields and their admissible values are the following, sorted by category:
Output
'print_level' : Output verbosity level. Sets the default verbosity level for console output. The larger this value the more detailed is the output. The valid range for this integer option is -2 <= print_level <= 12 and its default value is 5:
-1 : - J_INSUPPRESSIBLE
0 : - J_NONE
1 : - J_ERROR
2 : - J_STRONGWARNING
3 : - J_SUMMARY
4 : - J_WARNING
5 : - J_ITERSUMMARY
6 : - J_DETAILED
7 : - J_MOREDETAILED
8 : - J_VECTOR
9 : - J_MOREVECTOR
10 : - J_MATRIX
11 : - J_MOREMATRIX
12 : - J_ALL
13 - J_LAST_LEVEL
'option_file_name' : File name of options file (to overwrite default). By default, the name of the Ipopt options file is 'ipopt.opt' - or something else if specified in the IpoptApplication::Initialize call. If this option is set by SetStringValue BEFORE the options file is read, it specifies the name of the options file. It does not make any sense to specify this option within the options file. The default value for this string option is ''. Possible values: Any acceptable standard file name.
Termination
'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', 'primal_inf_tol', and 'cmpl_inf_tol' are met (This is epsilon_tol in Eqn. (6) in implementation paper). See also 'acceptable_tol' as a second termination criterion. Note, some other algorithmic features also use this quantity to determine thresholds etc. The valid range for this real option is 0 < tol < +inf and its default value is 1.10^-08.
's_max' : Scaling threshold for the NLP error. (See paragraph after Eqn. (6) in the implementation paper.)
'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.
'max_iter' : The algorithm terminates with an error message if the number of iterations exceeded this number. The valid range for this integer option is 0 <= max_iter < +inf and its default value is 3000
'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. The valid range for this real option is 0 < dual_inf_tol < +inf and its default value is 1.
'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. The valid range for this real option is 0 < constr_viol_tol < +inf and its default value is 0.0001.
'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. The valid range for this real option is 0 < compl_inf_tol < +inf and its default value is 0.0001.
'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. The valid range for this real option is 0 < acceptable_tol < +inf and its default value is 1.10^-6.
'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. The valid range for this real option is 0 < acceptable_constr_viol_tol < +inf and its default value is 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. The valid range for this real option is 0 < acceptable_dual_inf_tol < +inf and its default value is 1.10^+10.
'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. The valid range for this real option is 0 < acceptable_compl_inf_tol < +inf and its default value is 0.01.
'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. Its default value is 1e20.
'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. The valid range for this real option is 0 < diverging_iterates_tol < +inf and its default value is 1.10^+20.
'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. Its default value is 15.
NLP Scaling
'obj_scaling_factor' : Scaling factor for the objective function. This option sets a scaling factor for the objective function. The scaling is seen internally by Ipopt but the unscaled objective is reported in the console output. If additional scaling parameters are computed (e.g. user-scaling or gradient-based), both factors are multiplied. If this value is chosen to be negative, Ipopt will maximize the objective function instead of minimizing it. The valid range for this real option is -inf < obj_scaling_factor < +inf and its default value is 1.
'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') The default value for this string option is 'gradient-based'. Possible values:
'none' :: no problem scaling will be performed
'user-scaling' :: scaling parameters will come from the user
'gradient-based' :: scale the problem so the maximum gradient at the starting point is scaling_max_gradient
'equilibration-based' :: scale the problem so that first derivatives are of order 1 at random points (only available with MC19).
'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'. The valid range for this real option is 0 < nlp_scaling_max_gradient < +inf and its default value is 100.
'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.
'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.
'replace_bounds' : Indicates if all variable bounds should be replaced by inequality constraints. This option must be set for the inexact algorithm Possible values: no (leave bounds on variables), yes (replace variable bounds by inequality constraints).
NLP
'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.) The valid range for this real option is 0 <= bound_relax_factor < +inf and its default value is 1.10^-8.
'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. The default value for this string option is 'yes'. Possible values:
'no' :: Leave final point unchanged
'yes' :: Project final point back into original bounds
'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. The default value for this string option is 'no'. Possible values:
'no' :: Don't check (faster)
'yes' :: Check Jacobians and Hessian for Nan and Inf
'nlp_lower_bound_inf' : any bound less or equal this value will be considered -inf (i.e. not lower bounded). The valid range for this real option is -inf < nlp_lower_bound_inf < +inf and its default value is -1.10^+19.
'nlp_upper_bound_inf' : any bound greater or this value will be considered +inf (i.e. not upper bounded). The valid range for this real option is -inf < nlp_upper_bound_inf < +inf and its default value is 1.10^+19.
'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. The default value for this string option is 'make_parameter'. Possible values:
'make_parameter' :: Remove fixed variable from optimization variables
'make_constraint' :: Add equality constraints fixing variables
'relax_bounds' :: Relax fixing bound constraints
'dependency_detector' : Indicates which linear solver should be used to detect linearly dependent equality constraints. Its default value is 'none'. The default and available choices depend on how Ipopt has been compiled. This is experimental and does not work well. Possible values:
'none' :: don't check; no extra work at beginning
'mumps' :: use MUMPS
'wsmp' :: use WSMP
'ma28' :: use MA28
'dependency_detection_with_rhs' : Indicates if the right hand sides of the constraints should be considered during dependency detection. Its default value is 'no'. Possible values:
'no' :: only look at gradients
'yes' :: also consider right hand side
'num_linear_variables' : Number of linear variables. When the Hessian is approximated, it is assumed that the first num_linear_variables variables are linear. The Hessian is then not approximated in this space. If the 'get_number_of_nonlinear_variables' : method in the TNLP is implemented, this option is ignored. Its default value is 0.
'kappa_d' : Weight for linear damping term (to handle one-sided bounds). (see Section 3.7 in implementation paper.)
'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. The default value for this string option is 'no'. Possible values:
'no' :: Don't assume that all equality constraints are linear
'yes' :: Assume that equality constraints Jacobian are constant
'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. The default value for this string option is 'no'. Possible values:
'no' :: Don't assume that all inequality constraints are linear
'yes' :: Assume that equality constraints Jacobian are constant
'hessian_constant' : Indicates whether the problem is a quadratic problem. Activating this option will cause Ipopt to ask for the Hessian of the Lagrangian function only once from the NLP and reuse this information later. The default value for this string option is 'no'. Possible values:
'no' :: Assume that Hessian changes
'yes' :: Assume that Hessian is constant.
Initialization
'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). The valid range for this real option is 0 < bound_frac <= 0.5 and its default value is 0.01.
'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). The valid range for this real option is 0 < bound_push < +inf and its default value is 0.01.
'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). The valid range for this real option is 0 < slack_bound_frac <= 0.5 and its default value is 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). The valid range for this real option is 0 < slack_bound_push < +inf and its default value is 0.01.
'bound_mult_init_val' : Initial value for the bound multipliers. All dual variables corresponding to bound constraints are initialized to this value. The valid range for this real option is 0 < bound_mult_init_val < +inf and its default value is 1.
'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. The valid range for this real option is 0 <= constr_mult_init_max < +inf and its default value is 1000.
'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. The default value for this string option is 'constant'. Possible values:
'constant' :: set all bound multipliers to the value of bound_mult_init_val
'mu-based' :: initialize to mu_init/x_slack
'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. Its default value is 'no'. Possible values:
'no' :: take user-provided point
'yes' :: overwrite user-provided point with least-square estimates
'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' :. Its default value is 'no'. Possible values:
'no' :: use 'bound_mult_init_val' : and least-square equality constraint multipliers
'yes' :: overwrite user-provided point with least-square estimates
Barrier Parameter
'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'. The default value for this string option is 'no'. Possible values:
'no' :: Do the usual Ipopt algorithm
'yes' :: Do Mehrotra's predictor-corrector algorithm
'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.
Possible values:
'no' : Verify solution of linear system by computing residuals.
'yes' : Trust that linear systems are solved well.]
'mu_strategy' : Update strategy for barrier parameter. Determines which barrier parameter update strategy is to be used. The default value for this string option is 'monotone'. Possible values:
'monotone' :: use the monotone (Fiacco-McCormick) strategy
'adaptive' :: use the adaptive update strategy
'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'). The default value for this string option is 'quality-function'. Possible values:
'probing' :: Mehrotra's probing heuristic
'loqo' :: LOQO's centrality rule
'quality-function' :: minimize a quality function
'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'). The valid range for this integer option is 0 <= quality_function_max_section_steps < +inf and its default value is 8.
'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'). The default value for this string option is 'average_compl'. Possible values:
'probing' :: Mehrotra's probing heuristic
'loqo' :: LOQO's centrality rule
'quality-function' :: minimize a quality function
'average_compl' :: base on current average complementarity
'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'). The valid range for this real option is 0 < mu_init < +inf and its default value is 0.1.
'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'). The valid range for this real option is 0 < mu_max_fact < +inf and its default value is 1000.
'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'). The valid range for this real option is 0 < mu_max < +inf and its default value is 100000.
'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'). The valid range for this real option is 0 < mu_min < +inf and its default value is 1.10^-11.
'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). The valid range for this real option is 0 < barrier_tol_factor < +inf and its default value is 10.
'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. The valid range for this real option is 0 < mu_linear_decrease_factor < 1 and its default value is 0.2.
'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. The valid range for this real option is 1 < mu_superlinear_decrease_power < 2 and its default value is 1.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. Its default value is 'yes' :. Possible values:
'no' :: Take at least one iteration per barrier problem
'yes' :: Allow fast decrease of mu if barrier test it met
'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. Its default value is 0.99.
'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' :.)
'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' :.)
'quality_function_norm_type' : Norm used for components of the quality function. (Only used if option 'mu_oracle' : is set to 'quality-function' :). Possible values:
'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
'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 in the Loqo update rule. (Only
used if option 'mu_oracle' : is set to 'quality-function' :). Possible values:
'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
'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' :). Possible values:
'none' : no balancing term is added
'cubic' : Max(0,Max(dual_inf,primal_inf)-compl)^3
'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' :).
'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' :).
'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. Its default value is 1e10.
'line_search_method' : Globalization method used in backtracking line search. Its default value is 'cg-penalty' :. Possible values:
'filter' :: Filter method
'cg-penalty' :: Chen-Goldfarb penalty function
'penalty' :: Standard penalty function
'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' :). Its default value is 'obj-constr-filter' :. Possible values:
'kkt-error' :: nonmonotone decrease of kkt-error
'obj-constr-filter' :: 2-dim filter for objective and constraint violation
'never-monotone-mode' :: disables globalization
'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. Its default value is 4.
'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. Its default value is 0.9999.
'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' :. Its default value is 1e-5.
'filter_max_margin' : Maximum width of margin in obj-constr-filter adaptive globalization strategy. Its default value is 1.0.
'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). Its default value is 'no' :. Possible values:
'no' :: don't restore accepted iterate
'yes' :: restore accepted iterate
'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' :. Its default value is 0.8.
'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. Its default value is '2-norm-squared' :. Possible values:
'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
Multiplier Updates
'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.
'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. Possible values:
'no' : don't arbitrarily accept the full step
'yes' : always accept the full step
'accept_after_max_steps' : Accept a trial point after maximal this number of steps. Even if it does not satisfy line search conditions.
'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. The default value for this string option is 'primal' :. Possible values:
'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
'safe_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
'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. Its default value is 10.0.
'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. Its default value is 10.0*%eps.
'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. Its default value is 1e-2.
'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. The default value for this string option is 'no' :. Possible values:
'no' :: use the Newton step to update the multipliers
'yes' :: use least-square multiplier estimates
'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. The valid range for this real option is 0 < 'recalc_y_feas_tol' : < +inf and its default value is 1.10^-6.
'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
. (See also end of Section 3.5 in implementation paper -
but actual implementation might be somewhat different).
Line Search
'max_soc' : Maximum number of second order correction trial steps at each iteration. Choosing 0 disables the second order corrections. (This is pmax of Step A-5.9 of Algorithm A in the implementation paper.) The valid range for this integer option is 0 <= 'max_soc' : < +inf and its default value is 4.
'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. The valid range for this integer option is 0 <= 'watchdog_shortened_iter_trigger' : < +inf and its default value is 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. The valid range for this integer option is 1 <= 'watchdog_trial_iter_max' : < +inf and its default value is 3.
'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).
'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).
'eta_phi' : Relaxation factor in the Armijo condition. (See Eqn. (20) in the implementation paper).
'delta' : Multiplier for constraint violation in the switching rule. (See Eqn. (19) in the implementation paper).
's_phi' : Exponent for linear barrier function model in the switching rule. (See Eqn. (19) in the implementation paper).
's_theta' : Exponent for current constraint violation in the switching rule. (See Eqn. (19) in the implementation paper).
'gamma_phi' : Relaxation factor in the filter margin for the barrier function. (See Eqn. (18a) in the implementation paper).
'gamma_theta' : Relaxation factor in the filter margin for the constraint violation. (See Eqn. (18b) in the implementation paper).
'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).
'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).
'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.
'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.
'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.
'corrector_type' : The type of corrector steps that should be taken (unsupported!). If 'mu_strategy' : is 'adaptive' :, this option determines what kind of corrector steps should be tried. The default value for this string option is 'none' :. Possible values:
'none' :: no corrector
'affine' :: corrector step towards mu=0
'primal-dual' :: corrector step towards current mu
'skip_corr_if_neg_curv' : Skip the corrector step in negative curvature iteration (unsupported!). 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' :.
Possible values:
no : don't skip.
yes : skip.
'skip_corr_in_monotone_mode' : Skip the corrector step during monotone barrier parameter mode (unsupported!). 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' :.
Possible values:
no : don't skip.
yes : skip.
'corrector_compl_avrg_red_fact' : Complementarity tolerance factor for accepting corrector step (unsupported!). This option determines the factor by which complementarity is allowed to increase for a corrector step to be accepted.
'nu_init' :Initial value of the penalty parameter.
'nu_inc' : Increment of the penalty parameter.
'rho' : Value in penalty parameter update formula.
Warm Start
'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). The default value for this string option is 'no' :.
Possible values:
'no' :: do not use the warm start initialization
'yes' :: use the warm start initialization
'warm_start_same_structure' : Indicates whether a problem with a structure identical to the previous one is to be solved. If 'yes' : is chosen, then the algorithm assumes that an NLP is now to be solved, whose structure is identical to one that already was considered (with the same NLP object).
Possible values:
'no' : Assume this is a new problem.
'yes' : Assume this is problem has known structure
'warm_start_entire_iterate' : Tells algorithm whether to use the GetWarmStartIterate method in the NLP.
Possible values:
'no' : call GetStartingPoint in the NLP
'yes' : call GetWarmStartIterate in the NLP
'warm_start_bound_push' : same as bound_push for the regular initializer. The valid range for this real option is 0 < 'warm_start_bound_push' : < +inf and its default value is 0.001.
'warm_start_bound_frac' : same as 'bound_frac' : for the regular initializer. The valid range for this real option is 0 < 'warm_start_bound_frac' : <= 0.5 and its default value is 0.001.
'warm_start_slack_bound_frac' : same as 'slack_bound_frac' : for the regular initializer. The valid range for this real option is 0 < 'warm_start_slack_bound_frac' : <= 0.5 and its default value is 0.001.
'warm_start_slack_bound_push' : same as slack_bound_push for the regular initializer. The valid range for this real option is 0 < 'warm_start_slack_bound_push' : < +inf and its default value is 0.001.
'warm_start_mult_bound_push' : same as mult_bound_push for the regular initializer. The valid range for this real option is 0 < 'warm_start_mult_bound_push' : < +inf and its default value is 0.001.
'warm_start_mult_init_max' : Maximum initial value for the equality multipliers. The valid range for this real option is -inf < 'warm_start_mult_init_max' : < +inf and its default value is 1.10^+6.
'warm_start_target_mu' :Unsupported
Restoration Phase
'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. The default value for this string option is 'no' :. Possible values:
'no' :: the problem probably be feasible
'yes' :: the problem has a good chance to be infeasible
'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. The valid range for this real option is 0 <= 'expect_infeasible_problem_ctol' : < +inf and its default value is 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.
'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. The default value for this string option is 'no' :. Possible values:
'no' :: don't force start in restoration phase
'yes' :: force start in restoration phase
'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. The valid range for this real option is 0 <= soft_resto_pderror_reduction_factor < +inf and its default value is 0.9999.
'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. Its default value is 10.
'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. The valid range for this real option is 0 <= 'required_infeasibility_reduction' : < 1 and its default value is 0.9.
'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. Its default value is 3000000.
'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. The valid range for this real option is 0 <= 'bound_mult_reset_threshold' : < +inf and its default value is 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. The valid range for this real option is 0 <= 'constr_mult_reset_threshold' : < +inf and its default value is 0.
'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. The default value for this string option is 'yes' :. Possible values:
'no' :: skip evaluation
'yes' :: evaluate at every trial point
'resto_penalty_parameter' : Penalty parameter in the restoration phase objective function. This is the parameter rho in equation (31a) in the Ipopt implementation paper. Its default value is 1000.0.
Linear Solver
'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, the code must have been compiled with the linear solver you want to choose. Depending on your Ipopt installation, not all options are available. The default value for this string option is 'mumps'. Possible values:
'ma27' :: use the Harwell routine MA27 - NOT COMPILED IN THIS TOOLBOX.
'ma57' :: use the Harwell routine MA57 - NOT COMPILED IN THIS TOOLBOX.
'pardiso' :: use the Pardiso package - NOT COMPILED IN THIS TOOLBOX.
'wsmp' :: use WSMP package - NOT COMPILED IN THIS TOOLBOX.
'mumps' :: use MUMPS package
'custom' :: use custom linear solver
'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. This option is only available if Ipopt has been compiled with MC19. The default value for this string option is 'none' :. Possible values:
'none' :: no scaling will be performed
'mc19' :: use the Harwell routine MC19
'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. The default value for this string option is 'yes' :. Possible values:
'no' :: Always scale the linear system
'yes' :: Start using linear system scaling if solutions seem not good
'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. The valid range for this integer option is 0 <= 'max_refinement_steps' : < +inf and its default value is 10.
'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).
'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.
'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.
'neg_curv_test_tol' : Tolerance for heuristic to ignore wrong inertia. If positive, incorrect inertia in the augmented system is ignored, and we test if the direction is a direction of positive curvature. This tolerance determines when the direction is considered to be sufficiently positive.
'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). The valid range for this integer option is 0 <= 'min_refinement_steps' : < +inf and its default value is 1.
Hessian Perturbation
'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_wmax in the implementation paper). The valid range for this real option is 0 < 'max_hessian_perturbation' : < +inf and its default value is 1.10^+20.
'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_wmin in implementation paper). The valid range for this real option is 0 <= 'min_hessian_perturbation' : < +inf and its default value is 1.10^-20.
'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). The valid range for this real option is 0 < 'first_hessian_perturbation' : < +inf and its default value is 0.0001.
'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 in the
implementation paper). The valid range for this real option is 1 <
'perturb_inc_fact_first' : < +inf and its default value is 100.
'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). The valid range for this real option is 1 < 'perturb_inc_fact' : < +inf and its default value is 8.
'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 in the implementation paper). The valid
range for this real option is 0 < 'perturb_dec_fact' : < 1 and its
default value is 0.333333.
'jacobian_regularization_value' : Size of the
regularization for rank-deficient constraint Jacobians (This
is in the implementation paper). The valid range for this real
option is 0 <= 'jacobian_regularization_value' : < +inf and its
default value is 1.10^-8.
'jacobian_regularization_exponent' : Exponent
for mu in the regularization for rank-deficient constraint Jacobians.
(This is in the implementation paper). Its default value is
0.25.
'perturb_always_cd' : Active permanent
perturbation of constraint linearization. This options makes the
and
perturbation be used for the computation of every
search direction. Usually, it is only used when the iteration matrix
is singular. Its default value is 'no' :. Possible values:
'no' :: perturbation only used when required
'yes' :: always use perturbation
Quasi-Newton
'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. The default value for this string option is 'exact' :. Possible values:
'exact' :: Use second derivatives provided by the NLP
'limited-memory' :: Perform a limited-memory quasi-Newton approximation
'hessian_approximation_space' : Indicates in which subspace the Hessian information is to be approximated. Its default value is 'nonlinear-variables' :. Possible values:
'nonlinear-variables' :: only in space of nonlinear variables.
'all-variables' :: in space of all variables (without slacks)
'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. The valid range for this integer option is 0 <= 'limited_memory_max_history' : < +inf and its default value is 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. The valid range for this integer option is 1 <= 'limited_memory_max_skipping' : < +inf and its default value is 2.
'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. Its default value is 'bfgs' :. Possible values:
'bfgs' :: BFGS update (with skipping)
'sr1' :: SR1 (not working well)
'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. Its default value is 'scalar1' :. Possible values:
'scalar1' ::
'scalar2' ::
'constant' ::
'limited_memory_init_val' :
'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' :. Its default value 1e8.
'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' :. Its default value is 1e-8.
'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' :. Its default value is 1.
Derivative Test
'derivative_test' : Enable derivative checker If this option is enabled, a (slow) derivative test will be performed before the optimization. The test is performed at the user provided starting point and marks derivative values that seem suspicious. The default value for this string option is 'none' :. Possible values:
'none' :: do not perform derivative test
'first-order' :: perform test of first derivatives at starting point
'second-order' :: perform test of first and second derivatives at starting point
'only-second-order' :: perform test of second derivatives at starting point
'derivative_test_first_index' : Index of first quantity to be checked by derivative checker If this is set to -2, then all derivatives are checked. Otherwise, for the first derivative test it specifies the first variable for which the test is done (counting starts at 0). For second derivatives, it specifies the first constraint for which the test is done; counting of constraint indices starts at 0, and -1 refers to the objective function Hessian.
'derivative_test_perturbation' : Size of the finite difference perturbation in derivative test. This determines the relative perturbation of the variable entries. The valid range for this real option is 0 < 'derivative_test_perturbation' : < +inf and its default value is 1.10^-8.
'derivative_test_tol' : Threshold for indicating wrong derivative. If the relative deviation of the estimated derivative from the given one is larger than this value, the corresponding derivative is marked as wrong. The valid range for this real option is 0 < 'derivative_test_tol' : < +inf and its default value is 0.0001.
'derivative_test_print_all' : Indicates whether information for all estimated derivatives should be printed. Determines verbosity of derivative checker. The default value for this string option is 'no' :. Possible values:
'no' :: Print only suspect derivative
'yes' :: Print all derivatives
'point_perturbation_radius' : Maximal perturbation of an evaluation point. If a random perturbation of a points is required, this number indicates the maximal perturbation. This is for example used when determining the center point at which the finite difference derivative test is executed. The valid range for this real option is 0 <= 'point_perturbation_radius' : < +inf and its default value is 10.
'jacobian_approximation' : Specifies technique to compute constraint Jacobian. Its default value is 'exact' :. Possible values:
'exact' :: user-provided derivatives
'finite-difference-values' :: user-provided structure, values by finite differences
'findiff_perturbation' : Size of the finite difference perturbation for derivative approximation. This determines the relative perturbation of the variable entries. Its default value is 1e-7.
MA27 Linear Solver
'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. The valid range for this real option is 0 < 'ma27_pivtol' : < 1 and its default value is 1.10^-8.
'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. The valid range for this real option is 0 < 'ma27_pivtolmax' : < 1 and its default value is 0.0001.
'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. The valid range for this real option is 1 <= 'ma27_liw_init_factor' : < +inf and its default value is 5.
'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. The valid range for this real option is 1 <= 'ma27_la_init_factor' : < +inf and its default value is 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. The valid range for this real option is 1 <= 'ma27_meminc_factor' : < +inf and its default value is 10.
'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. Its default value is 'no' :. Possible values:
'no' :: check inertia
'yes' :: skip inertia check
'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. Its default value is 'no' :. Possible values:
'no' :: Don't have MA27 solve singular systems
'yes' :: Have MA27 solve singular systems
MA28 Linear Solver
'ma28_pivtol' : Pivot tolerance for linear solver MA28. This is used when MA28 tries to find the dependent constraints.
MA57 Linear Solver
'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. The valid range for this real option is 0 < 'ma57_pivtol' : < 1 and its default value is 1.10^-8
'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. The valid range for this real option is 0 < 'ma57_pivtolmax' : < 1 and its default value is 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. The valid range for this real option is 1 <= 'ma57_pre_alloc' : < +inf and its default value is 3.
'ma57_pivot_order' : Controls pivot order in MA57. This is INCTL(6) in MA57.
MUMPS Linear Solver
'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. The valid range for this real option is 0 <= 'mumps_pivtol' : <= 1 and its default value is 1.10^-6.
'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. The valid range for this real option is 0 <= 'mumps_pivtolmax' : <= 1 and its default value is 0.1
'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. The valid range for this integer option is 0 <= 'mumps_mem_percent' : < +inf and its default value is 1000.
'mumps_permuting_scaling' : Controls permuting and scaling in MUMPS. This is ICTL(6) in MUMPS. The valid range for this integer option is 0 <= 'mumps_permuting_scaling' : <= 7 and its default value is 7.
'mumps_pivot_order' : Controls pivot order in MUMPS. This is ICTL(7) in MUMPS. The valid range for this integer option is 0 <= 'mumps_pivot_order' : <= 7 and its default value is 7.
'mumps_scaling' : Controls scaling in MUMPS. This is ICTL(8) in MUMPS. The valid range for this integer option is -2 <= 'mumps_scaling' : <= 7 and its default value is 7.
'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. Its default value is -1.0.
Pardiso Linear Solver
'pardiso_matching_strategy' : Matching strategy to be used by Pardiso. This is IPAR(13) in Pardiso manual. This option is only available if Ipopt has been compiled with Pardiso. The default value for this string option is 'complete+2x2' :. Possible values:
'complete' :: Match complete (IPAR(13)=1)
'complete+2x2' :: Match complete+2x2 (IPAR(13)=2)
'constraints' :: Match constraints (IPAR(13)=3)
'pardiso_out_of_core_power' : Enables out-of-core variant of Pardiso. Setting this option to a positive integer k makes Pardiso work in the out-of-core variant where the factor is split in 2k subdomains. This is IPARM(50) in the Pardiso manual. This option is only available if Ipopt has been compiled with Pardiso. The valid range for this integer option is 0 <= 'pardiso_out_of_core_power' : < +inf and its default value is 0.
'pardiso_msglvl' : Pardiso message level This determines the amount of analysis output from the Pardiso solver. This is MSGLVL in the Pardiso manual.
'pardiso_max_iter' : Maximum number of Krylov-Subspace Iteration DPARM(1).
'pardiso_iter_relative_tol' : Relative Residual Convergence DPARM(2).
'pardiso_iter_coarse_size' : Maximum Size of Coarse Grid Matrix DPARM(3).
'pardiso_iter_max_levels' : Maximum Size of Grid Levels DPARM(4).
'pardiso_iter_dropping_factor' : dropping value for incomplete factor DPARM(5).
'pardiso_iter_dropping_schur' : dropping value for sparsify schur complement factor DPARM(6).
'pardiso_iter_max_row_fill' : max fill for each row DPARM(7).
'pardiso_iter_inverse_norm_factor' : DPARM(8).
'pardiso_iterative' :Switch on iterative solver in Pardiso library
Possible values: 'no' :, 'yes' :
'pardiso_max_droptol_corrections' : Maximal number of decreases of drop tolerance during one solve. This is relevant only for iterative Pardiso options.
'pardiso_redo_symbolic_fact_only_if_inertia_wrong' : Toggle for handling case when elements were perturbed by Pardiso. This option is only available if Ipopt has been compiled with Pardiso. Its default value is 'no' :. Possible value:
'no' :: Always redo symbolic factorization when elements were perturbed
'yes' :: Only redo symbolic factorization when elements were perturbed if also the inertia was wrong
'pardiso_repeated_perturbation_means_singular' : Interpretation of perturbed elements. This option is only available if Ipopt has been compiled with Pardiso. Its default value is 'no' :. Possible values:
'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
'pardiso_skip_inertia_check' : Always pretent 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. Its default value is 'no' :. Possible values:
'no' :: check inertia
'yes' :: skip inertia check
WSMP Linear Solver
'wsmp_num_threads' : Number of threads to be used in WSMP. This determines on how many processors WSMP is running on. This option is only available if Ipopt has been compiled with WSMP. The valid range for this integer option is 1 <= 'wsmp_num_threads' : < +inf and its default value is 1.
'wsmp_ordering_option' : Determines how ordering is done in WSMP. This corresponds to the value of WSSMP's IPARM(16). This option is only available if Ipopt has been compiled with WSMP. The valid range for this integer option is -2 <= 'wsmp_ordering_option' : <= 3 and its default value is 1.
'wsmp_pivtol' : Pivot tolerance for the linear solver WSMP. A smaller number pivots for sparsity, a larger number pivots for stability. This option is only available if Ipopt has been compiled with WSMP. The valid range for this real option is 0 < 'wsmp_pivtol' : < 1 and its default value is 0.0001.
'wsmp_pivtolmax' : Maximum pivot tolerance for the linear solver WSMP. Ipopt may increase pivtol as high as pivtolmax to get a more accurate solution to the linear system. This option is only available if Ipopt has been compiled with WSMP. The valid range for this real option is 0 < 'wsmp_pivtolmax' : < 1 and its default value is 0.1.
'wsmp_scaling' : Determines how the matrix is scaled by WSMP. This corresponds to the value of WSSMP's IPARM(10). This option is only available if Ipopt has been compiled with WSMP. The valid range for this integer option is 0 <= 'wsmp_scaling' : <= 3 and its default value is 0.
wantsol Solution report without -AMPL. Its default value is 8. Possible values:
1: write .sol file
2: print primal variable values
4: print dual variable values
8: do not print solution message
Print options
'print_user_options' :: If selected, the algorithm will print the list of all options set by the user including their values and whether they have been used. In some cases this information might be incorrect, due to the internal program flow.
'yes' : - print the list of options
'no' : - don't print the list of options
'print_options_documentation' :: If selected, the algorithm will print the list of all available algorithmic options with some documentation before solving the optimization problem.
'yes' : - print the list of options
'no' : - don't print the list of options
Options for C functions
'nnz_jac' : the number of non zeros elements in the Jacobian. This option is only mandatory if you use a C function for the Jacobian.
'nnz_hess' : the number of non zeros elements in the Hessian. This option is only mandatory if you use a C function for the Hessian.