Home > matpower5.0 > ipopt_options.m

ipopt_options

PURPOSE ^

IPOPT_OPTIONS Sets options for IPOPT.

SYNOPSIS ^

function opt = ipopt_options(overrides, mpopt)

DESCRIPTION ^

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.

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SOURCE CODE ^

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!

Generated on Mon 26-Jan-2015 15:21:31 by m2html © 2005