IPOPT_OPTIONS Sets options for IPOPT.
OPT = IPOPT_OPTIONS
OPT = IPOPT_OPTIONS(OVERRIDES)
OPT = IPOPT_OPTIONS(OVERRIDES, FNAME)
OPT = IPOPT_OPTIONS(OVERRIDES, MPOPT)
Sets the values for the options.ipopt struct normally passed to
IPOPT.
Inputs are all optional, second argument must be either a string
(FNAME) or a struct (MPOPT):
OVERRIDES - struct containing values to override the defaults
FNAME - name of user-supplied function called after default
options are set to modify them. Calling syntax is:
MODIFIED_OPT = FNAME(DEFAULT_OPT);
MPOPT - MATPOWER options struct, uses the following fields:
opf.violation - used to set opt.constr_viol_tol
verbose - used to opt.print_level
ipopt.opts - struct containing values to use as OVERRIDES
ipopt.opt_fname - name of user-supplied function used as FNAME,
except with calling syntax:
MODIFIED_OPT = FNAME(DEFAULT_OPT, MPOPT);
ipopt.opt - numbered user option function, if and only if
ipopt.opt_fname is empty and ipopt.opt is non-zero, the value
of ipopt.opt_fname is generated by appending ipopt.opt to
'ipopt_user_options_' (for backward compatibility with old
MATPOWER option IPOPT_OPT).
Output is an options.ipopt struct to pass to IPOPT.
There are multiple ways of providing values to override the default
options. Their precedence and order of application are as follows:
With inputs OVERRIDES and FNAME
1. FNAME is called
2. OVERRIDES are applied
With inputs OVERRIDES and MPOPT
1. FNAME (from ipopt.opt_fname or ipopt.opt) is called
2. ipopt.opts (if not empty) are applied
3. OVERRIDES are applied
Example:
If ipopt.opt = 3, then after setting the default IPOPT options,
IPOPT_OPTIONS will execute the following user-defined function
to allow option overrides:
opt = ipopt_user_options_3(opt, mpopt);
The contents of ipopt_user_options_3.m, could be something like:
function opt = ipopt_user_options_3(opt, mpopt)
opt.nlp_scaling_method = 'none';
opt.max_iter = 500;
opt.derivative_test = 'first-order';
See the options reference section in the IPOPT documentation for
details on the available options.
http://www.coin-or.org/Ipopt/documentation/
See also IPOPT, MPOPTION.0001 function opt = ipopt_options(overrides, mpopt) 0002 %IPOPT_OPTIONS Sets options for IPOPT. 0003 % 0004 % OPT = IPOPT_OPTIONS 0005 % OPT = IPOPT_OPTIONS(OVERRIDES) 0006 % OPT = IPOPT_OPTIONS(OVERRIDES, FNAME) 0007 % OPT = IPOPT_OPTIONS(OVERRIDES, MPOPT) 0008 % 0009 % Sets the values for the options.ipopt struct normally passed to 0010 % IPOPT. 0011 % 0012 % Inputs are all optional, second argument must be either a string 0013 % (FNAME) or a struct (MPOPT): 0014 % 0015 % OVERRIDES - struct containing values to override the defaults 0016 % FNAME - name of user-supplied function called after default 0017 % options are set to modify them. Calling syntax is: 0018 % MODIFIED_OPT = FNAME(DEFAULT_OPT); 0019 % MPOPT - MATPOWER options struct, uses the following fields: 0020 % opf.violation - used to set opt.constr_viol_tol 0021 % verbose - used to opt.print_level 0022 % ipopt.opts - struct containing values to use as OVERRIDES 0023 % ipopt.opt_fname - name of user-supplied function used as FNAME, 0024 % except with calling syntax: 0025 % MODIFIED_OPT = FNAME(DEFAULT_OPT, MPOPT); 0026 % ipopt.opt - numbered user option function, if and only if 0027 % ipopt.opt_fname is empty and ipopt.opt is non-zero, the value 0028 % of ipopt.opt_fname is generated by appending ipopt.opt to 0029 % 'ipopt_user_options_' (for backward compatibility with old 0030 % MATPOWER option IPOPT_OPT). 0031 % 0032 % Output is an options.ipopt struct to pass to IPOPT. 0033 % 0034 % There are multiple ways of providing values to override the default 0035 % options. Their precedence and order of application are as follows: 0036 % 0037 % With inputs OVERRIDES and FNAME 0038 % 1. FNAME is called 0039 % 2. OVERRIDES are applied 0040 % With inputs OVERRIDES and MPOPT 0041 % 1. FNAME (from ipopt.opt_fname or ipopt.opt) is called 0042 % 2. ipopt.opts (if not empty) are applied 0043 % 3. OVERRIDES are applied 0044 % 0045 % Example: 0046 % 0047 % If ipopt.opt = 3, then after setting the default IPOPT options, 0048 % IPOPT_OPTIONS will execute the following user-defined function 0049 % to allow option overrides: 0050 % 0051 % opt = ipopt_user_options_3(opt, mpopt); 0052 % 0053 % The contents of ipopt_user_options_3.m, could be something like: 0054 % 0055 % function opt = ipopt_user_options_3(opt, mpopt) 0056 % opt.nlp_scaling_method = 'none'; 0057 % opt.max_iter = 500; 0058 % opt.derivative_test = 'first-order'; 0059 % 0060 % See the options reference section in the IPOPT documentation for 0061 % details on the available options. 0062 % 0063 % http://www.coin-or.org/Ipopt/documentation/ 0064 % 0065 % See also IPOPT, MPOPTION. 0066 0067 % MATPOWER 0068 % Copyright (c) 2010-2016, Power Systems Engineering Research Center (PSERC) 0069 % by Ray Zimmerman, PSERC Cornell 0070 % 0071 % This file is part of MATPOWER. 0072 % Covered by the 3-clause BSD License (see LICENSE file for details). 0073 % See http://www.pserc.cornell.edu/matpower/ for more info. 0074 0075 %%----- initialization and arg handling ----- 0076 %% defaults 0077 verbose = 2; 0078 fname = ''; 0079 0080 %% second argument 0081 if nargin > 1 && ~isempty(mpopt) 0082 if ischar(mpopt) %% 2nd arg is FNAME (string) 0083 fname = mpopt; 0084 have_mpopt = 0; 0085 else %% 2nd arg is MPOPT (MATPOWER options struct) 0086 have_mpopt = 1; 0087 verbose = mpopt.verbose; 0088 if isfield(mpopt.ipopt, 'opt_fname') && ~isempty(mpopt.ipopt.opt_fname) 0089 fname = mpopt.ipopt.opt_fname; 0090 elseif mpopt.ipopt.opt 0091 fname = sprintf('ipopt_user_options_%d', mpopt.ipopt.opt); 0092 end 0093 end 0094 else 0095 have_mpopt = 0; 0096 end 0097 0098 %%----- set default options for IPOPT ----- 0099 %% printing 0100 if verbose 0101 opt.print_level = min(12, verbose*2+1); 0102 else 0103 opt.print_level = 0; 0104 end 0105 0106 %% convergence 0107 opt.tol = 1e-8; %% default 1e-8 0108 opt.max_iter = 250; %% default 3000 0109 opt.dual_inf_tol = 0.1; %% default 1 0110 if have_mpopt 0111 opt.constr_viol_tol = mpopt.opf.violation; %% default 1e-4 0112 opt.acceptable_constr_viol_tol = mpopt.opf.violation*100; %% default 1e-2 0113 end 0114 opt.compl_inf_tol = 1e-5; %% default 1e-4 0115 opt.acceptable_tol = 1e-8; %% default 1e-6 0116 % opt.acceptable_iter = 15; %% default 15 0117 % opt.acceptable_dual_inf_tol = 1e+10; %% default 1e+10 0118 opt.acceptable_compl_inf_tol = 1e-3; %% default 1e-2 0119 % opt.acceptable_obj_change_tol = 1e+20; %% default 1e+20 0120 % opt.diverging_iterates_tol = 1e+20; %% default 1e+20 0121 0122 %% NLP scaling 0123 % opt.nlp_scaling_method = 'none'; %% default 'gradient-based' 0124 0125 %% NLP 0126 % opt.fixed_variable_treatment = 'make_constraint'; %% default 'make_parameter' 0127 % opt.honor_original_bounds = 'no'; %% default 'yes' 0128 % opt.check_derivatives_for_naninf = 'yes'; %% default 'no' 0129 0130 %% initialization 0131 % opt.least_square_init_primal = 'yes'; %% default 'no' 0132 % opt.least_square_init_duals = 'yes'; %% default 'no' 0133 0134 %% barrier parameter update 0135 opt.mu_strategy = 'adaptive'; %% default 'monotone' 0136 0137 %% linear solver 0138 % opt.linear_solver = 'ma27'; 0139 % opt.linear_solver = 'ma57'; 0140 % opt.linear_solver = 'pardiso'; 0141 % opt.linear_solver = 'wsmp'; 0142 % opt.linear_solver = 'mumps'; %% default 'mumps' 0143 % opt.linear_solver = 'custom'; 0144 % opt.linear_scaling_on_demand = 'no'; %% default 'yes' 0145 0146 %% step calculation 0147 % opt.mehrotra_algorithm = 'yes'; %% default 'no' 0148 % opt.fast_step_computation = 'yes'; %% default 'no' 0149 0150 %% restoration phase 0151 % opt.expect_infeasible_problem = 'yes'; %% default 'no' 0152 0153 %% derivative checker 0154 % opt.derivative_test = 'second-order'; %% default 'none' 0155 0156 %% hessian approximation 0157 % opt.hessian_approximation = 'limited-memory'; %% default 'exact' 0158 0159 % ma57 options 0160 %opt.ma57_pre_alloc = 3; 0161 %opt.ma57_pivot_order = 4; 0162 0163 %%----- call user function to modify defaults ----- 0164 if ~isempty(fname) 0165 if have_mpopt 0166 opt = feval(fname, opt, mpopt); 0167 else 0168 opt = feval(fname, opt); 0169 end 0170 end 0171 0172 %%----- apply overrides ----- 0173 if have_mpopt && isfield(mpopt.ipopt, 'opts') && ~isempty(mpopt.ipopt.opts) 0174 opt = nested_struct_copy(opt, mpopt.ipopt.opts); 0175 end 0176 if nargin > 0 && ~isempty(overrides) 0177 opt = nested_struct_copy(opt, overrides); 0178 end 0179 0180 0181 %-------------------------- Options Documentation -------------------------- 0182 % (as printed by IPOPT 3.8) 0183 % ### Output ### 0184 % 0185 % print_level 0 <= ( 5) <= 12 0186 % Output verbosity level. 0187 % Sets the default verbosity level for console output. The larger this 0188 % value the more detailed is the output. 0189 % 0190 % output_file ("") 0191 % File name of desired output file (leave unset for no file output). 0192 % NOTE: This option only works when read from the ipopt.opt options file! 0193 % An output file with this name will be written (leave unset for no file 0194 % output). The verbosity level is by default set to "print_level", but can 0195 % be overridden with "file_print_level". The file name is changed to use 0196 % only small letters. 0197 % Possible values: 0198 % - * [Any acceptable standard file name] 0199 % 0200 % file_print_level 0 <= ( 5) <= 12 0201 % Verbosity level for output file. 0202 % NOTE: This option only works when read from the ipopt.opt options file! 0203 % Determines the verbosity level for the file specified by "output_file". 0204 % By default it is the same as "print_level". 0205 % 0206 % print_user_options ("no") 0207 % Print all options set by the user. 0208 % If selected, the algorithm will print the list of all options set by the 0209 % user including their values and whether they have been used. In some 0210 % cases this information might be incorrect, due to the internal program 0211 % flow. 0212 % Possible values: 0213 % - no [don't print options] 0214 % - yes [print options] 0215 % 0216 % print_options_documentation ("no") 0217 % Switch to print all algorithmic options. 0218 % If selected, the algorithm will print the list of all available 0219 % algorithmic options with some documentation before solving the 0220 % optimization problem. 0221 % Possible values: 0222 % - no [don't print list] 0223 % - yes [print list] 0224 % 0225 % print_timing_statistics ("no") 0226 % Switch to print timing statistics. 0227 % If selected, the program will print the CPU usage (user time) for 0228 % selected tasks. 0229 % Possible values: 0230 % - no [don't print statistics] 0231 % - yes [print all timing statistics] 0232 % 0233 % option_file_name ("") 0234 % File name of options file (to overwrite default). 0235 % By default, the name of the Ipopt options file is "ipopt.opt" - or 0236 % something else if specified in the IpoptApplication::Initialize call. If 0237 % this option is set by SetStringValue BEFORE the options file is read, it 0238 % specifies the name of the options file. It does not make any sense to 0239 % specify this option within the options file. 0240 % Possible values: 0241 % - * [Any acceptable standard file name] 0242 % 0243 % replace_bounds ("no") 0244 % Indicates if all variable bounds should be replaced by inequality 0245 % constraints 0246 % This option must be set for the inexact algorithm 0247 % Possible values: 0248 % - no [leave bounds on variables] 0249 % - yes [replace variable bounds by inequality 0250 % constraints] 0251 % 0252 % skip_finalize_solution_call ("no") 0253 % Indicates if call to NLP::FinalizeSolution after optimization should be 0254 % suppressed 0255 % In some Ipopt applications, the user might want to call the 0256 % FinalizeSolution method separately. Setting this option to "yes" will 0257 % cause the IpoptApplication object to suppress the default call to that 0258 % method. 0259 % Possible values: 0260 % - no [call FinalizeSolution] 0261 % - yes [do not call FinalizeSolution] 0262 % 0263 % print_info_string ("no") 0264 % Enables printing of additional info string at end of iteration output. 0265 % This string contains some insider information about the current iteration. 0266 % Possible values: 0267 % - no [don't print string] 0268 % - yes [print string at end of each iteration output] 0269 % 0270 % 0271 % 0272 % ### Convergence ### 0273 % 0274 % tol 0 < ( 1e-08) < +inf 0275 % Desired convergence tolerance (relative). 0276 % Determines the convergence tolerance for the algorithm. The algorithm 0277 % terminates successfully, if the (scaled) NLP error becomes smaller than 0278 % this value, and if the (absolute) criteria according to "dual_inf_tol", 0279 % "primal_inf_tol", and "cmpl_inf_tol" are met. (This is epsilon_tol in 0280 % Eqn. (6) in implementation paper). See also "acceptable_tol" as a second 0281 % termination criterion. Note, some other algorithmic features also use 0282 % this quantity to determine thresholds etc. 0283 % 0284 % s_max 0 < ( 100) < +inf 0285 % Scaling threshold for the NLP error. 0286 % (See paragraph after Eqn. (6) in the implementation paper.) 0287 % 0288 % max_iter 0 <= ( 3000) < +inf 0289 % Maximum number of iterations. 0290 % The algorithm terminates with an error message if the number of 0291 % iterations exceeded this number. 0292 % 0293 % max_cpu_time 0 < ( 1e+06) < +inf 0294 % Maximum number of CPU seconds. 0295 % A limit on CPU seconds that Ipopt can use to solve one problem. If 0296 % during the convergence check this limit is exceeded, Ipopt will terminate 0297 % with a corresponding error message. 0298 % 0299 % dual_inf_tol 0 < ( 1) < +inf 0300 % Desired threshold for the dual infeasibility. 0301 % Absolute tolerance on the dual infeasibility. Successful termination 0302 % requires that the max-norm of the (unscaled) dual infeasibility is less 0303 % than this threshold. 0304 % 0305 % constr_viol_tol 0 < ( 0.0001) < +inf 0306 % Desired threshold for the constraint violation. 0307 % Absolute tolerance on the constraint violation. Successful termination 0308 % requires that the max-norm of the (unscaled) constraint violation is less 0309 % than this threshold. 0310 % 0311 % compl_inf_tol 0 < ( 0.0001) < +inf 0312 % Desired threshold for the complementarity conditions. 0313 % Absolute tolerance on the complementarity. Successful termination 0314 % requires that the max-norm of the (unscaled) complementarity is less than 0315 % this threshold. 0316 % 0317 % acceptable_tol 0 < ( 1e-06) < +inf 0318 % "Acceptable" convergence tolerance (relative). 0319 % Determines which (scaled) overall optimality error is considered to be 0320 % "acceptable." There are two levels of termination criteria. If the usual 0321 % "desired" tolerances (see tol, dual_inf_tol etc) are satisfied at an 0322 % iteration, the algorithm immediately terminates with a success message. 0323 % On the other hand, if the algorithm encounters "acceptable_iter" many 0324 % iterations in a row that are considered "acceptable", it will terminate 0325 % before the desired convergence tolerance is met. This is useful in cases 0326 % where the algorithm might not be able to achieve the "desired" level of 0327 % accuracy. 0328 % 0329 % acceptable_iter 0 <= ( 15) < +inf 0330 % Number of "acceptable" iterates before triggering termination. 0331 % If the algorithm encounters this many successive "acceptable" iterates 0332 % (see "acceptable_tol"), it terminates, assuming that the problem has been 0333 % solved to best possible accuracy given round-off. If it is set to zero, 0334 % this heuristic is disabled. 0335 % 0336 % acceptable_dual_inf_tol 0 < ( 1e+10) < +inf 0337 % "Acceptance" threshold for the dual infeasibility. 0338 % Absolute tolerance on the dual infeasibility. "Acceptable" termination 0339 % requires that the (max-norm of the unscaled) dual infeasibility is less 0340 % than this threshold; see also acceptable_tol. 0341 % 0342 % acceptable_constr_viol_tol 0 < ( 0.01) < +inf 0343 % "Acceptance" threshold for the constraint violation. 0344 % Absolute tolerance on the constraint violation. "Acceptable" termination 0345 % requires that the max-norm of the (unscaled) constraint violation is less 0346 % than this threshold; see also acceptable_tol. 0347 % 0348 % acceptable_compl_inf_tol 0 < ( 0.01) < +inf 0349 % "Acceptance" threshold for the complementarity conditions. 0350 % Absolute tolerance on the complementarity. "Acceptable" termination 0351 % requires that the max-norm of the (unscaled) complementarity is less than 0352 % this threshold; see also acceptable_tol. 0353 % 0354 % acceptable_obj_change_tol 0 <= ( 1e+20) < +inf 0355 % "Acceptance" stopping criterion based on objective function change. 0356 % If the relative change of the objective function (scaled by 0357 % Max(1,|f(x)|)) is less than this value, this part of the acceptable 0358 % tolerance termination is satisfied; see also acceptable_tol. This is 0359 % useful for the quasi-Newton option, which has trouble to bring down the 0360 % dual infeasibility. 0361 % 0362 % diverging_iterates_tol 0 < ( 1e+20) < +inf 0363 % Threshold for maximal value of primal iterates. 0364 % If any component of the primal iterates exceeded this value (in absolute 0365 % terms), the optimization is aborted with the exit message that the 0366 % iterates seem to be diverging. 0367 % 0368 % 0369 % 0370 % ### NLP Scaling ### 0371 % 0372 % nlp_scaling_method ("gradient-based") 0373 % Select the technique used for scaling the NLP. 0374 % Selects the technique used for scaling the problem internally before it 0375 % is solved. For user-scaling, the parameters come from the NLP. If you are 0376 % using AMPL, they can be specified through suffixes ("scaling_factor") 0377 % Possible values: 0378 % - none [no problem scaling will be performed] 0379 % - user-scaling [scaling parameters will come from the user] 0380 % - gradient-based [scale the problem so the maximum gradient at 0381 % the starting point is scaling_max_gradient] 0382 % - equilibration-based [scale the problem so that first derivatives are 0383 % of order 1 at random points (only available 0384 % with MC19)] 0385 % 0386 % obj_scaling_factor -inf < ( 1) < +inf 0387 % Scaling factor for the objective function. 0388 % This option sets a scaling factor for the objective function. The scaling 0389 % is seen internally by Ipopt but the unscaled objective is reported in the 0390 % console output. If additional scaling parameters are computed (e.g. 0391 % user-scaling or gradient-based), both factors are multiplied. If this 0392 % value is chosen to be negative, Ipopt will maximize the objective 0393 % function instead of minimizing it. 0394 % 0395 % nlp_scaling_max_gradient 0 < ( 100) < +inf 0396 % Maximum gradient after NLP scaling. 0397 % This is the gradient scaling cut-off. If the maximum gradient is above 0398 % this value, then gradient based scaling will be performed. Scaling 0399 % parameters are calculated to scale the maximum gradient back to this 0400 % value. (This is g_max in Section 3.8 of the implementation paper.) Note: 0401 % This option is only used if "nlp_scaling_method" is chosen as 0402 % "gradient-based". 0403 % 0404 % nlp_scaling_obj_target_gradient 0 <= ( 0) < +inf 0405 % Target value for objective function gradient size. 0406 % If a positive number is chosen, the scaling factor the objective function 0407 % is computed so that the gradient has the max norm of the given size at 0408 % the starting point. This overrides nlp_scaling_max_gradient for the 0409 % objective function. 0410 % 0411 % nlp_scaling_constr_target_gradient 0 <= ( 0) < +inf 0412 % Target value for constraint function gradient size. 0413 % If a positive number is chosen, the scaling factor the constraint 0414 % functions is computed so that the gradient has the max norm of the given 0415 % size at the starting point. This overrides nlp_scaling_max_gradient for 0416 % the constraint functions. 0417 % 0418 % 0419 % 0420 % ### NLP ### 0421 % 0422 % nlp_lower_bound_inf -inf < ( -1e+19) < +inf 0423 % any bound less or equal this value will be considered -inf (i.e. not lower 0424 % bounded). 0425 % 0426 % nlp_upper_bound_inf -inf < ( 1e+19) < +inf 0427 % any bound greater or this value will be considered +inf (i.e. not upper 0428 % bounded). 0429 % 0430 % fixed_variable_treatment ("make_parameter") 0431 % Determines how fixed variables should be handled. 0432 % The main difference between those options is that the starting point in 0433 % the "make_constraint" case still has the fixed variables at their given 0434 % values, whereas in the case "make_parameter" the functions are always 0435 % evaluated with the fixed values for those variables. Also, for 0436 % "relax_bounds", the fixing bound constraints are relaxed (according to" 0437 % bound_relax_factor"). For both "make_constraints" and "relax_bounds", 0438 % bound multipliers are computed for the fixed variables. 0439 % Possible values: 0440 % - make_parameter [Remove fixed variable from optimization 0441 % variables] 0442 % - make_constraint [Add equality constraints fixing variables] 0443 % - relax_bounds [Relax fixing bound constraints] 0444 % 0445 % dependency_detector ("none") 0446 % Indicates which linear solver should be used to detect linearly dependent 0447 % equality constraints. 0448 % The default and available choices depend on how Ipopt has been compiled. 0449 % This is experimental and does not work well. 0450 % Possible values: 0451 % - none [don't check; no extra work at beginning] 0452 % - mumps [use MUMPS] 0453 % - wsmp [use WSMP] 0454 % - ma28 [use MA28] 0455 % 0456 % dependency_detection_with_rhs ("no") 0457 % Indicates if the right hand sides of the constraints should be considered 0458 % during dependency detection 0459 % Possible values: 0460 % - no [only look at gradients] 0461 % - yes [also consider right hand side] 0462 % 0463 % num_linear_variables 0 <= ( 0) < +inf 0464 % Number of linear variables 0465 % When the Hessian is approximated, it is assumed that the first 0466 % num_linear_variables variables are linear. The Hessian is then not 0467 % approximated in this space. If the get_number_of_nonlinear_variables 0468 % method in the TNLP is implemented, this option is ignored. 0469 % 0470 % kappa_d 0 <= ( 1e-05) < +inf 0471 % Weight for linear damping term (to handle one-sided bounds). 0472 % (see Section 3.7 in implementation paper.) 0473 % 0474 % bound_relax_factor 0 <= ( 1e-08) < +inf 0475 % Factor for initial relaxation of the bounds. 0476 % Before start of the optimization, the bounds given by the user are 0477 % relaxed. This option sets the factor for this relaxation. If it is set 0478 % to zero, then then bounds relaxation is disabled. (See Eqn.(35) in 0479 % implementation paper.) 0480 % 0481 % honor_original_bounds ("yes") 0482 % Indicates whether final points should be projected into original bounds. 0483 % Ipopt might relax the bounds during the optimization (see, e.g., option 0484 % "bound_relax_factor"). This option determines whether the final point 0485 % should be projected back into the user-provide original bounds after the 0486 % optimization. 0487 % Possible values: 0488 % - no [Leave final point unchanged] 0489 % - yes [Project final point back into original bounds] 0490 % 0491 % check_derivatives_for_naninf ("no") 0492 % Indicates whether it is desired to check for Nan/Inf in derivative matrices 0493 % Activating this option will cause an error if an invalid number is 0494 % detected in the constraint Jacobians or the Lagrangian Hessian. If this 0495 % is not activated, the test is skipped, and the algorithm might proceed 0496 % with invalid numbers and fail. 0497 % Possible values: 0498 % - no [Don't check (faster).] 0499 % - yes [Check Jacobians and Hessian for Nan and Inf.] 0500 % 0501 % jac_c_constant ("no") 0502 % Indicates whether all equality constraints are linear 0503 % Activating this option will cause Ipopt to ask for the Jacobian of the 0504 % equality constraints only once from the NLP and reuse this information 0505 % later. 0506 % Possible values: 0507 % - no [Don't assume that all equality constraints are 0508 % linear] 0509 % - yes [Assume that equality constraints Jacobian are 0510 % constant] 0511 % 0512 % jac_d_constant ("no") 0513 % Indicates whether all inequality constraints are linear 0514 % Activating this option will cause Ipopt to ask for the Jacobian of the 0515 % inequality constraints only once from the NLP and reuse this information 0516 % later. 0517 % Possible values: 0518 % - no [Don't assume that all inequality constraints 0519 % are linear] 0520 % - yes [Assume that equality constraints Jacobian are 0521 % constant] 0522 % 0523 % hessian_constant ("no") 0524 % Indicates whether the problem is a quadratic problem 0525 % Activating this option will cause Ipopt to ask for the Hessian of the 0526 % Lagrangian function only once from the NLP and reuse this information 0527 % later. 0528 % Possible values: 0529 % - no [Assume that Hessian changes] 0530 % - yes [Assume that Hessian is constant] 0531 % 0532 % 0533 % 0534 % ### Initialization ### 0535 % 0536 % bound_push 0 < ( 0.01) < +inf 0537 % Desired minimum absolute distance from the initial point to bound. 0538 % Determines how much the initial point might have to be modified in order 0539 % to be sufficiently inside the bounds (together with "bound_frac"). (This 0540 % is kappa_1 in Section 3.6 of implementation paper.) 0541 % 0542 % bound_frac 0 < ( 0.01) <= 0.5 0543 % Desired minimum relative distance from the initial point to bound. 0544 % Determines how much the initial point might have to be modified in order 0545 % to be sufficiently inside the bounds (together with "bound_push"). (This 0546 % is kappa_2 in Section 3.6 of implementation paper.) 0547 % 0548 % slack_bound_push 0 < ( 0.01) < +inf 0549 % Desired minimum absolute distance from the initial slack to bound. 0550 % Determines how much the initial slack variables might have to be modified 0551 % in order to be sufficiently inside the inequality bounds (together with 0552 % "slack_bound_frac"). (This is kappa_1 in Section 3.6 of implementation 0553 % paper.) 0554 % 0555 % slack_bound_frac 0 < ( 0.01) <= 0.5 0556 % Desired minimum relative distance from the initial slack to bound. 0557 % Determines how much the initial slack variables might have to be modified 0558 % in order to be sufficiently inside the inequality bounds (together with 0559 % "slack_bound_push"). (This is kappa_2 in Section 3.6 of implementation 0560 % paper.) 0561 % 0562 % constr_mult_init_max 0 <= ( 1000) < +inf 0563 % Maximum allowed least-square guess of constraint multipliers. 0564 % Determines how large the initial least-square guesses of the constraint 0565 % multipliers are allowed to be (in max-norm). If the guess is larger than 0566 % this value, it is discarded and all constraint multipliers are set to 0567 % zero. This options is also used when initializing the restoration phase. 0568 % By default, "resto.constr_mult_init_max" (the one used in 0569 % RestoIterateInitializer) is set to zero. 0570 % 0571 % bound_mult_init_val 0 < ( 1) < +inf 0572 % Initial value for the bound multipliers. 0573 % All dual variables corresponding to bound constraints are initialized to 0574 % this value. 0575 % 0576 % bound_mult_init_method ("constant") 0577 % Initialization method for bound multipliers 0578 % This option defines how the iterates for the bound multipliers are 0579 % initialized. If "constant" is chosen, then all bound multipliers are 0580 % initialized to the value of "bound_mult_init_val". If "mu-based" is 0581 % chosen, the each value is initialized to the the value of "mu_init" 0582 % divided by the corresponding slack variable. This latter option might be 0583 % useful if the starting point is close to the optimal solution. 0584 % Possible values: 0585 % - constant [set all bound multipliers to the value of 0586 % bound_mult_init_val] 0587 % - mu-based [initialize to mu_init/x_slack] 0588 % 0589 % least_square_init_primal ("no") 0590 % Least square initialization of the primal variables 0591 % If set to yes, Ipopt ignores the user provided point and solves a least 0592 % square problem for the primal variables (x and s), to fit the linearized 0593 % equality and inequality constraints. This might be useful if the user 0594 % doesn't know anything about the starting point, or for solving an LP or 0595 % QP. 0596 % Possible values: 0597 % - no [take user-provided point] 0598 % - yes [overwrite user-provided point with least-square 0599 % estimates] 0600 % 0601 % least_square_init_duals ("no") 0602 % Least square initialization of all dual variables 0603 % If set to yes, Ipopt tries to compute least-square multipliers 0604 % (considering ALL dual variables). If successful, the bound multipliers 0605 % are possibly corrected to be at least bound_mult_init_val. This might be 0606 % useful if the user doesn't know anything about the starting point, or for 0607 % solving an LP or QP. This overwrites option "bound_mult_init_method". 0608 % Possible values: 0609 % - no [use bound_mult_init_val and least-square 0610 % equality constraint multipliers] 0611 % - yes [overwrite user-provided point with least-square 0612 % estimates] 0613 % 0614 % 0615 % 0616 % ### Barrier Parameter Update ### 0617 % 0618 % mu_max_fact 0 < ( 1000) < +inf 0619 % Factor for initialization of maximum value for barrier parameter. 0620 % This option determines the upper bound on the barrier parameter. This 0621 % upper bound is computed as the average complementarity at the initial 0622 % point times the value of this option. (Only used if option "mu_strategy" 0623 % is chosen as "adaptive".) 0624 % 0625 % mu_max 0 < ( 100000) < +inf 0626 % Maximum value for barrier parameter. 0627 % This option specifies an upper bound on the barrier parameter in the 0628 % adaptive mu selection mode. If this option is set, it overwrites the 0629 % effect of mu_max_fact. (Only used if option "mu_strategy" is chosen as 0630 % "adaptive".) 0631 % 0632 % mu_min 0 < ( 1e-11) < +inf 0633 % Minimum value for barrier parameter. 0634 % This option specifies the lower bound on the barrier parameter in the 0635 % adaptive mu selection mode. By default, it is set to the minimum of 1e-11 0636 % and min("tol","compl_inf_tol")/("barrier_tol_factor"+1), which should be 0637 % a reasonable value. (Only used if option "mu_strategy" is chosen as 0638 % "adaptive".) 0639 % 0640 % adaptive_mu_globalization ("obj-constr-filter") 0641 % Globalization strategy for the adaptive mu selection mode. 0642 % To achieve global convergence of the adaptive version, the algorithm has 0643 % to switch to the monotone mode (Fiacco-McCormick approach) when 0644 % convergence does not seem to appear. This option sets the criterion used 0645 % to decide when to do this switch. (Only used if option "mu_strategy" is 0646 % chosen as "adaptive".) 0647 % Possible values: 0648 % - kkt-error [nonmonotone decrease of kkt-error] 0649 % - obj-constr-filter [2-dim filter for objective and constraint 0650 % violation] 0651 % - never-monotone-mode [disables globalization] 0652 % 0653 % adaptive_mu_kkterror_red_iters 0 <= ( 4) < +inf 0654 % Maximum number of iterations requiring sufficient progress. 0655 % For the "kkt-error" based globalization strategy, sufficient progress 0656 % must be made for "adaptive_mu_kkterror_red_iters" iterations. If this 0657 % number of iterations is exceeded, the globalization strategy switches to 0658 % the monotone mode. 0659 % 0660 % adaptive_mu_kkterror_red_fact 0 < ( 0.9999) < 1 0661 % Sufficient decrease factor for "kkt-error" globalization strategy. 0662 % For the "kkt-error" based globalization strategy, the error must decrease 0663 % by this factor to be deemed sufficient decrease. 0664 % 0665 % filter_margin_fact 0 < ( 1e-05) < 1 0666 % Factor determining width of margin for obj-constr-filter adaptive 0667 % globalization strategy. 0668 % When using the adaptive globalization strategy, "obj-constr-filter", 0669 % sufficient progress for a filter entry is defined as follows: (new obj) < 0670 % (filter obj) - filter_margin_fact*(new constr-viol) OR (new constr-viol) 0671 % < (filter constr-viol) - filter_margin_fact*(new constr-viol). For the 0672 % description of the "kkt-error-filter" option see "filter_max_margin". 0673 % 0674 % filter_max_margin 0 < ( 1) < +inf 0675 % Maximum width of margin in obj-constr-filter adaptive globalization 0676 % strategy. 0677 % 0678 % adaptive_mu_restore_previous_iterate("no") 0679 % Indicates if the previous iterate should be restored if the monotone mode 0680 % is entered. 0681 % When the globalization strategy for the adaptive barrier algorithm 0682 % switches to the monotone mode, it can either start from the most recent 0683 % iterate (no), or from the last iterate that was accepted (yes). 0684 % Possible values: 0685 % - no [don't restore accepted iterate] 0686 % - yes [restore accepted iterate] 0687 % 0688 % adaptive_mu_monotone_init_factor 0 < ( 0.8) < +inf 0689 % Determines the initial value of the barrier parameter when switching to the 0690 % monotone mode. 0691 % When the globalization strategy for the adaptive barrier algorithm 0692 % switches to the monotone mode and fixed_mu_oracle is chosen as 0693 % "average_compl", the barrier parameter is set to the current average 0694 % complementarity times the value of "adaptive_mu_monotone_init_factor". 0695 % 0696 % adaptive_mu_kkt_norm_type ("2-norm-squared") 0697 % Norm used for the KKT error in the adaptive mu globalization strategies. 0698 % When computing the KKT error for the globalization strategies, the norm 0699 % to be used is specified with this option. Note, this options is also used 0700 % in the QualityFunctionMuOracle. 0701 % Possible values: 0702 % - 1-norm [use the 1-norm (abs sum)] 0703 % - 2-norm-squared [use the 2-norm squared (sum of squares)] 0704 % - max-norm [use the infinity norm (max)] 0705 % - 2-norm [use 2-norm] 0706 % 0707 % mu_strategy ("monotone") 0708 % Update strategy for barrier parameter. 0709 % Determines which barrier parameter update strategy is to be used. 0710 % Possible values: 0711 % - monotone [use the monotone (Fiacco-McCormick) strategy] 0712 % - adaptive [use the adaptive update strategy] 0713 % 0714 % mu_oracle ("quality-function") 0715 % Oracle for a new barrier parameter in the adaptive strategy. 0716 % Determines how a new barrier parameter is computed in each "free-mode" 0717 % iteration of the adaptive barrier parameter strategy. (Only considered if 0718 % "adaptive" is selected for option "mu_strategy"). 0719 % Possible values: 0720 % - probing [Mehrotra's probing heuristic] 0721 % - loqo [LOQO's centrality rule] 0722 % - quality-function [minimize a quality function] 0723 % 0724 % fixed_mu_oracle ("average_compl") 0725 % Oracle for the barrier parameter when switching to fixed mode. 0726 % Determines how the first value of the barrier parameter should be 0727 % computed when switching to the "monotone mode" in the adaptive strategy. 0728 % (Only considered if "adaptive" is selected for option "mu_strategy".) 0729 % Possible values: 0730 % - probing [Mehrotra's probing heuristic] 0731 % - loqo [LOQO's centrality rule] 0732 % - quality-function [minimize a quality function] 0733 % - average_compl [base on current average complementarity] 0734 % 0735 % mu_init 0 < ( 0.1) < +inf 0736 % Initial value for the barrier parameter. 0737 % This option determines the initial value for the barrier parameter (mu). 0738 % It is only relevant in the monotone, Fiacco-McCormick version of the 0739 % algorithm. (i.e., if "mu_strategy" is chosen as "monotone") 0740 % 0741 % barrier_tol_factor 0 < ( 10) < +inf 0742 % Factor for mu in barrier stop test. 0743 % The convergence tolerance for each barrier problem in the monotone mode 0744 % is the value of the barrier parameter times "barrier_tol_factor". This 0745 % option is also used in the adaptive mu strategy during the monotone mode. 0746 % (This is kappa_epsilon in implementation paper). 0747 % 0748 % mu_linear_decrease_factor 0 < ( 0.2) < 1 0749 % Determines linear decrease rate of barrier parameter. 0750 % For the Fiacco-McCormick update procedure the new barrier parameter mu is 0751 % obtained by taking the minimum of mu*"mu_linear_decrease_factor" and 0752 % mu^"superlinear_decrease_power". (This is kappa_mu in implementation 0753 % paper.) This option is also used in the adaptive mu strategy during the 0754 % monotone mode. 0755 % 0756 % mu_superlinear_decrease_power 1 < ( 1.5) < 2 0757 % Determines superlinear decrease rate of barrier parameter. 0758 % For the Fiacco-McCormick update procedure the new barrier parameter mu is 0759 % obtained by taking the minimum of mu*"mu_linear_decrease_factor" and 0760 % mu^"superlinear_decrease_power". (This is theta_mu in implementation 0761 % paper.) This option is also used in the adaptive mu strategy during the 0762 % monotone mode. 0763 % 0764 % mu_allow_fast_monotone_decrease("yes") 0765 % Allow skipping of barrier problem if barrier test is already met. 0766 % If set to "no", the algorithm enforces at least one iteration per barrier 0767 % problem, even if the barrier test is already met for the updated barrier 0768 % parameter. 0769 % Possible values: 0770 % - no [Take at least one iteration per barrier problem] 0771 % - yes [Allow fast decrease of mu if barrier test it met] 0772 % 0773 % tau_min 0 < ( 0.99) < 1 0774 % Lower bound on fraction-to-the-boundary parameter tau. 0775 % (This is tau_min in the implementation paper.) This option is also used 0776 % in the adaptive mu strategy during the monotone mode. 0777 % 0778 % sigma_max 0 < ( 100) < +inf 0779 % Maximum value of the centering parameter. 0780 % This is the upper bound for the centering parameter chosen by the quality 0781 % function based barrier parameter update. (Only used if option "mu_oracle" 0782 % is set to "quality-function".) 0783 % 0784 % sigma_min 0 <= ( 1e-06) < +inf 0785 % Minimum value of the centering parameter. 0786 % This is the lower bound for the centering parameter chosen by the quality 0787 % function based barrier parameter update. (Only used if option "mu_oracle" 0788 % is set to "quality-function".) 0789 % 0790 % quality_function_norm_type ("2-norm-squared") 0791 % Norm used for components of the quality function. 0792 % (Only used if option "mu_oracle" is set to "quality-function".) 0793 % Possible values: 0794 % - 1-norm [use the 1-norm (abs sum)] 0795 % - 2-norm-squared [use the 2-norm squared (sum of squares)] 0796 % - max-norm [use the infinity norm (max)] 0797 % - 2-norm [use 2-norm] 0798 % 0799 % quality_function_centrality ("none") 0800 % The penalty term for centrality that is included in quality function. 0801 % This determines whether a term is added to the quality function to 0802 % penalize deviation from centrality with respect to complementarity. The 0803 % complementarity measure here is the xi in the Loqo update rule. (Only 0804 % used if option "mu_oracle" is set to "quality-function".) 0805 % Possible values: 0806 % - none [no penalty term is added] 0807 % - log [complementarity * the log of the centrality 0808 % measure] 0809 % - reciprocal [complementarity * the reciprocal of the 0810 % centrality measure] 0811 % - cubed-reciprocal [complementarity * the reciprocal of the 0812 % centrality measure cubed] 0813 % 0814 % quality_function_balancing_term("none") 0815 % The balancing term included in the quality function for centrality. 0816 % This determines whether a term is added to the quality function that 0817 % penalizes situations where the complementarity is much smaller than dual 0818 % and primal infeasibilities. (Only used if option "mu_oracle" is set to 0819 % "quality-function".) 0820 % Possible values: 0821 % - none [no balancing term is added] 0822 % - cubic [Max(0,Max(dual_inf,primal_inf)-compl)^3] 0823 % 0824 % quality_function_max_section_steps 0 <= ( 8) < +inf 0825 % Maximum number of search steps during direct search procedure determining 0826 % the optimal centering parameter. 0827 % The golden section search is performed for the quality function based mu 0828 % oracle. (Only used if option "mu_oracle" is set to "quality-function".) 0829 % 0830 % quality_function_section_sigma_tol 0 <= ( 0.01) < 1 0831 % Tolerance for the section search procedure determining the optimal 0832 % centering parameter (in sigma space). 0833 % The golden section search is performed for the quality function based mu 0834 % oracle. (Only used if option "mu_oracle" is set to "quality-function".) 0835 % 0836 % quality_function_section_qf_tol 0 <= ( 0) < 1 0837 % Tolerance for the golden section search procedure determining the optimal 0838 % centering parameter (in the function value space). 0839 % The golden section search is performed for the quality function based mu 0840 % oracle. (Only used if option "mu_oracle" is set to "quality-function".) 0841 % 0842 % 0843 % 0844 % ### Line Search ### 0845 % 0846 % alpha_red_factor 0 < ( 0.5) < 1 0847 % Fractional reduction of the trial step size in the backtracking line search. 0848 % At every step of the backtracking line search, the trial step size is 0849 % reduced by this factor. 0850 % 0851 % accept_every_trial_step ("no") 0852 % Always accept the first trial step. 0853 % Setting this option to "yes" essentially disables the line search and 0854 % makes the algorithm take aggressive steps, without global convergence 0855 % guarantees. 0856 % Possible values: 0857 % - no [don't arbitrarily accept the full step] 0858 % - yes [always accept the full step] 0859 % 0860 % accept_after_max_steps -1 <= ( -1) < +inf 0861 % Accept a trial point after maximal this number of steps. 0862 % Even if it does not satisfy line search conditions. 0863 % 0864 % alpha_for_y ("primal") 0865 % Method to determine the step size for constraint multipliers. 0866 % This option determines how the step size (alpha_y) will be calculated 0867 % when updating the constraint multipliers. 0868 % Possible values: 0869 % - primal [use primal step size] 0870 % - bound-mult [use step size for the bound multipliers (good 0871 % for LPs)] 0872 % - min [use the min of primal and bound multipliers] 0873 % - max [use the max of primal and bound multipliers] 0874 % - full [take a full step of size one] 0875 % - min-dual-infeas [choose step size minimizing new dual 0876 % infeasibility] 0877 % - safer-min-dual-infeas [like "min_dual_infeas", but safeguarded by 0878 % "min" and "max"] 0879 % - primal-and-full [use the primal step size, and full step if 0880 % delta_x <= alpha_for_y_tol] 0881 % - dual-and-full [use the dual step size, and full step if 0882 % delta_x <= alpha_for_y_tol] 0883 % - acceptor [Call LSAcceptor to get step size for y] 0884 % 0885 % alpha_for_y_tol 0 <= ( 10) < +inf 0886 % Tolerance for switching to full equality multiplier steps. 0887 % This is only relevant if "alpha_for_y" is chosen "primal-and-full" or 0888 % "dual-and-full". The step size for the equality constraint multipliers 0889 % is taken to be one if the max-norm of the primal step is less than this 0890 % tolerance. 0891 % 0892 % tiny_step_tol 0 <= (2.22045e-15) < +inf 0893 % Tolerance for detecting numerically insignificant steps. 0894 % If the search direction in the primal variables (x and s) is, in relative 0895 % terms for each component, less than this value, the algorithm accepts the 0896 % full step without line search. If this happens repeatedly, the algorithm 0897 % will terminate with a corresponding exit message. The default value is 10 0898 % times machine precision. 0899 % 0900 % tiny_step_y_tol 0 <= ( 0.01) < +inf 0901 % Tolerance for quitting because of numerically insignificant steps. 0902 % If the search direction in the primal variables (x and s) is, in relative 0903 % terms for each component, repeatedly less than tiny_step_tol, and the 0904 % step in the y variables is smaller than this threshold, the algorithm 0905 % will terminate. 0906 % 0907 % watchdog_shortened_iter_trigger 0 <= ( 10) < +inf 0908 % Number of shortened iterations that trigger the watchdog. 0909 % If the number of successive iterations in which the backtracking line 0910 % search did not accept the first trial point exceeds this number, the 0911 % watchdog procedure is activated. Choosing "0" here disables the watchdog 0912 % procedure. 0913 % 0914 % watchdog_trial_iter_max 1 <= ( 3) < +inf 0915 % Maximum number of watchdog iterations. 0916 % This option determines the number of trial iterations allowed before the 0917 % watchdog procedure is aborted and the algorithm returns to the stored 0918 % point. 0919 % 0920 % theta_max_fact 0 < ( 10000) < +inf 0921 % Determines upper bound for constraint violation in the filter. 0922 % The algorithmic parameter theta_max is determined as theta_max_fact times 0923 % the maximum of 1 and the constraint violation at initial point. Any 0924 % point with a constraint violation larger than theta_max is unacceptable 0925 % to the filter (see Eqn. (21) in the implementation paper). 0926 % 0927 % theta_min_fact 0 < ( 0.0001) < +inf 0928 % Determines constraint violation threshold in the switching rule. 0929 % The algorithmic parameter theta_min is determined as theta_min_fact times 0930 % the maximum of 1 and the constraint violation at initial point. The 0931 % switching rules treats an iteration as an h-type iteration whenever the 0932 % current constraint violation is larger than theta_min (see paragraph 0933 % before Eqn. (19) in the implementation paper). 0934 % 0935 % eta_phi 0 < ( 1e-08) < 0.5 0936 % Relaxation factor in the Armijo condition. 0937 % (See Eqn. (20) in the implementation paper) 0938 % 0939 % delta 0 < ( 1) < +inf 0940 % Multiplier for constraint violation in the switching rule. 0941 % (See Eqn. (19) in the implementation paper.) 0942 % 0943 % s_phi 1 < ( 2.3) < +inf 0944 % Exponent for linear barrier function model in the switching rule. 0945 % (See Eqn. (19) in the implementation paper.) 0946 % 0947 % s_theta 1 < ( 1.1) < +inf 0948 % Exponent for current constraint violation in the switching rule. 0949 % (See Eqn. (19) in the implementation paper.) 0950 % 0951 % gamma_phi 0 < ( 1e-08) < 1 0952 % Relaxation factor in the filter margin for the barrier function. 0953 % (See Eqn. (18a) in the implementation paper.) 0954 % 0955 % gamma_theta 0 < ( 1e-05) < 1 0956 % Relaxation factor in the filter margin for the constraint violation. 0957 % (See Eqn. (18b) in the implementation paper.) 0958 % 0959 % alpha_min_frac 0 < ( 0.05) < 1 0960 % Safety factor for the minimal step size (before switching to restoration 0961 % phase). 0962 % (This is gamma_alpha in Eqn. (20) in the implementation paper.) 0963 % 0964 % max_soc 0 <= ( 4) < +inf 0965 % Maximum number of second order correction trial steps at each iteration. 0966 % Choosing 0 disables the second order corrections. (This is p^{max} of 0967 % Step A-5.9 of Algorithm A in the implementation paper.) 0968 % 0969 % kappa_soc 0 < ( 0.99) < +inf 0970 % Factor in the sufficient reduction rule for second order correction. 0971 % This option determines how much a second order correction step must 0972 % reduce the constraint violation so that further correction steps are 0973 % attempted. (See Step A-5.9 of Algorithm A in the implementation paper.) 0974 % 0975 % obj_max_inc 1 < ( 5) < +inf 0976 % Determines the upper bound on the acceptable increase of barrier objective 0977 % function. 0978 % Trial points are rejected if they lead to an increase in the barrier 0979 % objective function by more than obj_max_inc orders of magnitude. 0980 % 0981 % max_filter_resets 0 <= ( 5) < +inf 0982 % Maximal allowed number of filter resets 0983 % A positive number enables a heuristic that resets the filter, whenever in 0984 % more than "filter_reset_trigger" successive iterations the last rejected 0985 % trial steps size was rejected because of the filter. This option 0986 % determine the maximal number of resets that are allowed to take place. 0987 % 0988 % filter_reset_trigger 1 <= ( 5) < +inf 0989 % Number of iterations that trigger the filter reset. 0990 % If the filter reset heuristic is active and the number of successive 0991 % iterations in which the last rejected trial step size was rejected 0992 % because of the filter, the filter is reset. 0993 % 0994 % corrector_type ("none") 0995 % The type of corrector steps that should be taken (unsupported!). 0996 % If "mu_strategy" is "adaptive", this option determines what kind of 0997 % corrector steps should be tried. 0998 % Possible values: 0999 % - none [no corrector] 1000 % - affine [corrector step towards mu=0] 1001 % - primal-dual [corrector step towards current mu] 1002 % 1003 % skip_corr_if_neg_curv ("yes") 1004 % Skip the corrector step in negative curvature iteration (unsupported!). 1005 % The corrector step is not tried if negative curvature has been 1006 % encountered during the computation of the search direction in the current 1007 % iteration. This option is only used if "mu_strategy" is "adaptive". 1008 % Possible values: 1009 % - no [don't skip] 1010 % - yes [skip] 1011 % 1012 % skip_corr_in_monotone_mode ("yes") 1013 % Skip the corrector step during monotone barrier parameter mode 1014 % (unsupported!). 1015 % The corrector step is not tried if the algorithm is currently in the 1016 % monotone mode (see also option "barrier_strategy").This option is only 1017 % used if "mu_strategy" is "adaptive". 1018 % Possible values: 1019 % - no [don't skip] 1020 % - yes [skip] 1021 % 1022 % corrector_compl_avrg_red_fact 0 < ( 1) < +inf 1023 % Complementarity tolerance factor for accepting corrector step 1024 % (unsupported!). 1025 % This option determines the factor by which complementarity is allowed to 1026 % increase for a corrector step to be accepted. 1027 % 1028 % nu_init 0 < ( 1e-06) < +inf 1029 % Initial value of the penalty parameter. 1030 % 1031 % nu_inc 0 < ( 0.0001) < +inf 1032 % Increment of the penalty parameter. 1033 % 1034 % rho 0 < ( 0.1) < 1 1035 % Value in penalty parameter update formula. 1036 % 1037 % kappa_sigma 0 < ( 1e+10) < +inf 1038 % Factor limiting the deviation of dual variables from primal estimates. 1039 % If the dual variables deviate from their primal estimates, a correction 1040 % is performed. (See Eqn. (16) in the implementation paper.) Setting the 1041 % value to less than 1 disables the correction. 1042 % 1043 % recalc_y ("no") 1044 % Tells the algorithm to recalculate the equality and inequality multipliers 1045 % as least square estimates. 1046 % This asks the algorithm to recompute the multipliers, whenever the 1047 % current infeasibility is less than recalc_y_feas_tol. Choosing yes might 1048 % be helpful in the quasi-Newton option. However, each recalculation 1049 % requires an extra factorization of the linear system. If a limited 1050 % memory quasi-Newton option is chosen, this is used by default. 1051 % Possible values: 1052 % - no [use the Newton step to update the multipliers] 1053 % - yes [use least-square multiplier estimates] 1054 % 1055 % recalc_y_feas_tol 0 < ( 1e-06) < +inf 1056 % Feasibility threshold for recomputation of multipliers. 1057 % If recalc_y is chosen and the current infeasibility is less than this 1058 % value, then the multipliers are recomputed. 1059 % 1060 % slack_move 0 <= (1.81899e-12) < +inf 1061 % Correction size for very small slacks. 1062 % Due to numerical issues or the lack of an interior, the slack variables 1063 % might become very small. If a slack becomes very small compared to 1064 % machine precision, the corresponding bound is moved slightly. This 1065 % parameter determines how large the move should be. Its default value is 1066 % mach_eps^{3/4}. (See also end of Section 3.5 in implementation paper - 1067 % but actual implementation might be somewhat different.) 1068 % 1069 % 1070 % 1071 % ### Warm Start ### 1072 % 1073 % warm_start_init_point ("no") 1074 % Warm-start for initial point 1075 % Indicates whether this optimization should use a warm start 1076 % initialization, where values of primal and dual variables are given 1077 % (e.g., from a previous optimization of a related problem.) 1078 % Possible values: 1079 % - no [do not use the warm start initialization] 1080 % - yes [use the warm start initialization] 1081 % 1082 % warm_start_same_structure ("no") 1083 % Indicates whether a problem with a structure identical to the previous one 1084 % is to be solved. 1085 % If "yes" is chosen, then the algorithm assumes that an NLP is now to be 1086 % solved, whose structure is identical to one that already was considered 1087 % (with the same NLP object). 1088 % Possible values: 1089 % - no [Assume this is a new problem.] 1090 % - yes [Assume this is problem has known structure] 1091 % 1092 % warm_start_bound_push 0 < ( 0.001) < +inf 1093 % same as bound_push for the regular initializer. 1094 % 1095 % warm_start_bound_frac 0 < ( 0.001) <= 0.5 1096 % same as bound_frac for the regular initializer. 1097 % 1098 % warm_start_slack_bound_push 0 < ( 0.001) < +inf 1099 % same as slack_bound_push for the regular initializer. 1100 % 1101 % warm_start_slack_bound_frac 0 < ( 0.001) <= 0.5 1102 % same as slack_bound_frac for the regular initializer. 1103 % 1104 % warm_start_mult_bound_push 0 < ( 0.001) < +inf 1105 % same as mult_bound_push for the regular initializer. 1106 % 1107 % warm_start_mult_init_max -inf < ( 1e+06) < +inf 1108 % Maximum initial value for the equality multipliers. 1109 % 1110 % warm_start_entire_iterate ("no") 1111 % Tells algorithm whether to use the GetWarmStartIterate method in the NLP. 1112 % Possible values: 1113 % - no [call GetStartingPoint in the NLP] 1114 % - yes [call GetWarmStartIterate in the NLP] 1115 % 1116 % 1117 % 1118 % ### Linear Solver ### 1119 % 1120 % linear_solver ("mumps") 1121 % Linear solver used for step computations. 1122 % Determines which linear algebra package is to be used for the solution of 1123 % the augmented linear system (for obtaining the search directions). Note, 1124 % the code must have been compiled with the linear solver you want to 1125 % choose. Depending on your Ipopt installation, not all options are 1126 % available. 1127 % Possible values: 1128 % - ma27 [use the Harwell routine MA27] 1129 % - ma57 [use the Harwell routine MA57] 1130 % - pardiso [use the Pardiso package] 1131 % - wsmp [use WSMP package] 1132 % - mumps [use MUMPS package] 1133 % - custom [use custom linear solver] 1134 % 1135 % linear_system_scaling ("none") 1136 % Method for scaling the linear system. 1137 % Determines the method used to compute symmetric scaling factors for the 1138 % augmented system (see also the "linear_scaling_on_demand" option). This 1139 % scaling is independent of the NLP problem scaling. By default, MC19 is 1140 % only used if MA27 or MA57 are selected as linear solvers. This option is 1141 % only available if Ipopt has been compiled with MC19. 1142 % Possible values: 1143 % - none [no scaling will be performed] 1144 % - mc19 [use the Harwell routine MC19] 1145 % 1146 % linear_scaling_on_demand ("yes") 1147 % Flag indicating that linear scaling is only done if it seems required. 1148 % This option is only important if a linear scaling method (e.g., mc19) is 1149 % used. If you choose "no", then the scaling factors are computed for 1150 % every linear system from the start. This can be quite expensive. 1151 % Choosing "yes" means that the algorithm will start the scaling method 1152 % only when the solutions to the linear system seem not good, and then use 1153 % it until the end. 1154 % Possible values: 1155 % - no [Always scale the linear system.] 1156 % - yes [Start using linear system scaling if solutions 1157 % seem not good.] 1158 % 1159 % 1160 % 1161 % ### Step Calculation ### 1162 % 1163 % mehrotra_algorithm ("no") 1164 % Indicates if we want to do Mehrotra's algorithm. 1165 % If set to yes, Ipopt runs as Mehrotra's predictor-corrector algorithm. 1166 % This works usually very well for LPs and convex QPs. This automatically 1167 % disables the line search, and chooses the (unglobalized) adaptive mu 1168 % strategy with the "probing" oracle, and uses "corrector_type=affine" 1169 % without any safeguards; you should not set any of those options 1170 % explicitly in addition. Also, unless otherwise specified, the values of 1171 % "bound_push", "bound_frac", and "bound_mult_init_val" are set more 1172 % aggressive, and sets "alpha_for_y=bound_mult". 1173 % Possible values: 1174 % - no [Do the usual Ipopt algorithm.] 1175 % - yes [Do Mehrotra's predictor-corrector algorithm.] 1176 % 1177 % fast_step_computation ("no") 1178 % Indicates if the linear system should be solved quickly. 1179 % If set to yes, the algorithm assumes that the linear system that is 1180 % solved to obtain the search direction, is solved sufficiently well. In 1181 % that case, no residuals are computed, and the computation of the search 1182 % direction is a little faster. 1183 % Possible values: 1184 % - no [Verify solution of linear system by computing 1185 % residuals.] 1186 % - yes [Trust that linear systems are solved well.] 1187 % 1188 % min_refinement_steps 0 <= ( 1) < +inf 1189 % Minimum number of iterative refinement steps per linear system solve. 1190 % Iterative refinement (on the full unsymmetric system) is performed for 1191 % each right hand side. This option determines the minimum number of 1192 % iterative refinements (i.e. at least "min_refinement_steps" iterative 1193 % refinement steps are enforced per right hand side.) 1194 % 1195 % max_refinement_steps 0 <= ( 10) < +inf 1196 % Maximum number of iterative refinement steps per linear system solve. 1197 % Iterative refinement (on the full unsymmetric system) is performed for 1198 % each right hand side. This option determines the maximum number of 1199 % iterative refinement steps. 1200 % 1201 % residual_ratio_max 0 < ( 1e-10) < +inf 1202 % Iterative refinement tolerance 1203 % Iterative refinement is performed until the residual test ratio is less 1204 % than this tolerance (or until "max_refinement_steps" refinement steps are 1205 % performed). 1206 % 1207 % residual_ratio_singular 0 < ( 1e-05) < +inf 1208 % Threshold for declaring linear system singular after failed iterative 1209 % refinement. 1210 % If the residual test ratio is larger than this value after failed 1211 % iterative refinement, the algorithm pretends that the linear system is 1212 % singular. 1213 % 1214 % residual_improvement_factor 0 < ( 1) < +inf 1215 % Minimal required reduction of residual test ratio in iterative refinement. 1216 % If the improvement of the residual test ratio made by one iterative 1217 % refinement step is not better than this factor, iterative refinement is 1218 % aborted. 1219 % 1220 % neg_curv_test_tol 0 < ( 0) < +inf 1221 % Tolerance for heuristic to ignore wrong inertia. 1222 % If positive, incorrect inertia in the augmented system is ignored, and we 1223 % test if the direction is a direction of positive curvature. This 1224 % tolerance determines when the direction is considered to be sufficiently 1225 % positive. 1226 % 1227 % max_hessian_perturbation 0 < ( 1e+20) < +inf 1228 % Maximum value of regularization parameter for handling negative curvature. 1229 % In order to guarantee that the search directions are indeed proper 1230 % descent directions, Ipopt requires that the inertia of the (augmented) 1231 % linear system for the step computation has the correct number of negative 1232 % and positive eigenvalues. The idea is that this guides the algorithm away 1233 % from maximizers and makes Ipopt more likely converge to first order 1234 % optimal points that are minimizers. If the inertia is not correct, a 1235 % multiple of the identity matrix is added to the Hessian of the Lagrangian 1236 % in the augmented system. This parameter gives the maximum value of the 1237 % regularization parameter. If a regularization of that size is not enough, 1238 % the algorithm skips this iteration and goes to the restoration phase. 1239 % (This is delta_w^max in the implementation paper.) 1240 % 1241 % min_hessian_perturbation 0 <= ( 1e-20) < +inf 1242 % Smallest perturbation of the Hessian block. 1243 % The size of the perturbation of the Hessian block is never selected 1244 % smaller than this value, unless no perturbation is necessary. (This is 1245 % delta_w^min in implementation paper.) 1246 % 1247 % perturb_inc_fact_first 1 < ( 100) < +inf 1248 % Increase factor for x-s perturbation for very first perturbation. 1249 % The factor by which the perturbation is increased when a trial value was 1250 % not sufficient - this value is used for the computation of the very first 1251 % perturbation and allows a different value for for the first perturbation 1252 % than that used for the remaining perturbations. (This is bar_kappa_w^+ in 1253 % the implementation paper.) 1254 % 1255 % perturb_inc_fact 1 < ( 8) < +inf 1256 % Increase factor for x-s perturbation. 1257 % The factor by which the perturbation is increased when a trial value was 1258 % not sufficient - this value is used for the computation of all 1259 % perturbations except for the first. (This is kappa_w^+ in the 1260 % implementation paper.) 1261 % 1262 % perturb_dec_fact 0 < ( 0.333333) < 1 1263 % Decrease factor for x-s perturbation. 1264 % The factor by which the perturbation is decreased when a trial value is 1265 % deduced from the size of the most recent successful perturbation. (This 1266 % is kappa_w^- in the implementation paper.) 1267 % 1268 % first_hessian_perturbation 0 < ( 0.0001) < +inf 1269 % Size of first x-s perturbation tried. 1270 % The first value tried for the x-s perturbation in the inertia correction 1271 % scheme.(This is delta_0 in the implementation paper.) 1272 % 1273 % jacobian_regularization_value 0 <= ( 1e-08) < +inf 1274 % Size of the regularization for rank-deficient constraint Jacobians. 1275 % (This is bar delta_c in the implementation paper.) 1276 % 1277 % jacobian_regularization_exponent 0 <= ( 0.25) < +inf 1278 % Exponent for mu in the regularization for rank-deficient constraint 1279 % Jacobians. 1280 % (This is kappa_c in the implementation paper.) 1281 % 1282 % perturb_always_cd ("no") 1283 % Active permanent perturbation of constraint linearization. 1284 % This options makes the delta_c and delta_d perturbation be used for the 1285 % computation of every search direction. Usually, it is only used when the 1286 % iteration matrix is singular. 1287 % Possible values: 1288 % - no [perturbation only used when required] 1289 % - yes [always use perturbation] 1290 % 1291 % 1292 % 1293 % ### Restoration Phase ### 1294 % 1295 % expect_infeasible_problem ("no") 1296 % Enable heuristics to quickly detect an infeasible problem. 1297 % This options is meant to activate heuristics that may speed up the 1298 % infeasibility determination if you expect that there is a good chance for 1299 % the problem to be infeasible. In the filter line search procedure, the 1300 % restoration phase is called more quickly than usually, and more reduction 1301 % in the constraint violation is enforced before the restoration phase is 1302 % left. If the problem is square, this option is enabled automatically. 1303 % Possible values: 1304 % - no [the problem probably be feasible] 1305 % - yes [the problem has a good chance to be infeasible] 1306 % 1307 % expect_infeasible_problem_ctol 0 <= ( 0.001) < +inf 1308 % Threshold for disabling "expect_infeasible_problem" option. 1309 % If the constraint violation becomes smaller than this threshold, the 1310 % "expect_infeasible_problem" heuristics in the filter line search are 1311 % disabled. If the problem is square, this options is set to 0. 1312 % 1313 % expect_infeasible_problem_ytol 0 < ( 1e+08) < +inf 1314 % Multiplier threshold for activating "expect_infeasible_problem" option. 1315 % If the max norm of the constraint multipliers becomes larger than this 1316 % value and "expect_infeasible_problem" is chosen, then the restoration 1317 % phase is entered. 1318 % 1319 % start_with_resto ("no") 1320 % Tells algorithm to switch to restoration phase in first iteration. 1321 % Setting this option to "yes" forces the algorithm to switch to the 1322 % feasibility restoration phase in the first iteration. If the initial 1323 % point is feasible, the algorithm will abort with a failure. 1324 % Possible values: 1325 % - no [don't force start in restoration phase] 1326 % - yes [force start in restoration phase] 1327 % 1328 % soft_resto_pderror_reduction_factor 0 <= ( 0.9999) < +inf 1329 % Required reduction in primal-dual error in the soft restoration phase. 1330 % The soft restoration phase attempts to reduce the primal-dual error with 1331 % regular steps. If the damped primal-dual step (damped only to satisfy the 1332 % fraction-to-the-boundary rule) is not decreasing the primal-dual error by 1333 % at least this factor, then the regular restoration phase is called. 1334 % Choosing "0" here disables the soft restoration phase. 1335 % 1336 % max_soft_resto_iters 0 <= ( 10) < +inf 1337 % Maximum number of iterations performed successively in soft restoration 1338 % phase. 1339 % If the soft restoration phase is performed for more than so many 1340 % iterations in a row, the regular restoration phase is called. 1341 % 1342 % required_infeasibility_reduction 0 <= ( 0.9) < 1 1343 % Required reduction of infeasibility before leaving restoration phase. 1344 % The restoration phase algorithm is performed, until a point is found that 1345 % is acceptable to the filter and the infeasibility has been reduced by at 1346 % least the fraction given by this option. 1347 % 1348 % max_resto_iter 0 <= ( 3000000) < +inf 1349 % Maximum number of successive iterations in restoration phase. 1350 % The algorithm terminates with an error message if the number of 1351 % iterations successively taken in the restoration phase exceeds this 1352 % number. 1353 % 1354 % evaluate_orig_obj_at_resto_trial("yes") 1355 % Determines if the original objective function should be evaluated at 1356 % restoration phase trial points. 1357 % Setting this option to "yes" makes the restoration phase algorithm 1358 % evaluate the objective function of the original problem at every trial 1359 % point encountered during the restoration phase, even if this value is not 1360 % required. In this way, it is guaranteed that the original objective 1361 % function can be evaluated without error at all accepted iterates; 1362 % otherwise the algorithm might fail at a point where the restoration phase 1363 % accepts an iterate that is good for the restoration phase problem, but 1364 % not the original problem. On the other hand, if the evaluation of the 1365 % original objective is expensive, this might be costly. 1366 % Possible values: 1367 % - no [skip evaluation] 1368 % - yes [evaluate at every trial point] 1369 % 1370 % resto_penalty_parameter 0 < ( 1000) < +inf 1371 % Penalty parameter in the restoration phase objective function. 1372 % This is the parameter rho in equation (31a) in the Ipopt implementation 1373 % paper. 1374 % 1375 % bound_mult_reset_threshold 0 <= ( 1000) < +inf 1376 % Threshold for resetting bound multipliers after the restoration phase. 1377 % After returning from the restoration phase, the bound multipliers are 1378 % updated with a Newton step for complementarity. Here, the change in the 1379 % primal variables during the entire restoration phase is taken to be the 1380 % corresponding primal Newton step. However, if after the update the 1381 % largest bound multiplier exceeds the threshold specified by this option, 1382 % the multipliers are all reset to 1. 1383 % 1384 % constr_mult_reset_threshold 0 <= ( 0) < +inf 1385 % Threshold for resetting equality and inequality multipliers after 1386 % restoration phase. 1387 % After returning from the restoration phase, the constraint multipliers 1388 % are recomputed by a least square estimate. This option triggers when 1389 % those least-square estimates should be ignored. 1390 % 1391 % 1392 % 1393 % ### Derivative Checker ### 1394 % 1395 % derivative_test ("none") 1396 % Enable derivative checker 1397 % If this option is enabled, a (slow!) derivative test will be performed 1398 % before the optimization. The test is performed at the user provided 1399 % starting point and marks derivative values that seem suspicious 1400 % Possible values: 1401 % - none [do not perform derivative test] 1402 % - first-order [perform test of first derivatives at starting 1403 % point] 1404 % - second-order [perform test of first and second derivatives at 1405 % starting point] 1406 % - only-second-order [perform test of second derivatives at starting 1407 % point] 1408 % 1409 % derivative_test_first_index -2 <= ( -2) < +inf 1410 % Index of first quantity to be checked by derivative checker 1411 % If this is set to -2, then all derivatives are checked. Otherwise, for 1412 % the first derivative test it specifies the first variable for which the 1413 % test is done (counting starts at 0). For second derivatives, it 1414 % specifies the first constraint for which the test is done; counting of 1415 % constraint indices starts at 0, and -1 refers to the objective function 1416 % Hessian. 1417 % 1418 % derivative_test_perturbation 0 < ( 1e-08) < +inf 1419 % Size of the finite difference perturbation in derivative test. 1420 % This determines the relative perturbation of the variable entries. 1421 % 1422 % derivative_test_tol 0 < ( 0.0001) < +inf 1423 % Threshold for indicating wrong derivative. 1424 % If the relative deviation of the estimated derivative from the given one 1425 % is larger than this value, the corresponding derivative is marked as 1426 % wrong. 1427 % 1428 % derivative_test_print_all ("no") 1429 % Indicates whether information for all estimated derivatives should be 1430 % printed. 1431 % Determines verbosity of derivative checker. 1432 % Possible values: 1433 % - no [Print only suspect derivatives] 1434 % - yes [Print all derivatives] 1435 % 1436 % jacobian_approximation ("exact") 1437 % Specifies technique to compute constraint Jacobian 1438 % Possible values: 1439 % - exact [user-provided derivatives] 1440 % - finite-difference-values [user-provided structure, values by finite 1441 % differences] 1442 % 1443 % findiff_perturbation 0 < ( 1e-07) < +inf 1444 % Size of the finite difference perturbation for derivative approximation. 1445 % This determines the relative perturbation of the variable entries. 1446 % 1447 % point_perturbation_radius 0 <= ( 10) < +inf 1448 % Maximal perturbation of an evaluation point. 1449 % If a random perturbation of a points is required, this number indicates 1450 % the maximal perturbation. This is for example used when determining the 1451 % center point at which the finite difference derivative test is executed. 1452 % 1453 % 1454 % 1455 % ### Hessian Approximation ### 1456 % 1457 % limited_memory_max_history 0 <= ( 6) < +inf 1458 % Maximum size of the history for the limited quasi-Newton Hessian 1459 % approximation. 1460 % This option determines the number of most recent iterations that are 1461 % taken into account for the limited-memory quasi-Newton approximation. 1462 % 1463 % limited_memory_update_type ("bfgs") 1464 % Quasi-Newton update formula for the limited memory approximation. 1465 % Determines which update formula is to be used for the limited-memory 1466 % quasi-Newton approximation. 1467 % Possible values: 1468 % - bfgs [BFGS update (with skipping)] 1469 % - sr1 [SR1 (not working well)] 1470 % 1471 % limited_memory_initialization ("scalar1") 1472 % Initialization strategy for the limited memory quasi-Newton approximation. 1473 % Determines how the diagonal Matrix B_0 as the first term in the limited 1474 % memory approximation should be computed. 1475 % Possible values: 1476 % - scalar1 [sigma = s^Ty/s^Ts] 1477 % - scalar2 [sigma = y^Ty/s^Ty] 1478 % - constant [sigma = limited_memory_init_val] 1479 % 1480 % limited_memory_init_val 0 < ( 1) < +inf 1481 % Value for B0 in low-rank update. 1482 % The starting matrix in the low rank update, B0, is chosen to be this 1483 % multiple of the identity in the first iteration (when no updates have 1484 % been performed yet), and is constantly chosen as this value, if 1485 % "limited_memory_initialization" is "constant". 1486 % 1487 % limited_memory_init_val_max 0 < ( 1e+08) < +inf 1488 % Upper bound on value for B0 in low-rank update. 1489 % The starting matrix in the low rank update, B0, is chosen to be this 1490 % multiple of the identity in the first iteration (when no updates have 1491 % been performed yet), and is constantly chosen as this value, if 1492 % "limited_memory_initialization" is "constant". 1493 % 1494 % limited_memory_init_val_min 0 < ( 1e-08) < +inf 1495 % Lower bound on value for B0 in low-rank update. 1496 % The starting matrix in the low rank update, B0, is chosen to be this 1497 % multiple of the identity in the first iteration (when no updates have 1498 % been performed yet), and is constantly chosen as this value, if 1499 % "limited_memory_initialization" is "constant". 1500 % 1501 % limited_memory_max_skipping 1 <= ( 2) < +inf 1502 % Threshold for successive iterations where update is skipped. 1503 % If the update is skipped more than this number of successive iterations, 1504 % we quasi-Newton approximation is reset. 1505 % 1506 % hessian_approximation ("exact") 1507 % Indicates what Hessian information is to be used. 1508 % This determines which kind of information for the Hessian of the 1509 % Lagrangian function is used by the algorithm. 1510 % Possible values: 1511 % - exact [Use second derivatives provided by the NLP.] 1512 % - limited-memory [Perform a limited-memory quasi-Newton 1513 % approximation] 1514 % 1515 % hessian_approximation_space ("nonlinear-variables") 1516 % Indicates in which subspace the Hessian information is to be approximated. 1517 % Possible values: 1518 % - nonlinear-variables [only in space of nonlinear variables.] 1519 % - all-variables [in space of all variables (without slacks)] 1520 % 1521 % 1522 % 1523 % ### MA27 Linear Solver ### 1524 % 1525 % ma27_pivtol 0 < ( 1e-08) < 1 1526 % Pivot tolerance for the linear solver MA27. 1527 % A smaller number pivots for sparsity, a larger number pivots for 1528 % stability. This option is only available if Ipopt has been compiled with 1529 % MA27. 1530 % 1531 % ma27_pivtolmax 0 < ( 0.0001) < 1 1532 % Maximum pivot tolerance for the linear solver MA27. 1533 % Ipopt may increase pivtol as high as pivtolmax to get a more accurate 1534 % solution to the linear system. This option is only available if Ipopt 1535 % has been compiled with MA27. 1536 % 1537 % ma27_liw_init_factor 1 <= ( 5) < +inf 1538 % Integer workspace memory for MA27. 1539 % The initial integer workspace memory = liw_init_factor * memory required 1540 % by unfactored system. Ipopt will increase the workspace size by 1541 % meminc_factor if required. This option is only available if Ipopt has 1542 % been compiled with MA27. 1543 % 1544 % ma27_la_init_factor 1 <= ( 5) < +inf 1545 % Real workspace memory for MA27. 1546 % The initial real workspace memory = la_init_factor * memory required by 1547 % unfactored system. Ipopt will increase the workspace size by 1548 % meminc_factor if required. This option is only available if Ipopt has 1549 % been compiled with MA27. 1550 % 1551 % ma27_meminc_factor 1 <= ( 10) < +inf 1552 % Increment factor for workspace size for MA27. 1553 % If the integer or real workspace is not large enough, Ipopt will increase 1554 % its size by this factor. This option is only available if Ipopt has been 1555 % compiled with MA27. 1556 % 1557 % ma27_skip_inertia_check ("no") 1558 % Always pretend inertia is correct. 1559 % Setting this option to "yes" essentially disables inertia check. This 1560 % option makes the algorithm non-robust and easily fail, but it might give 1561 % some insight into the necessity of inertia control. 1562 % Possible values: 1563 % - no [check inertia] 1564 % - yes [skip inertia check] 1565 % 1566 % ma27_ignore_singularity ("no") 1567 % Enables MA27's ability to solve a linear system even if the matrix is 1568 % singular. 1569 % Setting this option to "yes" means that Ipopt will call MA27 to compute 1570 % solutions for right hand sides, even if MA27 has detected that the matrix 1571 % is singular (but is still able to solve the linear system). In some cases 1572 % this might be better than using Ipopt's heuristic of small perturbation 1573 % of the lower diagonal of the KKT matrix. 1574 % Possible values: 1575 % - no [Don't have MA27 solve singular systems] 1576 % - yes [Have MA27 solve singular systems] 1577 % 1578 % 1579 % 1580 % ### MA57 Linear Solver ### 1581 % 1582 % ma57_pivtol 0 < ( 1e-08) < 1 1583 % Pivot tolerance for the linear solver MA57. 1584 % A smaller number pivots for sparsity, a larger number pivots for 1585 % stability. This option is only available if Ipopt has been compiled with 1586 % MA57. 1587 % 1588 % ma57_pivtolmax 0 < ( 0.0001) < 1 1589 % Maximum pivot tolerance for the linear solver MA57. 1590 % Ipopt may increase pivtol as high as ma57_pivtolmax to get a more 1591 % accurate solution to the linear system. This option is only available if 1592 % Ipopt has been compiled with MA57. 1593 % 1594 % ma57_pre_alloc 1 <= ( 3) < +inf 1595 % Safety factor for work space memory allocation for the linear solver MA57. 1596 % If 1 is chosen, the suggested amount of work space is used. However, 1597 % choosing a larger number might avoid reallocation if the suggest values 1598 % do not suffice. This option is only available if Ipopt has been compiled 1599 % with MA57. 1600 % 1601 % ma57_pivot_order 0 <= ( 5) <= 5 1602 % Controls pivot order in MA57 1603 % This is INCTL(6) in MA57. 1604 % 1605 % 1606 % 1607 % ### Pardiso Linear Solver ### 1608 % 1609 % pardiso_matching_strategy ("complete+2x2") 1610 % Matching strategy to be used by Pardiso 1611 % This is IPAR(13) in Pardiso manual. This option is only available if 1612 % Ipopt has been compiled with Pardiso. 1613 % Possible values: 1614 % - complete [Match complete (IPAR(13)=1)] 1615 % - complete+2x2 [Match complete+2x2 (IPAR(13)=2)] 1616 % - constraints [Match constraints (IPAR(13)=3)] 1617 % 1618 % pardiso_redo_symbolic_fact_only_if_inertia_wrong("no") 1619 % Toggle for handling case when elements were perturbed by Pardiso. 1620 % This option is only available if Ipopt has been compiled with Pardiso. 1621 % Possible values: 1622 % - no [Always redo symbolic factorization when 1623 % elements were perturbed] 1624 % - yes [Only redo symbolic factorization when elements 1625 % were perturbed if also the inertia was wrong] 1626 % 1627 % pardiso_repeated_perturbation_means_singular("no") 1628 % Interpretation of perturbed elements. 1629 % This option is only available if Ipopt has been compiled with Pardiso. 1630 % Possible values: 1631 % - no [Don't assume that matrix is singular if 1632 % elements were perturbed after recent symbolic 1633 % factorization] 1634 % - yes [Assume that matrix is singular if elements were 1635 % perturbed after recent symbolic factorization] 1636 % 1637 % pardiso_out_of_core_power 0 <= ( 0) < +inf 1638 % Enables out-of-core variant of Pardiso 1639 % Setting this option to a positive integer k makes Pardiso work in the 1640 % out-of-core variant where the factor is split in 2^k subdomains. This is 1641 % IPARM(50) in the Pardiso manual. This option is only available if Ipopt 1642 % has been compiled with Pardiso. 1643 % 1644 % pardiso_msglvl 0 <= ( 0) < +inf 1645 % Pardiso message level 1646 % This determines the amount of analysis output from the Pardiso solver. 1647 % This is MSGLVL in the Pardiso manual. 1648 % 1649 % pardiso_skip_inertia_check ("no") 1650 % Always pretent inertia is correct. 1651 % Setting this option to "yes" essentially disables inertia check. This 1652 % option makes the algorithm non-robust and easily fail, but it might give 1653 % some insight into the necessity of inertia control. 1654 % Possible values: 1655 % - no [check inertia] 1656 % - yes [skip inertia check] 1657 % 1658 % pardiso_max_iter 1 <= ( 500) < +inf 1659 % Maximum number of Krylov-Subspace Iteration 1660 % DPARM(1) 1661 % 1662 % pardiso_iter_relative_tol 0 < ( 1e-06) < 1 1663 % Relative Residual Convergence 1664 % DPARM(2) 1665 % 1666 % pardiso_iter_coarse_size 1 <= ( 5000) < +inf 1667 % Maximum Size of Coarse Grid Matrix 1668 % DPARM(3) 1669 % 1670 % pardiso_iter_max_levels 1 <= ( 10000) < +inf 1671 % Maximum Size of Grid Levels 1672 % DPARM(4) 1673 % 1674 % pardiso_iter_dropping_factor 0 < ( 0.5) < 1 1675 % dropping value for incomplete factor 1676 % DPARM(5) 1677 % 1678 % pardiso_iter_dropping_schur 0 < ( 0.1) < 1 1679 % dropping value for sparsify schur complement factor 1680 % DPARM(6) 1681 % 1682 % pardiso_iter_max_row_fill 1 <= ( 10000000) < +inf 1683 % max fill for each row 1684 % DPARM(7) 1685 % 1686 % pardiso_iter_inverse_norm_factor 1 < ( 5e+06) < +inf 1687 % 1688 % DPARM(8) 1689 % 1690 % pardiso_iterative ("no") 1691 % Switch on iterative solver in Pardiso library 1692 % Possible values: 1693 % - no [] 1694 % - yes [] 1695 % 1696 % pardiso_max_droptol_corrections 1 <= ( 4) < +inf 1697 % Maximal number of decreases of drop tolerance during one solve. 1698 % This is relevant only for iterative Pardiso options. 1699 % 1700 % 1701 % 1702 % ### Mumps Linear Solver ### 1703 % 1704 % mumps_pivtol 0 <= ( 1e-06) <= 1 1705 % Pivot tolerance for the linear solver MUMPS. 1706 % A smaller number pivots for sparsity, a larger number pivots for 1707 % stability. This option is only available if Ipopt has been compiled with 1708 % MUMPS. 1709 % 1710 % mumps_pivtolmax 0 <= ( 0.1) <= 1 1711 % Maximum pivot tolerance for the linear solver MUMPS. 1712 % Ipopt may increase pivtol as high as pivtolmax to get a more accurate 1713 % solution to the linear system. This option is only available if Ipopt 1714 % has been compiled with MUMPS. 1715 % 1716 % mumps_mem_percent 0 <= ( 1000) < +inf 1717 % Percentage increase in the estimated working space for MUMPS. 1718 % In MUMPS when significant extra fill-in is caused by numerical pivoting, 1719 % larger values of mumps_mem_percent may help use the workspace more 1720 % efficiently. On the other hand, if memory requirement are too large at 1721 % the very beginning of the optimization, choosing a much smaller value for 1722 % this option, such as 5, might reduce memory requirements. 1723 % 1724 % mumps_permuting_scaling 0 <= ( 7) <= 7 1725 % Controls permuting and scaling in MUMPS 1726 % This is ICNTL(6) in MUMPS. 1727 % 1728 % mumps_pivot_order 0 <= ( 7) <= 7 1729 % Controls pivot order in MUMPS 1730 % This is ICNTL(7) in MUMPS. 1731 % 1732 % mumps_scaling -2 <= ( 77) <= 77 1733 % Controls scaling in MUMPS 1734 % This is ICNTL(8) in MUMPS. 1735 % 1736 % mumps_dep_tol -inf < ( -1) < +inf 1737 % Pivot threshold for detection of linearly dependent constraints in MUMPS. 1738 % When MUMPS is used to determine linearly dependent constraints, this is 1739 % determines the threshold for a pivot to be considered zero. This is 1740 % CNTL(3) in MUMPS. 1741 % 1742 % 1743 % 1744 % ### MA28 Linear Solver ### 1745 % 1746 % ma28_pivtol 0 < ( 0.01) <= 1 1747 % Pivot tolerance for linear solver MA28. 1748 % This is used when MA28 tries to find the dependent constraints. 1749 % 1750 % 1751 % 1752 % ### Uncategorized ### 1753 % 1754 % warm_start_target_mu -inf < ( 0) < +inf 1755 % Unsupported!