Home > matpower7.0 > lib > 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.

   Please note that if there is a file named 'ipopt.opt' in your
   current working directory, it will override any options passed
   to the IPOPT MEX file, including any options returned by this
   function.

   Inputs are all optional, second argument must be either a string
   (FNAME) or a struct (MPOPT):

       OVERRIDES - struct containing values to override the defaults
       FNAME - name of user-supplied function called after default
           options are set to modify them. Calling syntax is:
                   MODIFIED_OPT = FNAME(DEFAULT_OPT);
       MPOPT - MATPOWER options struct, uses the following fields:
           opf.violation   - used to set opt.constr_viol_tol
           verbose         - used to opt.print_level
           ipopt.opts      - struct containing values to use as OVERRIDES
           ipopt.opt_fname - name of user-supplied function used as FNAME,
               except with calling syntax:
                   MODIFIED_OPT = FNAME(DEFAULT_OPT, MPOPT);
           ipopt.opt       - numbered user option function, if and only if
               ipopt.opt_fname is empty and ipopt.opt is non-zero, the value
               of ipopt.opt_fname is generated by appending ipopt.opt to
               'ipopt_user_options_' (for backward compatibility with old
               MATPOWER option IPOPT_OPT).

   Output is an options.ipopt struct to pass to IPOPT.

   There are multiple ways of providing values to override the default
   options. Their precedence and order of application are as follows:

   With inputs OVERRIDES and FNAME
       1. FNAME is called
       2. OVERRIDES are applied
   With inputs OVERRIDES and MPOPT
       1. FNAME (from ipopt.opt_fname or ipopt.opt) is called
       2. ipopt.opts (if not empty) are applied
       3. OVERRIDES are applied

   Example:

   If ipopt.opt = 3, then after setting the default IPOPT options,
   IPOPT_OPTIONS will execute the following user-defined function
   to allow option overrides:

       opt = ipopt_user_options_3(opt, mpopt);

   The contents of ipopt_user_options_3.m, could be something like:

       function opt = ipopt_user_options_3(opt, mpopt)
       opt.nlp_scaling_method = 'none';
       opt.max_iter           = 500;
       opt.derivative_test    = 'first-order';

   See the options reference section in the IPOPT documentation for
   details on the available options.

       http://www.coin-or.org/Ipopt/documentation/

   See also IPOPT, MPOPTION.

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

Generated on Mon 24-Jun-2019 15:58:45 by m2html © 2005