Octave can also solve Quadratic Programming problems, this is

```min 0.5 x'*H*x + x'*q
```

subject to

```     A*x = b
lb <= x <= ub
A_lb <= A_in*x <= A_ub
```
: `[x, obj, info, lambda] =` qp `(x0, H)`
: `[x, obj, info, lambda] =` qp `(x0, H, q)`
: `[x, obj, info, lambda] =` qp `(x0, H, q, A, b)`
: `[x, obj, info, lambda] =` qp `(x0, H, q, A, b, lb, ub)`
: `[x, obj, info, lambda] =` qp `(x0, H, q, A, b, lb, ub, A_lb, A_in, A_ub)`
: `[x, obj, info, lambda] =` qp `(…, options)`

Solve the quadratic program defined by

```min 0.5 x'*H*x + x'*q
x
```

subject to

```A*x = b
lb <= x <= ub
A_lb <= A_in*x <= A_ub
```

using a null-space active-set method.

Any bound (A, b, lb, ub, A_in, A_lb, A_ub) may be set to the empty matrix (`[]`) if not present. The constraints A and A_in are matrices with each row representing a single constraint. The other bounds are scalars or vectors depending on the number of constraints. The algorithm is faster if the initial guess is feasible.

options is a structure specifying additional parameters which control the algorithm. Currently, `qp` recognizes these options: `"MaxIter"`, `"TolX"`.

`"MaxIter"` proscribes the maximum number of algorithm iterations before optimization is halted. The default value is 200. The value must be a positive integer.

`"TolX"` specifies the termination tolerance for the unknown variables x. The default is `sqrt (eps)` or approximately 1e-8.

On return, x is the location of the minimum and fval contains the value of the objective function at x.

info

Structure containing run-time information about the algorithm. The following fields are defined:

`solveiter`

The number of iterations required to find the solution.

`info`

An integer indicating the status of the solution.

0

The problem is feasible and convex. Global solution found.

1

The problem is not convex. Local solution found.

2

The problem is not convex and unbounded.

3

Maximum number of iterations reached.

6

The problem is infeasible.

: `x =` pqpnonneg `(c, d)`
: `x =` pqpnonneg `(c, d, x0)`
: `x =` pqpnonneg `(c, d, x0, options)`
: `[x, minval] =` pqpnonneg `(…)`
: `[x, minval, exitflag] =` pqpnonneg `(…)`
: `[x, minval, exitflag, output] =` pqpnonneg `(…)`
: `[x, minval, exitflag, output, lambda] =` pqpnonneg `(…)`

Minimize ` (1/2 * x' * c * x + d' * x) ` subject to `x >= 0`.

c and d must be real matrices, and c must be symmetric and positive definite.

x0 is an optional initial guess for the solution x.

options is an options structure to change the behavior of the algorithm (see `optimset`). `pqpnonneg` recognizes one option: `"MaxIter"`.

Outputs:

x

The solution matrix

minval

The minimum attained model value, `1/2*xmin'*c*xmin + d'*xmin`

exitflag

An indicator of convergence. 0 indicates that the iteration count was exceeded, and therefore convergence was not reached; >0 indicates that the algorithm converged. (The algorithm is stable and will converge given enough iterations.)

output

A structure with two fields:

• `"algorithm"`: The algorithm used (`"nnls"`)
• `"iterations"`: The number of iterations taken.
lambda

Lagrange multipliers. If these are nonzero, the corresponding x values should be zero, indicating the solution is pressed up against a coordinate plane. The magnitude indicates how much the residual would improve if the `x >= 0` constraints were relaxed in that direction.