25.2 Quadratic Programming

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 a quadratic program (QP).

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.

See also: sqp.

: 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.

See also: lsqnonneg, qp, optimset.