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