TomWiki - User contributions [en]

Welcome

2014-09-12T13:48:04Z

Elias: /* Standalone */

The TOMLAB Environment is a modeling platform for solving applied optimization problems in [http://en.wikipedia.org/wiki/MATLAB MATLAB].

==Description==
TOMLAB is a general purpose development and modeling environment in MATLAB for research, teaching and practical solution of optimization problems. It enables a wider range of problems to be solved in MATLAB and provides many additional solvers.

==Optimization problems supported==
TOMLAB handles a wide range of problem types, among them:
* Linear programming
* Quadratic programming
* Nonlinear programming
* Mixed-integer programming
* Mixed-integer quadratic programming with or without convex quadratic constraints
* Mixed-integer nonlinear programming
* Linear and nonlinear least squares with L1, L2 and infinity norm
* Exponential data fitting
* Global optimization
* Semi-definite programming problem with bilinear matrix inequalities
* Constrained goal attainment
* Geometric programming
* Genetic programming
* Costly or expensive black-box global optimization
* Nonlinear complementarity problems

==TOMLAB Manuals==

===TOMLAB Manual===
Includes general TOMLAB information and solver reference for the TOMLAB Base Module.
* [[TOMLAB|TOMLAB Manual]]

===Quickguide===
Basics associated with solving problems using the TOMLAB Optimization Environment.
* [[Quickguide]]

===Models===
A short introduction to the TOMLAB Models.
* [[Models]]

===SAL===
Standalone execution of TOMLAB. Compilation instructions.
* [[SAL]]

===Installation===
Guide for installation of demos and permanently licensed TOMLAB components.
* [[Installation]]

==Product User's Guides==

====Included in the [[SOL|TOMLAB /SOL manual]]====
<table>
<tr>
<td>
*[[MINOS]]
</td>
<td>
*[[SOL_NPSOL|NPSOL]]
</td>
<td>
* [[SNOPT]]
</td>
</tr>
</table>

====Standalone====

<table>
<tr>
<td>
* [[SOL]]
</td>
<td>
* [[CGO]]
</td>
<td>
* [[Xpress]]
</td>
<td>
* [[CPLEX]]
</td>
<td>
* [[GUROBI]]
</td>
<td>
* [[MINLP]]
</td>
</tr>
<tr>
<td>
* [[PENOPT]]
</td>
<td>
* [[KNITRO]]
</td>
<td>
* [[OQNLP]]
</td>
<td>
* [[CONOPT]]
</td>
<td>
* [[NLPQL]]
</td>
<td>
* [[LGO]]
</td>
</tr>
<tr>
<td>
* [[GP]]
</td>
<td>
* [[GENO]]
</td>
<td>
* [[MAD]]
</td>
<td>
* [[AMPL]]
</td>
<td>
* [[PROPT]]
</td>
<td>
* [[TomSym]]
</td>
</tr>
<tr>
<td>
* [[MISQP]]
</td>
</tr>
</table>

==PDF==

*[[PDF|Manuals in PDF format]]

==Links==

* http://tomopt.com/

PDF

2012-01-22T20:08:27Z

Elias: /* Standalone */

Manuals in PDF format.

==TOMLAB Manuals==

===TOMLAB Manual===
Includes general TOMLAB information and solver reference for the TOMLAB Base Module.
* [[file:users_guide.pdf]]

===Quickguide===
Basics associated with solving problems using the TOMLAB Optimization Environment.
* [[file:quickguide.pdf]]

===Models===
A short introduction to the TOMLAB Models.
* [[file:models.pdf]]

===SAL===
Standalone execution of TOMLAB. Compilation instructions.
* [[file:sal.pdf]]

===Installation===
Guide for installation of demos and permanently licensed TOMLAB components.
* [[file:installation.pdf]]

==Product User's Guides==

====Included in [[file:sol.pdf]]====
<table>
<tr>
<td>
*[[file:Minos.pdf]]
</td>
<td>
*[[file:npsol.pdf]]
</td>
<td>
*[[file:snopt.pdf]]
</td>
</tr>
</table>

====Standalone====

<table>
<tr>
<td>
* [[file:sol.pdf]]
</td>
<td>
* [[file:cgo.pdf]]
</td>
<td>
* [[file:xpress.pdf]]
</td>
<td>
* [[file:cplex.pdf]]
</td>
<td>
* [[file:gurobi.pdf]]
</td>
<td>
* [[file:minlp.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:penopt.pdf]]
</td>
<td>
* [[file:knitro.pdf]]
</td>
<td>
* [[file:oqnlp.pdf]]
</td>
<td>
* [[file:conopt.pdf]]
</td>
<td>
* [[file:nlpql.pdf]]
</td>
<td>
* [[file:lgo.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:gp.pdf]]
</td>
<td>
* [[file:geno.pdf]]
</td>
<td>
* [[file:mad.pdf]]
</td>
<td>
* [[file:ampl.pdf]]
</td>
<td>
* [[file:propt.pdf]]
</td>
<td>
* [[file:tomsym.pdf]]
</td>
</tr>
</table>

Welcome

2012-01-22T20:02:03Z

Elias:

The TOMLAB Environment is a modeling platform for solving applied optimization problems in [http://en.wikipedia.org/wiki/MATLAB MATLAB].

==Description==
TOMLAB is a general purpose development and modeling environment in MATLAB for research, teaching and practical solution of optimization problems. It enables a wider range of problems to be solved in MATLAB and provides many additional solvers.

==Optimization problems supported==
TOMLAB handles a wide range of problem types, among them:
* Linear programming
* Quadratic programming
* Nonlinear programming
* Mixed-integer programming
* Mixed-integer quadratic programming with or without convex quadratic constraints
* Mixed-integer nonlinear programming
* Linear and nonlinear least squares with L1, L2 and infinity norm
* Exponential data fitting
* Global optimization
* Semi-definite programming problem with bilinear matrix inequalities
* Constrained goal attainment
* Geometric programming
* Genetic programming
* Costly or expensive black-box global optimization
* Nonlinear complementarity problems

==TOMLAB Manuals==

===TOMLAB Manual===
Includes general TOMLAB information and solver reference for the TOMLAB Base Module.
* [[TOMLAB|TOMLAB Manual]]

===Quickguide===
Basics associated with solving problems using the TOMLAB Optimization Environment.
* [[Quickguide]]

===Models===
A short introduction to the TOMLAB Models.
* [[Models]]

===SAL===
Standalone execution of TOMLAB. Compilation instructions.
* [[SAL]]

===Installation===
Guide for installation of demos and permanently licensed TOMLAB components.
* [[Installation]]

==Product User's Guides==

====Included in the [[SOL|TOMLAB /SOL manual]]====
<table>
<tr>
<td>
*[[MINOS]]
</td>
<td>
*[[SOL_NPSOL|NPSOL]]
</td>
<td>
* [[SNOPT]]
</td>
</tr>
</table>

====Standalone====

<table>
<tr>
<td>
* [[SOL]]
</td>
<td>
* [[CGO]]
</td>
<td>
* [[Xpress]]
</td>
<td>
* [[CPLEX]]
</td>
<td>
* [[GUROBI]]
</td>
<td>
* [[MINLP]]
</td>
</tr>
<tr>
<td>
* [[PENOPT]]
</td>
<td>
* [[KNITRO]]
</td>
<td>
* [[OQNLP]]
</td>
<td>
* [[CONOPT]]
</td>
<td>
* [[NLPQL]]
</td>
<td>
* [[LGO]]
</td>
</tr>
<tr>
<td>
* [[GP]]
</td>
<td>
* [[GENO]]
</td>
<td>
* [[MAD]]
</td>
<td>
* [[AMPL]]
</td>
<td>
* [[PROPT]]
</td>
<td>
* [[TomSym]]
</td>
</tr>
</table>

==PDF==

*[[PDF|Manuals in PDF format]]

==Links==

* http://tomopt.com/

PDF

2012-01-22T20:01:47Z

Elias:

Manuals in PDF format.

==TOMLAB Manuals==

===TOMLAB Manual===
Includes general TOMLAB information and solver reference for the TOMLAB Base Module.
* [[file:users_guide.pdf]]

===Quickguide===
Basics associated with solving problems using the TOMLAB Optimization Environment.
* [[file:quickguide.pdf]]

===Models===
A short introduction to the TOMLAB Models.
* [[file:models.pdf]]

===SAL===
Standalone execution of TOMLAB. Compilation instructions.
* [[file:sal.pdf]]

===Installation===
Guide for installation of demos and permanently licensed TOMLAB components.
* [[file:installation.pdf]]

==Product User's Guides==

====Included in [[file:sol.pdf]]====
<table>
<tr>
<td>
*[[file:Minos.pdf]]
</td>
<td>
*[[file:npsol.pdf]]
</td>
<td>
*[[file:snopt.pdf]]
</td>
</tr>
</table>

====Standalone====

<table>
<tr>
<td>
* [[file:sol.pdf]]
</td>
<td>
* [[file:cgo.pdf]]]
</td>
<td>
* [[file:xpress.pdf]]
</td>
<td>
* [[file:cplex.pdf]]
</td>
<td>
* [[file:gurobi.pdf]]
</td>
<td>
* [[file:minlp.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:penopt.pdf]]
</td>
<td>
* [[file:knitro.pdf]]
</td>
<td>
* [[file:oqnlp.pdf]]
</td>
<td>
* [[file:conopt.pdf]]
</td>
<td>
* [[file:nlpql.pdf]]
</td>
<td>
* [[file:lgo.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:gp.pdf]]
</td>
<td>
* [[file:geno.pdf]]
</td>
<td>
* [[file:mad.pdf]]
</td>
<td>
* [[file:ampl.pdf]]
</td>
<td>
* [[file:propt.pdf]]
</td>
<td>
* [[file:tomsym.pdf]]
</td>
</tr>
</table>

PDF

2012-01-22T20:00:29Z

Elias:

==Manuals in PDF format==

===TOMLAB Manuals===

===TOMLAB Manual===
Includes general TOMLAB information and solver reference for the TOMLAB Base Module.
* [[file:users_guide.pdf]]

===Quickguide===
Basics associated with solving problems using the TOMLAB Optimization Environment.
* [[file:quickguide.pdf]]

===Models===
A short introduction to the TOMLAB Models.
* [[file:models.pdf]]

===SAL===
Standalone execution of TOMLAB. Compilation instructions.
* [[file:sal.pdf]]

===Installation===
Guide for installation of demos and permanently licensed TOMLAB components.
* [[file:installation.pdf]]

===Product User's Guides===

====Included in [[file:sol.pdf]]====
<table>
<tr>
<td>
*[[file:Minos.pdf]]
</td>
<td>
*[[file:npsol.pdf]]
</td>
<td>
*[[file:snopt.pdf]]
</td>
</tr>
</table>

====Standalone====

<table>
<tr>
<td>
* [[file:sol.pdf]]
</td>
<td>
* [[file:cgo.pdf]]]
</td>
<td>
* [[file:xpress.pdf]]
</td>
<td>
* [[file:cplex.pdf]]
</td>
<td>
* [[file:gurobi.pdf]]
</td>
<td>
* [[file:minlp.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:penopt.pdf]]
</td>
<td>
* [[file:knitro.pdf]]
</td>
<td>
* [[file:oqnlp.pdf]]
</td>
<td>
* [[file:conopt.pdf]]
</td>
<td>
* [[file:nlpql.pdf]]
</td>
<td>
* [[file:lgo.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:gp.pdf]]
</td>
<td>
* [[file:geno.pdf]]
</td>
<td>
* [[file:mad.pdf]]
</td>
<td>
* [[file:ampl.pdf]]
</td>
<td>
* [[file:propt.pdf]]
</td>
<td>
* [[file:tomsym.pdf]]
</td>
</tr>
</table>

PDF

2012-01-22T19:59:47Z

Elias: Created page with "==Manuals in PDF format== ==TOMLAB Manuals== ===TOMLAB Manual=== Includes general TOMLAB information and solver reference for the TOMLAB Base Module. * file:users_guide.pdf..."

==Manuals in PDF format==

==TOMLAB Manuals==

===TOMLAB Manual===
Includes general TOMLAB information and solver reference for the TOMLAB Base Module.
* [[file:users_guide.pdf]]

===Quickguide===
Basics associated with solving problems using the TOMLAB Optimization Environment.
* [[file:quickguide.pdf]]

===Models===
A short introduction to the TOMLAB Models.
* [[file:models.pdf]]

===SAL===
Standalone execution of TOMLAB. Compilation instructions.
* [[file:sal.pdf]]

===Installation===
Guide for installation of demos and permanently licensed TOMLAB components.
* [[file:installation.pdf]]

==Product User's Guides==

====Included in [[file:sol.pdf]]====
<table>
<tr>
<td>
*[[file:Minos.pdf]]
</td>
<td>
*[[file:npsol.pdf]]
</td>
<td>
*[[file:snopt.pdf]]
</td>
</tr>
</table>

====Standalone====

<table>
<tr>
<td>
* [[file:sol.pdf]]
</td>
<td>
* [[file:cgo.pdf]]]
</td>
<td>
* [[file:xpress.pdf]]
</td>
<td>
* [[file:cplex.pdf]]
</td>
<td>
* [[file:gurobi.pdf]]
</td>
<td>
* [[file:minlp.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:penopt.pdf]]
</td>
<td>
* [[file:knitro.pdf]]
</td>
<td>
* [[file:oqnlp.pdf]]
</td>
<td>
* [[file:conopt.pdf]]
</td>
<td>
* [[file:nlpql.pdf]]
</td>
<td>
* [[file:lgo.pdf]]
</td>
</tr>
<tr>
<td>
* [[file:gp.pdf]]
</td>
<td>
* [[file:geno.pdf]]
</td>
<td>
* [[file:mad.pdf]]
</td>
<td>
* [[file:ampl.pdf]]
</td>
<td>
* [[file:propt.pdf]]
</td>
<td>
* [[file:tomsym.pdf]]
</td>
</tr>
</table>

File:Xpress.pdf

2012-01-22T19:36:14Z

Elias:

File:Users guide.pdf

2012-01-22T19:36:04Z

Elias:

File:Tomsym.pdf

2012-01-22T19:35:51Z

Elias:

File:Sol.pdf

2012-01-22T19:35:38Z

Elias:

File:Snopt.pdf

2012-01-22T19:35:22Z

Elias:

File:Sal.pdf

2012-01-22T19:35:12Z

Elias:

File:Quickguide.pdf

2012-01-22T19:35:04Z

Elias:

File:Propt.pdf

2012-01-22T19:34:51Z

Elias:

File:Penopt.pdf

2012-01-22T19:34:37Z

Elias:

File:Oqnlp.pdf

2012-01-22T19:34:24Z

Elias:

File:Npsol.pdf

2012-01-22T19:34:15Z

Elias:

File:Nlpql.pdf

2012-01-22T19:34:05Z

Elias:

File:Models.pdf

2012-01-22T19:33:55Z

Elias:

File:Minos.pdf

2012-01-22T19:33:45Z

Elias:

File:Minlp.pdf

2012-01-22T19:33:37Z

Elias:

File:Mad.pdf

2012-01-22T19:33:30Z

Elias:

File:Lgo.pdf

2012-01-22T19:33:20Z

Elias:

File:Knitro.pdf

2012-01-22T19:33:12Z

Elias:

File:Installation.pdf

2012-01-22T19:33:04Z

Elias:

File:Gurobi.pdf

2012-01-22T19:32:54Z

Elias:

File:Gp.pdf

2012-01-22T19:32:43Z

Elias:

File:Geno.pdf

2012-01-22T19:00:32Z

Elias:

File:Cplex.pdf

2012-01-22T18:53:16Z

Elias:

File:Conopt.pdf

2012-01-22T18:52:58Z

Elias:

File:Cgo.pdf

2012-01-22T18:52:40Z

Elias:

File:Ampl.pdf

2012-01-22T18:52:03Z

Elias:

SOL QPOPT

2012-01-22T18:27:14Z

Elias:

SQOPT

2012-01-22T18:15:28Z

Elias:

==Introduction==

TOMVIEW /SQOPT (hereafter referred to as SQOPT ) is a program for solving the large-scale ''linear or quadratic programming problem'', which is assumed to be stated in following form:

<math>
\begin{array}{cccc}
\min\limits_{x} & q(x) \\
s/t & \le \left(\begin{array}{c}x \\ Ax\end{array}\right) \le u, \\
\end{array}
</math>

where ''l ''and ''u ''are constant lower and upper bounds, and ''A ''is a sparse matrix and ''q''(''x'') is a linear or quadratic function objective function that may be specified in a variety of ways, depending upon the particular problem being solved. The optional parameter maximize may be used to specify a problem in which ''q ''is maximized instead of minimized.

Upper and lower bounds are specified for all variables and constraints. This form allows full generality in specifying various types of constraint. In particular, the ''j''th constraint may be defined as an ''equality ''by setting ''lj ''= ''uj ''. If certain bounds are not present, the associated elements of ''l ''or ''u ''may be set to special values that are treated as <math>-\infty</math> or <math>+\infty</math>.

The possible forms for the function ''q''(''x'') are summarized in [[#Table: Choices for the objective function q(x).]]. The most general form for ''q''(''x'') is
<math>
q(x) = f + \sum_{j= 1}^n c_j x_j + \frac{1}{2} \sum_{i= 1}^n\sum_{j= 1}^n x_i H_{ij} x_j = f + c^T x + \frac{1}{2} x^T H x,
</math>

where ''f ''is a constant, ''c ''is a constant ''n ''vector and ''H ''is a constant symmetric ''n × n ''matrix with elements <math>\{H_{ij}\}</math>. In this form, ''q ''is a quadratic function of ''x ''and Problem LCQP is known as a ''quadratic program ''(QP). SQOPT is suitable for all ''convex ''quadratic programs. The defining feature of a convex QP is that the matrix ''H ''must be ''positive semidefinite ''-i.e., it must satisfy ''xTHx >= ''0 for all ''x''. If not, ''q''(''x'') is nonconvex and SQOPT will terminate with the error indicator inform = 4.

====Table: Choices for the objective function ''q''(''x'').====

{|class="wikitable"
!Problem type||Objective function ''q''||Hessian matrix
|-valign="top"
|Quadratic Programming (QP)||<math>f+c^T x+\frac{1}{2} x^T Hx</math>||Symmetric positive semidefinite
|-valign="top"
|Linear Programming (LP)||<math>f+c^T x</math>||<math>H=0</math>
|-valign="top"
|Feasible Point (FP)||Not Applicable||<math>f=0</math>, <math>c=0</math>, <math>H=0</math>
|}

If ''H ''= 0, then ''q''(''x'') = ''f ''+ ''cTx ''and the problem is known as a ''linear program ''(LP).

If ''H ''= 0, ''f ''= 0, and ''c ''= 0, there is no objective function and the problem is a ''feasible point problem ''(FP), which is equivalent to finding a point that satisfies the constraints on ''x''. In the situation where no feasible point exists, several options are available for finding a point that minimizes the constraint violations (see the optional parameter Elastic option).

SQOPT is suitable for large LPs and QPs in which the matrix ''A ''is ''sparse ''-i.e., when there are sufficiently many zero elements in ''A ''to justify storing them implicitly.

SQOPT exploits structure or sparsity in ''H ''by requiring ''H ''to be defined ''implicitly ''in '''a subroutine that computes the product ''Hx ''for any given vector ''x. ''In many cases, the product ''Hx ''can be computed very efficiently for any given ''x-e.g., ''H ''may be a sparse matrix, or a sum of matrices of rank-one.

==Brief description of the method==

Here we briefly describe some features of the algorithm used in SQOPT and introduce some terminology used in the description of the subroutine and its arguments. For further details, see [[#Algorithmic Details]].

===Formulation of the problem===

The upper and lower bounds on the ''m ''components of ''Ax ''are said to define the ''general constraints ''of the problem. Internally SQOPT converts the general constraints to equalities by introducing a set of ''slack variables s'', where <math>s = (s_1,
s_2,\dots, s_m)^T</math>. For example, the linear constraint <math>5 \le 2x_1 +
3x_2 \le +\infty</math> is replaced by <math>2x_1 + 3x_2 - s_1 = 0</math> together with the bounded slack <math>5\le s_1 \le +\infty</math>. Problem LCQP can therefore be rewritten in the following equivalent form

<math>
\min_{x,s}\quad q(x)\quad \text{subject to} \quad A x - s = 0, \quad l \le \left(\begin{array}{c}x \\ s\end{array}\right) \le u.
</math>

Since the slack variables ''s ''are subject to the same upper and lower bounds as the components of ''Ax'', they allow us to think of the bounds on ''Ax ''and ''x ''as simply bounds on the combined vector (''x, s''). (In order to indicate their special role in problem QP, the original variables ''x ''are sometimes known as "column variables", and the slack variables ''s ''are known as "row variables")

Each LP or QP is solved using an ''active-set ''method. This is an iterative procedure with two phases: a ''phase 1 ''(sometimes called the ''feasibility phase ''), in which the sum of infeasibilities is minimized to find a feasible point; and a ''phase 2 ''(or ''optimality phase ''), in which ''q ''is minimized by constructing a sequence of iterations that lies within the feasible region.

Phase 1 involves solving a linear program of the form

<math>
\min{x,v,w} \ \ \ \sum_{j=1}^{n+m} v_j + w_j \quad
\text{subject to} \quad Ax - s = 0, \quad
\quad
l \le
\left(\begin{array}{c}
x\\s
\end{array}\right)
- v + w \le v,
\quad
v \ge 0, w \ge 0
</math>

which is equivalent to minimizing the sum of the constraint violations. If the constraints are feasible (i.e., at least one feasible point exists), eventually a point will be found at which both ''v ''and ''w ''are zero. The associated value of (''x, s'') satisfies the original constraints and is used as the starting point for the phase 2 iterations for minimizing ''q''.

If the constraints are infeasible (i.e., ''v ''= 0 or ''w ''= 0 at the end of phase 1), no solution exists for Problem LCQP and the user has the option of either terminating or continuing in so-called ''elastic mode ''(see the discussion of the optional parameter Elastic option). In elastic mode, a "relaxed" or "perturbed" problem is solved in which ''q''(''x'') is minimized while allowing some of the bounds to become "elastic"-i.e., to change from their specified values. Variables subject to elastic bounds are known as ''elastic variables''. An elastic variable is free to violate one or both of its original upper or lower bounds.

To make the relaxed problem meaningful, SQOPT minimizes ''q ''while (in some sense) finding the "smallest" violation of the elastic variables. In the situation where all the variables are elastic, the relaxed problem has the form

<math>
\text{Phase2}(\gamma)
</math>

<math>
\min_{x,v,w} q(x) + \gamma \sum_{j=1}^{n+m}(v_j + w_j)
</math>

<math>
\text{subject to}
Ax - s = 0, \quad l \le
\left(\begin{array}{c}
x\\s
\end{array}\right)
- v + w \le v,
\quad
v \ge 0, w \ge 0
</math>

where <math>\gamma</math> is a nonnegative parameter known as the ''elastic weight'', and <math>q(x) + \gamma\sum_j(v_j + w_j)</math> is called the ''composite'' ''objective''. In the more general situation where only a subset of the bounds are elastic, the ''v'''s and ''w'''s for the non-elastic bounds are fixed at zero.

The elastic weight can be chosen to make the composite objective behave like either the original objective ''q''(''x'') or the sum of infeasibilities. If ''γ''= 0, SQOPT will attempt to minimize ''q ''subject to the (true) upper and lower bounds on the nonelastic variables (and declare the problem infeasible if the nonelastic variables cannot be made feasible). At the other extreme, choosing ''γ'' sufficiently large, will have the effect of minimizing the sum of the violations of the elastic variables subject to the original constraints on the non-elastic variables. Choosing a large value of the elastic weight is useful for defining a "least-infeasible" point for an infeasible problem.

In phase 1 and elastic mode, all calculations involving ''v ''and ''w ''are done implicitly in the sense that an elastic variable ''xj ''is allowed to violate its lower bound (say) and an explicit value of ''v ''can be recovered as ''vj ''= ''lj - xj ''.

===The main iteration===

A constraint is said to be ''active ''or ''binding ''at ''x ''if the associated component of either ''x ''or ''Ax ''is equal to one of its upper or lower bounds. Since an active constraint in ''Ax ''has its associated slack variable at a bound, we can neatly describe the status of both simple and general upper and lower bounds in terms of the status of the variables (''x, s''). A variable is said to be ''nonbasic ''if it is temporarily fixed at its upper or lower bound. It follows that regarding a general constraint as being ''active ''is equivalent to thinking of its associated slack as being ''nonbasic''.

At each iteration of an active-set method, the constraints ''Ax - s ''= 0 are (conceptually) partitioned into the form ''BxB ''+ ''SxS ''+ ''NxN ''= 0, where ''xN ''comprises the nonbasic components of (''x, s'') and the ''basis matrix B ''is square and nonsingular. The elements of ''xB ''and ''xS ''are called the ''basic ''and ''superbasic ''variables respectively; with ''xN ''they are a permutation of the elements of ''x ''and ''s''. At a QP solution, the basic and superbasic variables will lie somewhere between their bounds, while the nonbasic variables will be equal to one of their upper or lower bounds. At each iteration, ''xS ''is regarded as a set of independent variables that are free to move in any desired direction, namely one that will improve the value of the QP objective (or sum of infeasibilities). The basis variables are then adjusted in order to ensure that (''x, s'') continues to satisfy ''Ax - s ''= 0. The number of superbasic variables (''nS'' say) therefore indicates the number of degrees of freedom remaining after the constraints have been satisfied. In broad terms, ''nS ''is a measure of ''how nonlinear ''the problem is. In particular, ''nS ''will always be zero for FP and LP problems.

If it appears that no improvement can be made with the current definition of ''B'', ''S ''and ''N '', a nonbasic variable is selected to be added to ''S'', and the process is repeated with the value of ''nS ''increased by one. At all stages, if a basic or superbasic variables encounters one of its bounds, the variable is made nonbasic and the value of ''nS ''is decreased by one.

Associated with each of the ''m ''equality constraints ''Ax - s ''= 0 is a ''dual variable πi ''. Similarly, each variable in (''x, s'') has an associated ''reduced gradient dj ''(also known as a ''reduced cost ''). The reduced gradients for the variables ''x ''are the quantities ''g - ATπ'', where ''g ''is the gradient of the QP objective; and the reduced gradients for the slacks ''s ''are the dual variables ''π''. The QP subproblem is optimal if ''dj >= ''0 for all nonbasic variables at their lower bounds, ''dj <= ''0 for all nonbasic variables at their upper bounds, and ''dj ''= 0 for all superbasic variables. In practice, an ''approximate ''QP solution is found by slightly relaxing these conditions on ''dj ''(see the Optimality tolerance described in [[#Description of the optional parameters]]).

The process of computing and comparing reduced gradients is known as ''pricing ''(a term first introduced in the context of the simplex method for linear programming). To "price" a nonbasic variable ''xj ''means that the reduced gradient ''dj ''associated with the relevant active upper or lower bound on ''xj ''is computed via the formula ''dj ''= ''gj - ajTπ'', where ''aj ''is the ''j''th column of ( ''A - I ''). (The variable selected by the price, and its corresponding value of ''dj ''(i.e., its reduced gradient) are printed in the columns marked +SBS and dj in the Print file output.) If ''A'' has significantly more columns than rows (i.e., <math>n\gg m</math>), pricing can be computationally expensive. In this case, a strategy known as ''partial pricing ''can be used to compute and compare only a subset of the ''dj '''s.

==The SPECS file==

The performance of SQOPT is controlled by a number of parameters or "options". These are normally set in ''Prob.SOL.optPar''. Each option has a default value that should be appropriate for most problems. (The defaults are given in the next section.) For special situations it is possible to specify non-standard values for some or all of the options, using data in the following general form:

<pre>
Begin SQOPT options
Iterations limit 500
Feasibility tolerance 1.0e-7
Scale all variables
End SQOPT options
</pre>

We shall call such data a SPECS file, since it specifies various options. The file starts with the keyword Begin and ends with End. The file is in free format. Each line specifies a single option, using one or more items as follows:

# A ''keyword ''(required for all options).
# A ''phrase ''(one or more words) that qualifies the keyword (only for some options).
# A ''number ''that specifies an integer or real value (only for some options). Such numbers may be up to 16 contiguous characters in Fortran 77's I, F, E or D formats, terminated by a space.

The items may be entered in upper or lower case or a mixture of both. Some of the keywords have synonyms, and certain abbreviations are allowed, as long as there is no ambiguity. Blank lines and comments may be used to improve readability. A comment begins with an asterisk (*), which may appear anywhere on a line. All subsequent characters on the line are ignored.

It may be useful to include a comment on the first (Begin) line of the file. This line is echoed to the SUMMARY file.

Most of the options described in the next section should be left at their default values for any given model. If experimentation is necessary, we recommend changing just one option at a time.

===SPECS File Checklist and Defaults===

The following example SPECS file shows all valid ''keywords ''and their ''default values''. The keywords are grouped according to the function they perform.

Some of the default values depend on ''E'', the relative precision of the machine being used. The values given here correspond to double-precision arithmetic on most current machines (''E ˜ ''2''.''22 ''× ''10''-''16 ). Similar values would apply to any machine having about 15 decimal digits of precision.

<pre>
BEGIN checklist of SPECS file parameters and their default values
* Printing
Print level 1 * 1-line iteration log
Print file 15 *
Summary file 6 * typically the screen
Print frequency 1 * iterations log on PRINT file
Summary frequency 1 * iterations log on SUMMARY file
Solution Yes * on the PRINT file
* Suppress options listing * default: options are listed

* Convergence Tolerances
Feasibility tolerance 1.0e-6 * for satisfying the simple bounds
Optimality tolerance 1.0e-6 * target value for reduced gradients

* Scaling
Scale option 2 * All constraints and variables
Scale tolerance 0.9 *
* Scale Print * default: scales are not printed

* Other Tolerances
Crash tolerance 0.1 *
LU factor tolerance 10.0 * limits size of multipliers in L
LU update tolerance 10.0 * the same during updates
LU singularity tolerance 2.0e-6 *
Pivot tolerance 3.7e-11 * ?^(2/3)

* LP/QP problems
Crash option 0 * all slack initial basis
Elastic weight 1.0 * used only during elastic mode
Iterations limit 10000 * or m if that is more
Minimize * (opposite of Maximize)
Partial price 1 * 10 for large LPs
Superbasics limit 500 * or n1+1 if that is less
Reduced Hessian dimension 500 * or Superbasics limit
Unbounded step size 1.0e+18 *

* Infeasible problems
Elastic weight 100 * used only during elastic mode
Elastic mode 1 * use elastic mode when infeasible
Elastic objective 2 * infinite weight on the elastics

* Frequencies
Check frequency 60 * test row residuals ||Ax - s||
Expand frequency 10000 * for anti-cycling procedure
Factorization frequency 100 *
Save frequency 100 * save basis map
</pre>

===Description of the optional parameters===

The following is an alphabetical list of the options that may appear in the SPECS file, and a description of their effect.

{| cellpadding="10"
|<tt>Check frequency</tt>||<tt>k</tt>||<tt>Default = 60</tt>
|}

Every ''k''th iteration after the most recent basis factorization, a numerical test is made to see if the current solution ''x ''satisfies the general constraints. The constraints are of the form ''Ax - s ''= 0, where ''s ''is the set of slack variables. To perform the numerical test, the residual vector ''r ''= ''s - Ax ''is computed. If the largest component of ''r ''is judged to be too large, the current basis is refactorized and the basic variables are recomputed to satisfy the general constraints more accurately.

Check frequency 1 is useful for debugging purposes, but otherwise this option should not be needed.

{| cellpadding="10"
|<tt>Crash option</tt>||<tt>i</tt>||<tt>Default = 0</tt>
|-
|<tt>Crash tolerance</tt>||<tt>r</tt>||<tt>Default = 0.1</tt>
|}

Except on restarts, a CRASH procedure is used to select an initial basis from certain rows and columns of the constraint matrix ( ''A - I ''). The Crash option ''i ''determines which rows and columns of ''A ''are eligible initially, and how many times CRASH is called. Columns of ''-I ''are used to pad the basis where necessary.

{|class="wikitable"
!i||Meaning
|-valign="top"
|0||The initial basis contains only slack variables: ''B ''= ''I ''.
|-valign="top"
|1||CRASH is called once, looking for a triangular basis in all rows and columns of the matrix ''A''.
|-valign="top"
|2||CRASH is called once, looking for a triangular basis in linear rows.
|-valign="top"
|3||CRASH is called twice. The two calls treat ''linear equalities ''and ''linear inequalities ''separately.
|}

If ''i >= ''1, certain slacks on inequality rows are selected for the basis first. (If ''i >= ''2, numerical values are used to exclude slacks that are close to a bound.) CRASH then makes several passes through the columns of ''A'', searching for a basis matrix that is essentially triangular. A column is assigned to "pivot" on a particular row if the column contains a suitably large element in a row that has not yet been assigned. (The pivot elements ultimately form the diagonals of the triangular basis.) For remaining unassigned rows, slack variables are inserted to complete the basis.

The Crash tolerance ''r ''allows the starting procedure CRASH to ignore certain "small" nonzeros in each column of ''A''. If ''a''max is the largest element in column ''j'', other nonzeros ''aij ''in the column are ignored if ''<nowiki>|</nowiki>aij<nowiki>|</nowiki> = a''max ''× r''. (To be meaningful, ''r ''should be in the range 0 ''<= r < ''1.)

When ''r > ''0''.''0, the basis obtained by CRASH may not be strictly triangular, but it is likely to be nonsingular and almost triangular. The intention is to obtain a starting basis containing more columns of ''A ''and fewer (arbitrary) slacks. A feasible solution may be reached sooner on some problems.

For example, suppose the first ''m ''columns of ''A'' form the matrix shown under LU factor tolerance; i.e., a tridiagonal matrix with entries ''-''1, 4, -1. To help CRASH choose all ''m ''columns for the initial basis, we would specify Crash tolerance ''r ''for some value of r > 1/4.

{| cellpadding="10"
|<tt>Elastic moden</tt>||<tt>i</tt>||<tt>Default = 1</tt>
|}

This parameter determines if (and when) elastic mode is to be started. Three elastic modes are available as follows:

{|class="wikitable"
!i||Meaning
|-
|0||Elastic mode is never invoked. SQOPT will terminate as soon as infeasibility is detected. There may be other points with significantly smaller sums of infeasibilities.
|-
|1||Elastic mode is invoked only if the constraints are found to be infeasible (the default). If the constraints are infeasible, continue in elastic mode with the composite objective determined by the values of Elastic objective and Elastic weight.
|-
|2||The iterations start and remain in elastic mode. This option allows you to minimize the composite objective function directly without first performing phase-1 iterations.

The success of this option will depend critically on your choice of Elastic weight. If Elastic weight is sufficiently large and the constraints are feasible, the minimizer of the composite objective and the solution of the original problem are identical. However, if the Elastic weight is not sufficiently large, the minimizer of the composite function may be infeasible, even though a feasible point for the constraints may exist.
|}

{| cellpadding="10"
|<tt>Elastic objective</tt>||<tt>i</tt>||<tt>Default = 2</tt>
|}

This option determines the form of the composite objective. Three types of composite objectives are available.

{|class="wikitable"
!i||Meaning
|-valign="top"
|0||Include only the true objective ''q''(''x'') in the composite objective. This option sets ''? ''= 0 in the composite objective and will allow SQOPT to ignore the elastic bounds and find a solution that minimizes ''q ''subject to the nonelastic constraints. This option is useful if there are some "soft" constraints that you would like to ignore if the constraints are infeasible.
|-valign="top"
|1||Use a composite objective defined with ''? ''determined by the value of Elastic weight. This value is intended to be used in conjunction with Elasticmode = 2.
|-valign="top"
|2||Include only the elastic variables in the composite objective. The elastics are weighted by ''? ''= 1. This choice minimizes the violations of the elastic variable at the expense of possibly increasing the true objective. This option can be used to find a point that minimizes the sum of the violations of a subset of constraints determined by the parameter helast.
|}

{| cellpadding="10"
|<tt>Elastic weight</tt>||<tt>r</tt>||<tt>Default = 1.0</tt>
|}

This keyword defines the value of γ in the composite objective.

*At each iteration of elastic mode, the composite objective is defined to be

<math>\min\ \ \sigma q(x) + r(\hbox{sum of infeasibilities}),</math>

where ''σ ''= 1 for Minimize, ''σ ''= ''-''1 for Maximize, and ''q ''is the current objective value.

*Note that the effect of ''r ''is ''not ''disabled once a feasible iterate is obtained.

{| cellpadding="10"
|<tt>Expand frequency</tt>||<tt>i</tt>||<tt>Default = 10000</tt>
|}

This option is part of the EXPAND anti-cycling procedure designed to make progress even on highly degenerate problems.

The strategy is to force a positive step at every iteration, at the expense of violating the bounds on the variables by a small amount. Suppose that the Feasibility tolerance is ''δ''. Over a period of ''i ''iterations, the tolerance actually used by SQOPT increases from 0''.''5''δ ''to ''δ ''(in steps of 0''.''5''δ/i'').

Increasing ''i ''helps reduce the number of slightly infeasible nonbasic basic variables (most of which are eliminated during a resetting procedure). However, it also diminishes the freedom to choose a large pivot element (see Pivot tolerance).

{| cellpadding="10"
|<tt>Factorization Frequency</tt>||<tt>k</tt>||<tt>Default = 100 (LP) or 50 (QP)</tt>
|}

At most ''k ''basis changes will occur between factorizations of the basis matrix.

*With linear programs, the basis factors are usually updated every iteration. The default ''k ''is reasonable for typical problems. Higher values up to ''k ''= 100 (say) may be more efficient on problems that are extremely sparse and well scaled.

*When the objective function is quadratic, fewer basis updates will occur as an optimum is approached. The number of iterations between basis factorizations will therefore increase. During these iterations a test is made regularly (according to the Check frequency) to ensure that the general constraints are satisfied. If necessary the basis will be refactorized before the limit of ''k ''updates is reached.

{| cellpadding="10"
|<tt>Feasibility tolerance</tt>||<tt>t</tt>||<tt>Default = 1.0E-6</tt>
|}

A ''feasible problem ''is one in which all variables satisfy their upper and lower bounds to within the absolute tolerance ''t''. (This includes slack variables. Hence, the general constraints are also satisfied to within ''t''.)

*SQOPT attempts to find a feasible point for the non-elastic constraints before optimizing the objective. If the sum of the infeasibilities of these constraints cannot be reduced to zero, the problem is declared INFEASIBLE. If sInf is quite small, it may be appropriate to raise ''t ''by a factor of 10 or 100. Otherwise, some error in the data should be suspected.

*Note: if sInf is not small and you have not asked SQOPT to minimize the violations of the elastic variables (i.e., you have not specified Elasticobjective = 2, there may be other points that have a ''significantly smaller sum of infeasibilities''. SQOPT will not attempt to find the solution that minimizes the sum unless Elasticobjective = 2.

*If scale is used, feasibility is defined in terms of the scaled problem (since it is then more likely to be meaningful).

{| cellpadding="10"
|<tt>Infinite Bound Size</tt>||<tt>r</tt>||<tt>Default = 1.0E + 20</tt>
|}

If ''r > ''0, ''r ''defines the "infinite" bound BigBnd in the definition of the problem constraints. Any upper bound greater than or equal to BigBnd will be regarded as plus infinity (and similarly for a lower bound less than or equal to ''-''BigBnd). If ''r <= ''0, the default value is used.

{| cellpadding="10"
|<tt>Iterations Limit</tt>||<tt>k</tt>||<tt>Default = 3 * m</tt>
|}

This is the maximum number of iterations of the simplex method or the QP reduced-gradient algorithm allowed.

*Itns is an alternative keyword.

*''k'' = 0 is valid. Both feasibility and optimality are checked.

{| cellpadding="10"
|<tt>Log Frequency</tt>||<tt>k</tt>||<tt>Default = 1</tt>
|}
see Print Frequency

{| cellpadding="10"
|<tt>LU factor tolerance</tt>||<tt>r1</tt>||<tt>Default = 100.0</tt>
|-
|<tt>LU update tolerance</tt>||<tt>r2</tt>||<tt>Default = 10.0</tt>
|}

These tolerances affect the stability and sparsity of the basis factorization ''B ''= ''LU ''during refactorization and updating, respectively. They must satisfy ''r''1 , ''r''2 ''>= 1.0. The matrix ''L ''is a product of matrices of the form

<math>
\left(\begin{array}{cc}
1 \\ \mu & \ 1
\end{array}\right),
</math>

where the multipliers <math>\mu</math> satisfy <math>|\mu| \le r_i</math>. Smaller values of <math>r_i</math> favor stability, while larger values favor sparsity. The default values usually strike a good compromise.

*For large and relatively dense problems, ''r''1 = 10''.''0 or 5.0 (say) may give a useful improvement in stability without impairing sparsity to a serious degree.

*For certain very regular structures (e.g., band matrices) it may be necessary to reduce ''r''1 and/or ''r''2 in order to achieve stability. For example, if the columns of ''A ''include a submatrix of the form

<math>
\left(\begin{array}{rrrrrr}
4 & -1 \\
-1 & 4 & -1 \\
& -1 & 4 & -1 \\
& & \ddots& \ddots& \ddots\\
& & & -1 & 4 & -1 \\
& & & & -1 & 4
\end{array}\right),
</math>

one should set both ''r''1 and ''r''2 to values in the range 1.0 <= ri < 4.0.

{| cellpadding="10"
|<tt>LU singularity tolerance</tt>||<tt>r3</tt>||<tt>Default = ε2/3</tt>
|}

This tolerance should satisfy <math>r_3 \le \epsilon^{1/4} \approx 10^{-4}</math>. It helps guard against ill-conditioned basis matrices. When the ''LU'' factors of ''B ''are computed directly (not updated), the diagonal elements of ''U ''are tested as follows: if <math>|U_{jj}| \le r_3</math> or <math>|U_{jj}| < r_3 \max_i |U_{ij}|</math>, the ''j''-th column of the basis is replaced by the corresponding slack variable. (Replacements are rare because the ''LU ''updating method is stable. They are most likely to occur during the first factorization.)

{| cellpadding="10"
|<tt>LU density tolerance</tt>||<tt>r1</tt>||<tt>Default = 0.6</tt>
|-
|<tt>LU singularity tolerance</tt>||<tt>r2</tt>||<tt>Default = <math>\epsilon^{2/3}\approx 10^{-11}</math></tt>
|}

The density tolerance ''r''1 is used during ''LU ''factorization of the basis matrix. Columns of ''L ''and rows of ''U ''are formed one at a time, and the remaining rows and columns of the basis are altered appropriately. At any stage, if the density of the remaining matrix exceeds ''r''1, the Markowitz strategy for choosing pivots is altered to reduce the time spent searching for each remaining pivot. Raising the density tolerance towards 1.0 may give slightly sparser ''LU ''factors, with a slight increase in factorization time.

The singularity tolerance ''r''2 helps guard against ill-conditioned basis matrices. When the basis is refactorized, the diagonal elements of ''U ''are tested as follows: if <math>|U_{jj}| \le r_2</math> or <math>|U_{jj}| < r_2 \max_i |U_{ij}|</math>, the ''j''th column of the basis is replaced by the corresponding slack variable. (This is most likely to occur after a restart, or at the start of a major iteration.)

{| cellpadding="10"
|<tt>Minimize</tt>||||<tt>Default</tt>
|-
|<tt>Maximize</tt>
|}

This specifies the required direction of optimization. It applies to both linear and quadratic terms in the objective.

{| cellpadding="10"
|<tt>Optimality tolerance</tt>||<tt>t</tt>||<tt>Default = 1.0e-6</tt>
|}

This is used to judge the size of the reduced gradients ''dj'' = ''gj - πTaj '', where ''gj'' is the ''j''th component of the gradient, ''aj'' is the associated column of the constraint matrix ''tmatA-I'', and ''π ''is the set of dual variables.

*By construction, the reduced gradients for basic variables are always zero. The problem will be declared optimal if the reduced gradients for nonbasic variables at their lower or upper bounds satisfy

<math>
d_j / ||{ \pi }|| \ge -t \quad \text{or} \quad
d_j / ||{ \pi }|| \le t
</math>

respectively, and if <math>\mod{d_j} / ||{ \pi }|| \le t</math> for superbasic variables.

*In the above tests, ''p ''is a measure of the size of the dual variables. It is included to make the tests independent of a scale factor on the objective function.

*The quantity ''p ''actually used is defined by

<math>
||{\pi}|| = \max\{\sigma / \sqrt{m}, 1\}, \text{where}
\sigma = \sum_{i=1}^m \mod{\pi_i},
</math>

so that only ''large ''scale factors are allowed for.

*If the objective is scaled down to be very ''small'', the optimality test reduces to comparing ''dj'' against 0.01t.

{| cellpadding="10"
|<tt>Partial Price</tt>||<tt>i</tt>||<tt>Default = 10 (LP) or 1 (QP)</tt>
|}

This parameter is recommended for large problems that have significantly more variables than constraints. It reduces the work required for each "pricing" operation (when a nonbasic variable is selected to become superbasic).

* When ''i ''= 1, all columns of the constraint matrix ( ''A - I '') are searched.

* Otherwise, ''A ''and ''I ''are partitioned to give ''i ''roughly equal segments ''Aj '', ''Ij ''(''j ''= 1 to ''i''). If the previous pricing search was successful on ''Aj '', ''Ij '', the next search begins on the segments ''Aj''+1 , ''Ij''+1 . (All subscripts here are modulo ''i''.)

*If a reduced gradient is found that is larger than some dynamic tolerance, the variable with the largest such reduced gradient (of appropriate sign) is selected to become superbasic. If nothing is found, the search continues on the next segments ''Aj''+2 , ''Ij''+2 , and so on.

*Partial price ''t ''(or ''t/''2 or ''t/''3) may be appropriate for time-stage models having ''t ''time periods.

{| cellpadding="10"
|<tt>Pivot Tolerance</tt>||<tt>r</tt>||<tt>Default = <math>\epsilon^{2/3}</math>/tt>
|}

Broadly speaking, the pivot tolerance is used to prevent columns entering the basis if they would cause the basis to become almost singular.

*When ''x ''changes to ''x ''+ ''αp ''for some search direction ''p'', a "ratio test" is used to determine which component of ''x ''reaches an upper or lower bound first. The corresponding element of ''p ''is called the pivot element.

*For linear problems, elements of ''p ''are ignored (and therefore cannot be pivot elements) if they are smaller than the pivot tolerance ''r''.

*It is common for two or more variables to reach a bound at essentially the same time. In such cases, the Feasibility tolerance (say ''t'') provides some freedom to maximize the pivot element and thereby improve numerical stability. Excessively small values of ''t ''should therefore not be specified.

*To a lesser extent, the Expand frequency (say ''f '') also provides some freedom to maximize the pivot element. Excessively ''large ''values of ''f ''should therefore not be specified.

{| cellpadding="10"
|<tt>Print frequency</tt>||<tt>k</tt>||<tt>Default = 1</tt>
|}

One line of the iteration log will be printed every ''k''th iteration. A value such as ''k ''= 10 is suggested for those interested only in the final solution.

{| cellpadding="10"
|<tt>Print level</tt>||<tt>k</tt>||<tt>Default = 1</tt>
|}

This controls the amount of printing produced by SQOPT as follows.

{|class="wikitable"
|0||No output except error messages. If you want to suppress all output, set Printfile = 0.
|-valign="top"
|''>= ''1||The set of selected options (including workspace limits), problem statistics, summary of the scaling procedure, information about the initial basis resulting from a CRASH or a BASIS file. A single line of output each iteration (controlled by Print frequency), and the exit condition with a summary of the final solution.
|-valign="top"
|''>= ''10||Basis factorization statistics.
|}

{| cellpadding="10"
|<tt>Save frequency</tt>||<tt>k</tt>||<tt>Default = 100</tt>
|}

If a NEW BASIS file has been specified, a basis map describing the current solution will be saved on the appropriate file every ''k''th iteration. A BACKUP BASIS file will also be saved if specified.

{| cellpadding="10"
|<tt>Scale option</tt>||<tt>i</tt>||<tt>Default = 2 (LP) or 1 (QP)</tt>
|-
|<tt>Scale tolerance</tt>||<tt>r</tt>||<tt>Default = 0.9</tt>
|-
|<tt>Scale Print</tt>
|}

Three scale options are available as follows:

{|class="wikitable"
!i||Meaning
|-valign="top"
|0||No scaling. This is recommended if it is known that ''x ''and the constraint matrix never have very large elements (say, larger than 1000).
|-valign="top"
|1||The constraints and variables are scaled by an iterative procedure that attempts to make the matrix coef- ficients as close as possible to 1.0. This will sometimes improve the performance of the solution procedures.
|-valign="top"
|2||The constraints and variables are scaled by the iterative procedure. Also, a certain additional scaling is performed that may be helpful if the right-hand side ''b ''or the solution ''x ''is large. This takes into account columns of ( ''A - I '') that are fixed or have positive lower bounds or negative upper bounds.
|}

Scale tolerance affects how many passes might be needed through the constraint matrix. On each pass, the scaling procedure computes the ratio of the largest and smallest nonzero coefficients in each column:

<math>
rho_j = \max_{i} |a_{ij}| / \min_i |a_{ij}| \qquad (a_{ij}\ne 0).
</math>

If maxj pj is less than ''r ''times its previous value, another scaling pass is performed to adjust the row and column scales. Raising ''r ''from 0.9 to 0.99 (say) usually increases the number of scaling passes through ''A''. At most 10 passes are made.

Scale Print causes the row-scales ''r''(''i'') and column-scales ''c''(''j'') to be printed. The scaled matrix coefficients are <math>\bar{ij} = a_{ij} c(j) / r(i)</math>, and the scaled bounds on the variables and slacks are <math>\bar{j} = l_j / c(j),\ \bar{j} = u_j / c(j)</math> where <math>c(j) \equiv r(j-n)</math> if <math>j>n</math>.

{| cellpadding="10"
|<tt>Solution </tt>||<tt>Yes</tt>
|-
|<tt>Solution</tt>||<tt>No</tt>
|-
|<tt>Solution</tt>||<tt>If Optimal, Infeasible, or Unbounded</tt>
|}

{| cellpadding="10"
|<tt>Summary file</tt>||<tt>f</tt>||<tt>Default = 6</tt>
|-
|<tt>Summary frequency</tt>||<tt>k</tt>||<tt>Default = 100/tt>
|}

If ''f > ''0, a brief log will be output to file ''f '', including one line of information every ''k''th iteration. In an interactive environment, it is useful to direct this output to the terminal, to allow a run to be monitored on-line. (If something looks wrong, the run can be manually terminated.) Further details are given in [[#The Summary File]].

{| cellpadding="10"
|<tt>Superbasics limit</tt>||<tt>i</tt>||<tt>Default = min''{''500'', n''1 + 1''}''</tt>
|-
|<tt>Summary frequency</tt>||<tt>k</tt>||<tt>Default = 100</tt>
|}

This places a limit on the storage allocated for superbasic variables. Ideally, ''i ''should be set slightly larger than the "number of degrees of freedom" expected at an optimal solution.

For linear programs, an optimum is normally a basic solution with no degrees of freedom. (The number of variables lying strictly between their bounds is no more than ''m'', the number of general constraints.) The default value of ''i ''is therefore 1.

For quadratic problems, the number of degrees of freedom is often called the "number of independent variables".

*Normally, ''i ''need not be greater than ncolH + 1, where ncolH is the number of leading nonzero columns of ''H ''.

*For many problems, ''i ''may be considerably smaller than ncolH. This will save storage if ncolH is very large.

*This parameter also sets the Reduced Hessian dimension, unless the latter is specified explicitly (and conversely).

{| cellpadding="10"
|<tt>Unbounded Step Size</tt>||<tt>''a''max</tt>||<tt>Default = 1.0E + 18</tt>
|}

This parameter is intended to detect unboundedness in a quadratic problem. (It may or may not achieve that purpose!) During a line search, ''q ''is evaluated at points of the form ''x ''+ ''αp'', where ''x ''and ''p ''are fixed and ''α ''varies. if ''a ''exceeds ''α''max, iterations are terminated with the exit message problem is unbounded.

Note that unboundedness in ''x ''is best avoided by placing finite upper and lower bounds on the variables.

==File Output==

The following information is output to the PRINT file during the solution of each problem referred to in the SPECS file.

*A listing of the relevant part of the SPECS file.

*A listing of the parameters that were or could have been set in the SPECS file.

*An estimate of the amount of working storage needed, compared to how much is available.

*Some statistics about the problem.

*The amount of storage available for the ''LU ''factorization of the basis matrix.

*A summary of the scaling procedure, if Scale was specified.

*Notes about the initial basis resulting from a CRASH procedure or a BASIS file.

*The iteration log.

*Basis factorization statistics.

*The EXIT condition and some statistics about the solution obtained.

*The printed solution, if requested.

The last four items are described in the following sections. Further brief output may be directed to the SUMMARY file, as discussed in [[#The Summary File]].

===The iteration Log===

If Printlevel ''> ''0, one line of information is output to the PRINT file every ''k''th iteration, where ''k ''is the specified Print frequency (default ''k ''= 1). A heading is printed before the first such line following a basis factorization. The heading contains the items described below. In this description, a PRICE operation is defined to be the process by which one or more nonbasic variables are selected to become superbasic (in addition to those already in the superbasic set). The variable selected will be denoted by jq. If the problem is purely linear, variable jq will usually become basic immediately (unless it should happen to reach its opposite bound and return to the nonbasic set).

If Partial price is in effect, variable jq is selected from ''A''pp or ''I''pp , the ppth segments of the constraint matrix (''A - I '').

{|class="wikitable"
!Label||Description
|-valign="top"
|Itn||The current iteration number.
|-valign="top"
|pp||The Partial Price indicator. The variable selected by the last PRICE operation came from the ppth partition of ''A ''and ''-I ''. pp is set to zero when the basis is refactored.
|-valign="top"
|dj||This is dj, the reduced cost (or reduced gradient) of the variable jq selected by PRICE at the start of the present iteration. Algebraically, dj is <math>d_j=g_j - \pi^T a_ j</math>, where ''gj'' is the gradient of the current objective function, ''π ''is the vector of dual variables, and ''aj ''is the ''j''th column of the constraint matrix (''A - I '').

Note that dj is the norm of the reduced-gradient vector at the start of the iteration, just after the PRICE operation.
|-valign="top"
|<nowiki>+</nowiki>SBS ||The variable jq selected by PRICE to be added to the superbasic set.
|-valign="top"
|<nowiki>-</nowiki>SBS||The variable chosen to leave the set of superbasics. It has become basic if the entry under -B is nonzero; otherwise it has become nonbasic.
|-valign="top"
|<nowiki>-</nowiki>BS||The variable removed from the basis (if any) to become nonbasic.
|-valign="top"
|<nowiki>-</nowiki>B||The variable removed from the basis (if any) to swap with a slack variable made superbasic by the latest PRICE. The swap is done to ensure that there are no superbasic slacks.
|-valign="top"
|Step||The step length ''a ''taken along the current search direction ''p''. The variables ''x ''have just been changed to ''x ''+ ''αp''. If a variable is made superbasic during the current iteration (i.e., +SBS is positive), Step will be the step to the nearest bound. During phase 2, the step can be greater than one only if the reduced Hessian is not positive definite.
|-valign="top"
|Pivot||If column ''aq ''replaces the ''r''th column of the basis ''B'', Pivot is the ''r''th element of a vector ''y ''satisfying ''By ''= ''aq ''. Wherever possible, Step is chosen to avoid extremely small values of Pivot (since they cause the basis to be nearly singular). In rare cases, it may be necessary to increase the Pivot tolerance to exclude very small elements of ''y ''from consideration during the computation of Step.
|-valign="top"
|L||The number of nonzeros representing the basis factor ''L''. Immediately after a basis factorization ''B ''= ''LU '', this is lenL, the number of subdiagonal elements in the columns of a lower triangular matrix. Further nonzeros are added to L when various columns of ''B ''are later replaced. (Thus, L increases monotonically.)
|-valign="top"
|U||The number of nonzeros in the basis factor ''U ''. Immediately after a basis factorization, this is lenU, the number of diagonal and superdiagonal elements in the rows of an upper-triangular matrix. As columns of ''B ''are replaced, the matrix ''U ''is maintained explicitly (in sparse form). The value of U may fluctuate up or down; in general it will tend to increase.
|-valign="top"
|ncp||The number of compressions required to recover storage in the data structure for ''U ''. This includes the number of compressions needed during the previous basis factorization. Normally ncp should increase very slowly. If not, the amount of integer and real workspace available to SQOPT should be increased by a significant amount. As a suggestion, the work arrays iw(*) and rw(*) should be extended by L + U elements.
|-valign="top"
|nInf||The number of infeasibilities ''before ''the present iteration. This number will not increase unless the iterations are in elastic mode.
|-valign="top"
|Sinf,Objective||If nInf ''> ''0, this is sInf, the sum of infeasibilities before the present iteration. (It will usually decrease at each nonzero Step, but if nInf decreases by 2 or more, sInf may occasionally increase. However, in elastic mode, it will decrease monotonically.)

Otherwise, it is the value of the current objective function ''after ''the present iteration. Note: If Elasticmode = 2, the heading is Composite Obj.
|-valign="top"
|colspan="2"|The following items are printed if the problem is a QP or if the superbasic set is non-empty (i.e., if the current solution is nonbasic).
|-valign="top"
|Norm rg||This quantity is rg, the norm of the reduced-gradient vector at the start of the iteration. (It is the Euclidean norm of the vector with elements ''dj ''for variables ''j ''in the superbasic set. During phase 2 this norm will be approximately zero after a unit step.
|-valign="top"
|nS||The current number of superbasic variables.
|-valign="top"
|Cond Hz||An estimate of the condition number of the reduced Hessian. It is the square of the ratio of the largest and smallest diagonals of the upper triangular matrix ''R''. This constitutes a lower bound on the condition number of the reduced Hessian ''RTR''.

To guard against high values of cond Hz, attention should be given to the scaling of the variables and the constraints.
|}

===Basis Factorization Statistics===

When PrintLevel ''= ''20 and Printfile ''> ''0, the following lines of intermediate printout (''< ''120 characters) are produced on the unit number specified by Print file whenever the matrix ''B ''or ''BS ''= (''B S '')''T ''is factorized. Gaussian elimination is used to compute an ''LU ''factorization of ''B ''or ''BS '', where ''PLPT ''is a lower triangular matrix and ''PUQ''is an upper triangular matrix for some permutation matrices ''P ''and ''Q''. This factorization is stabilized in the manner described under LU factor tolerance in [[#Description of the optional parameters]].

{|class="wikitable"
!Label||Description
|-valign="top"
|Factorize||The number of factorizations since the start of the run.
|-valign="top"
|Demand||A code giving the reason for the present factorization.

{|
!Code||Meaning
|-valign="top"
|0||First ''LU ''factorization.
|-valign="top"
|1||Number of updates reached the value of the optional parameter Factorization Frequency.
|-valign="top"
|2||Excessive non-zeros in updated factors.
|-valign="top"
|7||Not enough storage to update factors.
|-valign="top"
|10||Row residuals too large (see the description for Check Frequency).
|-valign="top"
|11||Ill-conditioning has caused inconsistent results.
|}
|-valign="top"
|Iteration||The current iteration number.
|-valign="top"
|Infeas||The number of infeasibilities at the ''start ''of the previous iteration.
|-valign="top"
|Objective|| If Infeas ''> ''0, this is the sum of infeasibilities at the start of the previous iteration.

If Infeas = 0, this is the value of the objective function ''after ''the previous iteration.
|-valign="top"
|Nonlinear||The number of nonlinear variables in the current basis ''B''. (not printed if ''BS ''is factorized). Linear The number of linear variables in ''B''. (not printed if ''BS ''is factorized).
|-valign="top"
|Slacks||The number of slack variables in ''B''. (not printed if ''BS ''is factorized).
|-valign="top"
|Elems||The number of nonzero matrix elements in ''B''. (not printed if ''BS ''is factorized).
|-valign="top"
|Density||The percentage nonzero density of ''B'', 100 ''× ''Elems''/''(m ''× ''m), where m is the number of rows in the problem (m = Linear + Slacks).
|-valign="top"
|Comprssns||The number of times the data structure holding the partially factored matrix needed to be compressed, to recover unused storage. Ideally this number should be zero. If it is more than 3 or 4, the amount of workspace available to SQOPT should be increased for efficiency.
|-valign="top"
|Merit||The average Markowitz merit count for the elements chosen to be the diagonals of ''P U Q''. Each merit count is defined to be (''c - ''1)(''r - ''1) where ''c ''and ''r ''are the number of nonzeros in the column and row containing the element at the time it is selected to be the next diagonal. Merit is the average of m such quantities. It gives an indication of how much work was required to preserve sparsity during the factorization.
|-valign="top"
|lenL||The number of nonzeros in ''L''. On most machines, each nonzero is represented by one eight-byte REAL and two two-byte integer data types.
|-valign="top"
|lenU||The number of nonzeros in ''U ''. The storage required for each nonzero is the same as for the nonzeros of ''L''.
|-
|Increase||The percentage increase in the number of nonzeros in ''L ''and ''U ''relative to the number of nonzeros in ''B''; i.e., 100 ''× ''(lenL + lenU ''- ''Elems)''/''Elems.
|-valign="top"
|m||is the number of rows in the problem. Note that m = Ut + Lt + bp.
|-valign="top"
|Ut||is the number of triangular rows of ''B ''at the top of ''U ''.
|-valign="top"
|d1||is the number of columns remaining when the density of the basis matrix being factorized reached 0.3.
|-valign="top"
|Lmax||The maximum subdiagonal element in the columns of ''L''. This will be no larger than the LU factor tolerance.
|-valign="top"
|Bmax||The maximum nonzero element in ''B''.
|-valign="top"
|Umax||The maximum nonzero element in ''U '', excluding elements of ''B ''that remain in ''U ''unaltered. (For example, if a slack variable is in the basis, the corresponding row of ''B ''will become a row of ''U ''without alteration. Elements in such rows will not contribute to Umax. If the basis is strictly triangular, ''none ''of the elements of ''B ''will contribute, and Umax will be zero.)

Ideally, Umax should not be substantially larger than Bmax. If it is several orders of magnitude larger, it may be advisable to reduce the LU factor tolerance to some value nearer 1.0. (The default value is 10.0.)
|-valign="top"
|Umax||is not printed if ''BS ''is factorized.
|-valign="top"
|Umin||The smallest ''diagonal ''element of ''P U Q ''in absolute magnitude.
|-valign="top"
|Growth||The ratio Umax''/''Bmax, which should not be too large (see above).

As long as Lmax is not large (say 10.0 or less), the ratio max''{''Bmax'', ''Umax''} ''/ Umin gives an estimate of the condition number of ''B''. If this number is extremely large, the basis is nearly singular and some numerical difficulties could conceivably occur. (However, an effort is made to avoid near-singularity by using slacks to replace columns of ''B ''that would have made Umin extremely small. Messages are issued to this effect, and the modified basis is refactored.)
|-valign="top"
|Lt||is the number of triangular columns of ''B ''at the beginning of ''L''.
|-valign="top"
|bp||is the size of the "bump" or block to be factorized nontrivially after the triangular rows and columns have been removed.
|-valign="top"
|d2||is the number of columns remaining when the density of the basis matrix being factorized reached 0.6.
|}

===Crash statistics===

When PrintLevel ''= ''20 and Printfile ''> ''0, the following CRASH statistics (''< ''120 characters) are produced on the unit number specified by Print file whenever Start = 'Cold', see [[#Description of the optional parameters]]. They refer to the number of columns selected by the CRASH procedure during each of several passes through ''A'', whilst searching for a triangular basis matrix.

{|class="wikitable"
!Label||Description
|-colspan="2"
|Slacks||is the number of slacks selected initially.
|-colspan="2"
|Free cols||is the number of free columns in the basis.
|-colspan="2"
|Preferred||is the number of "preferred" columns in the basis (i.e., hs(''j'') = 3 for some ''j = n'').
|-colspan="2"
|Unit||is the number of unit columns in the basis.
|-colspan="2"
|Double||is the number of double columns in the basis.
|-colspan="2"
|Triangle||is the number of triangular columns in the basis.
|-colspan="2"
|Pad||is the number of slacks used to pad the basis.
|}

===EXIT conditions===

For each problem in the SPECS file, a message of the form EXIT -- message is printed to summarize the final result. Here we describe each message and suggest possible courses of action.

A number is associated with each message below. It is the final value assigned to the integer variable inform.

'''The following messages arise when the SPECS file is found to contain no further problems.'''

<pre>
-2. EXIT -- input error.
</pre>

Otherwise, the SPECS file may be empty, or cards containing the keywords Skip or Endrun may imply that all problems should be ignored (see [[#the SPECS File]]).

<pre>
-1. ENDRUN
</pre>

This message is printed at the end of a run if SQOPT terminates of its own accord. Otherwise, the operating system will have intervened for one of many possible reasons (excess time, missing file, arithmetic error in the user routine, etc.).

'''The following messages arise when optimization terminates gracefully.'''

<pre>
0. EXIT -- optimal solution found
</pre>

The final point seems to be a unique solution of LCQP. This means that x is ''feasible ''(it satisfies the constraints to the accuracy requested by the Feasibility tolerance), the reduced gradient is negligible, the reduced costs are optimal, and ''R ''is nonsingular.

<pre>
1. EXIT -- the problem is infeasible
</pre>

Feasibility is measured with respect to the upper and lower bounds on the variables. The message tells us that among all the points satisfying the general constraints ''Ax - s ''= 0, there is apparently no point that satisfies the bounds on ''x ''and ''s''. Violations as small as the Feasibility tolerance are ignored, but at least one component of ''x ''or ''s ''violates a bound by more than the tolerance.

''Note:'' Although the objective function is the sum of infeasibilities (when nInf ''> ''0), this sum will usually not have been ''minimized ''when SQOPT recognizes the situation and exits. There may exist other points that have a significantly lower sum of infeasibilities.

<pre>
2. EXIT -- the problem is unbounded (or badly scaled)
</pre>

For linear problems, unboundedness is detected by the simplex method when a nonbasic variable can apparently be increased or decreased by an arbitrary amount without causing a basic variable to violate a bound. A message prior to the EXIT message will give the index of the nonbasic variable. Consider adding an upper or lower bound to the variable. Also, examine the constraints that have nonzeros in the associated column, to see if they have been formulated as intended.

Very rarely, the scaling of the problem could be so poor that numerical error will give an erroneous indication of unboundedness. Consider using the Scale option.

<pre>
3. EXIT -- iteration limit exceeded
</pre>

The Iterations limit was exceeded before the required solution could be found. Check the iteration log to be sure that progress was being made. If so, restart the run using a basis file that was saved (or ''should ''have been saved!) at the end of the run.

<pre>
4. EXIT -- QP Hessian appears to be indefinite
</pre>

The problem appears to be nonconvex and cannot be solved using this version of SQOPT. The matrix ''H ''cannot be positive semidefinite, i.e., there must exist a vector ''y ''such that ''yT H y < ''0.

<pre>
5. EXIT -- the superbasics limit is too small: nnn
</pre>

The problem appears to be more nonlinear than anticipated. The current set of basic and superbasic variables have been optimized as much as possible and a PRICE operation is necessary to continue, but there are already nnn superbasics (and no room for any more).

In general, raise the Superbasics limit ''s ''by a reasonable amount, bearing in mind the storage needed for the reduced Hessian. (The Hessian dimension ''h ''will also increase to ''s ''unless specified otherwise, and the associated storage will be about 1 ''s''2 words.) In extreme cases you may have to set ''h < s ''to conserve storage, but beware that the rate of convergence will probably fall off severely.

<pre>
6. EXIT -- weak solution found
</pre>

The final point is a ''weak minimizer''. (The objective value is a global optimum, but it may be achieved by an infinite set of points ''x''.)

This exit will occur when (i) the problem is feasible, (ii) the reduced gradient is negligible, (iii) the Lagrange multipliers are optimal, and (iv) the reduced Hessian is singular or there are some very small multipliers. This exit cannot occur if ''H ''is positive definite (i.e., ''q''(''x'') is strictly convex).

<pre>
10. EXIT -- cannot satisfy the general constraints
</pre>

An ''LU ''factorization of the basis has just been obtained and used to recompute the basic variables ''xB '', given the present values of the superbasic and nonbasic variables. A single step of "iterative refinement" has also been applied to increase the accuracy of ''xB ''. However, a row check has revealed that the resulting solution does not satisfy the current constraints ''Ax - s ''= 0 sufficiently well.

This probably means that the current basis is very ill-conditioned. Request the Scale option if there are any linear constraints and variables.

For certain highly structured basis matrices (notably those with band structure), a systematic growth may occur in the factor ''U ''. Consult the description of Umax, Umin and Growth in [[Basis Factorization Statistics, and set the LU factor tolerance to 2.0 (or possibly even smaller, but not less than 1.0).

'''If the following exits occur during the ''first ''basis factorization, the basic variables ''xB ''will have certain default values that may not be particularly meaningful, and the dual vector ''π ''will be zero.'''

<pre>
20. EXIT -- not enough integer/real storage for the basis factors
</pre>

An estimate of the additional storage required is given in messages preceding the exit.

<pre>
21. EXIT -- error in basis package
</pre>

A preceding message will describe the error in more detail. One such message says that the current basis has more than one element in row ''i ''and column ''j''.

<pre>
22. EXIT -- singular basis after nnn factorization attempts
</pre>

This exit is highly unlikely to occur. The first factorization attempt will have found the basis to be structurally or numerically singular. (Some diagonals of the triangular matrix ''PUQ ''were respectively zero or smaller than a certain tolerance.) The associated variables are replaced by slacks and the modified basis is refactorized. The ensuing singularity must mean that the problem is badly scaled, or the LU factor tolerance is too high.

<pre>
32. EXIT -- system error. Wrong no. of basic variables: nnn
</pre>

This exit should never happen. If it does, something is seriously awry in the SQOPT source code.

'''The following messages arise if additional storage is needed to allow optimization to begin. The problem is abandoned.'''

<pre>
42. EXIT -- not enough 8-character storage to start solving the problem
</pre>

<pre>
43. EXIT -- not enough integer storage to start solving the problem
</pre>

<pre>
44. EXIT -- not enough real storage to start solving the problem
</pre>

==Solution Output==

At the end of a run, the final solution will be output to the PRINT file. Some header information appears first to identify the problem and the final state of the optimization procedure. A ROWS section and a COLUMNS section then follow, giving one line of information for each row and column. The format used is similar to that seen in commercial systems, though there is no rigid industry standard.

===The ROWS section===

The general constraints take the form <math>l \le Ax \le u</math>. The ''i''th constraint is therefore of the form

<math>
\alpha \le a^T x \le \beta.
</math>

''Internally'', the constraints take the form ''Ax - s ''= 0, where ''s ''is the set of slack variables (which happen to satisfy the bounds <math>l \le s \le u</math>). For the ''i''th constraint it is the slack variable ''si ''that is directly available, and it is sometimes convenient to refer to its state. To reduce clutter, a "''·''" is printed for any numerical value that is exactly zero.

{|class="wikitable"
!Label||Description
|-valign="top"
|Number||The value ''n ''+ ''i''. This is the internal number used to refer to the ''i''th slack in the iteration log.
|-valign="top"
|Row||The name of the ''i''th row.
|-valign="top"
|State||The state of the ''i''th row relative to the bounds ''α'' and ''β''. The various states possible are as follows.

{|class="wikitable"
|LL||The row is at its lower limit, ''α''.
|-valign="top"
|UL||The row is at its upper limit, ''β''.
|-valign="top"
|EQ||The lower and upper limit are the same, ''α''= ''β''.
|-valign="top"
|BS||The constraint is not binding. ''si ''is basic.
|-valign="top"
|SBS||The constraint is not binding. ''si ''is superbasic.
|}

A key is sometimes printed before the State to give some additional information about the state of the slack variable.

{|class="wikitable"
|-valign="top"
|A||''Alternative optimum possible''. The slack is nonbasic, but its reduced gradient is essentially zero. This means that if the slack were allowed to start moving away from its bound, there would be no change in the value of the objective function. The values of the basic and superbasic variables ''might ''change, giving a genuine alternative solution. However, if there are any degenerate variables (labelled D), the actual change might prove to be zero, since one of them could encounter a bound immediately. In either case, the values of dual variables ''might ''also change.
|-valign="top"
|D||''Degenerate''. The slack is basic or superbasic, but it is equal to (or very close to) one of its bounds.
|-valign="top"
|I||''Infeasible''. The slack is basic or superbasic and it is currently violating one of its bounds by more than the Feasibility tolerance.
|-valign="top"
|N||''Not precisely optimal''. The slack is nonbasic or superbasic. If the Optimality tolerance were tightened by a factor of 10 (e.g., if it were reduced from 10''-''5 to 10''-''6 ), the solution would not be declared optimal because the reduced gradient for the slack would not be considered negligible. (If a loose tolerance has been used, or if the run was terminated before optimality, this key might be helpful in deciding whether or not to restart the run.)

''Note: ''If Scale is specified, the tests for assigning the A, D, I, N keys are made on the scaled problem, since the keys are then more likely to be correct.
|-valign="top"
|Activity||The row value; i.e., the value of ''aTx''.
|-valign="top"
|Slack activity||The amount by which the row differs from its nearest bound. (For free rows, it is taken to be minus the Activity.)
|-valign="top"
|Lower limit ''α''||the lower bound on the row.
|-valign="top"
|Upper limit ''β''||the upper bound on the row.
|-valign="top"
|Dual activity||The value of the dual variable ''pi '', often called the shadow price (or simplex multiplier) for the ''i''th constraint. The full vector ''p ''always satisfies ''BTp ''= ''gB '', where ''B ''is the current basis matrix and ''gB ''contains the associated gradients for the current objective function.
|-valign="top"
|I||The constraint number, ''i''.
|}
|}

===The COLUMNS section===

Here we talk about the "column variables" ''x''. For convenience we let the ''j''th component of ''x ''be the variable ''xj'' and assume that it satisfies the bounds ''a = xj = β''. A "''·''" is printed for any numerical value that is exactly zero.

{|class="wikitable"
!Label||Description
|-valign="top"
|Number||The column number, ''j''. This is the internal number used to refer to ''xj ''in the iteration log.
|-valign="top"
|Column||The name of ''xj ''.
|-valign="top"
|State||The state of ''xj ''relative to the bounds ''α ''and ''β''. The various states possible are as follows.
|-valign="top"
LL ''xj ''is nonbasic at its lower limit, ''α''.
|-valign="top"
UL ''xj ''is nonbasic at its upper limit, ''β''.
|-valign="top"
EQ ''xj ''is nonbasic and fixed at the value ''α ''= ''β''.
|-valign="top"
FR ''xj ''is nonbasic and currently zero, even though it is free to take any value. (Its bounds are ''α ''= ''-8, β ''= +''8''. Such variables are normally basic.)
|-valign="top"
BS ''xj ''is basic.
|-valign="top"
SBS ''xj ''is superbasic.
|}

A key is sometimes printed before the State to give some additional information about the state of ''xj ''. The possible keys are A, D, I and N. They have the same meaning as described above (for the ROWS section of the solution), but the words "the slack" should be replaced by "''xj ''".
|-valign="top"
|Activity||The value of the variable ''xj ''.
|-valign="top"
|Obj Gradient||''gj '', the ''j''th component of the linear and quadratic objective function ''q''(''x'') + ''cTx''. (We define ''gj ''= 0 if the current solution is infeasible.)
|-valign="top"
|Lower limit||''α'', the lower bound on ''xj ''.
|-valign="top"
|Upper limit ''β''||the upper bound on ''xj ''.
|-valign="top"
|Reduced gradnt||The reduced gradient <math>d_j = g_j - \pi^T a_j</math>, where ''aj ''is the ''j''th column of the constraint matrix (or the ''j''th column of the Jacobian at the start of the final major iteration).
|-valign="top"
|M+J||The value ''m ''+ ''j''.
|}

An example of the printed solution is given in [[#File Output]]. Infinite Upper and Lower limits are output as the word None. Other real values are output with format f16.5. The maximum record length is 111 characters, including the first (carriage-control) character.

''Note '': If two problems are the same except that one minimizes ''q''(''x'') and the other maximizes ''-q''(''x''), their solutions will be the same but the signs of the dual variables ''πi'' and the reduced gradients ''dj ''will be reversed.

===The SUMMARY file===

If Summary file ''f ''is specified certain brief information will be output to file ''f ''. For batch jobs a disk file should be used, to retain a concise log of each run if desired. (A SUMMARY file is more easily perused than the associated PRINT file).

A SUMMARY file (like the PRINT file) is not rewound after a problem has been processed. It can therefore accumulate a log for every problem in the SPECS file, if each specifies the same file. The maximum record length is 72 characters, including a carriage-control character in column 1.

The following information is included:

#The Begin card from the SPECS file.
#The status of the solution after each basis factorization (whether feasible; the objective value; the number of function calls so far).
#The same information every ''k''th iteration, where ''k ''is the specified Summary frequency (default ''k ''= 100).
#Warnings and error messages.
#The exit condition and a summary of the final solution.

Item 4 is preceded by a blank line, but item 5 is not.

All items are illustrated below, where we give the SUMMARY file for the first problem in the example program (Summary frequency = 1).

<pre>
==============================
S Q O P T 5.3 (Oct 97)
==============================

Begin sqmain (Example program for sqopt)

Scale option 2, Partial price 1

----------------------------------------------------------------
Itn 0: Phase 1A -- making the linear equality rows feasible

Itn dj Step nInf SumInf Objective
0 0.0E+00 0.0E+00 1 8.868E+01 0.00000000E+00
1 0.0E+00 3.3E+01 0 0.000E+00 0.00000000E+00
Itn 1: Feasible linear equality rows
Itn 1: Phase 1B -- making all linear rows feasible

Itn dj Step nInf SumInf Objective Norm rg nS
1 0.0E+00 0.0E+00 2 5.317E+01 0.00000000E+00 3.4E+00 3
2 0.0E+00 0.0E+00 2 5.317E+01 0.00000000E+00 4.6E-01 2
3 0.0E+00 4.7E+02 1 2.896E+01 0.00000000E+00 4.8E-02 1
4 0.0E+00 9.2E+02 1 2.681E+01 0.00000000E+00 0.0E+00 0

This is problem sqmain. ncolH = 5

5 6.4E-02 6.5E+03 0 0.000E+00 -1.46750000E+06 0.0E+00 0
Itn 5: Feasible linear rows
6 -4.1E+03 2.1E-01 0 0.000E+00 -1.78368567E+06 0.0E+00 0
7 1.4E+03 1.0E+00 0 0.000E+00 -1.98453602E+06 1.4E-12 1
8 -6.3E+02 9.8E-01 0 0.000E+00 -2.04366386E+06 1.3E+01 1
9 0.0E+00 1.0E+00 0 0.000E+00 -2.04366504E+06 1.1E-12 1
EXIT -- optimal solution found

Problem name sqdat1..
No. of iterations 9 Objective value -2.0436650381E+06
No. of Hessian products 8 Linear objective 0.0000000000E+00
Quadratic objective -2.0436650381E+06
No. of superbasics 1 No. of basic nonlinears 2
No. of degenerate steps 1 Percentage 11.11
Norm of xs (scaled) 3.5E+03 Norm of pi (scaled) 8.9E+03
Norm of xs 1.6E+03 Norm of pi 1.1E+04
Max Prim inf(scaled) 0 0.0E+00 Max Dual inf(scaled) 6 2.0E-12
Max Primal infeas 0 0.0E+00 Max Dual infeas 3 9.6E-13

Solution printed on file 9
</pre>

==Algorithmic Details==

SQOPT is based on an inertia-controlling method that maintains a Cholesky factorization of the reduced Hessian (see below). The method follows Gill and Murray. Here we briefly summarize the main features of the method. Where possible, explicit reference is made to items listed in the printed output, and to the names of the relevant optional parameters.

===Overview===

SQOPT's method has a ''feasibility phase ''(also known as ''phase 1 ''), in which a feasible point is found by minimizing the sum of infeasibilities, and an ''optimality phase ''(or ''phase 2 ''), in which the quadratic objective is minimized within the feasible region. The computations in both phases are performed by the same subroutines, with the change of phase being characterized by the objective changing from the sum of infeasibilities (the printed quantity sInf) to the quadratic objective (the printed quantity Objective).

In general, an iterative process is required to solve a quadratic program. Given an iterate (''x, s'') in both the original variables ''x ''and the slack variables ''s'', a new iterate <math>(\bar{x}, \bar{s})</math> is defined by

<math>
\left(\begin{array}{c}
\bar{x}\\
\bar{s}
\end{array}\right)
=
\left(\begin{array}{c}
x\\
s
\end{array}\right)
+ \alpha p,
</math>

where the ''step length a'' is a non-negative scalar, and ''p ''is called the ''search direction''. (For simplicity, we shall consider a typical iteration and avoid reference to the index of the iteration.). Once an iterate is feasible (i.e., satisfies the constraints), all subsequent iterates remain feasible.

===Definition of the working set===

At each iterate (''x, s''), a ''working set ''of constraints is defined to be a linearly independent subset of the constraints that are satisfied "exactly" (to within the value of the Feasibility tolerance). The working set is the current prediction of the constraints that hold with equality at a solution of the LP or QP. Let ''mw'' denote the number of constraints in the working set (including bounds), and let ''W ''denote the associated ''mw × ''(''n ''+ ''m'') ''working-set'' ''matrix ''consisting of the ''mw'' gradients of the working-set constraints.

The search direction is defined so that constraints in the working set remain ''unaltered ''for any value of the step length. It follows that ''p ''must satisfy the identity ''W p ''= 0. This characterization allows ''p ''to be computed using any <math>n\times n\Z</math> ''full-rank matrix ''Z ''that spans the null space of ''W ''. (Thus, ''nZ ''= ''n - mw ''and ''W Z ''= 0.) The null-space matrix ''Z ''is defined from a sparse ''LU ''factorization of part of ''W ''). The direction ''p ''will satisfy ''W p ''= 0 if ''p ''= ''ZpZ ''for any ''nZ''-vector ''pZ ''.

The working set contains the constraints ''Ax - s ''= 0 and a subset of the upper and lower bounds on the variables (''x, s''). Since the gradient of a bound constraint <math>x_j \ge l_j</math> or <math>x_j \le u_j</math> is a vector of all zeros except for <math>\pm1</math> in position ''j'', it follows that the working-set matrix contains the rows of ( ''A - I '' ) and the unit rows associated with the upper and lower bounds in the working set.

The working-set matrix ''W ''can be represented in terms of a certain column partition of the matrix ( ''A - I ''). As in [[#Brief description of the method]] we partition the constraints ''Ax - s ''= 0 so that

''BxB ''+ ''SxS ''+ ''NxN ''= 0'',''

where ''B ''is a square non-singular basis and ''xB '', ''xS'' and ''xN'' are the basic, superbasic and nonbasic variables respectively. The nonbasic variables are equal to their upper or lower bounds at (''x, s''), and the superbasic variables are independent variables that are chosen to improve the value of the current objective. The number of superbasic variables is ''nS '', which is printed as the quantity nS. Given values of ''xN ''and ''xS '', the basic variables ''xB ''are adjusted so that (''x, s'') satisfies ''BxB ''+ ''SxS ''+ ''NxN ''= 0.

If ''P ''is a permutation such that ''(A - I) P ''= ''(B S N)'', then the working-set matrix ''W ''satisfies

<math>
WP = \left(\begin{array}{ccc}
B & S & N \\
0 & 0 & I\N
\end{array}\right),
</math>

where ''IN ''is the identity matrix with the same number of columns as ''N ''.

The null-space matrix ''Z ''is defined from a sparse ''LU ''factorization of part of ''W ''. In particular, ''Z ''is maintained in "reduced-gradient" form, using the package LUSOL to maintain sparse ''LU ''factors of the basis matrix ''B ''that alters as the working set ''W ''changes. Given the permutation ''P '', the null-space basis is given by

<math>
Z = P \left(\begin{array}{c}
-B^{-1} S \\
I \\
0
\end{array}\right).
</math>

This matrix is used only as an operator, i.e., it is never computed explicitly. Products of the form ''Zv ''and ''ZTg ''are obtained by solving with ''B ''or ''BT''. This choice of ''Z ''implies that ''nZ '', the number of "degrees of freedom" at (''x, s''), is the same as ''nS '', the number of superbasic variables.

Let ''gZ'' and ''HZ'' denote the ''reduced gradient'' and ''reduced Hessian'':

''gZ ''= ''ZTg'' and ''HZ'' = ''ZTHZ,

where ''g ''is the objective gradient at (''x, s''). Roughly speaking, ''gZ'' and ''HZ'' describe the first and second derivatives of an ''nS''-dimensional ''unconstrained ''problem for the calculation of ''pZ ''. (The quantity Cond Hz printed in the summary-file output is a condition estimator of ''HZ''.)

At each iteration, an upper-triangular factor ''R ''is available such that ''HZ ''= ''RTR''. Normally, ''R ''is computed from

''RTR ''= ''ZTHZ ''at the start of phase 2 and is then updated as the QP working set changes. For efficiency the dimension of ''R ''should not be excessive (say, ''nS <= ''1000). This is guaranteed if the number of nonlinear variables is "moderate".

If the QP contains linear variables, ''H ''is positive semi-definite and ''R ''may be singular with at least one zero diagonal. However, an inertia-controlling active-set strategy is used to ensure that only the last diagonal of ''R ''can be zero.

If the initial ''R ''is singular, enough variables are fixed at their current value to give a nonsingular ''R''. This is equivalent to including temporary bound constraints in the working set. Thereafter, ''R ''can become singular only when a constraint is deleted from the working set (in which case no further constraints are deleted until ''R ''becomes nonsingular).

===The main iteration===

If the reduced gradient is zero, (''x, s'') is a constrained stationary point on the working set. During phase 1, the reduced gradient will usually be zero only at a vertex (although it may be zero elsewhere in the presence of constraint dependencies). During phase 2, a zero reduced gradient implies that ''x ''minimizes the quadratic objective when the constraints in the working set are treated as equalities. At a constrained stationary point, Lagrange multipliers <math>\lambda</math> are defined from the equations <math>W^T\lambda = g(x)</math>. A Lagrange multiplier ''λj ''corresponding to an inequality constraint in the working set is said to be ''optimal ''if <math>\lambda_j \le \sigma</math> when the associated constraint is at its ''upper bound'', or if <math>\lambda_j \ge - \sigma</math> when the associated constraint is at its ''lower bound'', where ''σ'' depends on the Optimality tolerance. If a multiplier is non-optimal, the objective function (either the true objective or the sum of infeasibilities) can be reduced by continuing the minimization with the corresponding constraint excluded from the working set (this step is sometimes referred to as "deleting" a constraint from the working set). If optimal multipliers occur during the feasibility phase but the sum of infeasibilities is not zero, there is no feasible point.

The special form of the working set allows the multiplier vector λ, the solution of ''WTλ ''= ''g'', to be written in terms of the vector

<math>
d = \left(\begin{array}{c}
g \\
0
\end{array}\right) - \left(\begin{array}{c}
A - I
\end{array}\right)^T\pi = \left(\begin{array}{c}
g - A^T\pi\\
\pi
\end{array}\right),
</math>

where ''π'' satisfies the equations ''BTp ''= ''gB '', and ''gB ''denotes the basic components of ''g''. The components of ''π'' are the Lagrange multipliers ''&lambdaj ''associated with the equality constraints ''Ax - s ''= 0. The vector ''dN ''of nonbasic components of ''d ''consists of the Lagrange multipliers ''δj ''associated with the upper and lower bound constraints in the working set. The vector ''dS ''of superbasic components of ''d ''is the reduced gradient ''gZ ''. The vector ''dB ''of basic components of ''d ''is zero, by construction. (The Euclidean norm of ''dS '', and the final values of ''dS '', ''g ''and ''π ''are the quantities norm rg, Reduced Gradnt, Obj Gradient and Dual Activity in the PRINT file output.)

If the reduced gradient is not zero, Lagrange multipliers need not be computed and the search direction is given by ''p ''= ''ZZpZ '', where ''pZ ''is defined below. The step length is chosen to maintain feasibility with respect to the satisfied constraints.

There are two possible choices for ''pZ '', depending on whether or not ''HZ ''is singular. If ''HZ ''is nonsingular, ''R ''is nonsingular and ''pZ ''is computed from the equations,

<math>
R^TRp_Z = -g_Z,
</math>

where ''gZ ''is the reduced gradient at ''x''. In this case, (''x, s'') + ''p ''is the minimizer of the objective function subject to the working-set constraints being treated as equalities. If (''x, s'') + ''p ''is feasible, ''α ''is defined to be one. In this case, the reduced gradient at <math>(\bar{x}, \bar{s})</math> will be zero, and Lagrange multipliers are computed at the next iteration. Otherwise, ''α ''is set to ''αN '', the step to the boundary of the "nearest" constraint along ''p''. This constraint is added to the working set at the next iteration.

If ''HZ ''is singular, then ''R ''must also be singular, and an inertia-controlling strategy is used to ensure that only the last diagonal element of ''R ''is zero. In this case, ''pZ ''satisfies

<math>
p_Z^T H_Z p_Z = 0 \quad \text{and} \quad g_Z^T p_Z \le 0,
</math>

which allows the objective function to be reduced by any step of the form (''x, s'') + ''αp'', ''a > ''0. The vector ''p ''= ''ZpZ ''is a direction of unbounded descent for the QP in the sense that the QP objective is linear and decreases without bound along ''p''. If no finite step of the form (''x, s'') + ''αp ''(''α > ''0) reaches a constraint not in the working set, the QP is unbounded and SQOPT terminates at (''x, s'') and declares the problem to be unbounded. Otherwise, ''α ''is defined as the maximum feasible step along ''p ''and a constraint active at (''x, s'') + ''αp ''is added to the working set for the next iteration.

===Miscellaneous===

If the basis matrix is not chosen carefully, the condition of the null-space matrix ''Z '' could be arbitrarily high. To guard against this, SQOPT implements a "basis repair" feature in the following way. LUSOL is used to compute the rectangular factorization

<math>
\left(\begin{array}{cc}
B & S
\end{array}\right)^T = LU,
</math>

returning just the permutation ''P ''that makes ''PLPT ''unit lower triangular. The pivot tolerance is set to require <math>|PLP^T|_{ij} \le
2</math>, and the permutation is used to define ''P ''. It can be shown that <math>||{Z}||</math> is likely to be little more than 1. Hence, ''Z ''should be well-conditioned ''regardless of the condition of W ''.

This feature is applied at the beginning of the optimality phase if a potential ''B''-''S ''ordering is known.

The EXPAND procedure is used to reduce the possibility of cycling at a point where the active constraints are nearly linearly dependent. Although there is no absolute guarantee that cycling will not occur, the probability of cycling is extremely small. The main feature of expand is that the feasibility tolerance is increased at every iteration, perhaps at the expense of violating the bounds on (''x, s'') by a simple amount.

Suppose that the value of Feasibility tolerance is ''δ''. Over a period of ''K ''iterations (where ''K ''is the value of the optional parameter Expand frequency, the feasibility tolerance used in SQOPT (i.e., the working feasibility tolerance) increases from <math>\frac{1}{2}\delta</math> to <math>\delta</math> in steps of <math>\frac{1}{2}\delta/K</math>.

At certain stages, the following "resetting procedure" is used to remove small constraint infeasibilities. First, all nonbasic variables are moved exactly onto their bounds. A count is kept of the number of non-trivial adjustments made. If the count is nonzero, the basic variables are recomputed. Finally, the working feasibility tolerance is reinitialized to <math>\frac{1}{2}\delta</math>.

If a problem requires more than ''K ''iterations, the resetting procedure is invoked and a new cycle of iterations is started. (The decision to resume phase 1 or phase 2 is based on comparing any constraint infeasibilities with ''δ''.)

The resetting procedure is also invoked if when SQOPT reaches an apparently optimal, infeasible, or unbounded solution, unless this situation has already occurred twice. If any non-trivial adjustments are made, iterations are continued.

The EXPAND procedure not only allows a positive step to be taken at every iteration, but also provides a potential ''choice ''of constraint to be added to the working set. All constraints at a distance <math>\alpha (\alpha \le \alpha_N)</math> along ''p ''from the current point are then viewed as acceptable candidates for inclusion in the working set. The constraint whose normal makes the biggest angle with the search direction is added to the working set. This strategy helps keep the basis matrix ''B ''well-conditioned.

SOL MINOS

2012-01-22T18:10:31Z

Elias:

{{Part Of Manual|title=the SOL Manual|link=[[SOL|SOL]]}}
==Direct Solver Call==

A direct solver call is not recommended unless the user is 100 % sure that no other solvers will be used for the problem. Please refer to subsection [[#Using TOMLAB|Using TOMLAB]] for information on how to use MINOS with TOMLAB.

===Purpose===

''minos ''solves nonlinear optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{lcccl}
& & x & &, \\
b_{L} & \leq & A x & \leq & b_{U} \\
& & c(x) & & \\
\end{array}
\end{array}
</math>

where <math>x \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A \in
\mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{n+m_1+m_2}</math>
and <math>c(x) \in \mathbb{R}^{m_2}</math>.

or quadratic optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x \\
& \\
s/t & \begin{array}{lcccl}
& & x & &, \\
b_{L} & \leq & g(x) & \leq & b_{U} \\
& & A x & & \\
\end{array}
\end{array}
</math>

where <math>c, x \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n \times n}</math>,
<math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in
\mathbb{R}^{m_1}</math>.

The full input matrix A has three parts A = [d/dx g(x); A; c'];

===Calling Syntax===

The file 'funfdf.m' must be defined and contain: function [mode, f, g] = funfdf(x, Prob, mode, nstate) to compute the objective function f and the gradient g at the point x.

The file 'funcdc.m' must be defined and contain: function [mode ,c ,dcS] = funcdc(x, Prob, mode, nstate) to compute the nonlinear constraint value c and the constraint Jacobian dcS for the nonlinear constraints at the point x.

NOTE: The matrix dcS MUST be a SPARSE MATLAB matrix. Do dcS = sparse(dcS); after dcS has been computed.

<pre>
[hs, xs, pi, rc, Inform, nS, nInf, sInf, Obj, iwCount, gObj, fCon, gCon] = minos(H, A, bl, bu, nnCon, nnObj,
nnJac, Prob, iObj, optPar, Warm, hs, xs, pi, nS, SpecsFile, PrintFile, SummFile, PriLev, ObjAdd, moremem,
ProbName );
</pre>

===Description of Inputs===

The following fields are used:

{| class="wikitable"
!Input!!Description
|-valign="top"
|''H''||Matrix n x n in a quadratic programming (QP) problem. DENSE or SPARSE. Leave empty if LP, or NLP problem.
|-valign="top"
|''A''||Constraint matrix, m x n SPARSE (nonlinear, linear and objective) m ''> ''0 always!!! Define dummy constraint for unconstrained problems.
|-valign="top"
|''bl''||Lower bounds on (x,g(x),Ax,c').
|-valign="top"
|''bu''||Upper bounds on (x,g(x),Ax,c').

NOTE! The bl and bu values for the last nonlinear constraint c must have reverse signs and be put in each other places: If ''cL <''= ''c''(''x'') ''<''= ''cU '', then ''bl ''= ''-cU ''and ''bu ''= ''-cL ''. This is because the bounds acts as the constraints on the slack variables for the nonlinear constraints.
|-valign="top"
|''nnCon''||Number of nonlinear constraints.
|-valign="top"
|''nnObj''||Number of nonlinear objective variables.
|-valign="top"
|''nnJac''||Number of nonlinear Jacobian variables.
|-valign="top"
|''Prob''||Must be a structure. No check is made in the MEX interface. If TOMLAB calls minos, then Prob is the standard TOMLAB problem structure, otherwise the user should set:

Prob.P = ProblemNumber, where ProblemNumber is some integer.

If the problem is a LP or QP problem (H defined), the user does not have to specify anything else in the structure.

For a general nonlinear objective or nonlinear constraints names of two user written routines must be given:

funfdf, actual name stored in Prob.FUNCS.fg, with syntax [mode, f, g] = funfdf(x, Prob, mode, nstate).

funcdc, actual name stored in Prob.FUNCS.cdc, with syntax [mode, c, dcS] = funcdc(x, Prob, mode, nstate).

MINOS is calling the TOMLAB routines nlp fg.m and nlp cdcS.m in the call- back, and they call funfdf and funcdc, respectively.

If these fields in Prob are empty (Prob.FUNCS.fg, Prob.FUNCS.cdc), the TOMLAB callback routines calls the usual function routines. Then the Prob struct should be normally defined, and the fields Prob.FUNCS.f, Prob.FUNCS.g, Prob.FUNCS.c, Prob.FUNCS.dc be set in the normal way (e.g. by the routine mFiles.m, or one of the Assign-routines like conAssign.m).

If the mode parameter is 0, funfdf should return f, otherwise both f and the gradient vector g. If the mode parameter is 0, funcdc should return c, otherwise both c and dcS. Note that each row in dcS corresponds to a constraint, and that dcS must be a SPARSE matrix.

The user could also write his own versions of the routines nlp fg.m and nlp cdcS.m and put them before in the path.
|-valign="top"
|''iObj''||Says which row of A is a free row containing a linear objective vector c. If there is no such vector, iObj = 0. Otherwise, this row must come after any nonlinear rows, so that nnCon ''<''= iObj ''<''= m.
|-valign="top"
|''optPar''||Vector with optimization parameters overriding defaults and the optionally specified SPECS file. If using only default options, set optPar as an empty matrix.
|-valign="top"
|''Warm''||Flag, if true: warm start. Default cold start (if empty). If 'Warm Start' xs, nS and hs must be supplied with correct values.
|-valign="top"
|''hs''||Basis status of variables + constraints (n+m x 1 vector). State of vari- ables: 0=nonbasic (on bl), 1=nonbasic (on bu) 2=superbasic (between bounds), 3=basic (between bounds).
|-valign="top"
|''xs''||Initial vector, optionally including m slacks at the end. If warm start, full xs must be supplied.
|-valign="top"
|''pi''||Lagrangian multipliers for the nnCon nonlinear constraints. If empty, set as 0.
|-valign="top"
|''nS''||# of superbasics. Only used if calling again with a Warm Start.
|-valign="top"
|''SpecsFile''||Name of the SPECS input parameter file, see [[TOMLAB]].
|-valign="top"
|''PrintFile''||Name of the Print file. Name includes the path, maximal number of characters = 500.
|-valign="top"
|''SummFile''||Name of the Summary file. Name includes the path, maximal number of char- acters = 500.
|-valign="top"
|''PriLev''||Printing level in the minos m-file and minos MEX-interface.

= 0 Silent

= 1 Summary information

= 2 More detailed information
|-valign="top"
|''ObjAdd''||Constant added to the objective for printing purposes, typically 0.
|-valign="top"
|''moremem''||Add extra memory for the sparse LU, might speed up the optimization. 1E6 is 10MB of memory. If empty, set as 0.
|-valign="top"
|''ProbName''||Name of the problem. ¡=100 characters are used in the MEX interface. In the MINOS solver the first 8 characters are used in the printed solution and in some routines that output BASIS files. Blank is OK.
|}

===Description of Outputs===

The following fields are used:

{| class="wikitable"
!Output!!Description
|-valign="top"
|''hs''||Basis status of variables + constraints (n+m x 1 vector). State of vari- ables: 0=nonbasic (on bl), 1=nonbasic (on bu) 2=superbasic (between bounds),
3=basic (between bounds).

Basic and superbasic variables may be outside their bounds by as much as the Feasibility tolerance. Note that if scaling is specified, the Feasibility tolerance applies to the variables of the ''scaled ''problem. In this case, the variables of the original problem may be as much as 0.1 outside their bounds, but this is unlikely unless the problem is very badly scaled. Check the "Primal infeasibility" printed after the EXIT message.

Very occasionally some nonbasic variables may be outside their bounds by as much as the Feasibility tolerance, and there may be some nonbasics for which xn(''j'') lies strictly between its bounds.

If ninf ''> ''0, some basic and superbasic variables may be outside their bounds by an arbitrary amount (bounded by sinf if scaling was not used).
|-valign="top"
|''xs''||Solution vector (n+m by 1) with n decision variable values together with the m slack variables.
|-valign="top"
|''pi''||Lagrangian multipliers (dual solution vector) (m x 1 vector)
|-valign="top"
|''rc''||Vector of reduced costs, ''g - ''( ''A I '')''Tp'', where ''g ''is the gradient of the objective function if xn is feasible, or the gradient of the Phase-1 objective otherwise. If ninf = 0, the last ''m ''entries are ''-p''. Reduced costs vector is of n+m length.
|-valign="top"
|''Inform''||Result of MINOS run.

0 Optimal solution found.

1 The problem is infeasible.

2 The problem is unbounded (or badly scaled).

3 Too many iterations.

4 Apparent stall. The solution has not changed for a large number of iterations (e.g. 1000).

5 The Superbasics limit is too small.

6 User requested termination (by returning bad value).

7 Gradient seems to be giving incorrect derivatives.

8 Jacobian seems to be giving incorrect derivatives.

9 The current point cannot be improved.

10 Numerical error in trying to satisfy the linear constraints (or the linearized nonlinear constraints). The basis is very ill-conditioned.

11 Cannot find a superbasic to replace a basic variable.

12 Basis factorization requested twice in a row. Should probably be treated as inform = 9.

13 Near-optimal solution found. Should probably be treated as inform = 9.

20 Not enough storage for the basis factorization.

21 Error in basis package.

22 The basis is singular after several attempts to factorize it (and add slacks where necessary).

30 An OLD BASIS file had dimensions that did not match the current problem.

32 System error. Wrong number of basic variables.

40 Fatal errors in the MPS file.

41 Not enough storage to read the MPS file.

42 Not enough storage to solve the problem.
|-valign="top"
|''nS''||# of superbasics.
|-valign="top"
|''nInf''||Number of infeasibilities.
|-valign="top"
|''sInf''||Sum of infeasibilities.
|-valign="top"
|''Obj''||Objective function value at optimum.
|-valign="top"
|''iwCount''||Number of iterations (major and minor), function and constraint calls.
|-valign="top"
|''gObj''||Gradient of the nonlinear objective.
|-valign="top"
|''fCon''||Nonlinear constraint vector.
|-valign="top"
|''gCon''||Gradient vector (non-zeros) of the nonlinear constraint vector.
|}

==Using TOMLAB==

===Purpose===

''minosTL ''solves nonlinear optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
c_{L} & \leq & c(x) & \leq & c_{U} \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A
\in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math>
and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.

===Calling Syntax===

Using the driver routine ''tomRun '':

<pre>
Prob = ''o''Assign( ... );
Result = tomRun('minos', Prob, 1);
</pre>

===Description of Inputs===

{| class="wikitable"
!colspan="2"|''Prob'', The following fields are used:
|-valign="top"
|''x_L, x_U''||Bounds on variables.
|-valign="top"
|''b_L, b_U''||Bounds on linear constraints.
|-valign="top"
|''c_L, c_U''||Bounds on nonlinear constraints.
|-valign="top"
|''A''||Linear constraint matrix.
|-valign="top"
|''QP.c''||Linear coefficients in objective function.
|-valign="top"
|''PriLevOpt''||Print level.
|-valign="top"
|''WarmStart''||If true, use warm start, otherwise cold start.
|-valign="top"
|''SOL.xs''||Solution and slacks from previous run.
|-valign="top"
|''SOL.hs''||State for solution and slacks from previous run.
|-valign="top"
|''SOL.nS''||Number of superbasics from previous run.
|-valign="top"
|''SOL.moremem''||Add more memory if MINOS stops with not enough storage message. 1E6 is 10MB of memory. Default n+m1+m2 (number of variables + linear + nonlin- ear constraints).
|-valign="top"
|''SOL.SpecsFile''||Name of user defined SPECS file, read BEFORE optPar() is used.
|-valign="top"
|''SOL.PrintFile''||Name of SOL Print file. Amount and type of printing determined by SPECS parameters or optPar parameters.
|-valign="top"
|''SOL.SummFile''||Name of SOL Summary File.
|-valign="top"
|''SOL.optPar''||Elements ''> ''-999 takes precedence over corresponding TOMLAB params. See Table in [[SOL Using the SOL Solvers in TOMLAB]].
|}

===Description of Outputs===

{| class="wikitable"
!colspan="2"|''Result'', The following fields are used:
|-valign="top"
|''Result''||The structure with results (see ResultDef.m).
|-valign="top"
|''f_k''||Function value at optimum.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''g_k''||Gradient of the function.
|-valign="top"
|''c_k''||Nonlinear constraint residuals.
|-valign="top"
|''cJac''||Nonlinear constraint gradients.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''cState''||State of nonlinear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrangian multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status from minos.m (similar to TOMLAB).
|-valign="top"
|''Inform ''||Result of MINOS run.

0 Optimal solution found.

1 The problem is infeasible.

2 The problem is unbounded (or badly scaled).

3 Too many iterations.

4 Apparent stall. The solution has not changed for a large number of iterations (e.g. 1000).

5 The Superbasics limit is too small.

6 User requested termination (by returning bad value).

7 Gradient seems to be giving incorrect derivatives.

8 Jacobian seems to be giving incorrect derivatives.

9 The current point cannot be improved.

10 Numerical error in trying to satisfy the linear constraints (or the linearized nonlinear constraints). The basis is very ill-conditioned.

11 Cannot find a superbasic to replace a basic variable.

12 Basis factorization requested twice in a row. Should probably be treated as inform = 9.

13 Near-optimal solution found. Should probably be treated as inform = 9.

20 Not enough storage for the basis factorization.

21 Error in basis package.

22 The basis is singular after several attempts to factorize it (and add slacks where necessary).

30 An OLD BASIS file had dimensions that did not match the current problem.

32 System error. Wrong number of basic variables.

40 Fatal errors in the MPS file.

41 Not enough storage to read the MPS file.

42 Not enough storage to solve the problem.
|-valign="top"
|''rc''||Vector of reduced costs, ''g-''(''AI'')''Tp'', where ''g'' is the gradient of the objective function if xn is feasible, or the gradient of the Phase-1 objective otherwise. If ninf = 0, the last ''m ''entries are ''-p''. Reduced costs vector is of n+m length.
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''FuncEv''||Number of function evaluations. ''GradEv ''Number of gradient evaluations.
|-valign="top"
|''ConstrEv''||Number of constraint evaluations.
|-valign="top"
|''QP.B''||Basis vector in TOMLAB QP standard.
|-valign="top"
|''MinorIter''||Number of minor iterations.
|-valign="top"
|''Solver''||Name of the solver (minos).
|-valign="top"
|''SolverAlgorithm''||Description of the solver.
|-valign="top"
|''SOL.xs''||Solution and slack variables.
|-valign="top"
|''SOL.hs''||Basis status of variables + constraints (n+m x 1 vector). State of vari- ables: 0=nonbasic (on bl), 1=nonbasic (on bu) 2=superbasic (between bounds), 3=basic (between bounds).

Basic and superbasic variables may be outside their bounds by as much as the Feasibility tolerance. Note that if scaling is specified, the Feasibility tolerance applies to the variables of the ''scaled ''problem. In this case, the variables of the original problem may be as much as 0.1 outside their bounds, but this is unlikely unless the problem is very badly scaled. Check the "Primal infeasibility" printed after the EXIT message.

Very occasionally some nonbasic variables may be outside their bounds by as much as the Feasibility tolerance, and there may be some nonbasics for which xn(''j'') lies strictly between its bounds.

If ninf ''> ''0, some basic and superbasic variables may be outside their bounds by an arbitrary amount (bounded by sinf if scaling was not used).
|-valign="top"
|''SOL.nS''||# of superbasics.
|-valign="top"
|''SOL.nInf''||# of infeasibilities.
|-valign="top"
|''SOL.sInf''||Sum of infeasibilities.
|}

==optPar==

===Description===

Use missing value (-999 or less), when no change of parameter setting is wanted. The default value will then be used by MINOS, unless the value is altered in the SPECS file.

Definition: nnL = max(nnObj,nnJac))

===Description of Inputs===

====Table: The following fields are used:====

{| class="wikitable"
!#!!SPECS keyword text
!Lower
!Default
!Upper
!Comment
|-valign="top"
|colspan="2"|'''Printing'''
|-valign="top"
|1.||PRINT LEVEL||0||0||11111||JFLXB: Jac, fCon, lambda, x, B=LU stats
|-valign="top"
|colspan="2"|'''Frequencies I'''
|-valign="top"
|5.||PRINT FREQUENCY||0||100
|-valign="top"
|6.||SUMMARY FREQUENCY||0||100
|-valign="top"
|7.||SOLUTION YES/NO||0||1||1||1 = YES; 0 = NO
|-valign="top"
|8.||SUPPRESS PARAMETERS||0||0||1||1 = True
|-valign="top"
|colspan="2"|'''Convergence Tolerances'''
|-valign="top"
|9.||ROW TOLERANCE||''> ''0||1E-6
|-valign="top"
|10.||OPTIMALITY TOLERANCE||''> ''0||colspan="3"|''max''(1''E - ''6'', ''(10''epsR '')0''.''5 ) = 1.73E-6
|-valign="top"
|11.||FEASIBILITY TOLERANCE||''> ''0||1E-6
|-valign="top"
|colspan="2"|'''Derivative checking'''
|-valign="top"
|13.||VERIFY LEVEL||-1||-1||3||-1,0,1,2,3
|-valign="top"
|14.||START OBJECTIVE CHECK AT COL||0||1||nnObj
|-valign="top"
|15.||STOP OBJECTIVE CHECK AT COL||0||nnObj||nnObj
|-valign="top"
|16.||START CONSTRAINT CHECK AT COL||0||1||nnJac
|-valign="top"
|17.||STOP CONSTRAINT CHECK AT COL||0||nnJac||nnJac
|-valign="top"
|colspan="2"|'''Scaling'''
|-valign="top"
|18.||SCALE OPTION

See Section 6.2 for more information.
||0||1 or 2||2||2 if LP,1 if NLP
|-valign="top"
|19.||SCALE TOLERANCE||''> ''0||0.9||''< ''1
|-valign="top"
|20.||SCALE PRINT||0||0||1||1 = True
|-valign="top"
|21.||CRASH TOLERANCE||0||0.1||''< ''1
|-valign="top"
|colspan="2"|'''Other Tolerances'''
|-valign="top"
|22.||LINESEARCH TOLERANCE||''> ''0||0.1||''< ''1
|-valign="top"
|colspan="2"|'''LU I'''
|-valign="top"
|23.||LU FACTORIZATION TOLERANCE||1||100 or 5||100 if LP
|-valign="top"
|24.||LU UPDATE TOLERANCE||1||10 or 5||10 if LP
|-valign="top"
|25.||LU SWAP TOLERANCE||''> ''0||1.22E-4||''eps^''1''/''4
|-valign="top"
|26.||LU SINGULARITY TOLERANCE||''> ''0||3.25E-11||''eps^''0''.''67
|-valign="top"
|colspan="2"|'''LP or LC subproblems'''
|-valign="top"
|27.||PIVOT TOLERANCE||''> ''0||3.25E-11||''eps^''0''.''67
|-valign="top"
|28.||CRASH OPTION ||0||3||3||0,1,2,3
|-valign="top"
|29.||WEIGHT ON LINEAR OBJECTIVE||0.0||0.0||during Phase 1
|-valign="top"
|30.||ITERATIONS LIMIT

m3=1 if length(Prob.QP.c) ''> ''0, otherwise m3=0.

TOMLAB default: max(10000,3(m+m3) + 10nnL).

||0||3(m+m3) + 10nnL
|-valign="top"
|colspan="2"|'''SLC method'''
|-valign="top"
|32.||MAXIMIZE||0||0||1||1=maximize
|-valign="top"
|33.||LAGRANGIAN||0||1||1||1=YES, 0=NO
|-valign="top"
|34.||PENALTY PARAMETER||0.0||1.0
|-valign="top"
|35.||MAJOR ITERATIONS LIMIT||''> ''0||50
|-valign="top"
|36.||MINOR ITERATIONS LIMIT||''> ''0||40
|-valign="top"
|37.||MAJOR DAMPING PARAMETER||''> ''0||2.0
|-valign="top"
|38.||MINOR DAMPING PARAMETER||''> ''0||2.0
|-valign="top"
|39.||DERIVATIVE LEVEL

Is always set by minosTL dependent on Prob.ConsDiff, Prob.NumDiff.
||0||3||3||0,1,2,3
|-valign="top"
|40.||RADIUS OF CONVERGENCE||0.0||0.01
|-valign="top"
|41.||FUNCTION PRECISION||''> ''0||3.0E-13||''eps''0''.''8 = ''epsR''
|-valign="top"
|42.||DIFFERENCE INTERVAL||''> ''0||5.48E-7||''eps''0''.''4
|-valign="top"
|43.||CENTRAL DIFFERENCE INTERVAL||''> ''0||6.69E-5||''eps''0''.''8''/''3
|-valign="top"
|44.||COMPLETION||0||1 LC, 0 1

NC

||0=PARTIAL

1=FULL
|-valign="top"
|45.||UNBOUNDED STEP SIZE||''> ''0||1E10
|-valign="top"
|46.||UNBOUNDED OBJECTIVE||''> ''0||1E20
|-valign="top"
|colspan="2"|'''Hessian approximation'''
|-valign="top"
|47.||HESSIAN DIMENSION||1||50||1+nnL
|-valign="top"
|48.||SUPERBASICS LIMIT||1||50||1+nnL

TOMLAB default (to avoid termination with Superbasics Limit too small):

If n ''<''= 5000: ''max''(50'', n ''+ 1)

If n ''> ''5000: ''max''(500'', n ''+ 200 ''- size''(''A, ''1) ''- length''(''cL ''))

Avoid setting REDUCED HESSIAN (number of columns in reduced Hessian).

It will then be set to the same value as the SUPERBASICS LIMIT by MINOS. Frequencies II
|-valign="top"
|51.||CHECK FREQUENCY||''> ''0||60
|-valign="top"
|52.||EXPAND FREQUENCY||''> ''0||10000
|-valign="top"
|53.||FACTORIZATION FREQUENCY||''> ''0||50
|-valign="top"
|colspan="2"|'''LU II'''
|-valign="top"
|63.||LU PARTIAL PIVOTING

or LU COMPLETE PIVOTING

or LU ROOK PIVOTING
||0||0||3||0=partial

1=complete

2=rook
|-valign="top"
|colspan="2"|'''Additional parameters'''
|-valign="top"
|67.||AIJ TOLERANCE

Elements ''<nowiki>|</nowiki>a''(''i, j'')''<nowiki>|</nowiki> < AI J ''TOLERANCE are set as 0
||0||1E-10
|-valign="top"
|70.||SUBSPACE

Convergence tolerance in current subspace before consider moving off another constraint.
||''> ''0||0.5||1||Subspace tolerance
|}

Models Global Optimization Problems: glb prob, lgo1 prob, lgo2 prob and gkls prob

2012-01-22T17:55:58Z

Elias:

==Example of a global optimization problem==

The basic structure of a global optimization problem with simple bounds is the following

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{llcccll}
-\infty < &x_{L} & \leq & x & \leq & x_{U}& < \infty \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>. The
variables <math>x \in I</math>, the index subset of <math>1,...,n</math>, are restricted
to be integers.

The following file is required to define a problem of this category in TOMLAB.

'''File: '''tomlab/quickguide/glbQGf.m

<pre>
f: Function
</pre>

An example of a problem of this class, (that is also found in the TOMLAB quickguide) is glbQG:

'''File: '''tomlab/quickguide/glbQG.m

<source lang="matlab">
% glbQG is a small example problem for defining and solving
% unconstrained global programming problems using the TOMLAB format.

Name = 'Shekel 5';
x_L = [ 0 0 0 0]'; % Lower bounds for x.
x_U = [10 10 10 10]'; % Upper bounds for x.
x_0 = [-3.0144 -2.4794 -3.1584 -3.1790]; % May not be used.
x_opt = [];
f_opt = -10.1531996790582;
f_Low=-20; % Lower bound on function.
x_min = [ 0 0 0 0]; % For plotting
x_max = [10 10 10 10]; % For plotting

Prob = glcAssign('glbQG_f', x_L, x_U, Name, [], [], [], ...
[], [], [], x_0, ...
[], [], [], [], ...
f_Low, x_min, x_max, f_opt, x_opt);

Prob.optParam.MaxFunc = 1500;

Result1 = tomRun('glbFast', Prob, 1); %Global solver
Result2 = tomRun('conSolve', Prob, 1); %Local solver

% Result = tomRun('glbSolve', Prob, 1);
% Result = tomRun('glcSolve', Prob, 1);
% Result = tomRun('glcFast', Prob, 1);
% Result = tomRun('lgo', Prob, 1);
% Result = tomRun('oqnlp', Prob, 1);
</source>

==glb_prob==

In <tt>glb_prob</tt> there are 51 unconstrained global optimization test problems with sizes to 100 variables. In order to define the problem n and solve it execute the following in Matlab:

<pre>
Prob = probInit('glb_prob',n);
Result = tomRun('',Prob);
</pre>

==lgo1_prob==

In <tt>glo1_prob</tt> there are 30 global optimization test problems in one dimension. In order to define the problem n and solve it execute the following in Matlab:

<pre>
Prob = probInit('lgo1_prob',n);
Result = tomRun('',Prob);
</pre>

==lgo2_prob==

In <tt>glo2_prob</tt> there are 30 global optimization test problems in two up to four dimensions. In order to define the problem n and solve it execute the following in Matlab:

<pre>
Prob = probInit('lgo2_prob',n);
Result = tomRun('',Prob);
</pre>

==gkls_prob==

In <tt>gkls_prob</tt> there are 300 global optimization test problems in two dimensions. In order to define the problem n and solve it execute the following in Matlab:

<pre>
Prob = probInit('gkls_prob',n);
Result = tomRun('',Prob);
</pre>

CGO Using the Matlab Interface

2012-01-22T17:30:40Z

Elias:

{{Part Of Manual|title=the CGO Manual|link=[[CGO|CGO Manual]]}}
The CGO solver package is accessed via the ''tomRun ''driver routine, which calls the ''rbfSolve'', ''ego ''or ''arbfMIP'' routines.

====Table: The Costly global solver routines.====

{|class="wikitable"
!Function||Description
|-valign="top"
|''rbfSolve''||Costly global solver routine called by the TOMLAB driver routine ''tomRun''. This routine will also call local and global subsolvers.
|-valign="top"
|''ego''||Costly global solver routine called by the TOMLAB driver routine ''tomRun''. This routine will also call local and global subsolvers.
|-valign="top"
|''arbfMIP''||Costly global solver routine called by the TOMLAB driver routine ''tomRun''. This routine will also call local and global subsolvers.
|}

Xpress Appendix A

2012-01-22T17:28:06Z

Elias:

{{Part Of Manual|title=the Xpress Manual|link=[[Xpress|Xpress Manual]]}}
==The Matlab Interface Routines - Main Routines==

===xpress===

====Purpose====

Xpress''MP'' mixed-integer linear and quadratic programming (MILP, MIQP) and linear and quadratic programming (LP, QP) interface. Xpress ''MP'' solves problems of the form

<math>
\begin{array}{cccccc}
\min\limits_{x} & f(x) = 0.5*x^T*F*x + c^T*x \\
s/t & x_{L} & \leq & x & \leq & x_{U} \\
& b_{L} & \leq & Ax & \leq & b_{U} \\
& & & x_i \mathrm{\ \ integer} & & i \in I \\
\end{array}
</math>

where <math>c, x, x_{L}, x_{U}\in \mathbb{R}^{n}</math>, <math>F\in \mathbb{R}^{n\times n}</math>, <math>A\in \mathbb{R}^{m\times n}</math> and <math>b_{L},b_{U}\in \mathbb{R}^{m}</math>. The variables <math>x \in I</math>, the index subset of <math>1,...,n</math>, are restricted to be integers.

====Calling Syntax====

<pre>
[x, slack, v, rc, f k, ninf, sinf, Inform, basis, lpiter, glnodes] = xpress(c, A, x L, x U, b L, b U, xpcontrol, callback, PriLev, Prob, IntVars,
PI, SC, SI, sos1, sos2, F, LogFile, SaveFile, SaveMode, iisRequest, iisFile, saRequest);
</pre>

====Description of Inputs====

Problem description structure. The following fields are used:

{|class="wikitable"
|''c''||Linear objective function cost coefficients, vector ''n × ''1.
|-valign="top"
|''F''||Square dense or sparse matrix. Empty if non-quadratic problem.
|-valign="top"
|''A''||Linear constraint matrix for linear constraints, dense or sparse matrix ''m × n''.
|-valign="top"
|''x_L''||Lower bounds on design parameters ''x''. If empty assumed as zero.
|-valign="top"
|''x_U''||Upper bounds on design parameters ''x''.
|-valign="top"
|''b_L''||Lower bounds on the linear constraints.
|-valign="top"
|||'''The following parameters are optional:'''
|-valign="top"
|''b_U''||Upper bounds on the linear constraints. If empty, then ''bU'' = ''bL'' assumed.
|-valign="top"
|''xpcontrol''||Structure, where the fields are set to the Xpress ''M P'' control parameters that the user wants to specify values for. The control parameters are listed in Section 7 in the Xpress-Optimizer Reference Manual. The prefix XPRS is not used.
|-valign="top"
|''callback''||Logical vector defining which callbacks to use in Xpress ''M P''. If the ''i''th entry of the logical vector ''callback'' is set, the corresponding callback is defined. The callback calls the m-file specified in Table below. The user may edit this file, or make a new copy, which is put in a directory that is searched before the ''xpress ''directory in the Matlab path.
|-valign="top"
|''PriLev''||Printing level in the ''xpress m''-file and the Xpress ''MP'' C-interface.

= 0 Silent

= 1 Summary information

= 2 More detailed information
|-valign="top"
|''Prob''||A structure. If TOMLAB calls ''xpress'', then ''Prob'' is the standard TOMLAB problem structure, otherwise the user optionally may set: ''Prob.P ''= ''ProblemNumber''; , where ProblemNumber is some integer. If any callback is defined then problem arrays are set as fields in ''Prob'', and the ''Prob ''structure is always passed to the callback routines as the last parameter. The defined fields are ''Prob.c'', ''Prob.x_L'', ''Prob.x_U'', ''Prob.A'', ''Prob.b_L'', ''Prob.b_U ''and ''Prob.QP.F''. If the input structure is empty ([ ]), then ''Prob.P'' = 1 is set. If ''Prob.MIP.KNAPSACK = 1 ''and ''callback'' == 1, then the simple heuristic in ''xpcb_GL ''is used. If callback(9) is set, and ''Prob.MIP.KNAPSACK'', or ''Prob.MIP ''is undefined, ''xpress ''is setting ''Prob.MIP.KNAPSACK = 0'', to avoid the call to the heuristic.
|-valign="top"
|''IntVars''||Defines which variables are integers, of the general type ''I ''or binary ''B''. Variable indices should be in the range [1,...,n]. If ''IntVars'' is a logical vector then all variables ''i ''where ''IntVars''(''i'') ''> ''0 are defined to be integers. If ''IntVars ''is determined to be a vector of indices then ''x''(''IntVars'') are defined as integers. If the input is empty ([ ]), then no integers of type I or B are defined. The interface routine ''xpress ''checks which of the integer variables have lower bound ''xL ''= 0 and upper bound ''xU ''= 1, i.e. are binary 0/1 variables.
|-valign="top"
|''PI''||Integer variables of type ''Partially Integer ''(PI), i.e. takes an integer value up to a specified limit, and any real value above that limit. PI must be a structure array where:

''PI.var'' is a vector of variable indices in the range [1'', ..., n''].

''PI.lim'' is a vector of limit values for each of the variables specified in PI.var, i.e. for variable ''i'', that is the PI variable with index ''j ''in ''P I .var'', then ''x''(''i'') takes integer values in [''xL ''(''i'')'', P I .lim''(''j'')] and continuous values in [''PI.lim''(''j'')'', xU ''(''i'')].
|-valign="top"
|''SC''||A vector with indices for the integer variables of type ''Semi-continuous ''(SC), i.e. that takes either the value 0 or a real value in the range [''xL ''(''i'')'', xU ''(''i'')], assuming for some ''j'', that ''i ''= ''SC ''(''j''), where ''i ''is an variable number in the range [1'', ..., n''].
|-valign="top"
|''SI''||A vector with indices for the integer variables of type ''Semi-integer ''(SI), i.e. that takes either the value 0 or an integer value in the range [''xL ''(''i'')'', xU ''(''i'')], assuming for some ''j'', that ''i ''= ''SI ''(''j''), where ''i ''is an variable number in the range [1'', ..., n''].
|-valign="top"
|''sos1''||A structure defining the ''Special Ordered Sets of Type One ''(sos1). Assume there are ''k ''sets of type sos1, then ''sos''1(''k'')''.var ''is a vector of indices for variables of type sos1 in set ''k''. ''sos''1(''k'')''.row ''is the row number for the reference row identifying the ordering information for the sos1 set, i.e. A(sos1(k).row,sos1(k).var) identifies this information. As ordering information, also the objective function coefficients ''c ''could be used. Then as row number, 0 is instead given in ''sos''1(''k'')''.row''.
|-valign="top"
|''sos2''||A structure defining the ''Special Ordered Sets of Type Two ''(sos2). Specified exactly as sos1 sets, see ''sos''1 input variable description.
|-valign="top"
|''LogFile''||File to write Xpress-MP log output to. Default is empty " in which case nothing is written.

Please note that Xpress-MP appends it's output to the log file.
|-valign="top"
|''SaveFile''||Filename for writing the problem prior to calling the Xpress-MP solver. If empty, no file is written. The type of output is determined by the SaveMode parameter. Xpress-MP will always add an extension to the filename given here. The extension depends on the SaveMode chosen, see below.
|-valign="top"
|''SaveMode''||Character string with any combination of the following character flags:

p - full precision of numerical values. o - one element per line.

n - scaled.

s - scrambled vector names. l - output in LP format.

The extension added to the SaveFile name is .mat, unless the 'l' flag is used in which case the extension is .lp.
|-valign="top"
|''iisRequest''||Flag indicating whether to compute an IIS and return it to MATLAB. This option can only be set for an LP problem. If an IIS is found, XPRESS automatically changes the problem to make it feasible and reoptimizes it.

= 0, Don't return IIS to MATLAB (default).

= 1, Compute IIS and return it to MATLAB if an LP problem has been proven infeasible. The IIS is returned through the output parameter 'iis'.
|-valign="top"
|''iisFile''||Flag indicating whether to write a file describing the IIS set or not. If is set to 1, a file: LPprob.iis will be written. Otherwise, no file is written..
|-valign="top"
|''saRequest''||Structure telling whether and how you want XPRESS to perform a sensitivity analysis (SA).

You can complete an SA on the objective function and right hand side vector. The saRequest structure contains two sub structures:

.obj and .rhs

They have one field each:

.index

In case of .obj.index, .index contains the indices of the columns whose objective function coefficients sensitivity ranges are required.

In case of .rhs.index, .index contains the indices of the rows whose RHS coefficients sensitivity ranges are required.

In both cases, the .index array has to be sorted, ascending.

To get an SA of objective function on the four variables 120 to 123 (included) and variable

6 the saRequest structure would look like this:

saRequest.obj.index = [6 120 121 122 123];

The result is returned through the output parameter 'sa'.
|}

====Table: Callback functions.====

{|class="wikitable"
!Index||m-file||Description
|-valign="top"
|(1)||xpcb_USN||User Select Node Callback
|-valign="top"
|(2)||xpcb_UPN||User Preprocess Node Callback
|-valign="top"
|(3)||xpcb_UON||User Optimal Node Callback
|-valign="top"
|(4)||xpcb_UIN||User Infeasible Node Callback
|-valign="top"
|(5)||xpcb_UIS||User Integer Solution Callback
|-valign="top"
|(6)||xpcb_UCN||User Node Cut-off Callback
|-valign="top"
|(7)||xpcb_UCB||User Choose Branching Variable Callback
|-valign="top"
|(8)||xpcb_IL||Simplex Log Callback
|-valign="top"
|(9)||xpcb_GL||Global Log Callback
|-valign="top"
|(10)||xpcb_BL||Barrier Log Callback
|-valign="top"
|(11)||xpcb_UOP||User Output Callback
|-valign="top"
|(12)||xpcb_CMI||User Defined Cut Manager Init Routine
|-valign="top"
|(13)||xpcb_CMS||User Defined Cut Manager Termination Routine
|-valign="top"
|(14)||xpcb_CM||User Defined Cut Manager Routine
|-valign="top"
|(15)||vxpcb_TCM||User Defined Top Cut Manager Routine
|}

====Description of Outputs====

The following fields are used:

{|class="wikitable"
!Output||Description
|-valign="top"
|''x''||Solution vector ''x ''with decision variable values (''n × ''1 vector).
|-valign="top"
|''slack''||Slack variables (''m × ''1 vector).
|-valign="top"
|''v''||Lagrangian multipliers (dual solution vector) (''m × ''1 vector).
|-valign="top"
|''rc ''||Reduced costs. Lagrangian multipliers for simple bounds on ''x''.
|-valign="top"
|''f_k ''||Objective function value ''f ''(''x'') = ''cT * x ''at optimum.
|-valign="top"
|''ninf ''||Number of infeasibilities.
|-valign="top"
|''sinf ''||Sum of infeasibilities.
|-valign="top"
|''Inform ''||Result of Xpress''M P'' run:

{|class="wikitable"
|0||Optimal solution found.
|-valign="top"
|2||Unbounded solution.
|-valign="top"
|4||Infeasible problem.
|-valign="top"
|5||Some error occurred.
|}

See the Xpress''MP'' problem attributes XPRS LPSTATUS (for LP and QP) and XPRS MIPSTATUS (for MILP and MIQP) for more exact information. They are available in the global variable ''xpProblemAttrib''.
|-valign="top"
|''basis ''||Basis status of constraints and variables, (''m ''+ ''n × ''1 vector).
|-valign="top"
|''lpiter''||Number of simplex iterations.
|-valign="top"
|''glnodes''||Number of nodes visited.
|-valign="top"
|''iis''||Structure containing IIS information (niis x 1). niis is the number of IISs found (see MAXIIS parameter). The fields:
|-valign="top"
|''iisStatus''||Status flag. (Only set in the first element of the iis array.) Possible values:

2 = IIS was written to file LPprob.iis.

1 = IIS was obtained.

-1 = Problem was infeasible but no IIS found.

-2 = Problem was not infeasible.
|-valign="top"
|''iisMessage''||Error message on error. (Only set in the first element of the iis array.)
|-valign="top"
|''colind''||The column indices of the IIS set.
|-valign="top"
|''rowind ''||The row indices of the IIS set.
|-valign="top"
|''sa''||Structure with information about the requested SA, if requested. The fields:
|-valign="top"
|''obj''||Ranges for the variables in the objective function.
|-valign="top"
|''rhs''||Ranges for the right hand side values.
|-valign="top"
|colspan="2"|These fields are structures themselves. All four structures have identical field names:
|-valign="top"
|''status''||Status of the SA operation. Possible values:

1 = Successful.

0 = SA not requested.

-1 = Error: MIP problem was presolved.
|-valign="top"
|''lower ''||The lower range.
|-valign="top"
|''upper ''||The upper range.
|}

====Global Parameters Used====

{|class="wikitable"
!Parameter||Description
|-valign="top"
|''xpControlVariables''||Structure with all Xpress''MP'' control variables listed in Section 7 in the Xpress-Optimizer Reference Manual. Available with fresh variables in each callback, and after the optimization.
|-valign="top"
|''xpProblemAttrib''||Structure with all Xpress''MP'' problem attributes listed in Section 8 in the Xpress-Optimizer Reference Manual. Available with fresh values in each callback, and after the optimization.
|}

====Description====

The interface routine ''xpress'' calls Xpress ''MP'' to solve LP, QP, MILP and MIQP problems. The matrix A is transformed in xpress.m to the Xpress ''MP'' sparse matrix format. Error checking is made on the lengths of the vectors and matrices.

===xpressTL===

====Purpose====

The TOMLAB ''/''Xpress MILP, MIQP, LP and QP Interface. It solves linear programming (LP), quadratic programming (QP), mixed integer linear programming (MILP) and mixed integer quadratic programming problems (MIQP). ''xpressTL ''solves problems of the form

<math>
\begin{array}{cccccc}
\min\limits_{x} & f(x) = 0.5*x^T*F*x + c^T*x \\
s/t & x_{L} & \leq & x & \leq & x_{U} \\
& b_{L} & \leq & Ax & \leq & b_{U} \\
& & & x_i \mathrm{\ \ integer} & & i \in I \\
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^{n}</math>, <math>F\in \mathbb{R}^{n\times n}</math> and <math>A\in \mathbb{R}^{m\times n}</math>. The variables <math>b_L, b_U \in
\mathbb{R}^{m}</math>, the index subset of <math>1,...,n</math>, are restricted to be integers.

====Calling Syntax====

<pre>
Prob = ProbCheck(Prob, 'xpress');
Result = xpressTL(Prob);
</pre>

====Description of Inputs====

''Prob'', the problem structure. The following fields are used:

{|class="wikitable"
!Field||Description
|-valign="top"
|''QP.c''||Linear objective function cost coefficients, vector ''n × ''1.
|-valign="top"
|''QP.F''||Square ''n × n ''dense or sparse matrix. Empty if non-quadratic problem.
|-valign="top"
|''A''||Linear constraint matrix for linear constraints, dense or sparse ''m × n ''matrix.
|-valign="top"
|''x_L''||Lower bounds on design parameters ''x''. If empty assumed to be ''-I nf ''.
|-valign="top"
|''x_U''||Upper bounds on design parameters ''x''. If empty assumed to be ''I nf ''.
|-valign="top"
|''b_L''||Lower bounds on the linear constraints.
|-valign="top"
|''b_U''||Upper bounds on the linear constraints.
|-valign="top"
|''PriLev''||Printing level in the ''xpress m''-file and the Xpress''M P ''C-interface.

= 0 Silent

= 1 Summary information

= 2 More detailed information
|-valign="top"
|''MIP.IntVars''||Defines which variables are integers, of the general type ''I ''or binary ''B''. Variable indices should be in the range [1,...,n]. If ''IntVars'' is a logical vector then all variables ''i ''where ''I ntV ars''(''i'') ''> ''0 are defined to be integers. If ''IntV ars ''is determined to be a vector of indices then ''x''(''IntVars'') are defined as integers. If the input is empty ([ ]), then no integers of type I or B are defined. The interface routine ''xpress ''checks which of the integer variables have lower bound ''xL ''= 0 and upper bound ''xU ''= 1, i.e. are binary 0/1 variables.
|-valign="top"
|''MIP.PI''||Integer variables of type ''Partially Integer ''(PI), i.e. takes an integer value up to a specified limit, and any real value above that limit. PI must be a structure array where:

''PI.var ''is a vector of variable indices in the range [1'', ..., n''].
|-valign="top"
|''PI.lim''||is a vector of limit values for each of the variables specified in PI.var, i.e. for variable ''i'', that is the PI variable with index ''j''in ''P I .var'', then ''x''(''i'') takes integer values in [''xL ''(''i'')'', P I .lim''(''j'')] and continuous values in [''P I .lim''(''j'')'', xU ''(''i'')].
|-valign="top"
|''MIP.SC''||A vector with indices for the integer variables of type ''Semi-continuous ''(SC), i.e. that takes either the value 0 or a real value in the range [''xL ''(''i'')'', xU ''(''i'')], assuming for some ''j'', that ''i ''= ''SC ''(''j''), where ''i ''is an variable number in the range [1'', ..., n''].
|-valign="top"
|''MIP.SI''||A vector with indices for the integer variables of type ''Semi-integer ''(SI), i.e. that takes either the value 0 or an integer value in the range [''xL ''(''i'')'', xU ''(''i'')], assuming for some ''j'', that ''i ''= ''SI ''(''j''), where ''i ''is an variable number in the range [1'', ..., n''].
|-valign="top"
|''MIP.sos1''||A structure defining the ''Special Ordered Sets of Type One ''(sos1). Assume there are ''k ''sets of type sos1, then ''sos''1(''k'')''.var ''is a vector of indices for variables of type sos1 in set ''k''. ''sos''1(''k'')''.row ''is the row number for the reference row identifying the ordering information for the sos1 set, i.e. A(sos1(k).row,sos1(k).var) identifies this information. As ordering information, also the objective function coefficients ''c ''could be used. Then as row number, 0 is instead given in ''sos''1(''k'')''.row''.
|-valign="top"
|''MIP.sos2''||A structure defining the ''Special Ordered Sets of Type Two ''(sos2). Specified exactly as sos1 sets, see ''M I P.sos''1 input variable description.
|-valign="top"
|''MIP.KNAPSACK''||True if a knapsack problem is to be solved and a knapsack heuristic is to be used. Also ''MIP.callback''(9) = 1 must be set if the heuristic is to be executed.
|-valign="top"
|''MIP.xpcontrol''||Structure, where the fields are set to the Xpress''M P ''control parameters that the user wants to specify values for. The control parameters are listed in Section 7 in the Xpress-Optimizer Reference Manual. The prefix XPRS is not used.
|-valign="top"
|''MIP.callback''||Logical vector defining which callbacks to use in Xpress''M P ''. If the ''i''th entry of the logical vector ''callback ''is set, the corresponding callback is defined. The callback calls the m-file specified in the Table 12 below. The user may edit this file, or make a new copy, which is put in a directory that is searched before the ''xpress ''directory in the Matlab path.
|-valign="top"
|''optParam''||Structure with special fields for optimization parameters

Fields used are: ''MaxIter ''- Maximal number of iterations or node visits.
|-valign="top"
|''XPRESS.LogFile''||File to write Xpress-MP log output to. Default is empty " in which case nothing is written.

Please note that Xpress-MP appends it's output to the log file.
|-valign="top"
|''XPRESS.SaveFile''||Filename for writing the problem prior to calling the Xpress-MP solver. If empty, no file is written. The type of output is determined by the SaveMode parameter. Xpress-MP will always add an extension to the filename given here. The extension depends on the SaveMode chosen, see below.
|-valign="top"
|''XPRESS.SaveMode''||Character string with any combination of the following character flags:

p - full precision of numerical values. o - one element per line.

n - scaled.

s - scrambled vector names. l - output in LP format.

The extension added to the SaveFile name is .mat, unless the 'l' flag is used in which case the extension is .lp.
|-valign="top"
|''iis''||Flag indicating whether to compute an IIS and return it to MATLAB. This option can only be set for an LP problem. If an IIS is found, XPRESS automatically changes the problem to make it feasible and reoptimizes it.

= 0, Don't return IIS to MATLAB (default).

= 1, Compute IIS and return it to MATLAB if an LP problem has been proven infeasible. The IIS is returned through the output parameter 'iis'.
|-valign="top"
|''iisFile''||Flag indicating whether to write a file describing the IIS set or not. If is set to 1, a file: LPprob.iis will be written. Otherwise, no file is written.
|-valign="top"
|''sa''||Structure telling whether and how you want XPRESS to perform a sensitivity analysis (SA).

You can complete an SA on the objective function and right hand side vector. The saRequest structure contains two sub structures:

.obj and .rhs

They have one field each:

.index

In case of .obj.index, .index contains the indices of the columns whose objective function coefficients sensitivity ranges are required.

In case of .rhs.index, .index contains the indices of the rows whose RHS coefficients sensitivity ranges are required.

In both cases, the .index array has to be sorted, ascending.

To get an SA of objective function on the four variables 120 to 123 (included) and variable

6 the saRequest structure would look like this:

saRequest.obj.index = [6 120 121 122 123];

The result is returned through the output parameter 'sa'.

{|class="wikitable"
|+<caption>Callback functions.</caption>
!Index||m-file||Description
|-valign="top"
|(1)||xpcb_USN||User Select Node Callback
|-valign="top"
|(2)||xpcb_UPN||User Preprocess Node Callback
|-valign="top"
|(3)||xpcb_UON||User Optimal Node Callback
|-valign="top"
|(4)||xpcb_UIN||User Infeasible Node Callback
|-valign="top"
|(5)||xpcb_UIS||User Integer Solution Callback
|-valign="top"
|(6)||xpcb_UCN||User Node Cut-off Callback
|-valign="top"
|(7)||xpcb_UCB||User Choose Branching Variable Callback
|-valign="top"
|(8)||xpcb_IL||Simplex Log Callback
|-valign="top"
|(9)||xpcb_GL||Global Log Callback
|-valign="top"
|(10)||xpcb_BL||Barrier Log Callback
|-valign="top"
|(11)||xpcb_UOP||User Output Callback
|-valign="top"
|(12)||xpcb_CMI||User Defined Cut Manager Init Routine
|-valign="top"
|(13)||xpcb_CMS||User Defined Cut Manager Termination Routine
|-valign="top"
|(14)||xpcb_CM||User Defined Cut Manager Routine
|-valign="top"
|(15)||xpcb_TCM||User Defined Top Cut Manager Routine
|}

|}

====Description of Outputs====

''Result ''structure. The following fields are used:

{|class="wikitable"
!Output||Description
|-valign="top"
|''Iter''||Number of iterations, or nodes visited.
|-valign="top"
|''ExitFlag''||0: OK.

1: Maximal number of iterations reached.

2: Unbounded feasible region.

4: No feasible point found.

5: Error of some kind.
|-valign="top"
|''Inform''||If a MIP problem the control variable XPRS MIPSTATUS (xpControlVariables.MIPSTATUS) else XPRS LPSTATUS (xpControlVariables.LPSTATUS).
|-valign="top"
|''x_0''||Initial starting point not known, set as empty.
|-valign="top"
|''QP.B''||Optimal active set, basis vector, in TOMLAB QP standard.

''B''(''i'') = 1: Include variable ''x''(''i'') is in basic set.

''B''(''i'') = 0: Variable ''x''(''i'') is set on its lower bound.

''B''(''i'') = ''-''1: Variable ''x''(''i'') is set on its upper bound.
|-valign="top"
|''f_k''||Function value at optimum, ''f ''(''xk '').
|-valign="top"
|''g_k''||Gradient value at optimum, ''c ''or ''c ''+ ''F * x''.
|-valign="top"
|''x_k''||Optimal solution vector ''xk ''.
|-valign="top"
|''v_k''||Lagrangian multipliers (for bounds and dual solution vector). Set as ''vk ''= [''rc''; ''v''], where ''rc'' is the ''n''-vector of reduced costs and ''v ''holds the ''m ''dual variables.
|-valign="top"
|''xState''||State of each variable.

0 = nonbasic (on x_L), 1 = nonbasic (on x_U), 2 = superbasic (between bounds), 3 = basic

(between bounds)
|-valign="top"
|''bState''||State of each constraint.

0 = nonbasic (on b L), 1 = nonbasic (on b U), 2 = superbasic (between bounds), 3 = basic

(between bounds)
|-valign="top"
|''Solver''||Solver used - Xpress''M P''.
|-valign="top"
|''SolverAlgorithm''||Solver algorithm used.
|-valign="top"
|''FuncEv''||Number of function evaluations. Set to ''Iter''. ''GradEv ''Number of gradient evaluations. Set to ''Iter''. ''ConstrEv ''Number of constraint evaluations. Set to ''Iter''. ''Prob'' Problem structure used.
|-valign="top"
|''MIP.ninf''||Number of infeasibilities.
|-valign="top"
|''MIP.sinf''||Sum of infeasibilities.
|-valign="top"
|''MIP.slack''||Slack variables (''m × ''1 vector).
|-valign="top"
|''MIP.lpiter''||Number of LP iterations.
|-valign="top"
|''MIP.glnodes''||Number of nodes visited.
|-valign="top"
|''MIP.basis''||Basis status of constraints and variables (''m ''+ ''n × ''1 vector) in the Xpress''MP'' format, fields xState and bState has the same information in the Tomlab format.
|-valign="top"
|''MIP.xpControlVariables''||Structure with all Xpress''M P'' control variables listed in Section 7 in the Xpress-Optimizer eference Manual [1].
|-valign="top"
|''MIP.xpProblemAttrib''||Structure with all Xpress''M P'' problem attributes listed in Section 8 in the Xpress-Optimizer Reference Manual [1].
|-valign="top"
|''XPRESS.iis''||Structure containing IIS information (niis x 1). niis is the number of IISs found (see MAXIIS parameter). The fields:
|-valign="top"
|''iisStatus''||Status flag. (Only set in the first element of the iis array.) Possible values:

2 = IIS was written to file LPprob.iis.

1 = IIS was obtained.

-1 = Problem was infeasible but no IIS found.

-2 = Problem was not infeasible.
|-valign="top"
|''iisMessage ''||Error message on error. (Only set in the first element of the iis array.)
|-valign="top"
|''colind ''||The column indices of the IIS set.
|-valign="top"
|''rowind ''||The row indices of the IIS set.
|-valign="top"
|''XPRESS.sa ''||Structure with information about the requested SA, if requested. The fields:
|-valign="top"
|''obj ''||Ranges for the variables in the objective function.
|-valign="top"
|''rhs ''||Ranges for the right hand side values.
|-valign="top"

|colspan="2"|These fields are structures themselves. All four structures have identical field names:
|-valign="top"
|''status''||Status of the SA operation. Possible values:

1 = Successful.

0 = SA not requested.

-1 = Error: MIP problem was presolved.
|-valign="top"
|''lower''||The lower range.
|-valign="top"
|''upper''||The upper range.
|}

====Global Parameters Used====

{|class="wikitable"
|''xpControlVariables''||Structure with all Xpress''M P'' control variables listed in Section 7 in the Xpress- Optimizer Reference Manual [1]. Available with fresh variables in each callback, and after the optimization.
|-valign="top"
|''xpProblemAttrib''||Structure with all Xpress''M P'' problem attributes listed in Section 8 in the Xpress- Optimizer Reference Manual [1]. Available with fresh variables in each callback, and after the optimization.
|}

====Description====

The TOMLAB Xpress''M P ''MILP, MIQP, QP and LP interface calls the interface routine ''xpress.m''. Values ''> ''1020 and ''I nf ''values are set to 1020 , and the opposite for negative numbers. An empty objective coefficient ''c''-vector is set to the zero-vector.

====Examples====

See ''mip prob''

====M-files Used====

''xpress.m'', ''mipRun.m''

====See Also====

''mipSolve''

Xpress Test Routines in Tomlab Format

2012-01-22T17:26:42Z

Elias:

{{Part Of Manual|title=the Xpress Manual|link=[[Xpress|Xpress Manual]]}}
A set of test routines have been defined illustrating the combined use of TOMLAB and Xpress''MP''. The test routines are shown in [[#Table: The test routines and utilities.]]. The knapsack test routine ''xpknapsTL'' is similar to ''xpknaps'' discussed in the previous subsection. It runs three knapsack test examples. It is possible to change the cut strategy and whether to use the knapsack heuristic in the callback routine ''xpcb_gl''. The problems are setup using the TOMLAB format.

====Table: The test routines and utilities.====

{|class="wikitable"
!Function||Description
|-valign="top"
|[[Xpress Appendix C#xptomtest1|xptomtest1]]||Tests of problems predefined in the TOMLAB IF format. LP, QP and MIP problems are solved calling the driver routine ''tomRun''.
|-valign="top"
|[[Xpress Appendix C#xptomtest2|xptomtest2]]||Tests of a simple MIP problem defined in the TOMLAB (TQ) format.

The problem is solved as an LP and MIP problem, with or without slacks defined. ''tomRun''.
|-valign="top"
|[[Xpress Appendix C#xpknapsTL|xpknapsTL]]||The same tests as in ''xpknaps'', but the TOMLAB format and system is used.
|}

The following example shows how to run a predefined problem, one of the problems in ''xpknapsTL'', using the TOMLAB Init File (IF) format. Some fields that changes control variables are set to make Xpress''MP'' work slower. Then a simple predefined heuristic is run to try to improve the convergence. For this example it can get down the number of node visited from 135 to 35.

<pre>
Prob = ProbInit('mip_prob',7); % Create Prob structure from predefined problem
Prob.MIP
ans =
xpcontrol: []
IntVars: [30x1 double]
VarWeight: [30x1 double]
KNAPSACK: 1
callback: [14x1 double]
% Make Xpress-MP work slower by disabling presolve and cuts.
Prob.MIP.xpcontrol.CUTSTRATEGY = 0; % Use no cuts
Prob.MIP.xpcontrol.PRESOLVE = 0; % Use no presolve
Prob.MIP.xpcontrol.MIPLOG = 3; % Call the callback each node
Result = tomRun('xpress-mp',Prob,1); % Call Xpress-MP using Tomlab driver

===== * * * =============================================== * * *
TOMLAB SOL - Three weeks demonstration single user license
=================================================================
Problem: mip_prob - 7: Weingartner 1 - 2/28 0-1 knapsack f_k -141278.000000000000000000
User given f(x_*)-141278.000000000000000000

Solver: Xpress-MP. EXIT=0. INFORM=6.
Mex-interface to Xpress-MP LP/QP/MIP/MIQP solver
Global search complete - integer solution found

FuncEv 135 GradEv 0 Iter 135
CPU time: 0.250000 sec. Elapsed time: 0.250000 sec.

Prob.MIP.callback(9) = 1; % Enable Global Log callback
Result = tomRun('xpress-mp',Prob,1);
% Because Prob.MIP.KNAPSACK == 1, the predefined heuristic is tried

--- Global Log. Node 1. Node depth 1. Best Bound -142019.000000.
Node 1: LP-obj -142019; Heuristic value -139508 *** Updated cutoff to -139507
--- Global Log. Node 2. Node depth 2. Best Bound -142019.000000.
Node 2: LP-obj -141897; Heuristic value -140768 *** Updated cutoff to -140767
--- Global Log. Node 3. Node depth 3. Best Bound -142019.000000.
Node 3: LP-obj -141873; Heuristic value -138493
--- Global Log. Node 4. Node depth 4. Best Bound -142019.000000.
Node 4: LP-obj -141726; Heuristic value -139618
--- Global Log. Node 5. Node depth 3. Best Bound -142019.000000.
Node 5: Not applying heuristic (status is Cutoff in dual)
--- Global Log. Node 6. Node depth 5. Best Bound -142019.000000.
Node 6: LP-obj -141707; Heuristic value -138168
--- Global Log. Node 7. Node depth 6. Best Bound -142019.000000.
Node 7: LP-obj -141655; Heuristic value -138068
--- Global Log. Node 8. Node depth 5. Best Bound -142019.000000.
Node 8: Not applying heuristic (status is Cutoff in dual)
--- Global Log. Node 9. Node depth 6. Best Bound -142019.000000.
Node 9: Not applying heuristic (status is Infeasible)
--- Global Log. Node 10. Node depth 6. Best Bound -142019.000000.
Node 10: Not applying heuristic (status is Cutoff in dual)
--- Global Log. Node 11. Node depth 2. Best Bound -142019.000000.
Node 11: LP-obj -141465; Heuristic value -139508
--- Global Log. Node 12. Node depth 3. Best Bound -142019.000000.
Node 12: LP-obj -141062; Heuristic value -139933
--- Global Log. Node 13. Node depth 3. Best Bound -142019.000000.
Node 13: Not applying heuristic (status is Infeasible)
--- Global Log. Node 14. Node depth 3. Best Bound -142019.000000.
Node 14: Not applying heuristic (status is Cutoff in dual)
--- Global Log. Node 15. Node depth 3. Best Bound -141896.953125.
Node 15: LP-obj -141721; Heuristic value -141278 *** Updated cutoff to -141277
--- Global Log. Node 16. Node depth 4. Best Bound -141896.953125.
Node 16: LP-obj -141694; Heuristic value -141168
--- Global Log. Node 17. Node depth 5. Best Bound -141896.953125.
Node 17: LP-obj -141640; Heuristic value -141168
--- Global Log. Node 18. Node depth 6. Best Bound -141896.953125.
Node 18: LP-obj -141572; Heuristic value -141278 *** Updated cutoff to -141277
--- Global Log. Node 19. Node depth 7. Best Bound -141896.953125.
Node 19: LP-obj -141360; Heuristic value -141258
--- Global Log. Node 20. Node depth 7. Best Bound -141896.953125.
Node 20: LP-obj -141565; Heuristic value -141278 *** Updated cutoff to -141277
--- Global Log. Node 21. Node depth 8. Best Bound -141896.953125.
Node 21: LP-obj -141349; Heuristic value -141247
--- Global Log. Node 22. Node depth 8. Best Bound -141896.953125.
Node 22: LP-obj -141498; Heuristic value -141278 *** Updated cutoff to -141277
--- Global Log. Node 23. Node depth 8. Best Bound -141896.953125.
Node 23: Not applying heuristic (status is Infeasible)
--- Global Log. Node 24. Node depth 8. Best Bound -141896.953125. Best MIP f(x) -141278.000000
Node 24: B&B integer solution found; objval -141278
--- Global Log. Node 25. Node depth 8. Best Bound -141726.000000. Best MIP f(x) -141278.000000
Node 25: B&B integer solution found; objval -141056
--- Global Log. Node 26. Node depth 4. Best Bound -141720.515625. Best MIP f(x) -141278.000000
Node 26: B&B integer solution found; objval -140695
--- Global Log. Node 27. Node depth 3. Best Bound -141693.593750. Best MIP f(x) -141278.000000
Node 27: B&B integer solution found; objval -141524
--- Global Log. Node 28. Node depth 4. Best Bound -141640.000000. Best MIP f(x) -141278.000000
Node 28: B&B integer solution found; objval -140974
--- Global Log. Node 29. Node depth 3. Best Bound -141465.140625. Best MIP f(x) -141278.000000
Node 29: LP-obj -141341; Heuristic value -139398
--- Global Log. Node 30. Node depth 3. Best Bound -141465.140625. Best MIP f(x) -141278.000000
Node 30: Not applying heuristic (status is Cutoff in dual)
--- Global Log. Node 31. Node depth 3. Best Bound -141465.140625. Best MIP f(x) -141278.000000
Node 31: Not applying heuristic (status is Infeasible)
--- Global Log. Node 32. Node depth 3. Best Bound -141360.000000. Best MIP f(x) -141278.000000
Node 32: Not applying heuristic (status is Cutoff in dual)
--- Global Log. Node 33. Node depth 7. Best Bound -141360.000000. Best MIP f(x) -141278.000000
Node 33: Not applying heuristic (status is Infeasible)
--- Global Log. Node 34. Node depth 7. Best Bound -141349.000000. Best MIP f(x) -141278.000000
Node 34: Not applying heuristic (status is Cutoff in dual)
--- Global Log. Node 35. Node depth 8. Best Bound -141349.000000. Best MIP f(x) -141278.000000
Node 35: Not applying heuristic (status is Infeasible)

===== * * * =============================================== * * *
TOMLAB SOL - Three weeks demonstration single user license
=================================================================
Problem: mip_prob - 7: Weingartner 1 - 2/28 0-1 knapsack f_k -141278.000000000000000000
User given f(x_*)-141278.000000000000000000

Solver: Xpress-MP. EXIT=0. INFORM=6.
Mex-interface to Xpress-MP LP/QP/MIP/MIQP solver
Global search complete - integer solution found

FuncEv 35 GradEv 0 Iter 35
CPU time: 3.156000 sec. Elapsed time: 3.156000 sec.
</pre>

The following example shows how to define and solve a problem using the TOMLAB Format (TQ). The matrices and vectors for the problem is defined in a ''mat ''file. Fields that changes the Xpress''MP'' control variables are set to show how to influence the work of the solver. In this case the changes slow down its performance.

<pre>
clear all
load bilp1.mat
whos
Name Size Bytes Class

A 27x1956 422496 double array
b_L 27x1 216 double array
b_U 27x1 216 double array
c 1956x1 15648 double array
noivars 1956x1 15648 double
x_L 1956x1 15648 double array
x_U 1956x1 15648 double array

Grand total is 58735 elements using 469880 bytes

Prob = mipAssign(c, A, b_L, b_U, x_L, x_U,[],'bilp1',[],[],noivars);
Result = tomRun('xpress-mp',Prob,1);

===== * * * =============================================== * * *
TOMLAB SOL - Three weeks demonstration single user license
=================================================================
Problem: No Init File - 1: bilp1 f_k 0.000000000000000000
sum(|constr|) 0.000000000000025960

Solver: Xpress-MP. EXIT=0. INFORM=6.
Mex-interface to Xpress-MP LP/QP/MIP/MIQP solver
Global search complete - integer solution found

FuncEv 67 GradEv 0 Iter 67
CPU time: 4.359000 sec. Elapsed time: 4.375000 sec.

=== * * * ================================================== * * *

Prob.MIP
ans =
IntVars: 1956
VarWeight: []
KNAPSACK: []
fIP: []
xIP: []
PI: []
SC: []
SI: []
sos1: []
sos2: []

% Make Xpress-MP work slower by disabling presolve and cuts.
Prob.MIP.xpcontrol.CUTSTRATEGY = 0;
Prob.MIP.xpcontrol.MIPPRESOLVE = 0;
Prob.MIP.xpcontrol.PRESOLVE = 0;
Result = tomRun('xpress-mp',Prob,2);

===== * * * =============================================== * * *
TOMLAB SOL - Three weeks demonstration single user license
=================================================================
Problem: No Init File - 1: bilp1 f_k 0.000000000000000000
sum(|constr|) 0.000000000000020365

Solver: Xpress-MP. EXIT=0. INFORM=6.
Mex-interface to Xpress-MP LP/QP/MIP/MIQP solver
Global search complete - integer solution found

FuncEv 105 GradEv 0 Iter 105
CPU time: 0.578000 sec. Elapsed time: 0.578000 sec.

=== * * * ================================================== * * *

Prob.MIP.xpcontrol.MIPPRESOLVE = 7; % Try another MIPPRESOLVE value
Result = tomRun('xpress-mp', Prob, 1);

===== * * * =============================================== * * *
TOMLAB SOL - Three weeks demonstration single user license
=================================================================
Problem: No Init File - 1: bilp1 f_k 0.000000000000000000
sum(|constr|) 0.000000000000011373

Solver: Xpress-MP. EXIT=0. INFORM=6.
Mex-interface to Xpress-MP LP/QP/MIP/MIQP solver
Global search complete - integer solution found

FuncEv 82 GradEv 0 Iter 82
CPU time: 3.250000 sec. Elapsed time: 3.250000 sec.
</pre>

Xpress Test Routines in Non-Tomlab Format

2012-01-22T17:25:00Z

Elias:

{{Part Of Manual|title=the Xpress Manual|link=[[Xpress|Xpress Manual]]}}
A set of test routines have been defined illustrating the use of the ''xpress ''main routine. The test routines and utilities are shown in [[#Table: The test routines and utilities.]].

It is easy to call the test routines, e.g.

<pre>
x = xptest1;
x = xptest2;
x = xptest3;
</pre>

will call the three routines solving GAP problems. The ''xpaircrew ''test problem has no input parameters, just call:

<pre>
xpaircrew;
</pre>

The knapsack test routine runs three test examples. It is possible to change the cut strategy (third input parameter) and whether to use the knapsack heuristic in the callback routine ''xpcb_gl ''(second input parameter). To run the second test example, using the simple knapsack heuristic, and aggressive cuts, the call is

<pre>
xpknaps(2,1,2);
</pre>

The first parameter selects the test problem. Calling without any parameters

<pre>
xpknaps
</pre>

is the same as the call

<pre>
xpknaps(1,0,0);
</pre>

====Table: The test routines and utilities.====

{|class="wikitable"
!Function||Description
|-valign="top"
|[[Xpress Appendix B#abc2gap|abc2gap]]||Utility to convert a Generalized Assignment Problem (GAP) to standard form for Xpress''MP''.
|-valign="top"
|[[Xpress Appendix C#xpbiptest|xpbiptest]]||Test of three large binary integer linear problems.
|-valign="top"
|[[Xpress Appendix C#xpiptest|xpiptest]]||Test of three large integer linear problems.
|-valign="top"
|[[Xpress Appendix C#xpknaps|xpknaps]]||Test of knapsack problems.
|-valign="top"
|[[Xpress Appendix C#xptest1|xptest1]]||Test of a Generalized Assignment Problem (GAP).
|-valign="top"
|[[Xpress Appendix C#xptest2|xptest2]]||Test of the same GAP problem as ''xptest1'', but using sos1 variables.
|-valign="top"
|[[Xpress Appendix C#xptest3|xptest3]]||Test of a Generalized Assignment Problem (GAP).
|}

Xpress Callbacks in Matlab

2012-01-22T17:22:46Z

Elias:

{{Part Of Manual|title=the Xpress Manual|link=[[Xpress|Xpress Manual]]}}
There are eleven of the Xpress''MP'' callbacks defined in the interface. A logical vector defines the callbacks to be used in Xpress ''MP''. This vector is named ''callback ''and is one of the input variables to the level 1 interface routine ''xpress''. If the ''i''th entry of the logical vector callback is set, the corresponding callback is defined. The callback calls the ''m''-file specified in [[#Table: The m-file callback routines.]]. The user can edit this ''m''-file directly, or make a new copy. It is important that a new copy is placed in a directory that is searched before the ''xpress ''directory when Matlab goes through the Matlab path.

====Table: The m-file callback routines.====

{| class="wikitable"
|+<caption>The m-file callback routines.</caption>
|-valign="top"
!Index||m-file||Description||Section
|-valign="top"
|(1)||xpcb_usn||User Select Node Callback||[[Xpress Appendix D#xpcb_usn]]
|-valign="top"
|(2)||xpcb_upn||User Preprocess Node Callback||[[Xpress Appendix D#xpcb_upn]]
|-valign="top"
|(3)||xpcb_uon||User Optimal Node Callback||[[Xpress Appendix D#xpcb_uon]]
|-valign="top"
|(4)||xpcb_uin||User Infeasible Node Callback||[[Xpress Appendix D#xpcb_uin]]
|-valign="top"
|(5)||xpcb_uis||User Integer Solution Callback||[[Xpress Appendix D#xpcb_uis]]
|-valign="top"
|(6)||xpcb_ucn||User Node Cut-off Callback||[[Xpress Appendix D#xpcb_ucn]]
|-valign="top"
|(7)||xpcb_ucb||User Choose Branching Variable Callback||[[Xpress Appendix D#xpcb_ucb]]
|-valign="top"
|(8)||xpcb_il||Simplex Log Callback||[[Xpress Appendix D#xpcb_il]]
|-valign="top"
|(9)||xpcb_gl||Global Log||[[Xpress Appendix D#xpcb_gl]]
|-valign="top"
|(10)||xpcb_bl||Barrier Log Callback||[[Xpress Appendix D#xpcb_bl]]
|-valign="top"
|(11)||xpcb_uop||User Output Callback||[[Xpress Appendix D#xpcb_uop]]
|}

Before each call to the callback routine, the interface is defining the control variables and problem attributes as global variables in Matlab. By making the following global declarations in the callback ''m''-file,

<pre>
global xpControlVariables xpProblemAttrib
</pre>

all control variables and problem attributes are accessible as subfields to the global variables.

The ''Prob ''structure is input to all callback ''m''-file routines as the last parameter. If TOMLAB calls ''xpress'', then ''Prob ''is the standard TOMLAB problem structure, otherwise the user optionally can set: ''Prob.P ''= ''ProblemNumber'';, where ProblemNumber is some integer. If any callback is defined (see description of callback) then the arrays that define the current problem are set by the interface as fields in ''Prob''. The defined fields are ''Prob.c'', ''Prob.x_L'', ''Prob.x_U'', ''Prob.A'', ''Prob.b_L'', ''Prob.b_U ''and. ''Prob.QP.F''. The user then has full access to the original problem in the callback routine.

In one of the callback routines, ''xpcb_gl'', a simple knapsack heuristic is implemented. This heuristic is also part of the standard Xpress''MP'' example files. Running the knapsack test program ''xpknaps'', with the second input argument ''Run ''= 1 runs the knapsack heuristic in the callback. ''xpknaps'' sets ''Prob.MIP.KNAPSACK = 1'' to enable execution of the heuristic in ''xpcb_gl''.

If there are no integer variables in the problem to be solved, i.e. a pure LP or QP problem, then the first seven callbacks as well as the 9th callback (Global Log) are automatically disabled. If the problem is a mixed-integer problem, then the 8th callback (Simplex Log Callback) is disabled. This change is made on around row 254 in ''xpress.m ''and the user may comment this row (''callback''(8) = 0;) to avoid it.

TOMLAB Problem Types and Solver Routines

2012-01-22T17:20:02Z

Elias:

[[Category:Manuals]]
{{Part Of Manual|title=the TOMLAB Manual|link=[[TOMLAB|TOMLAB Manual]]}}
Section [[#Problem Types Defined in TOMLAB|Problem Types Defined in TOMLAB]] defines all problem types in TOMLAB. Each problem definition is accompanied by brief suggestions on suitable solvers. This is followed in [[#Solver Routines in TOMLAB|Solver Routines in TOMLAB]] by a complete list of the available solver routines in TOMLAB and the various available extensions, such as /SOL and /CGO.

==Problem Types Defined in TOMLAB==

===Unconstrained Optimization Problem===

The '''unconstrained optimization '''('''uc''') problem is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math> and <math>f(x) \in \mathbb{R}</math> . For unbounded variables, the corresponding elements of <math>x_L,x_U</math> may be set to <math>\pm \infty</math>.

Recommended solvers: '''TOMLAB /KNITRO and TOMLAB /SNOPT'''.

The TOMLAB Base Module routine ''ucSolve ''includes several of the most popular search step methods for unconstrained optimization. The search step methods for unconstrained optimization included in ''ucSolve ''are: the Newton method, the quasi-Newton BFGS and DFP method, the Fletcher-Reeves and Polak-Ribiere conjugate-gradient method, and the Fletcher conjugate descent method. The quasi-Newton methods may either update the inverse Hessian (standard) or the Hessian itself. The Newton method and the quasi-Newton methods updating the Hessian use a subspace minimization technique to handle rank problems. The quasi-Newton algorithms also use safe guarding techniques to avoid rank problem in the updated matrix.

Another TOMLAB Base Module solver suitable for unconstrained problems is the structural trust region algorithm ''sTrustr'', combined with an initial trust region radius algorithm. It treats partially separable functions. Safeguarded BFGS or DFP are used for the quasi-Newton update, if the analytical Hessian is not used. The set of constrained nonlinear solvers could also be used for unconstrained problems.

===Quadratic Programming Problem===

The '''quadratic programming '''('''qp''') problem is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n \times n}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{m_1}</math>.

Recommended solvers: '''TOMLAB /KNITRO, TOMLAB /SNOPT and TOMLAB /MINLP'''.

A positive semidefinite ''F ''-matrix gives a convex QP, otherwise the problem is nonconvex. Nonconvex quadratic programs are solved with a standard active-set method, implemented in the TOM routine ''qpSolve''. ''qpSolve ''explicitly treats both inequality and equality constraints, as well as lower and upper bounds on the variables (simple bounds). It converges to a local minimum for indefinite quadratic programs.

In TOMLAB ''MINOS ''in the general or the QP-version (''QP-MINOS''), or the dense QP solver ''QPOPT ''may be used. In the TOMLAB /SOL extension the ''SQOPT ''solver is suitable for both dense and large, sparse convex QP and ''SNOPT ''works fine for dense or sparse nonconvex QP.

For very large-scale problems, an interior point solver is recommended, such as TOMLAB /KNITRO or TOMLAB /BARNLP.

TOMLAB /CPLEX, TOMLAB /Xpress and TOMLAB /XA should always be considered for large-scale QP problems.

===Constrained Nonlinear Optimization Problem===

The '''constrained nonlinear optimization '''problem ('''con''') is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
c_{L} & \leq & c(x) & \leq & c_{U} \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A
\in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math>
and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.

Recommended solvers: '''TOMLAB /SNOPT, TOMLAB /NPSOL and TOMLAB /KNITRO'''.

For general constrained nonlinear optimization a sequential quadratic programming (SQP) method by Schittkowski is implemented in the TOMLAB Base Module solver ''conSolve''. ''conSolve ''also includes an implementation of the Han-Powell SQP method. There are also a TOMLAB Base Module routine ''nlpSolve ''implementing the Filter SQP by Fletcher and Leyffer.

Another constrained solver in TOMLAB is the structural trust region algorithm ''sTrustr'', described above. Currently, ''sTrustr ''only solves problems where the feasible region, defined by the constraints, is convex. TOMLAB /MINOS solves constrained nonlinear programs. The TOMLAB /SOL extension gives an additional set of general solvers for dense or sparse problems.

''sTrustr'', ''pdco ''and ''pdsco ''in TOMLAB Base Module handle nonlinear problems with ''linear ''constraints only.

There are many other options for large-scale nonlinear optimization to consider in TOMLAB. TOMLAB /CONOPT, TOMLAB /BARNLP, TOMLAB /MINLP, TOMLAB /NLPQL and TOMLAB /SPRNLP.

===Box-bounded Global Optimization Problem===

The '''box-bounded global optimization '''('''glb''') problem is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{llcccll}
-\infty < &x_{L} & \leq & x & \leq & x_{U}& < \infty , \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, i.e. problems that have finite simple bounds on all variables.

Recommended solvers: '''TOMLAB /LGO and TOMLAB /CGO with TOMLAB /SOL'''.

The TOM solver ''glbSolve ''implements the DIRECT algorithm, which is a modification of the standard Lipschitzian approach that eliminates the need to specify a Lipschitz constant. In ''glbSolve ''no derivative information is used. For global optimization problems with expensive function evaluations the TOMLAB /CGO routine ''ego ''implements the Efficient Global Optimization (EGO) algorithm. The idea of the EGO algorithm is to first fit a response surface to data collected by evaluating the objective function at a few points. Then, EGO balances between finding the minimum of the surface and improving the approximation by sampling where the prediction error may be high.

===Global Mixed-integer Nonlinear Programming Problem===

The '''global mixed-integer nonlinear programming '''('''glc''') problem is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{llcccll}
-\infty < &x_{L} & \leq & x & \leq & x_{U}& < \infty \\
&b_{L} & \leq & A x & \leq & b_{U}& \\
&c_{L} & \leq & c(x) & \leq & c_{U},& x_{j} \in \mathbb{N}\ ~~\forall j \in I
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math> and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.
The variables <math>x \in I</math>, the index subset of <math>1,...,n</math>, are restricted to be integers.

Recommended solvers: '''TOMLAB /OQNLP'''.

The TOMLAB Base Module solver ''glcSolve ''implements an extended version of the DIRECT algorithm, that handles problems with both nonlinear and integer constraints.

===Linear Programming Problem===

The '''linear programming '''('''lp''') problem is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = c^T x \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>,
<math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{m_1}</math>.

Recommended solvers: '''TOMLAB /CPLEX, TOMLAB /Xpress and TOMLAB /XA'''.
The TOMLAB Base Module solver ''lpSimplex ''implements a simplex algorithm for '''lp '''problems.

When a dual feasible point is known in (6) it is efficient to use the dual simplex algorithm implemented in the TOMLAB Base Module solver ''DualSolve''. In TOMLAB /MINOS the LP interface to ''MINOS'', called ''LP-MINOS ''is efficient for solving large, sparse LP problems. Dense problems are solved by ''LPOPT''. The TOMLAB /SOL extension gives the additional possibility of using ''SQOPT ''to solve large, sparse LP.

The recommended solvers normally outperforms all other solvers.

===Mixed-integer Programming Problem===

The '''mixed-integer programming problem '''('''mip''') is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = c^T x \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U}, ~x_{j} \in \mathbb{N}\ ~~\forall j \in I \\
\end{array}
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>, <math>A \in \mathbb{R}^{m_1
\times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{m_1}</math>. The variables <math>x
\in I</math>, the index subset of <math>1,...,n</math> are restricted to be
integers. Equality constraints are defined by setting the lower
bound equal to the upper bound, i.e. for constraint <math>i: b_{L}(i)
= b_{U}(i)</math>.

Recommended solvers: '''TOMLAB /CPLEX, TOMLAB /Xpress and TOMLAB /XA'''.

Mixed-integer programs can be solved using the TOMLAB Base Module routine ''mipSolve ''that implements a standard branch-and-bound algorithm. When dual feasible solutions are available, mipSolve is using the TOMLAB dual simplex solver DualSolve to solve subproblems, which is significantly faster than using an ordinary linear programming solver, like the TOMLAB lpSimplex. ''mipSolve ''also implements user defined priorities for variable selection, and different tree search strategies. For 0/1 - knapsack problems a round-down primal heuristic is included. Another TOMLAB Base Module solver is the cutting plane routine ''cutplane'', using Gomory cuts. It is recommended to use ''mipSolve ''with the LP version of ''MINOS ''with warm starts for the subproblems, giving great speed improvement. The TOMLAB /Xpress extension gives access to the state-of-the-art LP, QP, MILP and MIQP solver Xpress-MP. For many MIP problems, it is necessary to use such a powerful solver, if the solution should be obtained in any reasonable time frame. TOMLAB /CPLEX is equally powerful as TOMLAB /Xpress and also includes a network solver.

===Linear Least Squares Problem===

The '''linear least squares '''('''lls''') problem is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} || C x - d || \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>d \in \mathbb{R}^M</math>,
<math>C \in \mathbb{R}^{M \times n}</math>,
<math>A \in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math> and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.

Recommended solvers: '''TOMLAB /LSSOL'''.

''Tlsqr ''solves unconstrained sparse '''lls '''problems. ''lsei ''solves the general dense problems. ''Tnnls ''is

a fast and robust replacement for the Matlab nnls. The general least squares solver ''clsSolve ''may also be used.

In the TOMLAB

/NPSOL or TOMLAB /SOL extension the ''LSSOL ''solver is suitable for dense linear least squares problems.

===Constrained Nonlinear Least Squares Problem===

The '''constrained nonlinear least squares '''('''cls''') problem is defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} r(x)^T r(x) \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
c_{L} & \leq & c(x) & \leq & c_{U} \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>r(x) \in \mathbb{R}^M</math>,
<math>A \in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math>
and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.

Recommended solvers: '''TOMLAB /NLSSOL'''.

The TOMLAB Base Module nonlinear least squares solver ''clsSolve ''treats problems with bound constraints in a similar way as the routine ''ucSolve''. This strategy is combined with an active-set strategy to handle linear equality and inequality constraints.

''clsSolve ''includes seven optimization methods for nonlinear least squares problems, among them: the Gauss-Newton method, the Al-Baali-Fletcher and the Fletcher-Xu hybrid method, and the Huschens TSSM method. If rank problems occur, the solver uses subspace minimization. The line search algorithm used is the same as for unconstrained problems.

Another fast and robust solver is ''NLSSOL'', available in the TOMLAB /NPSOL or the TOMLAB /SOL extension toolbox.

One important utility routine is the TOMLAB Base Module line search algorithm ''LineSearch'', used by the solvers ''conSolve'', ''clsSolve ''and ''ucSolve''. It implements a modified version of an algorithm by Fletcher. The line search algorithm uses quadratic and cubic interpolation. Another TOMLAB Base Module routine, ''preSolve'', is running a presolve analysis on a system of linear qualities, linear inequalities and simple bounds. An algorithm by Gondzio, somewhat modified, is implemented in ''preSolve''.

===Linear Semi-definite Programming Problem===

The '''linear semi-definite programming problem with linear matrix inequalities '''('''sdp''') is defined as

<math>
\begin{array}{rccccl}
\min\limits_{x} & {f(x) = {c^T}x} \\
& \\s/t & x_{L} & \leq & x & \leq & x_{U}\\
& b_{L} & \leq & Ax & \leq & b_{U} \\
& {r}{Q^{i}_0 + Q^{i}_{k}x_{k} \sum{k=1}^{n} \preccurlyeq 0,\qquad i=1,\ldots,m.} \\
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>, <math>A \in \mathbb{R}^{m_l\times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_l}</math> and <math>Q^{i}_{k}</math> are symmetric matrices of similar dimensions in each constraint <math>i</math>. If there are several LMI constraints, each may have it's own dimension.

Recommended solvers: '''TOMLAB /PENSDP and TOMLAB /PENBMI'''.

The '''linear semi-definite programming problem with bilinear matrix inequalities '''('''bmi''') is defined similarly to but with the matrix inequality

<math>
Q^{i}_0 + \sum_{k=1}^{n} Q^{i}_{k} x_{k} + \sum_{k=1}^{n} \sum_{l=1}^{n} x_{k}x_{l} K^{i}_{kl} \preccurlyeq 0
</math>

The MEX solvers ''pensdp ''and ''penbmi ''treat '''sdp '''and '''bmi '''problems, respectively. These are available in the TOMLAB /PENSDP and TOMLAB /PENBMI toolboxes.

The MEX-file solver ''pensdp ''available in the TOMLAB /PENSDP toolbox implements a penalty method aimed at large-scale dense and sparse '''sdp '''problems. The interface to the solver allows for data input in the sparse SDPA input format as well as a TOMLAB specific format corresponding to.

The MEX-file solver ''penbmi ''available in the TOMLAB /PENBMI toolbox is similar to ''pensdp'', with added support for the bilinear matrix inequalities.

==Solver Routines in TOMLAB==

===TOMLAB Base Module===

TOMLAB includes a large set of optimization solvers. Most of them were originally developed by the Applied Optimization and Modeling group (TOM). Since then they have been improved e.g. to handle Matlab sparse arrays and been further developed. [[#Table: The optimization solvers in TOMLAB Base Module.]]. lists the main set of TOM optimization solvers in all versions of TOMLAB.

====Table: The optimization solvers in TOMLAB Base Module.====

{| class="wikitable"
!Function
!Description
|- valign="top"
|[[clsSolve]]||Constrained nonlinear least squares. Handles simple bounds and linear equality and inequality constraints using an active-set strategy. Implements Gauss-Newton, and hybrid quasi-Newton and Gauss-Newton methods.
|- valign="top"
|[[conSolve]]||Constrained nonlinear minimization solver using two different sequential quadratic programming methods.
|- valign="top"
|[[cutPlane]]||Mixed-integer programming using a cutting plane algorithm.
|- valign="top"
|[[DualSolve]]||Solves a linear program with a dual feasible starting point.
|- valign="top"
|[[glbSolve]]||Box-bounded global optimization, using only function values.
|- valign="top"
|[[glcCluster]]||Hybrid algorithm for constrained mixed-integer global optimization. Uses a combination of ''glcFast ''(DIRECT) and a clustering algorithm.
|- valign="top"
|[[glcSolve]]||Global mixed-integer nonlinear programming, using no derivatives.
|- valign="top"
|[[infSolve]]||Constrained minimax optimization. Reformulates problem and calls any suitable nonlinear solver.
|- valign="top"
|[[lpSimplex]]||Linear programming using a simplex algorithm.
|- valign="top"
|[[MilpSolve]]||Mixed-integer programming using branch and bound.
|- valign="top"
|[[L1Solve]]||Constrained L1 optimization. Reformulates problem and calls any suitable nonlinear solver.
|- valign="top"
|[[mipSolve]]||Mixed-integer programming using a branch-and-bound algorithm.
|- valign="top"
|[[nlpSolve]]||Constrained nonlinear minimization solver using a filter SQP algorithm.
|- valign="top"
|[[pdcoTL]]||Linearly constrained nonlinear minimization solver using a primal- dual barrier algorithm.
|- valign="top"
|[[pdscoTL]]||Linearly constrained nonlinear minimization solver using a primal- dual barrier algorithm, for separable functions.
|- valign="top"
|[[qpSolve]]||Non-convex quadratic programming.
|- valign="top"
|[[slsSolve]]||Sparse constrained nonlinear least squares. Reformulates problem and calls any suitable sparse nonlinear solver.
|- valign="top"
|[[sTrustr]]||Constrained convex optimization of partially separable functions, using a structural trust region algorithm.
|- valign="top"
|[[ucSolve]]||Unconstrained optimization with simple bounds on the parameters. Implements Newton, quasi-Newton and conjugate-gradient methods.
|}

Additional Fortran solvers in TOMLAB are listed in [[#Table: Additional solvers in TOMLAB.]]. They are called using a set of MEX-file interfaces developed in TOMLAB.

====Table: Additional solvers in TOMLAB.====

{| class="wikitable"
!Function
!Description
|-
|''goalSolve''||Solves sparse multi-objective goal attainment problems
|-
|''lsei''||Dense constrained linear least squares
|-
|''qld''||Convex quadratic programming
|-
|''Tfzero''||Finding a zero to f(x) in an interval, ''x '' is one-dimensional.
|-
|''Tlsqr''|| Sparse linear least squares.
|-
|''Tnnls''||Nonnegative constrained linear least squares
|}

===TOMLAB /BARNLP===

The add-on toolbox TOMLAB /BARNLP solves large-scale nonlinear programming problems using a sparse primal-dual interior point algorithm, in conjunction with a filter for globalization. The solver package was developed in co-operation with Boeing Phantom Works. The TOMLAB /BARNLP package is described in a separate manual available at [http://tomopt.com/ http://tomopt.com].

===TOMLAB /CGO===

The add-on toolbox TOMLAB /CGO solves costly global optimization problems. The solvers are listed in [[#Table: Additional solvers in TOMLAB /CGO.]]. They are written in a combination of Matlab and Fortran code, where the Fortran code is called using a set of
MEX-file interfaces developed in TOMLAB.

====Table: Additional solvers in TOMLAB /CGO.====

{| class="wikitable"
!Function
!Description
|-
|''rbfSolve||''Costly constrained box-bounded optimization using a RBF algorithm.
|-
|''ego''||Costly constrained box-bounded optimization using the Efficient Global Optimization (EGO) algorithm.
|}

===TOMLAB /CONOPT===

The add-on toolbox TOMLAB /CONOPT solves large-scale nonlinear programming problems with a feasible path GRG method . The solver package was developed in co-operation with Arki Consulting and Development A/S. The TOMLAB /CONOPT is described in a separate manual available at [http://tomopt.com/ http://tomopt.com]. There is also m-file help available.

===TOMLAB /CPLEX===

The add-on toolbox TOMLAB /CPLEX solves large-scale mixed-integer linear and quadratic programming prob- lems. The solver package was developed in co-operation with ILOG S.A. The TOMLAB /CPLEX solver package and interface are described in a manual available at [http://tomopt.com/ http://tomopt.com].

===TOMLAB /KNITRO===

The add-on toolbox TOMLAB /KNITRO solves large-scale nonlinear programming problems with interior (barrier) point trust-region methods. The solver package was developed in co-operation with Ziena Optimization Inc. The TOMLAB /KNITRO manual is available at [http://tomopt.com/ http://tomopt.com].

===TOMLAB /LGO===

The add-on toolbox TOMLAB /LGO solves global nonlinear programming problems. The LGO solver package is developed by Pint´er Consulting Services, Inc. The TOMLAB /LGO manual is available at [http://tomopt.com/ http://tomopt.com/].

===TOMLAB /MINLP===

The add-on toolbox TOMLAB /MINLP provides solvers for continuous and mixed-integer quadratic programming

('''qp''','''miqp''') and continuous and mixed-integer nonlinear constrained optimization ('''con''', '''minlp''').

All four solvers, written by Roger Fletcher and Sven Leyffer, University of Dundee, Scotland, are available in sparse and dense versions. The solvers are listed in [[#Table: Solver routines in TOMLAB /MINLP.]].

The TOMLAB /MINLP manual is available at [http://tomopt.com/ http://tomopt.com].

===TOMLAB /MINOS===

Another set of Fortran solvers were developed by the Stanford Optimization Laboratory (SOL). [[#Table: The SOL optimization solvers in TOMLAB /MINOS.]] lists the solvers included in TOMLAB /MINOS. The solvers are called using a set of MEX-file interfaces developed as part of TOMLAB. All functionality of the SOL solvers are available and changeable in the TOMLAB framework in Matlab.

===TOMLAB /OQNLP===

The add-on toolbox TOMLAB /OQNLP uses a multistart heuristic algorithm to find global optima of smooth constrained nonlinear programs (NLPs) and mixed-integer nonlinear programs (MINLPs). The solver package was developed in co-operation with Optimal Methods Inc. The TOMLAB /OQNLP manual is available at [http://tomopt.com/ http://tomopt.com/]

====Table: Solver routines in TOMLAB /MINLP.====

{| class="wikitable"
!Function
!Description
|-
|''bqpd''||Quadratic programming using a null-space method.
|-
|''miqpBB''||Mixed-integer quadratic programming using ''bqpd ''as subsolver.
|-
|''filterSQP''||Constrained nonlinear minimization using a Filtered Sequential QP method.
|-valign="top"
|''minlpBB''||Constrained, mixed-integer nonlinear minimization using a branch- and-bound search scheme. ''filterSQP ''is used as NLP solver.
|}

====Table: The SOL optimization solvers in TOMLAB /MINOS.====

{| class="wikitable"
!Function
!Description
|-
|''MINOS 5.51||''Sparse linear and nonlinear programming with linear and nonlin- ear constraints.
|-
|''LP-MINOS||''A special version of the ''MINOS 5.5 ''MEX-file interface for sparse linear programming.
|-
|''QP-MINOS''||A special version of the ''MINOS 5.5 ''MEX-file interface for sparse quadratic programming.
|-
|''LPOPT 1.0-10''||Dense linear programming.
|-
|''QPOPT 1.0-10 ''||Non-convex quadratic programming with dense constraint matrix and sparse or dense quadratic matrix.
|}

===TOMLAB /NLPQL===

The add-on toolbox TOMLAB /NLPQL solves dense nonlinear programming problems, multi criteria optimiza- tion problems and nonlinear fitting problems. The solver package was developed in co-operation with Klaus Schittkowski. The TOMLAB /NLPQL manual is available at [http://tomopt.com/ http://tomopt.com].

===TOMLAB /NPSOL===

The add-on toolbox TOMLAB /NPSOL is a sub package of TOMLAB /SOL. The package includes the MINOS solvers as well as NPSOL, LSSOL and NLSSOL. The TOMLAB /NPSOL manual is available at [http://tomopt.com/ http://tomopt].

===TOMLAB /PENBMI===

The add-on toolbox TOMLAB /PENBMI solves linear semi-definite programming problems with linear and bilinear matrix inequalities. The solvers are listed in [[#Additional solvers in TOMLAB /PENBMI.]]. They are written in a combination of Matlab and C code. The TOMLAB /PENBMI manual is available at [http://tomopt.com/ http://tomopt.com].

====Additional solvers in TOMLAB /PENBMI.====

{| class="wikitable"
!Function
!Description
|-
|''penbmi''||Sparse and dense linear semi-definite programming using a penalty algorithm.
|-
|''penfeas bmi''||Feasibility check of systems of linear matrix inequalities, using ''penbmi''.
|}

===TOMLAB /PENSDP===

The add-on toolbox TOMLAB /PENSDP solves linear semi-definite programming problems with linear matrix inequalities. The solvers are listed in [[#Table: Additional solvers in TOMLAB /PENSDP.]]. They are written in a combination of Matlab and C code. The TOMLAB /PENSDP manual is available at [http://tomopt.com/ http://tomopt.com].

====Table: Additional solvers in TOMLAB /PENSDP.====

{| class="wikitable"
!Function
!Description
|-
|''pensdp''||Sparse and dense linear semi-definite programming using a penalty algorithm.
|-
|''penfeas_sdp''||Feasibility check of systems of linear matrix inequalities, using ''pensdp''.
|}

===TOMLAB /SNOPT===

The add-on toolbox TOMLAB /SNOPT is a sub package of TOMLAB /SOL. The package includes the MINOS solvers as well as SNOPT and SQOPT. The TOMLAB /SNOPT manual is available at [http://tomopt.com/ http://tomopt.com].

===TOMLAB /SOL===

The extension toolbox TOMLAB /SOL gives access to the complete set of Fortran solvers developed by the Stanford Systems Optimization Laboratory (SOL). These solvers are listed in [[#Table: The SOL optimization solvers in TOMLAB /MINOS.]] and [[#Table: The optimization solvers in the TOMLAB /SOL toolbox.]].

===TOMLAB /SPRNLP===

The add-on toolbox TOMLAB /SPRNLP solves large-scale nonlinear programming problems. SPRNLP is a state- of-the-art sequential quadratic programming (SQP) method, using an augmented Lagrangian merit function and safeguarded line search. The solver package was developed in co-operation with Boeing Phantom Works. The TOMLAB /SPRNLP package is described in a separate manual available at [http://tomopt.com/ http://tomopt.com].

====Table: The optimization solvers in the TOMLAB /SOL toolbox.====

{| class="wikitable"
!Function
!Description
|-
|''NPSOL 5.02''||Dense linear and nonlinear programming with linear and nonlinear constraints.
|-
|''SNOPT 6.2-2''||Large, sparse linear and nonlinear programming with linear and nonlinear constraints.
|-
|''SQOPT 6.2-2''||Sparse convex quadratic programming.
|-
|''NLSSOL 5.0-2''||Constrained nonlinear least squares. NLSSOL is based on NPSOL. No reference except for general NPSOL reference.
|-
|''LSSOL 1.05-4''||Dense linear and quadratic programs (convex), and constrained linear least squares problems.
|}

===TOMLAB /XA===

The add-on toolbox TOMLAB /XA solves large-scale linear, binary, integer and semi-continuous linear program- ming problems, as well as quadratic programming problems. The solver package was developed in co-operation with Sunset Software Technology. The TOMLAB /XA package is described in a separate manual available at [http://tomopt.com/ http://tomopt.com].

===TOMLAB /Xpress===

The add-on toolbox TOMLAB /Xpress solves large-scale mixed-integer linear and quadratic programming prob- lems. The solver package was developed in co-operation with Dash Optimization Ltd. The TOMLAB /Xpress solver package and interface are described in the html manual that comes with the installation package. There is also a TOMLAB /Xpress manual available at [http://tomopt.com/ http://tomopt.com].

===Finding Available Solvers===

To get a list of all available solvers, including Fortran, C and Matlab Optimization Toolbox solvers, for a certain ''solvType'', call the routine ''SolverList ''with ''solvType ''as argument. ''solvType ''should either be a string ('uc', 'con' etc.) or the corresponding ''solvType ''number as given in following [[#Table: solvProbType]]. For example, if wanting a list of all available solvers of ''solvType '''''con''', then

<source lang="matlab">
SolverList('con')
</source>

gives the output

<pre>
>> SolverList('con');

Tomlab recommended choice for Constrained Nonlinear Programming (NLP)

npsol

Other solvers for NLP

Licensed:

nlpSolve
conSolve
sTrustr
constr
minos
snopt
fmincon
filterSQP
PDCO

PDSCO

Non-licensed:

NONE

Solvers also handling NLP

Licensed:

glcSolve
glcFast
glcCluster
rbfSolve
minlpBB

Non-licensed:

NONE
</pre>

''SolverList ''also returns two output arguments: all available solvers as a string matrix and a vector with the corresponding ''solvType ''for each solver.

Note that solvers for a more general problem type may be used to solve the problem. In [[#Table: solvProbType]] an attempt has been made to classify these relations.

====Table: solvProbType====

The problem classes (''probType'') possible to solve with each type of solver (''solvType'') is marked with an ''x''. When the solver is in theory possible to use, but from a practical point of view is probably not suitable, parenthesis are added (''x'').

{| class="wikitable"
!|| colspan="10" align="center" border="2" | solvType
|-
!probType||uc||qp||con||ls||lls||cls||mip||lp||glb||glc
|-
|'''uc'''||x||||x||||||||||||x||(x)
|-
|'''qp'''||||x||x||||||||||||||(x)
|-
|'''con'''||||||x||||||||||||||(x)
|-
|'''ls'''||||||x||x||||x||||||||(x)
|-
|'''lls'''||||x||x||x||x||x||||||||(x)
|-
|'''cls'''||||||x||||||x||||||||(x)
|-
|'''mip'''||||||||||||||x||||||(x)
|-
|'''lp'''||||x||x||||||||x||x||||(x)
|-
|'''glb'''||||||(x)||||||||||||x||x
|-
|'''glc'''||||||(x)||||||||||||||x
|-
|'''exp'''||x||||x||(x)||||x||||||||(x)
|-
|}

SOL Using the SOL Solvers in TOMLAB

2012-01-22T17:09:46Z

Elias:

{{Part Of Manual|title=the SOL Manual|link=[[SOL|SOL]]}}
This section discusses the use of the TOMLAB solvers from Stanford Systems Optimization Laboratory (SOL). In order to use these solvers efficiently, it is recommended to read the corresponding solver details as well. It is important to do help on the m-files corresponding to each solver as well as the TOMLAB interface routine. The names for ''MINOS ''solver are ''minos.m ''and ''minosTL.m'', and similar for other solvers.

To learn all the different parameter settings for a solver it is useful to run the GUI, where all parameters are selectable, and all default values are shown. Furthermore there are short help available for the different solver parameters in the drag menus. Even if the user is not using the GUI to solve the particular user problem, it might be useful to run the test problems defined in TOMLAB to learn how to use the SOL solvers in the most efficient way.

==Setting Solver Parameters==

To handle the use of the SOL solvers, a special field in the ''Prob ''structure, ''Prob.SOL'', is used to send information to the SOL solvers. It is also used to store the information needed for warm starts of the SOL solvers.

The vector ''Prob.SOL.optPar ''of length 71 holds most of the different parameters that control the performance of the SOL solvers. All parameters have default values. If calling the SOL solver directly, not using TOMLAB, the user should set the values wanted in the ''optPar ''vector. The rest should have the value ''-''999, which gives the default value used by the solver. For information on other parameters that could effect the solution process see [[#Table: Information stored in the structure Prob.optParam. Default values in parenthesis.]]. The TOMLAB interface routine always has the name of the routine, with the additional two letters ''TL'', e.g. for ''MINOS ''the TOMLAB interface routine is ''minosTL''.

Other important fields to set when using the SOL solvers are the print and summary files that the solvers create. These files are very important to look through if any problems are occurring, to find what the causes might be, and if any warnings or errors are reported from the SOL solvers. To create a print and summary file, one example when running ''MINOS ''is the following statements

<pre>
Prob.SOL.optPar(1) = 111111; % Maximal print level
Prob.SOL.PrintFile = 'minos.pri' % Print file called minos.pri
Prob.SOL.SummFile = 'minos.sum' % Summary file called minos.sum
Prob.NumDiff = 6; % Tell TOMLAB that minos is estimating
Prob.ConsDiff = 6; % all derivatives (gradient and Jacobian)
</pre>

If ''MINOS ''is told that no derivatives are given, then ''MINOS ''will try to estimate them, and then TOMLAB must not do the same, i.e. ''Prob.NumDiff ''and ''Prob.ConsDiff ''must be set to six (internal solver estimation of derivatives). If ''MINOS ''is told that all derivatives are given, then TOMLAB might estimate them for ''MINOS ''using any of the five methods possible, or by using automatic differentiation.

==Derivatives for the Solvers==

The TOMLAB solvers from Stanford Systems Optimization Laboratory (SOL), have some useful special features, which influence the way that input is prepared to the solvers.

When defining the gradient vector and the constraint Jacobian matrix it is often the case that they are only partially known. The SOL solvers give the possibility to mark these elements. They will then be estimated by finite differences.

In TOMLAB the gradient and the constraint Jacobian matrix are defined in two separate routines. If any element is unknown, it is just marked with the standard Matlab element ''NaN''. The TOMLAB SOL interface routines will estimate the ''NaN ''elements if ''Prob.CheckNaN ''is set to 1.

If any gradient or constraint Jacobian element is infinite, in Matlab set as ''Inf ''or ''-Inf'', this element is converted to a big number, 1020 , in the TOMLAB SOL interface.

The following applies to the sparse nonlinear programming solvers ''MINOS ''and ''SNOPT''. When the constraint Jacobian matrix is sparse, then only the nonzero elements should be given. The sparse pattern is given as a sparse matrix ''Prob.ConsPattern''. In this matrix nonzero elements are marking nonzero elements in the constraint Jacobian. This pattern is static, i.e. given once before the call to the SOL solver. One problem is that a sparse matrix in Matlab is dynamic, i.e. only the nonzero elements of the matrix are stored. As soon as an element becomes zero, the vector of nonzeros are decreased one element. A gradient element that is normally nonzero might become zero during the optimization. Therefore care must be taken by the interface to return the correct values, because the SOL solvers assume the possible non-zero elements of the constraint Jacobian to be returned in the correct order.

The TOMLAB interface assumes the following conventions for the constraint Jacobian matrix:

*If the user returns a sparse matrix, and the number of nonzeros are equal to the number of nonzeros in ''Prob.ConsPattern'', no checks are done.

*If the user returns a sparse matrix, and the number of nonzeros are not equal to the number of nonzeros in ''Prob.ConsPattern'', the interface is matching all elements in the sparse array to find which nonzeros they represent, and returns the correct vector of static nonzeros.

*If the user returns a sparse matrix, and has given no pattern of nonzeros in ''Prob.ConsPattern'', i.e. it is an empty array, then the solver and the interface assumes a full, dense matrix and the interface makes a full matrix before returning the elements, column by column, to the solver.

*If the user returns a dense matrix, the interface just feeds all elements, column by column, back to the solver.

*If too few elements are returned, the solver will estimate the rest using finite differences.

When using the dense SOL nonlinear programming solvers, the constraint Jacobian matrix is always assumed to be dense. The interface will convert any sparse matrix returned by the user to a dense, full matrix, and return the elements, column by column, to the solver.

If no derivatives are available, it might be better to use the ''Nonderivative linesearch ''in ''SNOPT''. It is based on safeguarded quadratic interpolation. The default is to use a safeguarded cubic interpolation if derivatives are available. To select ''Nonderivative linesearch ''set the following parameter:

<pre>
Prob.SOL.optPar(40) = 0; % Use Nonderivative instead of Derivative Linesearch
</pre>

==Solver Output to Files==

The SOL solvers print different amount of information on ASCII files, one ''Print File ''with more information, and one ''Summary File ''with less information. ''SNOPT ''is using ''snoptpri.txt ''and ''snoptsum.txt ''as default names. ''MINOS ''is using ''minospri.txt ''and ''minossum.txt ''as default names. The following example shows how to set new names, other than the default, for these files.

Prob.SOL.PrintFile = 'snoptp.out'; % New name for Print File
Prob.SOL.SummFile = 'snopts.out'; % New name for Summary File

The ''SQOPT ''solver by default also defines the two log files as ''sqoptpri.txt ''and ''sqoptsum.txt''. If the print level is 0 no output will occur, unless some errors are encountered. It is possible to make ''SQOPT ''totally silent and avoid any opening of files by the following statements.

<pre>
Prob.SOL.PrintFile = '';
Prob.SOL.SummFile = '';
Prob.SOL.optPar(2) = 0;
Prob.SOL.optPar(3) = 0;
</pre>

The amount of printing is determined by a print level code, which is different for the solvers. See the help and manual for each solver. Some solvers also have two print levels, one major print level and one minor print level. This applies for ''SNOPT'', ''NPSOL ''and ''NLSSOL''. There are also different other parameters that influence how much output is written on the files. The following example show how to get maximum output for ''SNOPT ''on files with user defined names.

<pre>
Prob.SOL.PrintFile = 'sn.p'; % New name for Print File
Prob.SOL.SummFile = 'sn.s'; % New name for Summary File
Prob.SOL.optPar(1) = 111111; % Major print level, combination of six 0/1
Prob.SOL.optPar(2) = 10; % Minor print level, 0, 1 or 10. 10 is maximum
Prob.SOL.optPar(5) = 1; % Print Frequency
Prob.SOL.optPar(6) = 1; % Summary Frequency
Prob.SOL.optPar(7) = 1; % Solution yes. 0 = Solution not printed
Prob.SOL.optPar(8) = 1; % Full options listing, not default
</pre>

The other SOL solvers, ''NPSOL'', ''NLSSOL'', ''LSSOL'', ''QPOPT ''and ''LPOPT'', only define the ''Print File ''and ''Summary File ''if the user has defined names for them. See the help for each solver on how to set the correct print level and other parameters.

==Warm Starts for the Solvers==

In TOMLAB warm starts for the SOL solvers are automatically handled. The only thing needed is to call the routine ''WarmDefSOL ''after having solved the problem the first time, as the following principal example shows doing repeated calls to ''SNOPT''.

<pre>
... % Define first problem
Result = tomRun('snopt',Prob); % Solve problem at t=1
... for t=2:N
... % Changes at time t in Prob structure
Prob = WarmDefSOL('snopt', Prob, Result(t-1));
Result(t) = tomRun('snopt',Prob); % Call tomRun to solve again
... % Postprocessing
end
</pre>

The ''WarmDefSOL ''routine are setting the warm start flag ''Prob.WarmStart'', as true.

<pre>
Prob.WarmStart = 1;
</pre>

It is also moving subfields on the ''Result.SOL ''structure into ''Prob.SOL ''for the next run. For ''SNOPT'', ''SQOPT ''and ''MINOS ''the following commands are needed.

<pre>
Prob.SOL.xs = Result.SOL.xs
Prob.SOL.hs = Result.SOL.hs
Prob.SOL.nS = Result.SOL.nS
</pre>

For ''NPSOL ''and the other SOL solvers the commands are

<pre>
Prob.SOL.xs = Result.SOL.xs
Prob.SOL.iState = Result.SOL.iState
Prob.SOL.cLamda = Result.SOL.cLamda
Prob.SOL.H = Result.SOL.H
</pre>

The fields ''SOL.cLamda ''and ''SOL.H ''are not used for ''QPOPT'', ''LPOPT'', and ''LSSOL''. For ''NPSOL ''and ''NLSSOL ''the TOMLAB interface is automatically setting the necessary parameter ''Hessian Yes ''for subsequent runs. However, in order for the first warm start to work the user must set this parameter ''before ''the first run. The principal calls will be

<pre>
... % Define first problem
Prob.SOL.optPar(50) = 1; % Define Hessian Yes BEFORE first call
Result = tomRun('npsol',Prob); % Solve problem at t=1
... for t=2:N
...
Prob = WarmDefSOL('npsol', Prob, Result);
Result = tomRun('npsol',Prob);
...
end
</pre>

Note that for all solvers the new initial value are taken from the field ''Prob.SOL.xs ''and any user change in the standard initial value ''Prob.x_0 ''is neglected.

==Memory for the Solvers==

Some users have encountered problems where SOL solvers report insufficient memory on machines where memory should not be an issue. The solvers estimate their internal memory requirements at startup. This estimate is not always large enough so the user might have to specify additional memory. This can be accomplished by

<pre>
Prob.SOL.moremem = 1000; % or even larger if necessary
</pre>

==Parameters in Prob.optParam==

====Table: Information stored in the structure ''Prob.optParam''. Default values in parenthesis.====

{|class="wikitable"
!Field!!Description
|-valign="top"
|''PreSolve''||Flag if presolve analysis is to be applied on linear constraints ( 0).
|-valign="top"
|''DiffInt''||Difference interval in derivative estimates (used for ''Prob.NumDiff/ConsDiff'' -1 or 1).
|-valign="top"
|''CentralDiff''||Central difference interval in derivative estimates (used for ''Prob.NumDiff/ConsDiff ''-2 or 2).
|-valign="top"
|''splineSmooth''||Smoothness parameter sent to the SPLINE Toolbox routine ''csaps.m ''when computing numerical approximations of the derivatives (0''.''4) (used for ''Prob.NumDiff/ConsDiff ''-3 or 3).
|-valign="top"
|VARsplineTol||Tolerance parameter sent to the SPLINE Toolbox routine ''spaps.m ''when computing numerical approximations of the derivatives (10''-''3 ) (used for ''Prob.NumDiff/ConsDiff ''-4 or 4).
|-valign="top"
|''CHECK''||If true, no more check is done on the structure. Set to true (=1) after first call to solver (which then calls ''optParamSet'').
|}

SOL LPOPT

2012-01-22T17:03:33Z

Elias:

SOL Solver Reference

2012-01-22T16:58:57Z

Elias:

{{Part Of Manual|title=the SOL Manual|link=[[SOL|SOL]]}}
The SOL solvers are a set of Fortran solvers that were developed by the Stanford Systems Optimization Laboratory (SOL). [[#Table: The SOL optimization solvers in TOMLAB /SOL.]] lists the solvers included in TOMLAB /SOL. The solvers are called using a set of MEX-file interfaces developed as part of TOMLAB. All functionality of the SOL solvers are available and changeable in the TOMLAB framework in Matlab.

Detailed descriptions of the TOMLAB /SOL solvers are given in the following sections. Also see the M-file help for each solver.

The solvers reference guides for the TOMLAB /SOL solvers are available for download from the TOMLAB home page [http://tomopt.com/ http://tomopt.com]. There is also detailed instruction for using the solvers in [[SOL Using the SOL Solvers in TOMLAB]]. Extensive TOMLAB m-file help is also available, for example ''help snoptTL ''in Matlab will display the features of the SNOPT solver using the TOMLAB format.

TOMLAB /SOL solves '''nonlinear optimization '''problems ('''con''') defined as

<math>
\begin{array}{ll}\min\limits_{x} & f(x) \\& \\
s/t & \begin{array}{lcccl}x_{L} & \leq & x & \leq & x_{U}, \\b_{L} & \leq & A x & \leq & b_{U} \\c_{L} & \leq & c(x) & \leq & c_{U} \\\end{array}\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A
\in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math>
and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.

'''quadratic programming '''('''qp''') problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n
\times n}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in
\mathbb{R}^{m_1}</math>.

'''linear programming '''('''lp''') problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = c^T x \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>, <math>A \in \mathbb{R}^{m_1
\times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{m_1}</math>.

'''linear least squares '''('''lls''') problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} || C x - d || \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>d \in \mathbb{R}^M</math>, <math>C
\in \mathbb{R}^{M \times n}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>,
<math>b_L,b_U \in \mathbb{R}^{m_1}</math>.

and '''constrained nonlinear least squares '''problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} r(x)^T r(x) \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
c_{L} & \leq & c(x) & \leq & c_{U} \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>r(x) \in \mathbb{R}^M</math>,
<math>A \in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in
\mathbb{R}^{m_1}</math> and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.

====Table: The SOL optimization solvers in TOMLAB /SOL.====

{| class="wikitable"
!Function
!Description
|-
|''MINOS 5.5''||Sparse linear and nonlinear programming with linear and nonlinear constraints.
|-
|''LP-MINOS''||A special version of the ''MINOS 5.5 ''MEX-file interface for sparse linear programming.
|-
|''QP-MINOS''||A special version of the ''MINOS 5.5 ''MEX-file interface for sparse quadratic programming.
|-
|''LPOPT 1.0-10''||Dense linear programming.
|-
|''QPOPT 1.0-10''||Non-convex quadratic programming with dense constraint matrix and sparse or dense quadratic matrix.
|-
|''LSSOL 1.05-4''||Dense linear and quadratic programs (convex), and constrained linear least squares problems.
|-
|''NLSSOL 5.0-2''||Constrained nonlinear least squares. NLSSOL is based on NPSOL. No reference except for general NPSOL reference.
|-
|''NPSOL 5.02''||Dense linear and nonlinear programming with linear and nonlinear constraints.
|-
|''SNOPT 7.1-1''||Large, sparse linear and nonlinear programming with linear and nonlinear constraints.
|-
|''SQOPT 7.1-1''||Sparse convex quadratic programming.
|}

==MINOS==
*[[SOL MINOS|MINOS]]

==LP-MINOS==
*[[SOL LP-MINOS|LP-MINOS]]

==QP-MINOS==
*[[SOL QP-MINOS|QP-MINOS]]

==LPOPT==
*[[SOL LPOPT|LPOPT]]

==QPOPT==
*[[SOL QPOPT|QPOPT]]

==LSSOL==
*[[SOL LSSOL|LSSOL]]

==NLSSOL==
*[[SOL NLSSOL|NLSSOL]]

==NPSOL==
*[[SOL NPSOL|NPSOL]]

==SNOPT==
*[[SOL SNOPT|SNOPT]]

==SQOPT==
*[[SOL SQOPT|SQOPT]]

SOL Using the Matlab Interface

2012-01-22T16:54:53Z

Elias:

{{Part Of Manual|title=the SOL Manual|link=[[SOL|SOL]]}}
The main routines in the two-layer design of the interface are shown in [[#Table: The interface routines.]]. Page and section references are given to detailed descriptions on how to use the routines.

====Table: The interface routines.====

{| class="wikitable"
!Function
!Description
|-valign="top"
|''minos''||The layer one Matlab interface routine, calls the MEX-file interface ''minos.dll''
|-valign="top"
|''minosTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''minos.m''.
|-valign="top"
|''minosLPTL''||The layer two TOMLAB interface routine that calls ''minosLPTL.m''. Converts the input ''Prob ''format before calling ''minos.m ''and converts back to the output ''Result ''structure. This option only handles linear programming problems.
|-valign="top"
|''minosQPTL''||The layer two TOMLAB interface routine that calls ''minosQPTL.m''. Converts the input ''Prob ''format before calling ''minos.m ''and con- verts back to the output ''Result ''structure. This option only handles quadratic programming problems
|-valign="top"
|''lpopt''||The layer one Matlab interface routine, calls the MEX-file interface ''lpopt.dll''
|-valign="top"
|''lpoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''lpopt.m''.
|-valign="top"
|''qpopt''||The layer one Matlab interface routine, calls the MEX-file interface ''qpopt.dll''
|-valign="top"
|''qpoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''qpopt.m''.
|-valign="top"
|''lssol''||The layer one Matlab interface routine, calls the MEX-file interface ''lssol.dll''
|-valign="top"
|''lssolTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''lssol.m''.
|-valign="top"
|''nlssol''||The layer one Matlab interface routine, calls the MEX-file interface ''nlssol.dll''
|-valign="top"
|''nlssolTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''nlssol.m''.
|-valign="top"
|''npsol''||The layer one Matlab interface routine, calls the MEX-file interface ''npsol.dll''
|-valign="top"
|''npsolTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''npsol.m''.
|-valign="top"
|''snopt''||The layer one Matlab interface routine, calls the MEX-file interface ''snopt.dll''
|-valign="top"
|''snoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''snopt.m''.
|-valign="top"
|''sqopt''||The layer one Matlab interface routine, calls the MEX-file interface ''sqopt.dll''
|-valign="top"
|''sqoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''sqopt.m''.
|}

The SOL control parameters are possible to set from Matlab.

They can be set as inputs to the interface routine ''minos ''for example and the others. The user sets fields in a structure called ''Prob.SOL.optPar'', where the subfield names follow the SOL standard for setting solver options. The following example shows how to set the maximum number of iterations.

<pre>
Prob.SOL.optPar(30) = 500; % Setting maximum number of iterations
</pre>

SOL Using the Matlab Interface

2012-01-22T16:54:32Z

Elias:

{{Part Of Manual|title=the SOL Manual|link=[[SOL|SOL]]}}
The main routines in the two-layer design of the interface are shown in [[#Table: The interface routines.]]. Page and section references are given to detailed descriptions on how to use the routines.

====Table: The interface routines.====

{| class="wikitable"
!Function
!Description
|''minos''||The layer one Matlab interface routine, calls the MEX-file interface ''minos.dll''
|-valign="top"
|''minosTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''minos.m''.
|-valign="top"
|''minosLPTL''||The layer two TOMLAB interface routine that calls ''minosLPTL.m''. Converts the input ''Prob ''format before calling ''minos.m ''and converts back to the output ''Result ''structure. This option only handles linear programming problems.
|-valign="top"
|''minosQPTL''||The layer two TOMLAB interface routine that calls ''minosQPTL.m''. Converts the input ''Prob ''format before calling ''minos.m ''and con- verts back to the output ''Result ''structure. This option only handles quadratic programming problems
|-valign="top"
|''lpopt''||The layer one Matlab interface routine, calls the MEX-file interface ''lpopt.dll''
|-valign="top"
|''lpoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''lpopt.m''.
|-valign="top"
|''qpopt''||The layer one Matlab interface routine, calls the MEX-file interface ''qpopt.dll''
|-valign="top"
|''qpoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''qpopt.m''.
|-valign="top"
|''lssol''||The layer one Matlab interface routine, calls the MEX-file interface ''lssol.dll''
|-valign="top"
|''lssolTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''lssol.m''.
|-valign="top"
|''nlssol''||The layer one Matlab interface routine, calls the MEX-file interface ''nlssol.dll''
|-valign="top"
|''nlssolTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''nlssol.m''.
|-valign="top"
|''npsol''||The layer one Matlab interface routine, calls the MEX-file interface ''npsol.dll''
|-valign="top"
|''npsolTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''npsol.m''.
|-valign="top"
|''snopt''||The layer one Matlab interface routine, calls the MEX-file interface ''snopt.dll''
|-valign="top"
|''snoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''snopt.m''.
|-valign="top"
|''sqopt''||The layer one Matlab interface routine, calls the MEX-file interface ''sqopt.dll''
|-valign="top"
|''sqoptTL''||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''sqopt.m''.
|}

The SOL control parameters are possible to set from Matlab.

They can be set as inputs to the interface routine ''minos ''for example and the others. The user sets fields in a structure called ''Prob.SOL.optPar'', where the subfield names follow the SOL standard for setting solver options. The following example shows how to set the maximum number of iterations.

<pre>
Prob.SOL.optPar(30) = 500; % Setting maximum number of iterations
</pre>

OQNLP

2012-01-22T15:59:37Z

Elias:

==Introduction==

===Overview===

Welcome to the TOMLAB /OQNLP User's Guide. The package includes the OQNLP solvers from Optimal Methods Inc. and an interface to The MathWorks' MATLAB. The TOMLAB /OQNLP package includes OQNLP, MSNLP and LSGRG2, while TOMLAB /MSNLP includes MSNLP and LSGRG2.

TOMLAB /OQNLP is a multistart heuristic algorithm designed to find global optima of smooth constrained nonlinear programs (NLPs) and mixed-integer nonlinear programs (MINLPs).

TOMLAB /MSNLP is also a multistart heuristic algorithm designed to find global optima of smooth constrained nonlinear programs (NLPs). The latest release support integers (MINLPs).

LSGRG2 can be called directly. The solver does not find global optima but only local solutions, which may be sufficient for many user cases. Up to 10,000 variables and constraints are supported

The multistart feature calls an NLP solver with a different set of initial values and return the feasible solutions as well as the optimal point. The starting points are calculated from scatter search algorithm, see [http://www.opttek.com/ http://www.opttek.com/] for additional information. The user may also choose to use uniformly distributed initial values. Neither of the two options guarantee that a global optimum is obtained, however the likelihood is high.

The main advantage with OQNLP/MSNLP for smooth problems is that good local solutions are easily obtained, and that integer variables are handled.

===Contents of this Manual===

*[[#Overview]] provides a basic overview of the TOMLAB /OQNLP and TOMLAB /MSNLP solver packages.
*[[#Using the Matlab Interface]] provides an overview of the Matlab interfaces to OQNLP and MSNLP (LSGRG2).
*[[#Setting OQNLP Options]] describes how to set OQNLP and MSNLP (LSGRG2) solver options from Matlab.
*[[#OQNLP Solver Reference]] gives detailed information about the interface routines ''oqnlpTL'', ''msnlpTL ''and ''lsgrg2TL''.

===More information===

Please visit the following links for more information:

*[http://tomopt.com/tomlab/products/oqnlp/ http://tomopt.com/tomlab/products/oqnlp/]
*[http://www.opttek.com/ http://www.opttek.com]

===Prerequisites===

In this manual we assume that the user is familiar with global optimization and nonlinear programming, setting up problems in TOMLAB (in particular constrained nonlinear ('''con''') problems) and the Matlab language in general.

==Using the Matlab Interface==

The OQNLP and MSNLP (LSGRG2) solvers are accessed via the ''tomRun ''driver routine, which calls the appropriate interface routine (for example ''oqnlpTL''). The solvers themselves are located in a set of MEX files: ''oqnlp'', ''msnlp ''and ''lsgrg2''.

====Table: The interface routines.====

{|class="wikitable
!Function||Description
|-valign="top"
|''oqnlpTL''||The interface routine called by the TOMLAB driver routine ''tomRun''.

This routine then calls the MEX file ''oqnlp''
|-valign="top"
|''oqnlp_g''||Interface routine called by OQNLP when an objective gradient is not given and integer variables are included.
|-valign="top"
|''oqnlp_dc''||Interface routine called by OQNLP when a Jacobian is not given and integer variables are included.
|-valign="top"
|''oqnlp_gdc''||Interface routine called by OQNLP when a gradient or Jacobian are not given using the ''simAssign ''format and integer variables are included.
|-valign="top"
|''msnlpTL''||The interface routine called by the TOMLAB driver routine ''tomRun''.

This routine then calls the MEX file ''msnlp''
|-valign="top"
|''lsgrg2TL''||The interface routine called by the TOMLAB driver routine ''tomRun''.

This routine then calls the MEX file ''lsgrg''2
|}

==Setting OQNLP Options==

All OQNLP, MSNLP and LSGRG2 control parameters are possible to set from Matlab.

===Setting options using the OQNLP.options structure===

The parameters can be set as subfields in the ''Prob.OQNLP.options ''structure for TOMLAB /OQNLP and TOMLAB /MSNLP. If using the LSGRG2 solver, ''Prob.LSGRG2.options ''applies. The following example shows how to set a limit for the maximum number of iterations.

<pre>
Prob = conAssign(...) % Setup problem, see help conAssign for more information
Prob.OQNLP.options.ITERATION_LIMIT = 2000; % Setting maximum number of iterations
</pre>

The maximum number of iterations can also be done through the TOMLAB parameter ''MaxIter'':

<pre>
Prob.optParam.MaxIter = 200;
</pre>

In the cases where a solver specific parameter has a corresponding TOMLAB general parameter, the latter is used only if the user has not given the solver specific parameter.

A complete description of the available parameters can be found in [[#OQNLP and MSNLP options]].

==OQNLP Solver Reference==

A detailed description of the TOMLAB /OQNLP solver interface is given below. Also see the M-file help for ''oqnlpTL ''and ''msnlpTL''.

===oqnlpTL===

====Purpose====

Solves global constrained nonlinear mixed-integer problems.

OQNLP solves problems of the form

<math>
\begin{array}{ccccccl}
\min\limits_{x} & f(x) & \\
s/t & x_L & \leq & x & \leq & x_U & \\
{} & b_L & \leq & Ax & \leq & b_U & \\
{} & c_L & \leq & c(x) & \leq & c_U & \\
\end{array}
</math>

where <math>x,x_L,x_U \in R^{n},\, A \in R^{m_1 \times n},\,
b_L,b_U \in R^{m_1}</math> and <math>c(x), c_L, c_U \in R^{m_2}</math>.
The variables <math>x \in I</math>, the index subset of <math>1,...,n</math>, are
restricted to be integers.

====Calling Syntax====

<pre>
Prob = minlpAssign(...);
Result = tomRun('oqnlp',Prob,...)
</pre>

====Description of Inputs====

''Prob'' Problem description structure. The following fields are used:

{|class="wikitable"
!Input||Description
|-valign="top"
|''A''||Linear constraints coefficient matrix.
|-valign="top"
|''x_L, x_U''||Bounds on variables.
|-valign="top"
|''b_L, b_U''||Bounds on linear constraints.
|-valign="top"
|''c_L, c_U''||Bounds on nonlinear constraints. For equality constraints (or fixed variables), set e.g. b_L(k) == b_U(k).
|-valign="top"
|''PriLevOpt''||Print level in MEX interface.
|-valign="top"
|''LargeScale''||Flag telling whether to treat the problem as sparse (1) or dense. If set to 1, the user should also provide a sparse 0-1 matrix in Prob.ConsPattern giving the nonzero pattern.
|-valign="top"
|''MIP''||Structure with fields defining the integer properties of the problem. The following fields are used:
|-valign="top"
|''IntVars''||Vector designating which variables are restricted to integer values. This field is interpreted differently depending on the length.

If length(IntVars) = length(x), it is interpreted as a zero-one vector where all non-zero elements indicate integer values only for the corresponding variable.

A length less than the problem dimension indicates that IntVars is a vector of indices for the integer variables, for example [1 2 3 6 7 12].
|-valign="top"
|''OQNLP''||Structure with special fields for the OQNLP solver:
|-valign="top"
|''options''||Structure array with options.
|-valign="top"
|''morereal''||Number of extra REAL workspace locations. Set to ''<''0 for problem dependent default strategy.
|-valign="top"
|''moreint''||Number of extra INTEGER workspace locations. Set to ''<''0 for problem de- pendent default strategy.
|}

====Description of Outputs====

''Result'' Structure with result from optimization. The following fields are set:

{|class="wikitable"
!Output||Description
|-valign="top"
|''f_k''||Function value at optimum.
|-valign="top"
|''g_k''||Gradient of the function.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''c_k''||Nonlinear constraint residuals.
|-valign="top"
|''cJac''||Nonlinear constraint gradients.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''cState''||State of nonlinear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrange multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status from OQNLP (TOMLAB standard).
|-valign="top"
|''Inform''||OQNLP information parameter.

''< ''0 = Setup Error.

0 = Status not set.

1 = Optimal solution found.

2 = Fractional change in objective too small.

3 = All remedies failed.

4 = Too many iterations.

5 = Problem is unbounded.

6-10 = Problem infeasible.

11-38 = Runtime failure.

39 = Termination by user.

40 = Jacobian overflow.

41 = OPTQUEST Error.

42 = Time limit exceeded.

43 = Feasible solution found. Other = Unknown return code.
|-valign="top"
|''rc''||Reduced costs. If ninf=0, last m == -v_k.
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''FuncEv''||Number of function evaluations. ''GradEv ''Number of gradient evaluations. ''ConstrEv ''Number of constraint evaluations.
|-valign="top"
|''QP.B''||Basis vector in TOMLAB QP standard.
|-valign="top"
|''Solver''||Name of the solver (OQNLP).
|-valign="top"
|''SolverAlgorithm''||Description of the solver.
|}

===msnlpTL===

====Purpose====

Solves global constrained nonlinear problems.

MSNLP solves problems of the form

<math>
\begin{array}{ccccccl}
\min\limits_{x} & f(x) & \\
\\
s/t & x_L & \leq & x & \leq & x_U & \\
{} & b_L & \leq & Ax & \leq & b_U & \\
{} & c_L & \leq & c(x) & \leq & c_U & \\
\end{array}
</math>

where <math>x,x_L,x_U \in R^{n},\, A \in R^{m_1 \times n},\,
b_L,b_U \in R^{m_1}</math> and <math>c(x), c_L, c_U \in R^{m_2}</math>.

====Calling Syntax====

<pre>
Prob = conAssign(...);
Result = tomRun('msnlp',Prob,...)
</pre>

====Description of Inputs====

''Prob ''Problem description structure. The following fields are used:

{|class="wikitable"
|''A''||Linear constraints coefficient matrix.
|-valign="top"
|''x_L, x_U''||Bounds on variables.
|-valign="top"
|''b_L, b_U''||Bounds on linear constraints.
|-valign="top"
|''c_L, c_U''||Bounds on nonlinear constraints. For equality constraints (or fixed variables), set e.g. b_L(k) == b_U(k).
|-valign="top"
|''PriLevOpt''||Print level in MEX interface.
|-valign="top"
|''LargeScale''||Flag telling whether to treat the problem as sparse (1) or dense. If set to 1, the user should also provide a sparse 0-1 matrix in Prob.ConsPattern giving the nonzero pattern.
|-valign="top"
|''MIP''||Structure with fields defining the integer properties of the problem. The following fields are used:
|-valign="top"
|''OQNLP''||Structure with special fields for the MSNLP solver:
|-valign="top"
|''options''||Structure array with options.
|-valign="top"
|''morereal''||Number of extra REAL workspace locations. Set to ''<''0 for problem dependent default strategy.
|-valign="top"
|''moreint''||Number of extra INTEGER workspace locations. Set to ''<''0 for problem de- pendent default strategy.
|}

====Description of Outputs====

''Result'' Structure with result from optimization. The following fields are set:

{|class="wikitable"
!Output||Description
|-valign="top"
|''f_k''||Function value at optimum.
|-valign="top"
|''g_k''||Gradient of the function.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''c_k''||Nonlinear constraint residuals.
|-valign="top"
|''cJac''||Nonlinear constraint gradients.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''cState''||State of nonlinear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrange multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status from MSNLP (TOMLAB standard).
|-valign="top"
|''Inform''||MSNLP information parameter. ''< ''0 = Setup Error.

0 = Status not set.

1 = Optimal solution found.

2 = Fractional change in objective too small.

3 = All remedies failed.

4 = Too many iterations.

5 = Problem is unbounded.

6-10 = Problem infeasible.

11-38 = Runtime failure.

39 = Termination by user.

40 = Jacobian overflow.

41 = OPTQUEST Error.

42 = Time limit exceeded.

43 = Feasible solution found. Other = Unknown return code.
|-valign="top"
|''rc''||Reduced costs. If ninf=0, last m == -v k.
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''FuncEv''||Number of function evaluations.
|-valign="top"
|''GradEv''||Number of gradient evaluations.
|-valign="top"
|''ConstrEv''||Number of constraint evaluations.
|-valign="top"
|''QP.B''||Basis vector in TOMLAB QP standard.
|-valign="top"
|''Solver''||Name of the solver (MSNLP).
|-valign="top"
|''SolverAlgorithm''||Description of the solver.
|}

===lsgrg2TL===

====Purpose====

Solves constrained nonlinear problems.

LSGRG2 solves problems of the form

<math>
\begin{array}{ccccccl}
\min\limits_{x} & f(x) & \\
\\
s/t & x_L & \leq & x & \leq & x_U & \\
{} & b_L & \leq & Ax & \leq & b_U & \\
{} & c_L & \leq & c(x) & \leq & c_U & \\
\end{array}
</math>

where <math>x,x_L,x_U \in R^{n},\, A \in R^{m_1 \times n},\,
b_L,b_U \in R^{m_1}</math> and <math>c(x), c_L, c_U \in R^{m_2}</math>.

====Calling Syntax====

<pre>
Prob = conAssign(...);
Result = tomRun('lsgrg2',Prob,...)
</pre>

====Description of Inputs====

''Prob ''Problem description structure. The following fields are used:

{|class="wikitable"
!Input||Description
|-valign="top"
|''A''||Linear constraints coefficient matrix.
|-valign="top"
|''x_L, x_U''||Bounds on variables.
|-valign="top"
|''b_L, b_U''||Bounds on linear constraints.
|-valign="top"
|''c_L, c_U''||Bounds on nonlinear constraints. For equality constraints (or fixed variables), set e.g. b_L(k) == b_U(k).
|-valign="top"
|''PriLevOpt''||Print level in optimizer and MEX interface. Set Prob.LSGRG2.options.IPR to set optimizer print level separately.
|-valign="top"
|''LargeScale''||Flag telling whether to treat the problem as sparse (1) or dense. If set to 1, the user should also provide a sparse 0-1 matrix in Prob.ConsPattern giving the nonzero pattern.
|-valign="top"
|''MaxCPU''||Maximum allowed time in seconds for the LSGRG2 run. It is also possible to set this through the Prob.LSGRG2.options.MAXTIME parameter, in which case Prob.MaxCPU is ignored. LSGRG2's default value for MAXTIME is 1000 seconds.
|-valign="top"
|''optParam.MaxIter''||Maximum number of iterations. Default is 10000.
|-valign="top"
|''LSGRG2''||Structure with special fields for the LSGRG2 solver:
|-valign="top"
|''options''||Structure array with options. See the TOMLAB /OQNLP User's Guide for instructions and examples.
|-valign="top"
|''PrintFile''||Name of file to receive the LSGRG2 iteration and results log. Independent of PriLevOpt.
|}

====Description of Outputs====

''Result'' Structure with result from optimization. The following fields are set:

{|class="wikitable"
!Output||Description
|-valign="top"
|''f_k''||Function value at optimum.
|-valign="top"
|''g_k''||Gradient of the function.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''c_k''||Nonlinear constraint residuals.
|-valign="top"
|''cJac''||Nonlinear constraint gradients.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equalit == 3;
|-valign="top"
|''cState''||State of nonlinear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrange multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status from LSGRG2 (TOMLAB standard).
|-valign="top"
|''Inform''||LSGRG2 information parameter. ''< ''0 = Setup Error.

0 = Status not set.

1 = Kuhn-Tucker conditions satisfied.

2 = Fractional change in objective too small.

3 = All remedies failed.

4 = Too many iterations.

5 = Problem is unbounded.

6-10 = Problem infeasible.

11-38 = Runtime failure.

39 = Termination by user.

40 = Jacobian overflow.

41 = Engine Error.

42 = Time limit exceeded. Other = Unknown return code.
|-valign="top"
|''rc''||Reduced costs. If ninf=0, last m == -v k.
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''FuncEv''||Number of function evaluations. ''GradEv ''Number of gradient evaluations. ''ConstrEv ''Number of constraint evaluations.
|-valign="top"
|''QP.B''||Basis vector in TOMLAB QP standard.
|-valign="top"
|''Solver''||Name of the solver (LSGRG2).
|-valign="top"
|''SolverAlgorithm''||Description of the solver.
|}

===OQNLP and MSNLP options===

The following table shows all the options that the user can set for the OQNLP and MSNLP solvers. The LSGRG2 solver options are in Table 9. Observe that parameters which mention OptQuest are only available when using OQNLP (The OptQuest engine is part of OQNLP). All parameters should be set in ''Prob.OQNLP.options''

User options for the TOMLAB /OQNLP solvers. The following fields are used:

{|class="wikitable"
!Option||Description||Default
|-valign="top"
|''BASIN_DECREASE_FACTOR''||This value must be between 0 and 1. If DYNAMIC DISTANCE FILTER is set to 1, the MAXDIST value associated with any local solution is reduced by (1-BASIN_DECREASE_FACTOR) if MERIT WAITCYCLE consecutive trial points have distance from the solution less than MAXDIST.||0.2
|-valign="top"
|''BASIN_OVERLAP_FIX''||A value of 1 turns on logic which checks the MAXDIST values of all pairs 1 of local solutions, and reduces any pair of MAXDIST values if their sum is greater then the distance between the 2 solutions. This ensures that the spherical models of their basins of attracting do not overlap. A value of 0 turns off this logic. Turning it off can reduce the number of NLP solver calls, but can also cause OQNLP to miss the global solution.||1
|-valign="top"
|''DISTANCE_FACTOR''||If the distance between an OptQuest trial point and any local solution found previously is less then DISTANCE FACTOR ''* ''MAXDIST, the NLP solver is not started from that trial point. MAXDIST is the largest distance ever traveled to get to that local solution. Increasing DIS- TANCE FACTOR leads to fewer solver calls and risks finding a worse solution. Decreasing it leads to more solver calls and possibly a better solution.||1.0
|-valign="top"
|''DYNAMIC_DISTANCE_FILTER''||A value of 1 turns on logic which reduces the value of MAXDIST 1 (described under the DISTANCE FILTER keyword) for a local solution if MERIT WAITCYCLE consecutive trial points have a distance from that solution less than MAXDIST. MAXDIST is multiplied by (1-BASIN REDUCTION FACTOR). A value of 0 turns off this logic. Turning it off can decrease the number of NLP solver calls, but can also lead to a worse final solution.||1
|-valign="top"
|''DYNAMIC_MERIT_FILTER''||A value of 1 turns on logic which dynamically varies the pa- 1 rameters which increases the merit filter threshold, THRESH- OLD INCREASE FACTOR. If MERIT WAITCYCLE consecutive trial points have been rejected by the merit filter, this value is replaced by max(THRESHOLD INCREASE FACTOR, val), where val is the value of THRESHOLD INCREASE FACTOR which causes the merit filter to just accept the best of the previous MERIT WAITCYCLE trial points. A value of 0 turns off this logic. Turning it off can reduce NLP solver calls, but may lead to a worse final solution.||1
|-valign="top"
|''FEASIBILITY_TOLERANCE''||This tolerance is used to check each point returned by an NLP solver for feasibility. If the largest absolute infeasibility at the point is larger than this tolerance, the point is classified infeasible. This test is made because points returned by NLP solvers may occasionally be infeasible despite feasible status codes. Some NLP solvers use internal scaling before testing for feasibility. The unscaled problem may be infeasible, while the scaled one is feasible. If this occurs, increasing this tolerance (to 1.e-2 or larger) often eliminates the problem.||1.e-4
|-valign="top"
|''FEASIBILITY_MODE''||If this option is set to 1 the system focuses on finding a feasible point, 0 stopping after the first NLP solver call which finds such a point. If set to 0, the system tries to find the global optimum of the objective function subject to the constraints.||0
|-valign="top"
|''INFBND''||This value (its negative) is given to OptQuest as the upper (lower) bound for any variable with no upper and lower bound. However, the original bounds are given to the local solver, so it can produce solutions not limited by this artificial bound. OptQuest must have finite upper and lower bounds for each variable. If INFBND (or any of the user-supplied bounds) is much larger than any component of the optimal solution, OptQuest will be less efficient because it is searching over a region that is much larger than needed. Hence the user is advised to try to provide realistic values for all upper and lower bounds. It is even more dangerous to make INFBND smaller then some component of a globally optimal solution, since OptQuest can never generate a trial point near that solution. It is possible, however, for the local solver to reach a global solution in this case, since the artificial bounds are not imposed on it.||1.e5
|-valign="top"
|''ITERATION_PRINT_FREQUENCY''||If the OQNLP iteration log is written to the OQNLP log file, one line 20 of output is written every k'th OptQuest iteration, where k is the value given here.||20
|-valign="top"
|''ITERATION_LIMIT''||Increasing this limit can allow OQNLP to find a better solution. Try it if your run using 1000 iterations doesn't take too long. Surprisingly, the best solution using, say 2000 iterations, may be found in the first 1000 iterations, and that solution may be better then the one found with an iteration limit of 1000. This is because OptQuest changes its search strategy depending on the iteration limit. Because of this, it is also possible that increasing the iteration limit will yield a worse solution, but this is rare. Decreasing this iteration limit usually leads to a worse solution, but also reduces run time.||1000
|-valign="top"
|''LOCALS_FILE''||Specify a complete path and name for a file to which the objective value and values of all variables for all local solutions found will be written. For example, C:''\''temp''\''opt.out. There are 2 possible formats for this file, specified by the LOCALS FILE FORMAT option below. If there is no LOCALS FILE specified, the locals file will not be created. '''WARNING''', no file will be created unless ''Prob.OQNLP.PrintFile ''is set.
|-valign="top"
|''LOCALS_FILE_FORMAT''||There are 2 possible values for this option. The REPORT entry creates the locals file in a format designed to be examined easily by eye, but processed less easily by a computer program or spreadsheet. The DATA1 entry creates a file with many records, each on a single line, each having the following format: ''< indexof localoptimum >< objval >< varindex >< varindex >''.||DATA1
|-valign="top"
|''MAX_LOCALS''||When the number of distinct local solutions found by OQNLP exceeds the value specified here, OQNLP will stop, returning the best solution found.||1000
|-valign="top"
|''MAX_SOLVER_CALLS''||When the number of calls to the NLP solver exceeds the value specified here, OQNLP will stop, returning the best solution found.||1000
|-valign="top"
|''MAX_SOLVER_CALLS_NOIMPROVEMENT''||The positive integer specified here will cause OQNLP to stop whenever the number of consecutive solver calls with a fractional improvement in the best objective value found less than 1.e-4 exceeds that values. In other words, if the value specified is 50, and there are more than 50 consecutive solver calls where the relative change in the best objective was less then 1.e-4 in all iterations, OQNLP will stop.||100
|-valign="top"
|''MAXTIME''||When the execution time spent by OQNLP exceeds this number of sec- onds, OQNLP will stop and return the best solution found.||1000
|-valign="top"
|''MERIT_WAITCYCLE''||This value must be a positive integer. If the merit filter is used, and there 20 are MERIT WAITCYCLE consecutive iterations where the merit filter logic causes the NLP solver not to be started, the merit filter threshold is increased by the factor THRESHOLD INCREASE FACTOR (see below). Increasing MERIT WAITCYCLE usually leads to fewer solver calls, but risks finding a worse solution. Decreasing it leads to more solver calls, but may find a better solution.||20
|-valign="top"
|''OPTQUEST_ONLY''||If you think the NLP solver is taking too long and/or not working well, 0 choosing 1 will stop it from being called. This may occur if the problem is of type "DNLP", where one or more problem functions are discontin- uous or have discontinuous derivatives. If the problem has only discrete (integer) variables, choose 1, as there is nothing for the NLP solver to do (since it optimizes over the continuous variables when the integers are fixed, and there aren't any).||0
|-valign="top"
|''OQ_ALL_DISCRETE''||This option sets the filter logic for problems with discrete variables. Setting this option to 1 has the potential to produce better solutions but also consumes more computing time.||0
|-valign="top"
|''PENALTY_FUNCTION''||Results using either choice are usually similar, but choosing 1 can lead 1 to fewer iterations. The 1 value causes the exact penalty function to be used, while 0 uses OptQuest's internal penalty function, whose penalty term is the largest percentage violation of all violated constraints.||1
|-valign="top"
|''POINT GENERATION''||''OPTQUEST'' causes trial points to be generated by the OptQuest driver. This option is only available with TOMLAB /OQNLP and is the default for this option. ''RANDOM'' causes trial points to be generated by sampling each variable from a uniform distribution defined within its bounds. ''SMARTRANDOM1'' generates trial points by sampling each variable independently from either normal or triangular distributions. This is the default for TOMLAB /MSNLP.||See text
|-valign="top"
|''RANDOM_NUMBER_SEED''||The options are: String 'RANDOM' = random seed computed from clock. String 'DEFAULT' = default seed value 1234. Any positive value = seed set to that value. Negative values = negated to positive. 0 = equivalent to 'DEFAULT'.||0
|-valign="top"
|''SAMPLING_DISTRIBUTION''||This keyword is relevant only when POINT GENERATION is set to 0 SMARTRANDOM1. Then a value of 0 causes normal distributions to be used to generate trial points, while a value of 1 causes triangular distributions to be used.||0
|-valign="top"
|''SEARCH_PARAMETER''||This parameter has a range between zero and one, and a default value of 0.5. Increasing it causes more trial points to be directed towards the boundary. This is advisable if you believe the optimal solution will be on the boundary or at a vertex, as is true for problems where a concave function is maximized subject to linear constraints.||0.5
|-valign="top"
|''SEARCH TYPE''||This option controls the search strategy used by OptQuest. The three choices that are relevant for use within OQNLP are:
'''aggressive '''This choice controls the population update of the OptQuest algorithm. It triggers a very aggressive update, which keeps the best of the points generated from the current population as the new population. The risk in this is that all points in the new population may cluster in a small portion of the search volume, and regions far from this volume will not be explored in the next cycle.
'''boundary '''This option affects the trial points generated by OptQuest, directing them toward the boundary of the region defined by the linear constraints and variables bounds. The value of SEARCH PARAMETER discussed below controls the fraction of points that are directed towards the boundary.
'''crossover '''This option affects how OptQuest trial points are generated from population points. It retains the linear combination operator, but adds a "crossover" operator, similar to those used in evolutionary or genetic algorithms, to create 2 additional trial points.||boundary
|-valign="top"
|''STAGE1_ITERATIONS''||Specifies the total number of OptQuest iterations in stage 1 of the OQNLP algorithm, where no NLP solver calls are made. Increasing this sometimes leads to a better starting point for the first local solver call in stage 2, at the cost of delaying the call. Decreasing it can lead to more solver calls, but the first call occurs sooner.||200
|-valign="top"
|''STARTING_MULTIPLIER''||Since no Lagrange multiplier values are available until the first solver call at the end of stage 1, this value is used for all multipliers if PENALTY_FUNCTION is set to 1.||1000
|-valign="top"
|''START_WITH_NLP_SOLVER''||In the beginning, OQNLP passes the starting point defined in the TOMLAB model to the NLP subsolver. This will ensure that solutions gen- erated with OQNLP will be always as good as the one generated by the NLP subsolver alone. After this initial call the OQNLP algorithm con- tinues as usual. The initial call to the NLP subsolver starting from the point defined by the TOMLAB model can be suppressed by setting this parameter to 0.||1
|-valign="top"
|''THRESHOLD_INCREASE_FACTOR''||This value must be nonnegative. If there are MERIT WAITCYCLE con- secutive OptQuest iterations where the merit filter logic causes the NLP solver not to be called, the merit threshold is increased by multiplying it by (1+THRESHOLD INCREASE FACTOR)||0.2
|-valign="top"
|''USE_DISTANCE_FILTER''||Use 0 to turn off the distance filter, the logic which starts the NLP 1 solver at a trial point only if the (Euclidean) distance from that point to any local solution found thus far is greater than the distance threshold. Turning off the distance filter leads to more solver calls and more run time, and increases the chances of finding a global solution. Turn off both distance and merit filters to find (almost) all local solutions.||1
|-valign="top"
|''USE_LINEAR_CONSTRAINTS''||This option applies only to problems which have linear constraints other 0 than simple bounds on the variables. Using 1 (all OptQuest trial points satisfy the linear constraints) often leads to fewer iterations and solver calls, but OptQuest has to solve an LP to project each trial point onto the linear constraints. For large problems (more than 100 variables), this can greatly increase run time, so the default value is off (0)||0
|-valign="top"
|''USE_MERIT_FILTER''||Use 0 to turn off the merit filter, the logic which starts the NLP solver 1 at a trial point only if the penalty function value at that point is below the merit threshold. This will lead to more solver calls, but increase the chances of finding a global solution. Turn off both filters of you want to find (almost) all local solutions. This will cause the solver to be called at each stage 2 iteration.||1
|-valign="top"
|''WAITCYCLE''||This value must be a positive integer. If the merit filter is used, and 20 there are WAITCYCLE consecutive iterations where the merit filter logic causes the NLP solver not to be started, the merit filter thresh- old is increased by the factor THRESHOLD INCREASE FACTOR (see above). Increasing WAITCYCLE usually leads to fewer solver calls, but risks finding a worse solution. Decreasing it leads to more solver calls, but may find a better solution.||20
|}

===LSGRG2 options===

The following options are available for the LSGRG2 solver included with the TOMLAB /OQNLP /MSNLP package. The fields are set in ''Prob.LSGRG2.options''. It is only possible to set these fields when calling LSGRG2 directly, i.e. they are ignored if calling OQNLP.

User options for the TOMLAB /OQNLP - LSGRG2 solver. The following fields are used:

{|class="wikitable"
!Option||Description||Default
|-valign="top"
|''EPNEWT''||A constraint is assumed to be binding if it is within this epsilon of one of its bounds.||1e-4
|-valign="top"
|''EPINIT''||If it is desired to run the problem with EPNEWT initially set fairly large and then tightened at the end of the optimization then this is accomplished by assigning EPINIT the initial tolerance and EPNEWT the final one. Doing this often reduces run time.||1e-4
|-valign="top"
|''EPSTOP''||If the fractional change in the objective is less than EPSTOP for NSTOP consecutive iterations, the program will stop. The program will also stop if Kuhn-Tucker optimality conditions are satisfied to within EPSTOP.||1e-4
|-valign="top"
|''EPSPIV''||If, in constructing the basis inverse, the absolute value of a prospective pivot element is less than EPSPIV, the pivot will be rejected and another pivot element will be sought.||1e-6
|-valign="top"
|''PH1EPS''||If nonzero, the phase 1 objective (normally the sum of infeasibilities, sinf ) is aug- mented by a multiplier, say w, times the true objective, obj, so that the new phase 1 objective is sinf+w\*obj. The multiplier, w, is selected so that, at the initial point, ''w *obj ''= ''P H ''1''EP S *sinf ''. In phase 1 the term ''w *obj ''should be small relative to sinf, so PH1EPS should be less than 1.0, with 0.1 a reasonable default value. The reason for setting PH1EPS positive is to cause phase 1 to pay a small amount of attention to the objective, so that any feasible point found will have a ''good ''objective value.||0.0
|-valign="top"
|''AIJTOL''||Zero tolerance for Jacobian elements. Any derivative with absolute value less than this value will be set to zero.||1e-10
|-valign="top"
|''PIVPCT''||When choosing pivots for each row, all columns with updated entries within PIVPCT of the maximum will be considered.||1e-1
|-valign="top"
|''PSTEP''||This is the step size used in PARSHF and PARSHC for estimating partial derivatives of the functions with respect to the variables. This value is computed from the calculated machine precision.||1e-8
|-valign="top"
|''FUNPR''||The function precision.||1e-8
|-valign="top"
|''CONDTL''||When factoring the basis matrix, this is the largest condition number which is ac- ceptable. Blocks whose estimated condition number exceeds CONDTL are considered to be ill-conditioned, and an error message is issued to that effect. If you see these messages, either automatic or user scaling can improve the situation.||1e+8
|-valign="top"
|''EPBOUN''||A variable is considered to be at its bound if it is within EPBOUN of the bound.||1e-6
|-valign="top"
|''EPDEG''||If problem becomes degenerate, the variable bounds will be perturbed by this relative tolerance, and the problem resolved.||1e-4
|-valign="top"
|''MAXTIME''||Time limit in seconds.||1000
|-valign="top"
|''NSTOP''||If the fractional change in the objective is less than EPSTOP for NSTOP consecutive 3 iterations, the program will stop.||3
|-valign="top"
|''ITLIM''||If subroutine newton takes ITLIM iterations without converging satisfactorily, the 10 iterations are stopped and corrective action is taken.||10
|-valign="top"
|''LIMSER''||If the number of completed one dimensional searches equals LIMSER, optimization will terminate.||10000
|-valign="top"
|''INPRNT''||If 1, turns on printing of initial problem structure, option settings, initial values, 0 bounds, and status of variables and rows.||0
|-valign="top"
|''OTPRNT''||If 1, turns on printing of final values and status of rows and variables, Lagrange 0 multipliers, reduced gradients, and run statistics.||0
|-valign="top"
|''IPR''||Suppress all output printing except initial and final reports. 1 = Print one line of output for each one dimensional search. 2 = Provide more detailed information on the progress of each one dimensional search. 3 = Expand the output to include the problem function values and variable values at each iteration as well as the separation of constraints into nonbinding and binding and variables into basic, superbasic and nonbasic. 4 = At each iteration the reduced gradient, the search direction and the tangent vector are printed. 5 = Provides details of the basis inversion process including the initial basis and its inverse. also displays the variable values and constraint errors for each newton iteration. 6 = This is the maximum level of print available and includes all of the above along with detailed progress of the basis construction phase, including the basis inverse at each pivot.||0
|-valign="top"
|''IPN#''||If IPN# is greater than zero then IPR will be set to # after IPN# iterations. The 0 symbol # may be 4, 5, or 6. For example, setting IPN5 to 20 sets the print level IPR to 5 after 20 iterations.||0
|-valign="top"
|''IPER''||If IPER is greater than zero then for every IPER th iteration, LSGRG2 output will 0 use the current value of IPR, otherwise use IPR=1.||0
|-valign="top"
|''IQUAD''||Method for initial estimates of basic variables for each one dimensional search. 0 = Tangent vector and linear extrapolation will be used. 1 = Quadratic extrapolation will be used.||0
|-valign="top"
|''KDERIV''||Method for obtaining partial derivatives. 0 = Forward difference approximation. 1 = Central difference approximation. 2 = User supplied subroutine parsh is used.||0
|-valign="top"
|''MODCG''||MODCG and MAXHES (see below) control use of a conjugate gradient (cg) method. If the number of superbasic variables exceeds MAXHES, the cg method indicated by MODCG is used. Default value of ''MODCG ''= 6. To use a cg method at each iteration, set ''MAXHES ''= 0. 1 = Uses fletcher reeves formula. 2 = Uses polak ribiere formula. 3 = Uses perrys formula. 4 = Uses 1 step version of the DFP quasi-newton method. 5 = Uses 1 step version of the BFGS quasi-newton method. 6 = Uses limited memory version of the BFGS quasi-newton method. NOTE: if ''MODC G ''= 6, the optional parameters MEMCG and HSCALE (see below) are relevant.||0
|-valign="top"
|''MXTABU''||The maximum length of the tabu list in chuzq.||25
|-valign="top"
|''IDEGLM''||The maximum number of consecutive degenerate steps before the subroutine terminates.||25
|-valign="top"
|''ISCALE''||Determines whether Jacobian scaling will be used at the initial point. 0 = Do not scale jacobian. 1 = Scale the jacobian.||0
|-valign="top"
|''ISCLAG''||Rescale the Jacobian after every ISCLAG line searches are performed. 0 = No rescaling is performed. ''> ''0 = Rescale after ISCLAG line searches.||0
|-valign="top"
|''MEMCG''||If using ''MODC G ''= 6, MEMCG is the memory length of the limited memory cgmethod. Note: this method is only used if ''MODCG'' = 6.||3
|-valign="top"
|''IBVBLM''||If a basic variable is in the basis at a bound for IBVBLM consecutive iterations, the LSGRG2 basis factorization routine does not try to replace it.||2
|-valign="top"
|''HRDBND''||The maximum length of the tabu list in chuzq. 0 = This allows the user routines to be called with some variables outside their bounds. This can cause errors when routines contain functions like square roots, logs, etc. 1 = All variables will be within their bounds.||0
|-valign="top"
|''FIXPIV''||The maximum length of the tabu list in chuzq. 0 = The pivot tolerance PIVPCT will be fixed at the specified level. 1 = The pivot tolerance PIVPCT will be adjusted dynamically.||0
|-valign="top"
|''GFEAS''||Phase control. 0 = Both phase 1 and phase 2 are performed. 1 = Only a phase 1 is performed. The algorithm will terminate when a feasible point is found.||0
|-valign="top"
|''USEPH0''||Phase control. 0 = No phase 0 is performed. Instead, a normal phase 1 is performed if the initial point is not feasible. 1 = A phase 0 is performed to attempt to find an initial feasible point via newtons method. This method is usually faster, but can occasionally cause LSGRG2 to fail, in which case it should be disabled.||1
|}

===LSGRG2 printing===

The LSGRG2 printing logic is described below. Prob.PriLevOpt is called PriLev in the text.

PriLev controls the amount of output from LSGRG2, by setting the print level (IPR) to PriLev. PriLev also controls whether information shall be printed to the MATLAB screen or not. If PriLev is ''> ''0, information from LSGRG2 is printed to the MATLAB screen.

Prob.LSGRG2.options.IPR is a solver specific option controlling the amount of output to be printed. It takes precedence to PriLev, i.e. an old IPR value set by PriLev is reset to the new Prob.LSGRG2.options.IPR value. IMPORTANT: PriLev remains PriLev, and it still controls any output to the MATLAB screen.

Prob.LSGRG2.PrintFile is the name of the output file. If set by the user and printing is turned on, the file will be created.

If ''PriLev <''= 0 and printing is enabled through solver specific options and no Prob.LSGRG2.PrintFile name is given, a default file is opened.

If ''PriLev > ''0 and printing is enabled in some way and no Prob.LSGRG2.PrintFile name is given, no default file will be opened, as the user may only want screen printing.

Options controlling printing are: Prob.LSGRG2.options.INPRNT, .OTPRNT, .IPR, .IPN\#, .IPER. In summary:

*Prob.PriLevOpt controls .IPR as long as .IPR is not given explicitly.

*No default print file is created if Prob.PriLevOpt is set. Although, if Prob.LSGRG2.PrintFile is set, a print file always is created, as long as there is something to print.

==Algorithm==

===Multistart overview===

A pseudo-code description of the MSNLP algorithm follows, in which SP(xt) denotes the starting point generator and xt is the candidate starting point produced. We refer to the local NLP solver as L(xs, xf ), where xs is the starting point and xf the final point. The function UPDATE LOCALS(xs, xf, w) processes and stores solver output xf, using the starting point xs to compute the distance from xs to xf, and produces updated penalty weights, w.

====MSNLP Algorithm====

'''STAGE 1'''

x0 = user initial point

Call L(x0, xf )

Call UPDATE LOCALS(x0, xf,w)

'''FOR '''i = 1, n1 '''DO '''Call SP(xt(i)) Evaluate P(xt(i),w)

'''ENDDO'''

xt* = point yielding best value of P(xt(i),w) over all stage one points, (i = 1, 2, ..., n1). call L(xt*, xf )

Call UPDATE LOCALS(xt*, xf,w)

threshold = P(xt\*,w)

'''STAGE 2'''

'''FOR''' i = 1, n2 '''DO''' Call SP(xt(i)) Evaluate P(xt(i),w)

Perform merit and distance filter tests: Call distance filter(xt(i), dstatus)

Call merit filter(xt(i), threshold, mstatus)

'''IF '''(dstatus and mstatus = 'accept') '''THEN'''

Call L(xt(i), xf )

Call UPDATE LOCALS(xt(i), xf, w)

'''ENDIF ENDDO'''

After an initial call to L at the user-provided initial point, x0, stage 1 of the algorithm performs n1 iterations in which SP(xt) is called, and the L1 exact penalty value P(xt,w) is calculated. The user can set n1 through the MSNLP options structure using the STAGE1 ITERATIONS keyword. The point with the smallest of these P values is chosen as the starting point for the next call to L, which begins stage 2. In this stage, n2 iterations are performed in which candidate starting points are generated and L is started at any one which passes the distance and merit filter tests.

The distance filter helps insure that the starting points for L are diverse, in the sense that they are not too close to any previously found local solution. Its goal is to prevent L from starting more than once within the basin of attraction of any local optimum. When a local solution is found, it is stored in a linked list, ordered by its objective value, as is the Euclidean distance between it and the starting point that led to it. If a local solution is located more than once, the maximum of these distances, maxdist, is updated and stored. For each trial point, t, if the distance between t and any local solution already found is less than DISTANCE FACTOR\*maxdist, L is not started from the point, and we obtain the next trial solution from the generator.

This distance filter implicitly assumes that the attraction basins are spherical, with radii at least maxdist. The default value of DISTANCE FACTOR is 1.0, and it can be set to any positive value. As DISTANCE FACTOR approaches zero, the filtering effect vanishes, as would be appropriate if there were many closely spaced local solutions. As it becomes larger than 1, the filtering effect increases until eventually L is never started.

The merit filter helps insure that the starting points for L have high quality, by not starting from candidate points whose exact penalty function value P1 is greater than a threshold. This threshold is set initially to the P1 value of the best candidate point found in the first stage of the algorithm. If trial points are rejected by this test for more than WAITCYCLE consecutive iterations, the threshold is increased by the updating rule:

threshold ''< - ''threshold + THRESHOLD INCREASE FACTOR''*''(1''.''0 + ''abs''(''threshold''))

where the default value of THRESHOLD INCREASE FACTOR is 0.2 and that for WAITCYCLE is 20. The additive 1.0 term is included so that threshold increases by at least THRESHOLD INCREASE FACTOR when its current value is near zero. When a trial point is accepted by the merit filter, threshold is decreased by setting it to the P1 value of that point.

The combined effect of these 2 filters is that L is started at only a few percent of the trial points, yet global optimal solutions are found for a very high percentage of the test problems. However, the chances of finding a global opti- mum are increased by increasing ITERATION LIMIT (which we recommend trying first) or by 'loosening' either or both filters, although this is rarely necessary if the dynamic filters and basin overlap fix are used, as they are by default. If the ratio of stage 2 iterations to solver calls is more than 20 using the current filter parameters, and com- putation times with the default filter parameters are reasonable, one can try loosening the filters. This is achieved for the merit filter either by decreasing WAITCYCLE or by increasing THRESHOLD INCREASE FACTOR (or doing both), and for the distance filter by decreasing DISTANCE FACTOR. Either or both filters may be turned off, by setting USE DISTANCE FILTER and/or USE MERIT FILTER to 0. Turning off both causes an NLP solver call at every stage 2 trial point. This is the best way to insure that all local optima are found, but it can take a long time.

===Pure and smart random drivers===

The 'pure' random (PR) driver generates uniformly distributed points within the hyper-rectangle S defined by the variable bounds. However, this rectangle is often very large, because users often set bounds to (-inf,+inf ), (0,+inf ), or to large positive and/or negative numbers, particularly in problems with many variables. This usually has little adverse impact on a good local solver, as long as the starting point is chosen well inside the bounds. But the PR generator will often generate starting points with very large absolute component values when some bounds are very large, and this sharply degrades solver performance. Thus we were motivated to develop random generators which control the likelihood of generating candidate points with large components, and intensify the search by focusing points into promising regions. We present two variants, one using normal, the other triangular distributions. Pseudo-code for this 'smart random' generator using normal distributions follows, where w is the set of penalty weights determined by the 'update locals' logic discussed above, after the first solver call at the user-specified initial point.

'''Smart Random Generator with Normal Distributions, SRN(xt)'''

'''IF '''(first call) '''THEN'''

Generate k1 (default 400) diverse points in S and evaluate the exact penalty function P(x,w) at each point. B=subset of S with k2 (default 10) best P values

'''FOR '''i = 1,nvars '''DO'''

xmax(i) = max of component i of points in B xmin(i)= min of component i of points in B mu(i) = (xmax(i) + xmin(i))/2

ratio(i) = (xmax(i) - xmin(i))/(1+buvar(i)-blvar(i))

sigfactor = 2.0

'''IF '''(ratio''>''0.7) sigfactor = f(ratio)

sigma(i) = (xmax(i) - xmin(i))/sigfactor

'''ENDDO ENDIF'''

'''FOR '''i = 1,nvars '''DO'''

Generate a normally distributed random variable rv(i) with mean mu(i) and standard deviation sigma(i) If rv(i) is between blvar(i) and buvar(i), xt(i) = rv(i)

If rv(i)''<''blvar(i), generate xt(i) uniformly between blvar(i) and xmin(i)

If rv(i)''>''buvar(i), generate xt(i) uniformly between xmax(i) and buvar(i)

'''ENDDO'''

Return xt

This SRN generator attempts to find a subset, B, of k2 'good' points, and generates most of its trial points xt, within the smallest rectangle containing B. It first generates a set of k1 diverse points within the bounds using a stratified random sampling procedure with frequency-based memory. For each variable x(i), this divides the interval \[blvar(i), buvar(i)\] into 4 equal segments, chooses a segment with probability inversely proportional to the frequency with which it has been chosen thus far, then generates a random point in this segment. We choose k2 of these points having the best P(x,w) penalty values, and use the smallest rectangle containing these, intersecting the ith axis at points [xmin(i), xmax(i)], to define n univariate normal distributions (driver SRN) or n univariate triangular distributions (driver SRT). The mean of the ith normal distribution, mu(i), is the midpoint of the interval \[xmin(i), xmax(i)\], and this point is also the mode of the ith triangular distribution, whose lower and upper limits are blvar(i) and buvar(i). The standard deviation of the ith normal distribution is selected as described below. The trial point xt is generated by sampling n times independently from these distributions. For the driver using normals, if the generated point lies within the bounds, it is accepted. Otherwise, we generate a uniformly distributed point between the violated bound and the start of the interval.

To determine the standard deviation of the normal distributions, we compute ratio, roughly the ratio of interval width to distance between bounds, where the factor 1.0 is included to avoid division by zero when the bounds are equal (fixed variables). If the interval width is small relative to the distance between bounds for variable i

(''ratio = ''0''.''7), then the standard deviation sigma(i) is half the interval width, so about 1/3 of the xt(i) values fall outside the interval, providing diversity when the interval does not contain an optimal value for x(i). If the bounds are large, then ratio should be small, say less than 0.1, so xt(i) values near the bounds are very unlikely. If ratio ''> ''0.7, the function f sets sigfactor equal to 2.56 if ratio is between 0.7 and 0.8, increasing in steps to 6.2 if textitratio ''> ''0.999. Thus if ratio is near 1.0, more than 99% of the values fall within the interval, and few have to be projected back within the bounds. The projecting back process avoids undesirable clustering of trial points at a bound, by generating points uniformly between the violated bound and the nearest edge of the interval \[xmin(i), xmax(i)\]. When the interval \[xmin(i), xmax(i)\] is sharply skewed toward one of the variable bounds and is much narrower than the distance between the bounds, a symmetric distribution like the normal, combined with our projection procedure, generates too many points between the interval and its nearest bound. A quick scan of the test results indicates that this happens rarely, but an asymmetric distribution like the triangular overcomes this difficulty, and needs no projection.

MINLP Solver Reference

2012-01-22T15:54:29Z

Elias:

{{Part Of Manual|title=the MINLP Manual|link=[[MINLP|MINLP]]}}
The MINLP solvers are a set of Fortran solvers that were developed by Roger Fletcher and Sven Leyffer, Univer- sity of Dundee, Scotland. All solvers are available for sparse and dense continuous and mixed-integer quadratic programming ('''qp''','''miqp''') and continuous and mixed-integer nonlinear constrained optimization.

[[#Table: Solver routines in TOMLAB /MINLP.]] lists the solvers included in TOMLAB /MINLP. The solvers are called using a set of MEX-file interfaces developed as part of TOMLAB. All functionality of the MINLP solvers are available and changeable in the TOMLAB framework in Matlab.

Detailed descriptions of the TOMLAB /MINLP solvers are given in the following sections. Extensive TOMLAB m-file help is also available, for example ''help minlpBBTL ''in Matlab will display the features of the minlpBB solver using the TOMLAB format.

TOMLAB /MINLP package solves '''mixed-integer nonlinear programming '''('''minlp''') problem defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{llcccll}
-\infty < &x_{L} & \leq & x & \leq & x_{U}& < \infty \\
&b_{L} & \leq & A x & \leq & b_{U}& \\
&c_{L} & \leq & c(x) & \leq & c_{U},&
~x_{j} \in \mathbb{N}\ ~~\forall j \in $I$, \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A
\in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math>
and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>. The variables <math>x \in I</math>,
the index subset of <math>1,...,n</math>, are restricted to be integers.

'''mixed-integer quadratic programming '''('''miqp''') problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n
\times n}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in
\mathbb{R}^{m_1}</math>. The variables <math>x \in I</math>, the index subset of
<math>1,...,n</math>, are restricted to be integers.

as well as sub-types of these problems.

====Table: Solver routines in TOMLAB /MINLP.====

{|class="wikitable"
!Function||Description||Reference
|-valign="top"
|''bqpd''||Quadratic programming using a null-space method.||''bqpdTL.m''
|-valign="top"
|''miqpBB''||Mixed-integer quadratic programming using ''bqpd ''as subsolver.||''miqpBBTL.m''
|-valign="top"
|''filterSQP''||Constrained nonlinear minimization using a Filtered Sequential QP method.||''filterSQPTL.m''
|-valign="top"
|''minlpBB''||Constrained, mixed-integer nonlinear minimization using a branch- and bound search scheme. ''filterSQP ''is used as NLP solver.||''minlpBBTL.m''
|}

==bqpd==

The BQPD code solves quadratic programming (minimization of a quadratic function subject to linear constraints) and linear programming problems. If the Hessian matrix Q is positive definite, then a global solution is found. A global solution is also found in the case of linear programming (Q=0). When Q is indefinite, a Kuhn-Tucker point that is usually a local solution is found.

The code implements a null-space active set method with a technique for resolving degeneracy that guarantees that cycling does not occur even when round-off errors are present. Feasibility is obtained by minimizing a sum of constraint violations. The Devex method for avoiding near-zero pivots is used to promote stability. The matrix algebra is implemented so that the algorithm can take advantage of sparse factors of the basis matrix. Factors of the reduced Hessian matrix are stored in a dense format, an approach that is most effective when the number of free variables is relatively small. The user must supply a subroutine to evaluate the Hessian matrix Q, so that sparsity in Q can be exploited. An extreme case occurs when Q=0 and the QP reduces to a linear program. The code is written to take maximum advantage of this situation, so that it also provides an efficient method for linear programming.

===Direct Solver Call===

A direct solver call is not recommended unless the user is 100 % sure that no other solvers will be used for the problem. Please refer to Section 3.1.2 for information on how to use bqpd with TOMLAB.

====Purpose====

''bqpd ''solves quadratic optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x\\
& \\
s/t & \begin{array}{lcccl}
& & x & &, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n \times n}</math>,
<math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{n+m_1}</math>.

===Calling Syntax===

<pre>
[Inform, x k, Obj, g, Iter, k, ls, e, peq, lp, v k] = bqpds(A, x 0, bl, bu,
H, fLowBnd, mlp, mode, kmax, PriLev, PrintFile, k, ls, e, peq, lp, optPar, Prob, moremem);
</pre>

The sparse version MEX is bqpds, the dense is bqpdd.

====Description of Inputs====

The following fields are used:

{|class="wikitable"
!Input||Description
|-valign="top"
|''A ''||Constraint matrix, n x m+1 (SPARSE).
|-valign="top"
|''bl''||Lower bounds on (x, Ax).
|-valign="top"
|''bu''||Upper bounds on (x, Ax).
|-valign="top"
|''x_0''||Initial x vector (if empty set as 0).
|-valign="top"
|''H''||Quadratic matrix, n x n, SPARSE or DENSE, empty if LP problem. If H is a string, H should be the name of a function routine, e.g if H = 'HxComp' then the function routine.

<pre>
function Hx = HxComp(x, nState, Prob)
</pre>

should compute H * x. The user must define this routine nState == 1 if calling for the first time, otherwise 0. Third argument, the Prob structure, should only be used if calling BQPD with the additional input parameter Prob, see below.

Tomlab implements this callback to the predefined Matlab function HxFunc.m, using the call if Prob.DUNDEE.callback == 1.
|-valign="top"
|''fLowBnd''||Lower bound on optimal f(x).
|-valign="top"
|''mlp''||Maximum number of levels of recursion.
|-valign="top"
|''mode''||Mode of operation, default set as 2*Prob.WarmStart.
|-valign="top"
|''kmax''||Max dimension of reduced space (k), default n, set as 0 if LP.
|-valign="top"
|''PriLev''||Print Level. (0 = off, 1 = summary, 2 = scalar information, 3 = verbose)
|-valign="top"
|''PrintFile''||Name of the Print file. Unit 9 is used. Name includes the path, maximal number of characters = 500. Output is written on file bqpd.txt, if not given. To make bqpd to not open and not write anything to file: Set PriLev = 0.
|-valign="top"
|colspan="2"|For Warm Start:
|-valign="top"
|''k''||Dimension of the reduced space (Warm Start).
|-valign="top"
|''ls''||Indices of active constraints, first n-k used for warm start.
|-valign="top"
|''e''||Steepest-edge normalization coefficients (Warm Start).
|-valign="top"
|''peq''||Pointer to the end of equality constraint indices in ls (Warm Start).
|-valign="top"
|''lp''||List of pointers to recursion information in ls (Warm Start).
|-valign="top"
|''optPar''||Vector of optimization parameters. If -999, set to default. Length from 0 to 20 allowed.

{|class="wikitable"
|''optPar(1): iprint''||Print level in BQPD, default 0.
|-valign="top"
|''optPar(2): tol''||Relative accuracy in solution, default 1E-10.
|-valign="top"
|''optPar(3): emin''||Use cscale (constraint scaling) 0.0 no scaling, default 1.0.
|-valign="top"
|''optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic, default 5E-4.
|-valign="top"
|''optPar(5): nrep''||Max number of refinement steps, default 2.
|-valign="top"
|''optPar(6): npiv''||No repeat if no more than npiv steps were taken, default 3.
|-valign="top"
|''optPar(7): nres''||Max number of restarts if unsuccessful, default 2.
|-valign="top"
|''optPar(8): nfreq''||The max interval between refactorizations, default 500.
|}

|-valign="top"
|''Prob''||Sending the Prob structure is optional, only of use if sending H as a function string, see input H.
|-valign="top"
|''moremem''||Scalar or 2x1-vector with workspace increase. If ''<''0, use default strategy. If scalar, use same increase for both real and integer workspaces. If vector, first element is for real workspace, second for integer.
|}

====Description of Outputs====

The following fields are used:

{|class="wikitable"
!Output||Description
|-valign="top"
|''Inform''||Result of BQPD run, 0 = Optimal solution found. See the same parameter in section 3.1.2.
|-valign="top"
|''x_k''||Solution vector with n decision variable values.
|-valign="top"
|''Obj''||Objective function value at optimum. If infeasible, the sum of infeasibilities
|-valign="top"
|''g''||Gradient at solution.
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|colspan="2"|For Warm Start:
|-valign="top"
|''k''||Dimension of the reduced space (Warm Start).
|-valign="top"
|''ls''||Indices of active constraints, first n-k used for warm start.
|-valign="top"
|''e''||Steepest-edge normalization coefficients (Warm Start).
|-valign="top"
|''peq''||Pointer to the end of equality constraint indices in ls (Warm Start).
|-valign="top"
|''lp''||List of pointers to recursion information in ls (Warm Start).
|-valign="top"
|''v_k''||Lagrange parameters.
|}

===Using TOMLAB===

====Purpose====

''bqpdTL ''solves nonlinear optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x\\
& \\
s/t & \begin{array}{lcccl}
& & x & &, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n \times n}</math>,
<math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{n+m_1}</math>.

====Calling Syntax====

Using the driver routine ''tomRun '':

<pre>
Prob = ''o''Assign( ... );
Result = tomRun('bqpd', Prob ... );
</pre>

or

<pre>
Prob = ProbCheck(Prob,'bpqd');
Result = bqpdTL(Prob);
</pre>

Call Prob = ''o''Assign( ... ) or Prob=ProbDef; to define the Prob for the second option.

====Description of Inputs====

''Prob'', The following fields are used:

{|class="wikitable"
!Field||Description
|-valign="top"
|''x_L, x_U''||Bounds on variables.
|-valign="top"
|''b_L, b_U''||Bounds on linear constraints.
|-valign="top"
|''A''||Linear constraint matrix.
|-valign="top"
|''QP.c ''||Linear coefficients in objective function.
|-valign="top"
|''QP.F ''||Quadratic matrix of size n x n.
|-valign="top"
|''PriLevOpt''||Print Level (0 = off, 1 = summary, 2 = scalar information, 3 = verbose).
|-valign="top"
|''WarmStart''||If TRUE (=1), use warm start, otherwise cold start.
|-valign="top"
|''LargeScale ''||If TRUE (=1), use sparse version, otherwise dense.
|-valign="top"
|''DUNDEE.QPmin''||Lower bound for the QP subproblems. Default: -1E300.
|-valign="top"
|''DUNDEE.callback''||If 1, use a callback to Matlab to compute QP.F * x for different x. Faster when F is very large and almost dense, avoiding copying of F from Matlab to MEX.
|-valign="top"
|''DUNDEE.kmax''||Max dimension of reduced space (k), default n, set as 0 if LP.
|-valign="top"
|''DUNDEE.mlp''||Maximum number of levels of recursion.
|-valign="top"
|''DUNDEE.mode''||Mode of operation, default set as 2*Prob.WarmStart.
|-valign="top"
|''DUNDEE.x''||Solution (Warm Start).
|-valign="top"
|''DUNDEE.k''||Dimension of the reduced space (Warm Start).
|-valign="top"''
|''DUNDEE.e''||Steepest-edge normalization coefficients (Warm Start).
|-valign="top"
|''DUNDEE.ls''||Indices of active constraints, first n-k used for warm start.
|-valign="top"
|''DUNDEE.lp''||List of pointers to recursion information in ls (Warm Start).
|-valign="top"
|''DUNDEE.peq ''||Pointer to the end of equality constraint indices in ls (Warm Start).
|-valign="top"
|''DUNDEE.PrintFile ''||Name of print file. Amount/print type determined by optPar(1). Default name bqpd.txt.
|-valign="top"
|''DUNDEE.optPar ''||Vector of optimization parameters. If -999, set to default Length from 0 to 20 allowed. Elements used:

{|class="wikitable"
|''DUNDEE.optPar(1): iprint''||Print level in PrintFile, default 0.
|-valign="top"
|''DUNDEE.optPar(2): tol''||Relative accuracy in solution, default 1E-10.
|-valign="top"
|''DUNDEE.optPar(3): emin''||1.0 Use cscale (constraint scaling) 0.0 no scaling, default 1.0.
|-valign="top"
|''DUNDEE.optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic, default 5E-4.
|-valign="top"
|''DUNDEE.optPar(5): nrep''||Max number of refinement steps, default 2.
|-valign="top"
|''DUNDEE.optPar(6): npiv''||No repeat if no more than npiv steps were taken, default 3.
|-valign="top"
|''DUNDEE.optPar(7): nres''||Max number of restarts if unsuccessful, default 2.
|-valign="top"
|''DUNDEE.optPar(8): nfreq ''||The max interval between refactorizations, default 500.
|}
|}

===Description of Outputs===

''Result'', The following fields are used:

{|class="wikitable"
!Output||Description
|-valign="top"
|''Result''||The structure with results (see ResultDef.m).
|-valign="top"
|''f_k''||Function value at optimum or constraint deviation if infeasible.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''g_k''||Exact gradient computed at optimum.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrangian multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status from bqpd.m (similar to TOMLAB).
|-valign="top"
|''Inform''||BQPD information parameter.

0 - Solution obtained

1 - Unbounded problem detected (f(x)¡=fLow occurred)

2 - Lower bound bl(i) ''> ''bu(i) (upper bound) for some i

3 - Infeasible problem detected in Phase 1

4 - Incorrect setting of m, n, kmax, mlp, mode or tol

5 - Not enough space in lp

6 - Not enough space for reduced Hessian matrix (increase kmax)

7 - Not enough space for sparse factors

8 - Maximum number of unsuccessful restarts taken
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''MinorIter''||Number of minor iterations. Always set to 0. ''FuncEv ''Number of function evaluations. Set to Iter.
|-valign="top"
|''GradEv''||Number of gradient evaluations. Set to Iter. ''ConstrEv ''Number of constraint evaluations. Set to 0.
|-valign="top"
|''QP.B''||Basis vector in TOMLAB QP standard.
|}

==filterSQP==

The solver filterSQP is a Sequential Quadratic Programming solver suitable for solving large, sparse or dense linear, quadratic and nonlinear programming problems. The method avoids the use of penalty functions. Global convergence is enforced through the use of a trust-region and the new concept of a "filter" which accepts a trial point whenever the objective or the constraint violation is improved compared to all previous iterates. The size of the trust-region is reduced if the step is rejected and increased if it is accepted (provided the agreement between the quadratic model and the nonlinear functions is sufficiently good).

This method has performed very well in comparative numerical testing, and has the advantage that the user does not need to supply any estimates of penalty parameters. The NLP problem is specified by means of user subroutines, and it is necessary to provide information about both first and second derivatives of the nonlinear functions in the problem.

It must be used in conjunction with the bqpd solver.

===Direct Solver Call===

A direct solver call is not recommended unless the user is 100 % sure that no other solvers will be used for the problem. Please refer to Section 3.2.2 for information on how to use filterSQP with TOMLAB.

====Purpose====

''filterSQP ''solves constrained nonlinear optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{lcccl}
& & x & &, \\
b_{L} & \leq & A x & \leq & b_{U} \\
& & c(x) & & \\
\end{array}
\end{array}
</math>

where <math>x \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A \in
\mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{n+m_1+m_2}</math>
and <math>c(x) \in \mathbb{R}^{m_2}</math>

The full input matrix A has three parts A = A = [g ConsPattern' A'];

Where g is a vector of length n, values irrelevant, ConsPattern is the 0-1 pattern of the nonlinear constraint gradients and A is the linear constraint coefficient matrix.

====Calling Syntax====

The file 'funfdf.m' must be defined and contain: function [mode, f, g] = funfdf(x, Prob, mode, nstate) to compute the objective function f and the gradient g at the point x.

The file 'funcdc.m' must be defined and contain: function [mode ,c ,dcS] = funcdc(x, Prob, mode, nstate) to compute the nonlinear constraint value c and the constraint Jacobian dcS for the nonlinear constraints at the point x.

[ifail, x k, f k, c k, v k, lws, istat, rstat] = filSQPs( A, bl, bu, nnCon, x 0, Scale, scmode, fLow, MaxIter, rho, mlp, kmax, maxf, WarmStart, lws, istat, PriLev, pname, optPar, Prob, moremem);

The sparse version MEX is filSQPs, the dense is filSQPd.

====Description of Inputs====

The following fields are used:

{|class="wikitable"
|-valign="top"
|''A''||Gradient matrix [g ConsPattern' A'] (sparse or dense).
|-valign="top"
|''bl''||Lower bounds on (x,c(x),Ax).
|-valign="top"
|''bu''||Upper bounds on (x,c(x),Ax).
|-valign="top"
|''nnCon''||Number of nonlinear constraints (i.e. length(c(x)).
|-valign="top"
|''x_0''||Initial x vector (if empty set as 0).
|-valign="top"
|''Scale''||n+m vector scale factors for variables and constraints (same ordering as bl, bu).
|-valign="top"
|''scmode''||Scale mode:

0 - unit variable and constraint scaling (Scale can be set empty).

1 - User provided scale factors for variables. Scale must be of length n.

2 - Unit variable scaling, user provided constraint scaling. Scale must be of length n+m, but only the last m elements are used.

3- User provided variable AND constraint scaling. Scale must be of length n+m (n+nnCon+nnLin)
|-valign="top"
|''fLow''||A lower bound on the objective function value.
|-valign="top"
|''MaxIter''||Maximum number of iterations.
|-valign="top"
|''rho''||Initial trust-region radius.
|-valign="top"
|''mlp''||Maximum level parameter for resolving degeneracy in BQPD.
|-valign="top"
|''kmax''||Maximum size of null-space (at most n).
|-valign="top"
|''maxf''||Maximum size of the filter.
|-valign="top"
|''WarmStart''||Set to 1 to restart the solver. If a warmstart is requested, the input parameters lws and istat must be provided. Also, n and m (the number of variables and constraints) may not change.
|-valign="top"
|''lws''||Used only when doing a warmstart. This must be the lws vector returned by the previous call to filterSQP. Otherwise, set to empty.
|-valign="top"
|''lam''||Multipliers, n+m values required for warmstarts. If wrong length, zeros are set in the MEX interface.
|-valign="top"
|''istat''||Used only when doing a warmstart. Must be the first element of the istat vector returned by the previous call to filterSQP. Otherwise, set to empty.
|-valign="top"
|''PriLev''||Print level. See also input parameter pname.

0 - Silent, except for minor output into ¡pname¿.out

1 - One line per iteration

2 - Scalar information printed

3 - Scalar and vector information printed
|-valign="top"
|''pname''||Problem name, at most 10 characters. The output files are named ''<''pname''>''.sum and ''<''pname''>''.out.
|-valign="top"
|''optPar''||Vector of max length 20 with optimization parameters: If any element is -999, default value is assigned. Elements 2-8 are BQPD parameters, 1,9-11,19-20 for filterSQP.

{|class="wikitable"
|''optPar(1): iprint''||Print level in filterSQP, default 0.
|-valign="top"
|''optPar(2): tol ''||Relative tolerance for BQPD subsolver, default 1E-10.
|-valign="top"
|''optPar(3): emin''||1=Use cscale in BQPD, 0=no scaling , default 1.0.
|-valign="top"
|''optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic (BQPD), default 5E-4.
|-valign="top"
|''optPar(5): nrep''||Max number of refinement steps (BQPD), default 2.
|-valign="top"
|''optPar(6): npiv''||No repeat if no more than npiv steps were taken, default 3.
|-valign="top"
|''optPar(7): nres''||Max number of restarts if unsuccessful, default 2.
|-valign="top"
|''optPar(8): nfreq''||The max interval between refactorizations, default 500.
|-valign="top"
|''optPar(9): NLP eps''||NLP subproblem tolerance, default 1E-6.
|-valign="top"
|''optPar(10): ubd''||Upper bound on constraint violation used in the filter, default 1E-2.
|-valign="top"
|''optPar(11): tt''||Parameter related to ubd. The actual upper bound is defined by the maximum of ubd and tt multiplied by the initial constraint violation., default 0.125.
|-valign="top"
|''optPar(19): infty''||A large value representing infinity, default 1E20.
|-valign="top"
|''optPar(20): Nonlin''||If 1, skip linear feasibility tests filterSQP treating all constraints as nonlinear, default 0.
|}

|-valign="top"
|''Prob''||The Tomlab problem definition structure.
|-valign="top"
|''moremem''||Scalar or 2x1-vector with workspace increase. If ''<''0, use default strategy. If scalar, use same increase for both real and integer workspaces. If vector, first element is for real workspace, second for integer.
|}

====Description of Outputs====

The following fields are used:

{|class="wikitable"
!Output||Description
|-valign="top"
|''Inform''||Exit flag indicating success or failure:

0 - Solution found

1 - Unbounded: feasible point x with f(x)''<''=fmin found

2 - Linear constraints are infeasible

3 - (Locally) nonlinear infeasible, optimal solution to feasibility problem found

4 - Terminated at point with h(x)''<''=eps but QP infeasible

5 - Terminated with rho''<''=eps

6 - Terminated due to too many iterations

7 - Crash in user routine could not be resolved

8 - Unexpected failure in QP solver

9 - Not enough real workspace

10 - Not enough integer workspace
|-valign="top"
|''x_k''||Solution vector (n+m by 1) with n decision variable values together with the m slack variables.
|-valign="top"
|''f_k''||Function value at optimum x k
|-valign="top"
|''c_k''||Nonlinear constraints vector at optimum.
|-valign="top"
|''v_k''||Lagrange multipliers vector (bounds, nonlinear, linear).
|-valign="top"
|''lws''||Integer vector (used as input when doing warmstarts).
|-valign="top"
|''istat ''||Solution statistics, integer values. First element is required as input if doing a warmstart.

{|class="wikitable"
|''istat(1)''||Dimension of nullspace at solution
|-valign="top"
|''istat(2)''||Number of iterations
|-valign="top"
|''istat(3)''||Number of feasibility iterations
|-valign="top"
|''istat(4)''||Number of objective evaluations
|-valign="top"
|''istat(5)''||Number of constraint evaluations
|-valign="top"
|''istat(6)''||Number of gradient evaluations
|-valign="top"
|''istat(7)''||Number of Hessian evaluations
|-valign="top"
|''istat(8)''||Number of QPs with mode''<''=2 ''
|-valign="top"
|istat(9)''||Number of QPs with mode''>''=4
|-valign="top"
|''istat(10)''||Total number of QP pivots
|-valign="top"
|''istat(11)''||Number of SOC steps
|-valign="top"
|''istat(12)''||Maximum size of filter
|-valign="top"
|''istat(13)''||Maximum size of Phase 1 filter
|-valign="top"
|''istat(14)''||Number of QP crashes
|-valign="top"
|''rstat''||Solution statistics, real values.
|-valign="top"
|''rstat(1)''||l 2 norm of KT residual
|-valign="top"
|''rstat(3) ''||Largest modulus multiplier
|-valign="top"
|''rstat(4)''||l inf norm of final step
|-valign="top"
|''rstat(5)''||Final constraint violation h(x)
|}

|}

====Using TOMLAB====

===Purpose===

''filterSQPTL ''solves constrained nonlinear optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
c_{L} & \leq & c(x) & \leq & c_{U} \\
\end{array}
\end{array}
</math>

where <math>x, x_L, x_U \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A
\in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{m_1}</math>
and <math>c_L,c(x),c_U \in \mathbb{R}^{m_2}</math>.

====Calling Syntax====

Using the driver routine ''tomRun '':

<pre>
Prob = ''o''Assign( ... );
Result = tomRun('filterSQP', Prob ... );
</pre>

or

<pre>
Result = filterSQPTL(funfdf, funcdc, Prob)
</pre>

where the inputs are:

funfdf Name of routine [f, gradf ] = funfdf(x, Prob, mode, nstate).

Normally funfdf = nlp fg, included in TOMLAB.

funcdc Name of routine [g, gJac] = funcdc(x, Prob, mode, nstate).

Normally funcdc = nlp cdcS, included in TOMLAB. Probroblem structure in TOMLAB format.

Call Prob = ''o''Assign( ... ) or Prob=ProbDef; to define the Prob for the second option.

====Description of Inputs====

''Prob'', The following fields are used:

{|class="wikitable"
!Input||Description
|-valign="top"
|''x_L, x_U''||Bounds on variables.
|-valign="top"
|''b_L, b_U''||Bounds on linear constraints.
|-valign="top"
|''c_L, c_U''||Bounds on nonlinear constraints. For equality constraints (or fixed variables), set e.g. b L(k) == b U(k).
|-valign="top"
|''LargeScale''||If 1 use sparse version of solver. The default is 0, the dense version.
|-valign="top"
|''PriLevOpt''||Print level in the filterSQP solver.
|-valign="top"
|''WarmStart''||Indicates that the solver should be warmstarted. See Prob.DUNDEE for nec- essary arguments when doing warmstarts.
|-valign="top"
|''optParam''||Structure with optimization parameters. Fields used:
|-valign="top"
|''MaxIter''||Maximum number of iterations.
|-valign="top"
|''DUNDEE''||Structure with special fields for filterSQP optimization parameters. The following fields are used:
|-valign="top"
|''DUNDEE.QPmin''||Lower bound for the QP subproblems. Default: -1E300.
|-valign="top"
|''DUNDEE.rho ''||Initial trust region radius. Default: 10.0 (REAL).
|-valign="top"
|''DUNDEE.kmax''||Maximum size of the null-space, less than or equal to no. of variables. Default: n (INTEGER).
|-valign="top"
|''DUNDEE.maxf''||Maximum size of the filter. Default: 100 (INTEGER).
|-valign="top"
|''DUNDEE.mlp''||Maximum level parameter for resolving degeneracy in BQPD QP subsolver.

Default: 100 (INTEGER).
|-valign="top"
|''DUNDEE.Name''||Problem name, at most 10 characters. The output files are named ''<''pname''>''.sum and ''<''pname''>''.out. Default name filterSQP, i.e. files filter- SQP.sum, filterSQP.out.
|-valign="top"
|''DUNDEE.optPar''||Vector of max length 20 with optimization parameters: If any element is -999, default value is assigned.

{|class="wikitable"
|''DUNDEE.optPar(1): iprint''||Print level in filterSQP, default 0.
|-valign="top"
|''DUNDEE.optPar(2): tol''||Relative tolerance for BQPD subsolver, default 1E-10. ''DUNDEE.optPar(3): emin ''1=Use cscale in BQPD, 0=no scaling , default 1.0.
|-valign="top"
|''DUNDEE.optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic (BQPD), default 5E-4.
|-valign="top"
|''DUNDEE.optPar(5): nrep''||Max number of refinement steps (BQPD), default 2.
|-valign="top"
|''DUNDEE.optPar(6): npiv''||No repeat if no more than npiv steps were taken, default 3.
|-valign="top"
|''DUNDEE.optPar(7): nres''||Max number of restarts if unsuccessful, default 2.
|-valign="top"
|''DUNDEE.optPar(8): nfreq''||The max interval between refactorizations, default 500.
|-valign="top"
|''DUNDEE.optPar(9): NLP eps''||NLP subproblem tolerance, default 1E-6.
|-valign="top"
|''DUNDEE.optPar(10): ubd''||Upper bound on constraint violation used in the filter, default 1E-2.
|-valign="top"
|''DUNDEE.optPar(11): tt''||Parameter related to ubd. The actual upper bound is defined by the maximum of ubd and tt multiplied by the initial constraint violation., default 0.125.
|-valign="top"
|''DUNDEE.optPar(19): infty''||A large value representing infinity, default 1E20.
|-valign="top"
|''DUNDEE.optPar(20): Nonlin''||If 1, skip linear feasibility tests filterSQP treating all constraints as nonlinear, default 0.
|}

|-valign="top"
|''lws''||If doing warmstarts, this field is set to the Result.DUNDEE.lws field from the previous run.
|-valign="top"
|''istat''||Similarly, for warmstarts, set istat to Result.DUNDEE.istat from the previous run. Only the first element is used.
|-valign="top"
|''lam''||Vector of initial multipliers. Necessary for warmstarts, but can always be given if desired. Must be n+m elements in order to be used.
|-valign="top"
|''morereal''||Increase of REAL workspace. A problem dependent default value is used if ''<''0 or empty.
|-valign="top"
|''moreint''||Increase of INTEGER workspace. A problem dependent default value is used if ''<''0 or empty.

Scaling parameters: It is possible to supply scale factors for the variables and/or the constraints. Normally, the DUNDEE solvers does not differentiate between linear and nonlinear constraints with regard to scaling, but the Tomlab interface handles this automatically. Thus is it possible to give scale factors e.g. for the nonlinear constraints only. All scaling values must be greater than zero.
|-valign="top"
|''xScale''||Vector of scale factors for variables. If less than n values given, 1's are used for the missing elements.
|-valign="top"
|''bScale''||Vector of scale factors for the linear constraints. If length(bScale) is less than the number of linear constraints ( size(Prob.A,1) ), 1's are used for the missing elements.
|-valign="top"
|''cScale''||Vector of scale factors for the nonlinear constraints. If length(cScale) is less than the number of nonlinear constraints, 1's are used for the missing elements.
|}

====Description of Outputs====

''Result'', The following fields are used:

{|class="wikitable"
!Result||The structure with results (see ResultDef.m).
|-valign="top"
|''f_k''||Function value at optimum.
|-valign="top"
|''g_k''||Gradient of the function.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''c_k''||Nonlinear constraint residuals.
|-valign="top"
|''cJac''||Nonlinear constraint gradients.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''cState''||State of nonlinear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrangian multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status from filterSQP MEX.
|-valign="top"
|''Inform''||filterSQP information parameter:

0 - Solution found

1 - Unbounded: feasible point x with f(x)''<''=fmin found

2 - Linear constraints are infeasible

3 - (Locally) nonlinear infeasible, optimal solution to feasibility problem found

4 - Terminated at point with h(x)''<''=eps but QP infeasible

5 - Terminated with rho''<''=eps

6 - Too many iterations

7 - Crash in user routine could not be resolved

8 - Unexpected ifail from QP solver. This is often due to too little mem- ory being allocated and is remedied by setting appropriate values in the Prob.DUNDEE.morereal and Prob.DUNDEE.moreint parameters.

9 - Not enough REAL workspace

10 - Not enough INTEGER workspace
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''FuncEv''||Number of function evaluations. ''GradEv ''Number of gradient evaluations.
|-valign="top"
|''ConstrEv''||Number of constraint evaluations.
|-valign="top"
|''Solver''||Name of the solver (filterSQP).
|-valign="top"
|''SolverAlgorithm''||Description of the solver.
|-valign="top"
|''DUNDEE.lws''||Workspace vector, should be treated as integer valued. Required if doing warm- starts.
|-valign="top"
|''DUNDEE.lam''||Vector of multipliers, required if doing warmstarts.
|-valign="top"
|''istat''||Solution statistics, integer values. First element is required as input if doing a warmstart.

{|class="wikitable"
|''istat(1) ''||Dimension of nullspace at solution
|-valign="top"
|''istat(2) ''||Number of iterations
|-valign="top"
|''istat(3) ''||Number of feasibility iterations
|-valign="top"
|''istat(4) ''||Number of objective evaluations
|-valign="top"
|''istat(5)''||Number of constraint evaluations
|-valign="top"
|''istat(6) ''||Number of gradient evaluations
|-valign="top"
|''istat(7)''||Number of Hessian evaluations
|-valign="top"
|''istat(8) ''||Number of QPs with mode''<''=2
|-valign="top"
|''istat(9)''||Number of QPs with mode''>''=4
|-valign="top"
|''istat(10) ''||Total number of QP pivots
|-valign="top"
|''istat(11) ''||Number of SOC steps
|-valign="top"
|''istat(12) ''||Maximum size of filter
|-valign="top"
|''istat(13) ''||Maximum size of Phase 1 filter
|-valign="top"
|''istat(14) ''||Number of QP crashes
|}
|-valign="top"
|''rstat''||Solution statistics, floating point values.
{|class="wikitable"
|''rstat(1)''||l 2 norm of KT residual
|-valign="top"
|''rstat(3)''||Largest modulus multiplier
|-valign="top"
|''rstat(4)''||l inf norm of final step
|-valign="top"
|''rstat(5)''||Final constraint violation h(x)
|}

|}

==minlpBB==

The solver minlpBB solves large, sparse or dense mixed-integer linear, quadratic and nonlinear programming problems. minlpBB implements a branch-and-bound algorithm searching a tree whose nodes correspond to con- tinuous nonlinearly constrained optimization problems. The user can influence the choice of branching variable by providing priorities for the integer variables.

The solver must be used in conjunction with both filterSQP and bqpd.

===Direct Solver Call===

A direct solver call is not recommended unless the user is 100 % sure that no other solvers will be used for the problem. Please refer to Section 3.2.2 for information on how to use filterSQP with TOMLAB.

====Purpose====

''filterSQP ''solves constrained nonlinear optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) \\
& \\
s/t & \begin{array}{lcccl}
& & x & &, \\
b_{L} & \leq & A x & \leq & b_{U} \\
& & c(x) & & \\
\end{array}
\end{array}
</math>

where <math>x \in \mathbb{R}^n</math>, <math>f(x) \in \mathbb{R}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>, <math>b_L,b_U \in \mathbb{R}^{n+m_1+m_2}</math> and <math>c(x) \in \mathbb{R}^{m_2}</math>.

The full input matrix A has three parts A = A = [g ConsPattern' A'];

Where g is a vector of length n, values irrelevant, ConsPattern is the 0-1 pattern of the nonlinear constraint gradients and A is the linear constraint coefficient matrix.

====Calling Syntax====

The file 'funfdf.m' must be defined and contain: function [mode, f, g] = funfdf(x, Prob, mode, nstate) to compute the objective function f and the gradient g at the point x.

The file 'funcdc.m' must be defined and contain: function [mode ,c ,dcS] = funcdc(x, Prob, mode, nstate) to compute the nonlinear constraint value c and the constraint Jacobian dcS for the nonlinear constraints at the point x.

<pre>
[ifail, x k, f k, c k, v k, lws, istat, rstat] = filSQPs( A, bl, bu, nnCon, x
0, Scale, scmode, fLow, MaxIter, rho, mlp, kmax, maxf, WarmStart, lws, istat,
PriLev, pname, optPar, Prob, moremem);
</pre>

The sparse version MEX is filSQPs, the dense is filSQPd.

====Description of Inputs====

The following fields are used:

{|class="wikitable"
|''A''||Gradient matrix [g ConsPattern' A'] (sparse or dense).
|-valign="top"
|''bl''||Lower bounds on (x,c(x),Ax).
|-valign="top"
|''bu''||Upper bounds on (x,c(x),Ax).
|-valign="top"
|''nnCon''||Number of nonlinear constraints (i.e. length(c(x)).
|-valign="top"
|''x_0''||Initial x vector (if empty set as 0).
|-valign="top"
|''Scale'||'n+m vector scale factors for variables and constraints (same ordering as bl, bu).
|-valign="top"
|''scmode''||Scale mode:

0 - unit variable and constraint scaling (Scale can be set empty).

1 - User provided scale factors for variables. Scale must be of length n.

2 - Unit variable scaling, user provided constraint scaling. Scale must be of length n+m, but only the last m elements are used.

3- User provided variable AND constraint scaling. Scale must be of length n+m (n+nnCon+nnLin)
|-valign="top"
|''fLow ''||A lower bound on the objective function value.
|-valign="top"
|''MaxIter''||Maximum number of iterations.
|-valign="top"
|''rho''||Initial trust-region radius.
|-valign="top"
|''mlp''||Maximum level parameter for resolving degeneracy in BQPD.
|-valign="top"
|''kmax''||Maximum size of null-space (at most n).
|-valign="top"
|''maxf''||Maximum size of the filter.
|-valign="top"
|''WarmStart''||Set to 1 to restart the solver. If a warmstart is requested, the input parameters lws and istat must be provided. Also, n and m (the number of variables and constraints) may not change.
|-valign="top"
|''lws''||Used only when doing a warmstart. This must be the lws vector returned by the previous call to filterSQP. Otherwise, set to empty.
|-valign="top"
|''lam''||Multipliers, n+m values required for warmstarts. If wrong length, zeros are set in the MEX interface.
|-valign="top"
|''istat''||Used only when doing a warmstart. Must be the first element of the istat vector returned by the previous call to filterSQP. Otherwise, set to empty.
|-valign="top"
|''PriLev''||Print level. See also input parameter pname.

0 - Silent, except for minor output into ¡pname¿.out

1 - One line per iteration

2 - Scalar information printed

3 - Scalar and vector information printed
|-valign="top"
|''pname''||Problem name, at most 10 characters. The output files are named ''<''pname''>''.sum and ''<''pname''>''.out.
|-valign="top"
|''optPar''||Vector of max length 20 with optimization parameters: If any element is -999, default value is assigned. Elements 2-8 are BQPD parameters, 1,9-11,19-20 for filterSQP.

{|class="wikitable"
|''optPar(1): iprint''||Print level in filterSQP, default 0.
|-valign="top"
|''optPar(2): tol''||Relative tolerance for BQPD subsolver, default 1E-10.
|-valign="top"
|''optPar(3): emin''||1=Use cscale in BQPD, 0=no scaling , default 1.0.
|-valign="top"
|''optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic (BQPD), default 5E-4.
|-valign="top"
|''optPar(5): nrep''||Max number of refinement steps (BQPD), default 2.
|-valign="top"
|''optPar(6): npiv''||No repeat if no more than npiv steps were taken, default 3.
|-valign="top"
|''optPar(7): nres''||Max number of restarts if unsuccessful, default 2.
|-valign="top"
|''optPar(8): nfreq''||The max interval between refactorizations, default 500. ''optPar(9): NLP eps ''NLP subproblem tolerance, default 1E-6.
|-valign="top"
|''optPar(10): ubd''||Upper bound on constraint violation used in the filter, default 1E-2.
|-valign="top"
|''optPar(11): tt||''Parameter related to ubd. The actual upper bound is defined by the maximum of ubd and tt multiplied by the initial constraint violation., default 0.125.
|-valign="top"
|''optPar(19): infty''||A large value representing infinity, default 1E20.
|-valign="top"
|''optPar(20): Nonlin''||If 1, skip linear feasibility tests filterSQP treating all constraints as nonlinear, default 0.
|}
|-valign="top"
|''Prob ''||The Tomlab problem definition structure.
|-valign="top"
|''moremem''||Scalar or 2x1-vector with workspace increase. If ''<''0, use default strategy. If scalar, use same increase for both real and integer workspaces. If vector, first element is for real workspace, second for integer.
|}

====Description of Outputs====

The following fields are used:

{|class="wikitable"
|''Inform''||Exit flag indicating success or failure:

0 - Solution found

1 - Unbounded: feasible point x with f(x)''<''=fmin found

2 - Linear constraints are infeasible

3 - (Locally) nonlinear infeasible, optimal solution to feasibility problem found

4 - Terminated at point with h(x)''<''=eps but QP infeasible

5 - Terminated with rho''<''=eps

6 - Terminated due to too many iterations

7 - Crash in user routine could not be resolved

8 - Unexpected failure in QP solver

9 - Not enough real workspace

10 - Not enough integer workspace
|-valign="top"
|''x_k''||Solution vector (n+m by 1) with n decision variable values together with the m slack variables.
|-valign="top"
|''f_k''||Function value at optimum x k
|-valign="top"
|''c_k''Nonlinear constraints vector at optimum.
|-valign="top"
|''v_k''||Lagrange multipliers vector (bounds, nonlinear, linear).
|-valign="top"
|''lws''||Integer vector (used as input when doing warmstarts).
|-valign="top"
|''istat''||Solution statistics, integer values. First element is required as input if doing a warmstart.

{|class="wikitable"
|''istat(1)''||Dimension of nullspace at solution
|-valign="top"
|''istat(2)''||Number of iterations
|-valign="top"
|''istat(3)''||Number of feasibility iterations
|-valign="top"
|''istat(4)''||Number of objective evaluations
|-valign="top"
|''istat(5)''||Number of constraint evaluations
|-valign="top"
|''istat(6)''||Number of gradient evaluations
|-valign="top"
|''istat(7)''||Number of Hessian evaluations
|-valign="top"
|''istat(8)''||Number of QPs with mode''<''=2
|-valign="top"
|''istat(9)''||Number of QPs with mode''>''=4
|-valign="top"
|''istat(10)''||Total number of QP pivots
|-valign="top"
|''istat(11)''||Number of SOC steps
|-valign="top"
|''istat(12)''||Maximum size of filter
|-valign="top"
|''istat(13)''||Maximum size of Phase 1 filter
|-valign="top"
|''istat(14)''||Number of QP crashes
|}

|-valign="top"
|''rstat''||Solution statistics, real values.
|-valign="top"
|''rstat(1)''||l 2 norm of KT residual
|-valign="top"
|''rstat(3)''||Largest modulus multiplier
|-valign="top"
|''rstat(4)''||l inf norm of final step
|-valign="top"
|''rstat(5)''||Final constraint violation h(x)
|}

===Using TOMLAB===

====Purpose====

''minlpBBTL ''solves mixed-integer nonlinear optimization problems defined as

<math>
\begin{array}{cccccc}
\min\limits_{x} & f(x) \\
s/t & x_{L} & \leq & x & \leq & x_{U} \\
& b_{L} & \leq & Ax & \leq & b_{U} \\
& c_{L} & \leq & c(x) & \leq & c_{U}
\end{array}
</math>

where <math>x,x_{L},x_{U}\in \mathbb{R}^{n}</math>, <math>A\in \mathbb{R}^{m_{1}\times n}</math> and <math>b_{L},b_{U}\in \mathbb{R}^{m_{1}}</math> and <math>c(x),c_{L},c_{U}\in \mathbb{R} ^{m_{2}}</math>, Furthermore, <math>x_i,\, i\in\mathbb{I}</math> are restricted to integer values only.

In addition, Special Ordered Sets of type 1 (SOS1) can be defined.

The algorithm uses a branch-and-bound scheme with a depth-first search strategy. The NLP relaxations are solved using the solver filterSQP by R. Fletcher and S. Leyffer.

====Calling Syntax====

Using the driver routine ''tomRun '':

<pre>
Prob = ''o''Assign( ... );
Result = tomRun('minlpBB', Prob ... );
</pre>

or

<pre>
Result = minlpBBTL(Prob).
</pre>

Call Prob = ''o''Assign( ... ) or Prob=ProbDef; to define the Prob for the second option.

====Description of Inputs====

''Prob'', The following fields are used:

{|class="wikitable"
|''A''||Linear constraints coefficient matrix.
|-valign="top"
|''x_L, x_U''||Bounds on variables.
|-valign="top"
|''b_L, b_U''||Bounds on linear constraints.
|-valign="top"
|''c_L, c_U''||Bounds on nonlinear constraints.
|-valign="top"
|''LargeScale''||If 1 use sparse version of solver. The default is 0, the dense version.
|-valign="top"
|''PriLevOpt''||Print level in the minlpBB solver.
|-valign="top"
|''optParam.MaxIter''||Maximum number of iterations.
|-valign="top"
|''MIP''||Structure with fields defining the integer properties of the problem. The following fields are used:
|-valign="top"
|''IntVars''||Vector designating which variables are restricted to integer values. This field is interpreted differently depending on the length.

If length(IntVars) = length(x), it is interpreted as a zero-one vector where all non-zero elements indicate integer values only for the corresponding variable.

A length less than the problem dimension indicates that IntVars is a vector of indices for the integer variables, for example [1 2 3 6 7 12]
|-valign="top"
|''VarWeight''||Defines the priorities of the integer variables. Can be any values, but minlpBB uses integer priorities internally, with higher values implying higher priorities.
|-valign="top"
|''sos1''||Structure defining the Special Ordered Sets of Type 1 (SOS1). If there are k sets of type sos1, then sos1(1).var is a vector of indices for variables in sos1, set 1. sos1(1).row is the row number for the reference row identifying the ordering information for the sos1 set, i.e. A(sos1(1).row,sos1(1).var) identifies this information sos1(1).prio sets the priority for sos1 test 1.

sos1(2).var is a vector of indices for variables in sos1, set 2. sos1(2).row is the row number for the reference row of sos1 set 2. sos1(2).prio is the priority for sos1 set 2.

sos1(k).var is a vector of indices for variables in sos1, set k. sos1(k).row is the row number for the reference row of sos1 set k. sos1(k).prio is the priority for sos1 set k.
|-valign="top"
|''DUNDEE''||Structure with special fields for minlpBB optimization parameters. The following fields are used:
|-valign="top"
|''stackmax''||Maximum size of the LIFO stack storing info about B&B tree. Default: 10000.
|-valign="top"
|''QPmin''||Lower bound for the QP subproblems. Default: -1E300.
|-valign="top"
|''rho''||Initial trust region radius. Default: 10.0 (REAL).
|-valign="top"
|''kmax''||Maximum size of the null-space, less than or equal to no. of variables Default:

n (INTEGER).
|-valign="top"
|''maxf''||Maximum size of the filter Default: 100 (INTEGER).
|-valign="top"
|''mlp''||Maximum level parameter for resolving degeneracy in BQPD QP subsolver..
|-valign="top"
|''lam''||Multipliers (n+m) on entry (NOTE: Experimental parameter).
|-valign="top"
|''Name''||Problem name, at most 10 characters. The output files are named ''<''pname''>''.sum and ''<''pname''>''.out. Default name minlpBB, i.e. files minlpBB.sum, minlpBB.out.
|-valign="top"
|''optPar''||Vector of max length 20 with optimization parameters. If any element is -999, default value is assigned. The elements used by minlpBB are:

{|class="wikitable"
|''optPar(1): iprint''||Print level in minlpBB Summary on file minlpBB.sum. More printout on file minlpBB.out. Default 0.
|-valign="top"
|''optPar(2): tol''||Relative tolerance for BQPD subsolver. Default 1E-10.
|-valign="top"
|''optPar(3): emin''||1=Use cscale in BQPD, 0=no scaling. Default 1.0.
|-valign="top"
|''optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic (BQPD). Default 5E-4.
|-valign="top"
|''optPar(5): nrep''||Max number of refinement steps (BQPD). Default 2.
|-valign="top"
|''optPar(6): npiv''||No repeat if no more than npiv steps were taken. Default 3.
|-valign="top"
|''optPar(7): nres ''||Max number of restarts if unsuccessful. Default 2.
|-valign="top"
|''optPar(8): nfreq ''||The max interval between refactorizations. Default 500.
|-valign="top"
|''optPar(9): NLP eps''||NLP subproblem tolerance. Default 1E-6.
|-valign="top"
|''optPar(10): ubd''||Upper bound on constraint violation used in the filter. Default 1E-2.
|-valign="top"
|''optPar(11): tt ''||Parameter related to ubd. The actual upper bound is defined by the maximum of ubd and tt multiplied by the initial constraint violation. Default 0.125.
|-valign="top"
|''optPar(12): epsilon''||Tolerance for x-value tests. Default 1E-6.
|-valign="top"
|''optPar(13): MIopttol ''||Tolerance for function value tests. Default 1E-4.
|-valign="top"
|''optPar(17): branchtype ''||Branch strategy. Currently only 1 strategy.
|-valign="top"
|''optPar(19): infty ''||A large value representing infinity. Default 1E20.
|-valign="top"
|''optPar(20): Nonlin ''||If 1, skip linear feasibility tests minlpBB treating all constraints as nonlinear.

Default 0.
|}

|-valign="top"
|''morereal ''||Number of extra REAL workspace locations. Set to ''<''0 for problem dependent default strategy.
|-valign="top"
''moreint''||Number of extra INTEGER workspace locations. Set to ''<''0 for problem dependent default strategy.

Scaling parameters. It is possible to supply scale factors for the variables and/or the constraints. Normally, the DUNDEE solvers does not differentiate between linear and nonlinear constraints with regard to scaling, but the TOMLAB interface handles this automatically. Thus is it possible to give scale factors e.g. for the nonlinear constraints only. The three parameters in the Prob.DUNDEE substructure that control scaling are:
|-valign="top"
|''xScale''||Vector of scale factors for variables. If less than n values given, 1's are used for the missing elements.
|-valign="top"
|''bScale''||Vector of scale factors for the linear constraints. If length(bScale) is less than the number of linear constraints ( size(Prob.A,1) ), 1's are used for the missing elements.
|-valign="top"
|''cScale''||Vector of scale factors for the nonlinear constraints. If length(cScale) is less than the number of nonlinear constraints, 1's are used for the missing elements.
|}

====Description of Outputs====

''Result'', The following fields are used:

{|class="wikitable"
!Result||The structure with results (see ResultDef.m).
|-valign="top"
|''f_k''||Function value at optimum.
|-valign="top"
|''g_k''||Gradient of the function.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''c-k''||Nonlinear constraint residuals.
|-valign="top"
|''cJac''||Nonlinear constraint gradients.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''cState''||State of nonlinear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrangian multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status.
|-valign="top"
|''Inform''||minlpBB information parameter:

0 - Optimal solution found

1 - Root problem infeasible

2 - Integer infeasible

3 - Stack overflow - some integer solution. obtained

4 - Stack overflow - no integer solution obtained

5 - SQP termination with rho ''< ''eps

6 - SQP termination with iter ''> ''max iter

7 - Crash in user supplied routines

8 - Unexpected ifail from QP solvers This is often due to too little mem- ory being allocated and is remedied by setting appropriate values in the Prob.DUNDEE.morereal and Prob.DUNDEE.moreint parameters.

9 - Not enough REAL workspace or parameter error

10 - Not enough INTEGER workspace or parameter error
|-valign="top"
|''rc''||Reduced costs. If ninf=0, last m == -v k.
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''FuncEv''||Number of function evaluations. ''GradEv ''Number of gradient evaluations. ''ConstrEv ''Number of constraint evaluations.
|-valign="top"
|''QP.B''||Basis vector in TOMLAB QP standard.
|-valign="top"
|''Solver''||Name of the solver (minlpBB).
|-valign="top"
|''SolverAlgorithm''||Description of the solver (sparse or dense, mainly).
|}

===miqpBB===

The solver miqpBB solves sparse and dense mixed-integer linear and quadratic programs. The package implements the Branch and Bound method with some special features such as the computation of improved lower bounds and hot starts for the QP subproblems. miqpBB allows the user to influence the choice of branching variable in two ways: Firstly by employing user supplied priorities in the branching decision and secondly by supplying a choice of branching routines. The package is also efficient as an MILP solver.

====Direct Solver Call====

A direct solver call is not recommended unless the user is 100 % sure that no other solvers will be used for the problem. Please refer to Section 3.4.2 for information on how to use miqpBB with TOMLAB.

===Purpose===

''miqpBB ''solves mixed-integer quadratic optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x\\
& \\
s/t & \begin{array}{lcccl}
& & x & &, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n \times n}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{n+m_1}</math>.

The variables <math>x \in I</math>, the index subset of <math>1,...,n</math>, are restricted to be integers.

If F is empty, an LP or MILP problem is solved.

====Calling Syntax====

<pre>
[Inform, x k, Obj, Iter] = miqpbb(A, bl, bu, IntVars, Priority, Func, mlp,
kmax, stackmax, optPar, PriLev, Print- File, Prob, moremem);
</pre>

====Description of Inputs====

The following fields are used:

{|class="wikitable"
!Input||Description
|-valign="top"
|''[c A']''||Linear constraint matrix, dense or sparse n x (m+1) matrix. miqpBB requires the transpose of the constraint matrix, and also with the linear part of the objective function as the first column.
|-valign="top"
|''bl, bu''||Lower and upper bounds on variables and constraints. Length must be n+m where the first n elements are simple bounds on the variables.
|-valign="top"
|''IntVars''||Vector with integer variable indices.
|-valign="top"
|''Priority''||Priorities for the integer variables. Length must the same as that of IntVars.
|-valign="top"
|''Func''||Name of MATLAB callback function that performs the Hessian - vector multiplication F*x. A standard routine is supplied in tomlab/lib/HxFunc.m, using the Prob.QP.F matrix. If the user for some reason wants to write his own callback function, it must take arguments similar to those of HxFunc.m. The second argument nState is always 0.0 in the current version of the solver.
|-valign="top"
''mlp''Maximum level parameter for resolving degeneracy in BQPD which is used as sub-problem solver. If empty, the MEX interface sets mlp to m, the number of constraints.
|-valign="top"
|''kmax''||Maximum dimension of reduced space. Default (and maximum) value is n, the number of variables.
|-valign="top"
|''stackmax''||Size of the stack storing information during the tree-search. Default value if empty: 5000.
|-valign="top"
|''optPar''||Vector of optimization parameters. If -999, set to default. Length from 0 to 20 allowed. The following elements are used by miqpBB:

{|class="wikitable"
|''optPar(1): iprint''||Print level in miqpbb, default 0.
|-valign="top"
|''optPar(2): tol''||Relative accuracy in solutio, default 1E-10.
|-valign="top"
''optPar(3): emin''||1.0 Use cscale (constraint scaling) 0.0 no scaling, default 1.0.
|-valign="top"
|''optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic, default 5E-4.
|-valign="top"
|''optPar(5): nrep ''||Max number of refinement steps, default 2.
|-valign="top"
''optPar(6): npiv ''||No repeat if no more than npiv steps were taken, default 3.
|-valign="top"
|''optPar(7): nres''||Max number of restarts if unsuccessful, default 2.
|-valign="top"
|''optPar(8): nfreq''||The max interval between refactorizations, default 500.
|-valign="top"
|''optPar(12): epsilon''||Tolerance used for x value tests, default 1E-5.
|-valign="top"
|''optPar(13): MIopttol''||Tolerance used for function value tests, default 1E-4.
|-valign="top"
|''optPar(14): fIP''||Upper bound on f(x). Only consider solutions ''< ''fIP - epsilon, default 1E20.
|-valign="top"
|''optPar(15): timing''||No Timing = 1, Use timing, = 0. Default, no timing
|-valign="top"
|''optPar(16): max time''||Maximal time allowed for the run in seconds, default 4E3. ''optPar(17): branchType ''Branch on variable with highest priority. If tie:

= 1. Variable with largest fractional part, among those branch on the variable giving the largest increase in the objective.

= 2. Tactical Fletcher (PMO) branching. The var that solves max(min(e+,e-)) is chosen. The problem than corresponding to min(e+,e-) is placed on the stack first.

= 3. Tactical branching, Padberg/Rinaldi,91, Barahona et al.,89 (i) Choose the branching variable the one that most violates the integrality restrictions. i.e. find max(i)min(pi+,pi-) pi+ = int(x(i)+1) - x(i) , pi- = x(i) - int(x(i)) (ii) among those branch on the variable that gives the greatest increase in the obj. function (iii) Finally a LOWER BOUND is computed on the branched problems using the bounding method of Fletcher and Leyffer (dual active set step) DEFAULT = 1.
|-valign="top"
|''optPar(18): ifsFirst''||If 1, then only search for first ifs (ifail=6), Default 0.
|-valign="top"
|''optPar(19): infty''||Real value for infinity, default 1E20.
|}

|-valign="top"
|''PriLev''||Print level in the MEX interface: 0 = off, 1 = only result is printed, 2 = result and intermediate steps are printed. scalar information, 3 = verbose).
|-valign="top"
|''PrintFile''||Name of print file. Amount/print type determined by PriLev parameter. Default name miqpbbout.txt.
|-valign="top"
|''Prob''||The Tomlab problem description structure. This is a necessary argument if the standard HxFunc.m callback routine is used. HxFunc uses Prob.QP.F to calculate the Hessian*vector multiplication.
|-valign="top"
|''moremem''||Scalar or 2x1-vector giving values for extra work memory allocation. If scalar, the value given is added to both the INTEGER and REAL workspaces. If a vector is given, the first element controls the REAL workspace increase and the second the INTEGER workspace. Set one or both elements to values ¡0 for problem dependent memory increases.
|}

====Description of Outputs====

The following fields are used:

{|class="wikitable"
|-valign="top"
|''ifail''||Status code: the following values are defined:

0 - Solution found

1 - Error in parameters for BQPD

2 - Unbounded QP encountered

3 - Stack overflow - no integer solution found

4 - Stack overflow - some integer solution found

5 - Integer infeasible

6 - (on I/O) only search for first ifs and stop

7 - Infeasible root problem
|-valign="top"
|''x_k''||The solution vector, if any found. If ifail is other than 0 or 4, the contents of x is undefined.
|-valign="top"
|''Obj''||The value of the objective function at x k.
|-valign="top"
|''iter''||The number of iterations used to solve the problem.
|}

===Using TOMLAB===

====Purpose====

''miqpBBTL ''solves mixed-integer quadratic optimization problems defined as

<math>
\begin{array}{ll}
\min\limits_{x} & f(x) = \frac{1}{2} x^T F x + c^T x \\
& \\
s/t & \begin{array}{lcccl}
x_{L} & \leq & x & \leq & x_{U}, \\
b_{L} & \leq & A x & \leq & b_{U} \\
\end{array}
\end{array}
</math>

where <math>c, x, x_L, x_U \in \mathbb{R}^n</math>, <math>F \in \mathbb{R}^{n
\times n}</math>, <math>A \in \mathbb{R}^{m_1 \times n}</math>, and <math>b_L,b_U \in \mathbb{R}^{m_1}</math>.

The variables <math>x \in I</math>, the index subset of <math>1,...,n</math>, are restricted to be integers

If F is empty, an LP or MILP problem is solved.

miqpBBTL converts the problem from the Tomlab structure format and calls either miqpBBs (sparse) or miqpBBd (dense). On return converts the result to the Tomlab structure format.

====Calling Syntax====

Using the driver routine ''tomRun '':

<pre>
Prob = ''o''Assign( ... );
Result = tomRun('miqpBB', Prob ... );
</pre>

or

<pre>
Result = miqpBBTL(Prob);
</pre>

Call Prob = ''o''Assign( ... ) or Prob=ProbDef; to define the Prob for the second option.

====Description of Inputs====

''Prob'', The following fields are used:

{|class="wikitable"
!Input||Description
|-valign="top"
|''x_L, x_U''||Lower and upper bounds on variables.
|-valign="top"
|''b_L, b_U''||Lower and upper bounds on linear constraints.
|-valign="top"
|''A''||Linear constraint matrix, dense or sparse m x n matrix.
|-valign="top"
|''QP.c''||Linear coefficients in objective function, size n x 1.
|-valign="top"
|''QP.F''||Quadratic matrix of size n x n.
|-valign="top"
|''PriLevOpt''||Print Level (0 = off, 1 = summary, 2 = scalar information, 3 = verbose). ''>'' 10 Pause statements, and maximal printing (debug mode)
|-valign="top"
|''LargeScale''||If TRUE (=1), use sparse version, otherwise dense.
|-valign="top"
|''optParam.MaxIter''||Limit of iterations.
|-valign="top"
|''MIP.IntVars''||Defines which variables are integers. Variable indices should be in the range [1,...,n]. IntVars is a logical vector ==''> ''x(find(IntVars ''> ''0)) are integers. IntVars is a vector of indices ==''> ''x(IntVars) are integers (if [], then no integers of type I or B are defined).
|-valign="top"
|''MIP.VarWeight''||Variable priorities. Lower value means higher priority.
|-valign="top"
|''DUNDEE.kmax''||Max dimension of reduced space (k), default n, set as 0 if LP.
|-valign="top"
|''DUNDEE.mlp ''||Maximum number of levels of recursion.
|-valign="top"
|''DUNDEE.stackmax''||Maximum size of the LIFO stack storing info about B&B tree. Default 5000.
|-valign="top"
|''DUNDEE.PrintFile''||Name of print file. Amount/print type determined by optPar(1) Default name miqpBBout.txt.
|-valign="top"
|''DUNDEE.optPar''||Vector of optimization parameters. If -999, set to default Length from 0 to 20 allowed.

{|class="wikitable"
|-valign="top"
|''DUNDEE.optPar(1)''||Print level in miqpBB.

= 0 Silent

= 1 Warnings and Errors

= 2 Summary information

= 3 More detailed information ''DUNDEE.optPar(2): tol ''Relative accuracy in solution, default 1E-10. ''DUNDEE.optPar(3): emin ''1.0 Use cscale (constraint scaling) 0.0 no scaling, default 1.0.
|-valign="top"
|''DUNDEE.optPar(4): sgnf''||Max rel error in two numbers equal in exact arithmetic, default 5E-4.
|-valign="top"
|''DUNDEE.optPar(5): nrep''||Max number of refinement steps, default 2.
|-valign="top"
|''DUNDEE.optPar(6): npiv''||No repeat if no more than npiv steps were taken, default 3.
|-valign="top"
|''DUNDEE.optPar(7): nres''||Max number of restarts if unsuccessful, default 2.
|-valign="top"
|''DUNDEE.optPar(8): nfreq''||The max interval between refactorizations, default 500.
|-valign="top"
|''DUNDEE.optPar(12): epsilon''||Tolerance used for x value tests, default 1E-5. ''DUNDEE.optPar(13): MIopttol ''Tolerance used for function value tests, default 1E-4.
|-valign="top"
|''DUNDEE.optPar(14): fIP''||Upper bound on f(x). Only consider solutions ''< ''fIP - MIopttol, default 1E20.
|-valign="top"
|''DUNDEE.optPar(15): timing ''||If 1 - use timing, if 0 no timing (default).
|-valign="top"
|''DUNDEE.optPar(16): max time''||Maximal time allowed for the run in seconds, default 4E3. ''DUNDEE.optPar(17): branchType ''Branch on variable with highest priority. If tie:

= 1. Variable with largest fractional part, among those branch on the variable giving the largest increase in the objective.

= 2. Tactical Fletcher (PMO) branching. The var that solves max(min(e+,e-)) is chosen. The problem than corresponding to min(e+,e-) is placed on the stack first.

= 3. Tactical branching, Padberg/Rinaldi,91, Barahona et al.,89. (i) Choose the branching variable the one that most violates the integrality restrictions. i.e. find max(i)min(pi+,pi-) pi+ = int(x(i)+1) - x(i) , pi- = x(i) - int(x(i)) (ii) among those branch on the variable that gives the greatest increase in the obj. function (iii) Finally a LOWER BOUND is computed on the branched problems using the bounding method of Fletcher and Leyffer (dual active set step) DEFAULT = 1.
|-valign="top"
|''DUNDEE.optPar(18): ifsFirst ''||If 1, then only search for first ifs (ifail=6), DEFAULT 0.
|-valign="top"
|''DUNDEE.optPar(19): infty''||Real value for infinity (default 1E20).
|}

|-valign="top"
|''DUNDEE.morereal''||Number of extra REAL workspace locations. Set to ''<''0 for problem dependent default value.
|-valign="top"
|''DUNDEE.moreint''||Number of extra INTEGER workspace locations. Set to ''<''0 for problem de- pendent default value.
|}

====Description of Outputs====

''Result'', The following fields are used:

{|class="wikitable"
|-valign="top"
!Result||The structure with results (see ResultDef.m).
|-valign="top"
|''f_k''||Function value at optimum.
|-valign="top"
|''x_k''||Solution vector.
|-valign="top"
|''x_0''||Initial solution vector.
|-valign="top"
|''g_k''||Gradient of the function.
|-valign="top"
|''xState''||State of variables. Free == 0; On lower == 1; On upper == 2; Fixed == 3;
|-valign="top"
|''bState''||State of linear constraints. Free == 0; Lower == 1; Upper == 2; Equality == 3;
|-valign="top"
|''v_k''||Lagrangian multipliers (for bounds + dual solution vector).
|-valign="top"
|''ExitFlag''||Exit status from miqpBB.m (similar to TOMLAB).
|-valign="top"
|''Inform''||miqpBB information parameter.

0 - Optimal solution obtained

1 - Error in parameters for BQPD

2 - Unbounded QP encountered

3 - Stack overflow NO ifs found

4 - Stack overflow some ifs obtained

5 - Integer infeasible

6 - (on I/O) only search for first ifs and stop

7 - Infeasible root problem
|-valign="top"
|''rc''||Reduced costs. NOT SET.
|-valign="top"
|''Iter''||Number of iterations.
|-valign="top"
|''FuncEv''||Number of function evaluations. Set to Iter.
|-valign="top"
|''GradEv''||Number of gradient evaluations. Set to Iter.
|-valign="top"
|''ConstrEv''||Number of constraint evaluations. Set to 0.
|-valign="top"
|''QP.B''||Basis vector in TOMLAB QP standard.
|-valign="top"
|''MinorIter''||Number of minor iterations. NOT SET.
|-valign="top"
|''Solver''||Name of the solver (miqpBB)
|-valign="top"
|''SolverAlgorithm''||Description of the solver.
|-valign="top"
|''DUNDEE.kmax''||Max dimension of reduced space (k), default n, set as 0 if LP.
|-valign="top"
|''DUNDEE.mlp''||Maximum number of levels of recursion.
|-valign="top"
|''DUNDEE.stackmax''||Maximum size of the LIFO stack storing info about B&B tree.
|-valign="top"
|''DUNDEE.mode''||Mode of operation, default set as 2 Prob.WarmStart.
|-valign="top"
|''DUNDEE.x ''||Solution (Warm Start).
|-valign="top"
|''DUNDEE.k''||Dimension of the reduced space (Warm Start).
|-valign="top"
|''DUNDEE.e''||Steepest-edge normalization coefficients (Warm Start).
|-valign="top"
|''DUNDEE.ls''||Indices of active constraints, first n-k used for warm start.
|-valign="top"
|''DUNDEE.lp''||List of pointers to recursion information in ls (Warm Start).
|-valign="top"
|''DUNDEE.peq''||Pointer to the end of equality constraint indices in ls (Warm Start).
|}

MINLP Using the Matlab Interface

2012-01-22T15:50:54Z

Elias:

{{Part Of Manual|title=the MINLP Manual|link=[[MINLP|MINLP]]}}

The main routines in the two-layer design of the interface are shown in [[#Table: The interface routines.]]. Page and section references are given to detailed descriptions on how to use the routines.

====Table: The interface routines.====

{|class="wikitable"
!Function||Description
|-valign="top"
|[[MINLP Solver Reference#bqpd|bqpd]]||The layer one Matlab interface routine, calls the MEX-file interface ''bqpd.dll''
|-valign="top"
|[[MINLP Solver Reference#bqpdTL|bqpdTL]]||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''bqpd.m''.
|-valign="top"
|[[MINLP Solver Reference#filterSQP|filterSQP]]||The layer one Matlab interface routine, calls the MEX-file interface ''filterSQP.dll''
|-valign="top"
|[[MINLP Solver Reference#filterSQPTL|filterSQPTL]]||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''filterSQP.m''.
|-valign="top"
|[[MINLP Solver Reference#minlpBB|minlpBB]]||The layer one Matlab interface routine, calls the MEX-file interface ''minlpBB.dll''
|-valign="top"
|[[MINLP Solver Reference#minlpBBTL|minlpBBTL]]||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''minlpBB.m''.
|-valign="top"
|[[MINLP Solver Reference#miqpBB|miqpBB]]||The layer one Matlab interface routine, calls the MEX-file interface ''miqpBB.dll''
|-valign="top"
|[[MINLP Solver Reference#miqpBBTL|miqpBBTL]]||The layer two interface routine called by the TOMLAB driver routine ''tomRun''. This routine then calls ''minlpBB.m''.
|}

The MINLP control parameters are possible to set from Matlab.

They can be set as inputs to the interface routine ''bqpd ''and the others. The user sets fields in a structure called ''Prob.DUNDEE.optPar''. The following example shows how to set the print level.

<pre>
Prob.DUNDEE.optPar(1) = 1; % Setting the print level
</pre>