Global option settings for solvers.
s = mpt_solvers_options
s |
options structure Class: struct |
s.clp |
settings for CLP solver Class: struct |
s.clp.solver |
Which method to choose for solving LP/QP. Class: double Allowed values:
Default: 1 |
s.clp.maxnumiterations |
Maximum number of iterations allowed Class: double Default: 99999999 |
s.clp.maxnumseconds |
Maximum time allowed for computation in seconds Class: double Default: 3600 |
s.clp.primaltolerance |
Tolerance on the primal solution. Class: double Default: 1e-7 |
s.clp.dualtolerance |
Tolerance on the dual solution. Class: double Default: 1e-7 |
s.clp.primalpivot |
Which pivot method to choose for primal solution. Class: double Allowed values:
Default: 1 |
s.clp.dualpivot |
Which pivot method to choose for dual solution. Class: double Allowed values:
Default: 1 |
s.clp.verbose |
Verbosity level. Class: double Allowed values:
Default: 0 |
s.cplexint |
Settings for CPLEX solver interfaced by Automatic Control Laboratory (cplexint). Class: struct |
s.cplexint.verbose |
Verbosity level. Class: double Allowed values:
Default: 0 |
s.cplexint.logfile |
Redirect output to a file. Class: logical Allowed values:
Default: 0 |
s.cplexint.lic_rel |
After how many runs to release the license. Class: double Default: 1e3 |
s.cplex |
Settings for CPLEX solver interfaced by IBM. Class: struct |
s.cplex.lpmethod |
Which method to use for solving LP. Class: char Allowed values:
Default: 2 |
s.cplex.qpmethod |
Which method to use for solving QP. Class: char Allowed values:
Default: 2 |
s.plcp |
settings for PLCP solver Class: struct |
s.plcp.bfs |
Perform breadth first search when explorting the parameter space. Class: logical Allowed values:
Default: 1 |
s.plcp.dfs |
Perform breadth first search when explorting the parameter space. Class: logical Allowed values:
Default: 0 |
s.plcp.debug |
Debugging level Class: double Allowed values:
Default: 0 |
s.plcp.fixedstep |
Always perform a step over the facet with a fixed step size given as region_tol.
An alternative way to detect regions while exploring the parameter space. The approach is useful
when numerical problems occurs with the standard method where the step size is computed automatically.
Class: logical Allowed values:
Default: 0 |
s.plcp.QRfactor |
Inside the main pivoting funtion use recursive QR factorization instead of direct LU factorization.
It will speed up the computation time but will suffer from numerical problems for large LCP problems.
Class: logical Allowed values:
Default: 0 |
s.plcp.checkoverlaps |
Check for overlaps while exploring the parameter space. This option enforces to search through all
discovered regions at each step for overlaps. If the overlap is detected, the overlapping part is discarted
via set-difference operation. Since this requires solving an LP for each region, this option reduces the
computational time significantly.
Class: logical Allowed values:
Default: 0 |
s.plcp.rescue |
If the variable step approach fails to find adjacent region, retry with the fixed step.
The step size is given as the Chebyshev radius of the smallest allowable region, i.e. half of
the region_tol.
Class: logical Allowed values:
Default: 0 |
s.plcp.maxsteps |
Maximum number of steps to perform with the fixed step approach in case no new regions
have been found. Minimum 2-steps must be provided.
Class: double Default: 200 |
s.plcp.maxlayers |
Maximum value of layers to be explored for breadth first search (BFS). This option is valid only with
BFS option. Useful only if there are too many regions far from the initial region that can be discarded from
optimal solution. The layered list of regions is returned in the field layer_list.
Class: double Default: Inf |
s.plcp.maxregions |
Maximum number of regions to be generated.
Class: double Default: Inf |
s.plcp.maxpivots |
The maximum number of pivots to be performed to find a neighboring region. Typically, the are
1, 2 pivots to be performed to find a neighboring regions. For a degenerate case, more pivots are needed.
The maximum value of the pivots is given by the RecursionLimit of MATLAB which 500 by default.
If the value of maxpivots is greater than RecursionLimit, change also this value by
set(0,'RecursionLimit',N).
Class: double Default: 100 |
s.plcp.adjcheck |
Force verification of the adjacency list in the postprocessing phase. This option activates
a subfunction in the PLCP solver where the adjacency list is checked for any missing links in the graph
and performs correction. The option is turned off by default because the verification can be time
consuming for large partitions.
Class: logical Allowed values:
Default: 0 |
s.lcp |
settings for LCP solver Class: struct |
s.lcp.zerotol |
Less than this treshold the value is considered as zero. Class: double Default: 1e-10 |
s.lcp.lextol |
Lexicographic tolerance - a small treshold from which values are considered as equal. Class: double Default: 1e-9 |
s.lcp.nstepf |
If options.routine is 0, then every nstepf pivot steps the basis is refactorized to
avoid numerical problems for LUMOD. For other routines the factorization
is performed at each step.
Class: double Default: 50 |
s.lcp.maxpiv |
Maximum number of pivots to be performed. Class: double Default: 1e4 |
s.lcp.clock |
Show the information about the computational time. Class: logical Allowed values:
Default: 0 |
s.lcp.verbose |
Verbose output. Class: logical Allowed values:
Default: 0 |
s.lcp.routine |
Routine which should be used to obtain a basis solution. Class: double Allowed values:
Default: 1 |
s.lcp.timelimit |
Time limit in seconds. If this limit is exceeded, the pivoting algorithm
is terminated and current basis is returned. Class: double Default: 3600 |
s.lcp.normalize |
Input matrices ![]() ![]() ![]() ![]() ![]() ![]() ![]() ![]() Class: logical Allowed values:
Default: 1 |
s.lcp.normalizethres |
If the normalize option is on, then the matrix scaling is performed
only if 1 norm of matrix ![]() Class: double Default: 1e6 |
s.glpk |
settings for GLPK solver Class: struct |
s.glpk.msglev |
Level of messages output by solver routines. Class: double Allowed values:
Default: 0 |
s.glpk.lpsolver |
Which method to choose for solving primal LP. Class: double Allowed values:
Default: 1 |
s.glpk.scale |
Which method of scaling to use. Class: double Allowed values:
Default: 1 |
s.glpk.dual |
Which method to choose for solving dual LP. Class: double Allowed values:
Default: 1 |
s.glpk.price |
Pricing option (for both primal and dual simplex). Class: double Allowed values:
Default: 1 |
s.glpk.r_test |
Ratio test technique. Class: double Allowed values:
Default: 1 |
s.glpk.relax |
Relaxation parameter used in the ratio test.
If it is zero, the textbook ratio test is used. If it is non-zero (should be
positive), Harris two-pass ratio test is used. In the latter case on the
first pass of the ratio test basic variables (in the case of primal
simplex) or reduced costs of non-basic variables (in the case of dual
simplex) are allowed to slightly violate their bounds, but not more than
relax*tolbnd or relax*toldj
(thus, relax is a percentage of tolbnd or toldj).
Class: double Default: 0.07 |
s.glpk.tolbnd |
Relative tolerance used to check ifthe current basic
solution is primal feasible. It is not recommended that you change this
parameter unless you have a detailed understanding of its purpose.
Class: double Default: 1e-7 |
s.glpk.toldj |
Absolute tolerance used to check if the current basic
solution is dual feasible. It is not recommended that you change this
parameter unless you have a detailed understanding of its purpose.
Class: double Default: 1e-7 |
s.glpk.tolpiv |
Relative tolerance used to choose eligible pivotal
elements of the simplex table. It is not recommended that you change this
parameter unless you have a detailed understanding of its purpose.
Class: double Default: 1e-9 |
s.glpk.round |
Solution rounding option.
Class: logical Allowed values:
Default: 0 |
s.glpk.objll |
Lower limit of the
objective function. If on the phase II the objective
function reaches this limit and continues decreasing, the
solver stops the search. This parameter is used in the
dual simplex method only.
Class: double Default: -1e12 |
s.glpk.objul |
Upper limit of the
objective function. If on the phase II the objective
function reaches this limit and continues increasing,
the solver stops the search. This parameter is used in
the dual simplex only.
Class: double Default: 1e12 |
s.glpk.itlim |
Simplex iterations limit.
If this value is positive, it is decreased by one each
time when one simplex iteration has been performed, and
reaching zero value signals the solver to stop the search.
Negative value means no iterations limit.
Class: double Default: 1e4 |
s.glpk.itcnt |
Output frequency, in iterations.
This parameter specifies how frequently the solver sends
information about the solution to the standard output.
Class: double Default: 200 |
s.glpk.usecuts |
glp_intopt generates and adds cutting planes to
the MIP problem in order to improve its LP relaxation
before applying the branch-and-bound method. Class: double Allowed values:
Default: 1 |
s.glpk.pprocess |
Pre-processing technique option (for MIP only).
Class: double Allowed values:
Default: 2 |
s.glpk.binarize |
Binarizeation option (for MIP), used only if presolver is enabled.
Class: logical Allowed values:
Default: 0 |
s.glpk.tmlim |
Searching time limit, in
seconds. If this value is positive, it is decreased each
time when one simplex iteration has been performed by the
amount of time spent for the iteration, and reaching zero
value signals the solver to stop the search. Negative
value means no time limit
Class: double Default: -1 |
s.glpk.branch |
Branching heuristic option (for MIP only).
Class: double Allowed values:
Default: 2 |
s.glpk.btrack |
Backtracking heuristic option (for MIP only).
Class: double Allowed values:
Default: 2 |
s.glpk.tolint |
Relative tolerance used
to check if the current basic solution is integer
feasible. It is not recommended that you change this
parameter unless you have a detailed understanding of
its purpose.
Class: double Default: 1e-6 |
s.glpk.outdly |
Output delay, in seconds.
This parameter specifies how long the solver should
delay sending information about the solution to the standard
output. Non-positive value means no delay.
Class: double Default: 0 |
s.glpk.tolobj |
Relative tolerance used
to check if the value of the objective function is not
better than in the best known integer feasible solution.
It is not recommended that you change this parameter
unless you have a detailed understanding of its purpose.
Class: double Default: 1e-7 |
s.glpk.presol |
If this flag is set, the routine
lpx_simplex solves the problem using the built-in LP presolver.
Otherwise the LP presolver is not used.
Class: logical Allowed values:
Default: 1 |
s.glpk.save |
If this parameter is nonzero save a copy of
the original problem to file.
Class: logical Allowed values:
Default: 0 |
s.glpk.mipgap |
The relative mip gap tolerance.
If the relative mip gap for currently known best integer feasible
solution falls below this tolerance, the solver terminates
the search. This allows obtaining suboptimal interger
feasible solutions if solving the problem to optimality
takes too long.
Class: double Default: 0 |
s.gurobi |
settings for GUROBI solver Class: struct |
s.gurobi.BarIterLimit |
Limits the number of barrier iterations performed (barrier only). Class: double Default: 1e12 |
s.gurobi.CutOff |
If the objective value for the optimal solution is better than the specified cutoff,
the solver will return the optimal solution. Otherwise, it will terminate with a CUTOFF status.
Class: double Default: 1e12 |
s.gurobi.IterationLimit |
Limits the number of simplex iterations performed. Class: double Default: 1e6 |
s.gurobi.NodeLimit |
Limits the number of MIP nodes explored (MIP only). Class: double Default: 1e12 |
s.gurobi.SolutionLimit |
Limits the number of feasible solutions found (MIP only). Class: double Default: 1e12 |
s.gurobi.TimeLimit |
Limits the total time expended (in seconds). Class: double Default: 1e12 |
s.gurobi.BarConvTol |
Barrier convergence tolerance (barrier only). The barrier solver
terminates when the relative difference between the primal and dual
objective values is less than the specified tolerance.
Value must be in range [1e-10, 1].
Class: double Default: 1e-8 |
s.gurobi.BarConvTol |
Barrier convergence tolerance (barrier only). The barrier solver
terminates when the relative difference between the primal and dual
objective values is less than the specified tolerance.
Value must be in range [1e-10, 1].
Class: double Default: 1e-8 |
s.gurobi.BarQCPConvTol |
The barrier solver terminates when the relative difference between the
primal and dual objective values is less than the specified tolerance.
ightening this tolerance may lead to a more accurate solution, but it may
also lead to a failure to converge.
Values must be in range [0, 1];
Class: double Default: 1e-6 |
s.gurobi.FeasibilityTol |
All constraints must be satisfied to a tolerance of FeasibilityTol.
Tightening this tolerance can produce smaller constraint violations,
but for numerically challenging models it can sometimes lead to much larger iteration counts.
Value must be in range [1e-9, 1e-2].
Class: double Default: 1e-6 |
s.gurobi.IntFeasTol |
Integer feasibility tolerance (MIP only). An integrality restriction on a
variable is considered satisfied when the variable's value is less than
INTFEASTOL from the nearest integer value.
Value must be in range [1e-9, 1e-1].
Class: double Default: 1e-5 |
s.gurobi.OptimalityTol |
Dual feasibility tolerance. Reduced costs must all be smaller than
OptimalityTol in the improving direction in order for a model to be
declared optimal.
Value must be in range [1e-9, 1e-2].
Class: double Default: 1e-6 |
s.gurobi.MIPGap |
Relative MIP optimality gap (MIP only). The MIP engine will terminate
(with an optimal result) when the gap between the lower and upper
objective bound is less than MIPGap times the upper bound.
Class: double Default: 1e-4 |
s.gurobi.PSDTol |
Positive semi-definite tolerance (QP/MIQP only). Sets a limit on the
amount of diagonal perturbation that the optimizer is allowed to perform
on the Q matrix in order to correct minor PSD violations. If a larger
perturbation is required, the optimizer will terminate with an
GRB_ERROR_Q_NOT_PSD error.
Class: double Default: 1e-6 |
s.gurobi.InfUnbdInfo |
Determines whether simplex (and crossover) will compute
additional information when a model is determined to be infeasible or
unbounded. Set this parameter if you want to query the unbounded ray for
unbounded models (through the UnbdRay attribute), or the infeasibility
proof for infeasible models (through the FarkasDual and FarkasProof
attributes).
Class: logical Allowed values:
Default: 0 |
s.gurobi.NormAdjust |
Chooses from among multiple pricing norm variants. The details of
how this parameter affects the simplex pricing algorithm are subtle and
difficult to describe, so we've simply labeled the options 0 through 3.
The default value of -1 chooses automatically.
Changing the value of this parameter rarely produces a significant benefit.
Class: double Default: -1 |
s.gurobi.PerturbValue |
Magnitude of the simplex perturbation. Note that
perturbation is only applied when progress has stalled, so the parameter
will often have no effect. Values must be in range [0, 0.01].
Class: double Default: 0.0002 |
s.gurobi.ScaleFlag |
Enables or disables model scaling. Scaling usually
improves the numerical properties of the model, which typically leads to
reduced solution times, but it may sometimes lead to larger constraint
violations in the original, unscaled model.
Class: logical Allowed values:
Default: 1 |
s.gurobi.ObjScale |
Divides the model objective by the specified value to avoid
numerical errors that may result from very large objective coefficients.
The default value of 0 decides on the scaling automatically. A value less
than zero uses the maximum coefficient to the specified power as the
scaling (so ObjScale=-0.5 would scale by the square root of the largest
objective coefficient).
Class: double Default: 0 |
s.gurobi.BarCorrectors |
Limits the number of central corrections performed in each barrier iteration.
The default value chooses automatically, depending on problem characteristics.
The automatic strategy generally works well, although it is often possible to obtain
higher performance on a specific model by selecting a value manually. The values must
be in range [-1, Inf)
Class: double Default: -1 |
s.gurobi.Method |
Algorithm used to solve continuous models or the root node of a MIP model.
Concurrent optimizers run multiple solvers on multiple threads simultaneously, and choose the one
that finishes first. Deterministic concurrent (Method=4) gives the exact same result each time,
while Method=3 is often faster but can produce different optimal bases when run multiple times.
In the current release, the default Automatic (Method=-1) will typically choose non-deterministic concurrent
(Method=3) for an LP, barrier (Method=2) for a QP or QCP, and dual (Method=1) for the MIP root node.
Only simplex and barrier algorithms are available for continuous QP models. Only primal and dual
simplex are available for solving the root of an MIQP model. Only barrier is available for
continuous QCP models.
The default setting is rarely significantly slower than the best possible setting, so you
generally won't see a big gain from changing this parameter. There are classes of models where
one particular algorithm is consistently fastest, though, so you may want to experiment with
different options when confronted with a particularly difficult model.
Note that if memory is tight on an LP model, you should consider choosing the dual
simplex method (Method=1). The default will invoke the concurrent optimizer, which typically
consumes a lot more memory than dual simplex alone.
Class: double Allowed values:
Default: 1 |
s.gurobi.Presolve |
Controls the presolve level. A value of -1 corresponds to an automatic
setting.
Class: double Allowed values:
Default: -1 |
s.gurobi.TimeLimit |
Limits the total time expended (in seconds).
Class: double Default: 1e12 |
s.gurobi.Threads |
Controls the number of threads to apply to parallel MIP. The default
value of 0 sets the thread count equal to the maximum value, which is the
number of processors in the machine.
Value should range from 0 to maximum number of processors.
Class: double Default: 0 |
s.gurobi.OutputFlag |
Verbosity level.
Class: logical Allowed values:
Default: 0 |
s.gurobi.DisplayInterval |
Controls the frequency at which log lines are printed (in seconds).
Class: double Default: 5 |
s.nag |
settings for NAG solver Class: struct |
s.nag.qp |
settings for QP solver Class: struct |
s.nag.qp.ftol |
The maximum acceptable violation in each constraint at a "feasible" point. Class: double Default: 1e-9 |
s.nag.qp.rank_tol |
Enables the user to control the condition number of the triangular factor ![]() Class: double Default: 1e-20 |
s.nag.qp.crash_tol |
A constraint of the form ![]() ![]() Class: double Default: 0.1 |
s.nag.qp.reset_ftol |
This option is part of an anti-cycling procedure designed to guarantee
progress even on highly degenerate problems.
Class: double Default: 5 |
s.nag.qp.max_iter |
maximum number of iterations to be performed
Class: double Default: 1e6 |
s.nag.qp.fcheck |
every fcheck iterations, a numerical test is
made to see if the current solution satisfies
the constraints in the working set
Class: double Default: 50 |
s.nag.qp.inf_bound |
defines the "infinite" bound in the definition
of the problem constraints
Class: double Default: 1e12 |
s.nag.lp |
settings for LP solver Class: struct |
s.nag.lp.ftol |
The maximum acceptable violation in each constraint at a "feasible" point. Class: double Default: 1e-9 |
s.nag.lp.optim_tol |
Enables the user to control the condition number of the triangular factor ![]() Class: double Default: 1e-13 |
s.nag.lp.crash_tol |
A constraint of the form ![]() ![]() Class: double Default: 0.1 |
s.nag.lp.reset_ftol |
This option is part of an anti-cycling procedure designed to guarantee
progress even on highly degenerate problems.
Class: double Default: 5 |
s.nag.lp.max_iter |
maximum number of iterations to be performed
Class: double Default: 1e6 |
s.nag.lp.fcheck |
every fcheck iterations, a numerical test is
made to see if the current solution satisfies
the constraints in the working set
Class: double Default: 50 |
s.nag.lp.inf_bound |
defines the "infinite" bound in the definition
of the problem constraints
Class: double Default: 1e12 |
s.qpip |
settings for QPC interior point solver "qpip" Class: struct |
s.qpip.mu |
Desired complementarity gap target (point on central-path). Class: double Default: 0 |
s.qpip.method |
If method=1, then a faster but less accurate linear
solve step is used. Conversely, if method=0 then a slower but
more accurate linear solve step is used.
Class: logical Default: 0 |
s.qpspline |
settings for QPspline solver Class: struct |
s.qpspline.maxiter |
The maximum number of iterations. Class: double Default: 10000 |
s.qpspline.abs_tol |
Absolute tolerance. Class: double Default: 1e-8 |
s.qpspline.nstepf |
After these nstepf steps the basis will be refactored with new ![]() ![]() Class: double Default: 30 |
s.qpspline.nqrelems |
Do recursive QR factorization if the number of changed elements
(rows/cols) is less than this treshold. If the treshold is large, the
recursive factorization may actually consume more time than direct
factorization. Large treshold causes also accumulation of numerical
errors. Class: double Default: 20 |
s.qpspline.timelimit |
Time limit on the computations in seconds.
Class: double Default: 3600 |
s.qpspline.verbose |
Show the iteration progress.
Class: logical Allowed values:
Default: 0 |
s.quadprog |
settings for QUADPROG solver Class: struct |
s.quadprog.MaxIter |
Maximum number of iterations allowed. Class: double Default: 1e6 |
s.quadprog.TolFun |
Termination tolerance on the function value. Class: double Default: 1e-10 |
s.quadprog.TolX |
Termination tolerance on the solution. Class: double Default: 1e-10 |
s.quadprog.Display |
Display progress of optimization. Class: char Allowed values:
Default: off |
s.quadprog.Algorithm |
Algorithm for solving the QP Class: char Allowed values:
Default: active-set |
s.quadprog.LargeScale |
Use large-scale or medium-scale algorithms. Class: char Allowed values:
Default: off |
s.linprog |
settings for LINPROG solver Class: struct |
s.linprog.MaxIter |
Maximum number of iterations allowed. Class: double Default: 1e6 |
s.linprog.TolFun |
Termination tolerance on the function value. Class: double Default: 1e-10 |
s.linprog.TolX |
Termination tolerance on the solution. Class: double Default: 1e-10 |
s.linprog.Display |
Display progress of optimization. Class: char Allowed values:
Default: off |
s.sedumi |
settings for SEDUMI solver Class: struct |
s.sedumi.fid |
Verbosity level Class: logical Allowed values:
Default: 0 |
s.sedumi.alg |
Type of algorithm that solves the problem.
Class: double Allowed values:
Default: 2 |
s.sedumi.theta |
The wide region parameter which varies ![]() Class: double Default: 0.25 |
s.sedumi.beta |
The neighborhood region parameter which varies ![]() Class: double Default: 0.5 |
s.sedumi.stepdif |
Set primal/dual differentiation step length. Class: double Default: 2 |
s.sedumi.w |
The weights for the relative primal, dual and gap residuals as
w(1):w(2):1 in order to find the optimal step differentiation. Class: double Default: [1 1] |
s.sedumi.eps |
The desired accuracy. Class: double Default: 1e-10 |
s.sedumi.bigeps |
In case the desired accuracy cannot be achieved, SEDUMI tries to satisfy this accuracy. Class: double Default: 1e-6 |
s.sedumi.maxiter |
Maximum iterations allowed. Class: double Default: 1e6 |
s.sedumi.cg |
Settings for preconditioned conjugate gradient method (CG),
which is only used if results from Cholesky are inaccurate. Class: struct |
s.sedumi.cg.maxiter |
Maximum number of CG-iterates (per solve). Theoretically needed
is |add|+2*|skip|, the number of added and skipped pivots in Cholesky. Class: double Default: 49 |
s.sedumi.cg.restol |
Terminates if residual is a restol fraction of duality gap.
Should be smaller than 1 in order to make progress. Class: double Default: 5e-3 |
s.sedumi.cg.refine |
Number of refinement loops that are allowed. The maximum number
of actual CG-steps will thus be 1+(1+refine)*maxiter.
Class: double Default: 1 |
s.sedumi.cg.stagtol |
Terminates if relative function progress less than stagtol. Class: double Default: 4e-14 |
s.sedumi.cg.qprec |
Stores cg-iterates in quadruple precision if true. Class: logical Allowed values:
Default: 0 |
s.sedumi.chol |
Parameters for controling the Cholesky solve.
Class: struct |
s.sedumi.chol.canceltol |
Relative tolerance for detecting cancelation during Cholesky. Class: double Default: 1e-12 |
s.sedumi.chol.maxu |
Adds to diagonal if max(abs(L(:,j))) > maxu otherwise. Class: double Default: 5e5 |
s.sedumi.chol.abstol |
Skips pivots falling below abstol.
Class: double Default: 1e-20 |
s.sedumi.chol.maxuden |
Pivots in dense-column factorization so that these factors
satisfy max(abs(Lk)) <= maxuden. Class: double Default: 5e2 |
s.sedumi.chol.errors |
If this field is true then SEDUMI outputs some error
measures as defined in the Seventh DIMACS Challenge. Class: logical Allowed values:
Default: 0 |
[1] Stephen Boyd and Lieven Vandenberghe: Convex Optimization; Cambridge University Press
◀ | mpt_call_qpc | mpt_call_cplex | ▶ |
© 2010-2013 Martin Herceg: ETH Zurich, herceg@control.ee.ethz.ch