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