The solvers perform most efficiently when given problems in Matrix form, with the objective function and constraints specified as Vectors, Matrices, or procedures with Vector and Matrix parameters. Matrix form requires the least amount of preprocessing because it is most similar to the format used by the internal solvers. This leads to reduced storage needs and faster computation.

Consider an optimization problem in the form:

minimize $f\left(x\right)$

subject to

$v\left(x\right)\le 0$ (nonlinear inequality constraints)

$w\left(x\right)=0$ (nonlinear equality constraints)

$A·x\le b$ (linear inequality constraints)

$\mathrm{Aeq}·x=\mathrm{beq}$ (linear equality constraints)

$\mathrm{b1}\le x\le \mathrm{bu}$ (bounds)

where $x$ is the vector of problem variables; $f\left(x\right)$ is the real-valued objective function; $v\left(x\right)$ and $w\left(x\right)$ are vector-valued functions of $x$; $b$, $\mathrm{beq}$, $\mathrm{bl}$, and $\mathrm{bu}$ are vectors; and $A$ and $\mathrm{Aeq}$ are matrices.  The dimension of $x$ is $n$. The relations involving matrices and vectors are element-wise. The specifications of each component are given in the following sections.

Bounds on the problem variables are accepted by all the Optimization solvers that take Matrix-form input.  They are provided as a list $\left[\mathrm{bl}\,\mathrm{bu}\right]$ containing lower bounds followed by upper bounds.  If the list is empty, the bounds are assumed to be $-\mathrm{\infty }$ and $\mathrm{\infty }$ respectively.

The bounds bl and bu can be specified as Vectors of dimension $n$ or as numeric values.  If a numeric value is provided, it is interpreted as a Vector of dimension $n$ in which each element is equal to that value.

If there are upper bounds but no lower bounds, bl must be set to -Float(infinity).  If there are lower bounds, but no upper bounds, bu must be set to Float(infinity).

The assume=nonnegative option can be used to specify the constraint that all variables must be non-negative. For more information, see the Optimization/Options help page.

Linear programs using the interior point method require finite lower bounds to be specified for each variable.

Initial values are accepted by all the Optimization solvers that take Matrix-form input and are specified using the option initialpoint=p where p is a Vector of dimension $n$.  For more information about the initialpoint option, see the Optimization/Options help page.

The solution is a list $\left[\mathrm{objval}\,\mathrm{solpt}\right]$ where objval is a floating-point number representing the final minimum (or maximum) value and solpt is a Vector representing a point (the computed extremum).

For best performance, the components described previously must satisfy the following additional conditions.

All Matrix and Vector arguments must be constructed with datatype=float. Otherwise, the solvers must perform conversions.

A symmetric Matrix argument, such as the Hessian matrix for the QPSolve command, must be created with shape=symmetric and storage=rectangular. Otherwise, the solver must perform this conversion.

When the interior point method for linear programs is used, the constraint matrices should be specified with the option storage=sparse. Otherwise, any constraint matrices with non-sparse storage will be converted to sparse storage.

When possible, input procedures must be created so that they can be evaluated by the evalhf command. Otherwise, the solvers cannot take advantage of the more efficient evalhf mode of computation.

Procedures returning a scalar result must return a floating-point value in all cases, not simply an expression that evaluates to a float.

The following additional condition must be met. If a procedure returns a Vector or Matrix result using an output parameter, only floating-point values can be assigned to the parameter.  Otherwise, an error is issued.

$\mathrm{with}\left(\mathrm{Optimization}\right)\:$

$c≔\mathrm{Vector}\left(\left[-1\,-1\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$A≔\mathrm{Matrix}\left(\left[\left[-3\,1\right]\,\left[5\,1\right]\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$b≔\mathrm{Vector}\left(\left[0.5\,2\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$\mathrm{LPSolve}\left(c\,\left[A\,b\right]\,\left[0.\,\mathrm{\infty }\right]\right)$

$\left[\mathrm{-1.25000000000000}\,\left[\begin{array}{c}0.187500000000000\\ 1.06250000000000\end{array}\right]\right]$

$c≔\mathrm{Vector}\left(\left[2\,5\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$H≔\mathrm{Matrix}\left(\left[\left[6\,3\right]\,\left[3\,4\right]\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$A≔\mathrm{Matrix}\left(\left[\left[-1\,1\right]\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$b≔\mathrm{Vector}\left(\left[-2\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$\mathrm{QPSolve}\left(\left[c\,H\right]\,\left[A\,b\right]\right)$

$\left[\mathrm{-3.53333333333333}\,\left[\begin{array}{c}0.466666666666667\\ \mathrm{-1.60000000000000}\end{array}\right]\right]$

p := proc (V)
        V[3]^3*(V[1]-V[3])^2+(V[3]-V[2]-1)^2+
        (V[2]-V[4]-2)^2+(V[4]-V[5]-3)^2
     end proc:

nlc := proc(V, W, needc)
           if needc[1] > 0.0 then
             W[1] := V[3]^2+V[2]^2+V[4]+V[5]-5
           end if:
       end proc:

$\mathrm{Aeq}≔\mathrm{Matrix}\left(\left[\left[-1\,0\,0\,0\,1\right]\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$\mathrm{beq}≔\mathrm{Vector}\left(\left[0\right]\,\mathrm{datatype}=\mathrm{float}\right)\:$

$\mathrm{lc}≔\left[\mathrm{NoUserValue}\,\mathrm{NoUserValue}\,\mathrm{Aeq}\,\mathrm{beq}\right]\:$

objgra := proc (V, W)
                W[1] := 2*V[3]^3*(V[1]-V[3]);
                W[2] :=-2*V[3]+4*V[2]-2-2*V[4];
                W[3] := 3*V[3]^2*(V[1]-V[3])^2-2*V[3]^3*(V[1]-V[3])+
                        2*V[3]-2*V[2]-2;
                W[4] :=-2*V[2]+4*V[4]-2-2*V[5];
                W[5] :=-2*V[4]+2*V[5]+6
              end proc:

conjac := proc(V, M, needc)
    if needc[1] > 0.0 then
        M[1,1] := 0;
        M[1,2] := 2*V[2];
        M[1,3] := 2*V[3];
        M[1,4] := 1;
        M[1,5] := 1;
    end if
end proc:

$\mathrm{NLPSolve}\left(5\,p\,1\,\mathrm{nlc}\,\mathrm{lc}\,\mathrm{objectivegradient}=\mathrm{objgra}\,\mathrm{constraintjacobian}=\mathrm{conjac}\,\mathrm{assume}=\mathrm{nonnegative}\right)$

$\left[9.26002553760621794\,\left[\begin{array}{c}0.\\ 1.60516113308118\\ 0.907741706680391\\ 1.30258056909003\\ 4.118049995\times {10}^{\mathrm{-310}}\end{array}\right]\right]$