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