qps_bpmpd

qps_bpmpd(H, c, A, l, u, xmin, xmax, x0, opt)
qps_bpmpd() - Quadratic Program Solver based on BPMPD_MEX.
[X, F, EXITFLAG, OUTPUT, LAMBDA] = ...
    QPS_BPMPD(H, C, A, L, U, XMIN, XMAX, X0, OPT)
[X, F, EXITFLAG, OUTPUT, LAMBDA] = QPS_BPMPD(PROBLEM)
A wrapper function providing a standardized interface for using
BPMPD_MEX (http://www.pserc.cornell.edu/bpmpd/) to solve the
following QP (quadratic programming) problem:

    min 1/2 X'*H*X + C'*X
     X

subject to

    L <= A*X <= U       (linear constraints)
    XMIN <= X <= XMAX   (variable bounds)

Inputs (all optional except H, C, A and L):
    H : matrix (possibly sparse) of quadratic cost coefficients
    C : vector of linear cost coefficients
    A, L, U : define the optional linear constraints. Default
        values for the elements of L and U are -Inf and Inf,
        respectively.
    XMIN, XMAX : optional lower and upper bounds on the
        X variables, defaults are -Inf and Inf, respectively.
    X0 : optional starting value of optimization vector X
    OPT : optional options structure with the following fields,
        all of which are also optional (default values shown in
        parentheses)
        verbose (0) - controls level of progress output displayed
            0 = no progress output
            1 = some progress output
            2 = verbose progress output
        bp_opt - options vector for BP, value in verbose
                overrides these options
    PROBLEM : The inputs can alternatively be supplied in a single
        PROBLEM struct with fields corresponding to the input arguments
        described above: H, c, A, l, u, xmin, xmax, x0, opt

Outputs:
    X : solution vector
    F : final objective function value
    EXITFLAG : exit flag,
          1 = optimal solution
         -1 = suboptimal solution
         -2 = infeasible primal
         -3 = infeasible dual
        -10 = not enough memory
        -99 = BPMPD bug: returned infeasible solution
    OUTPUT : output struct with the following fields:
        message - exit message
    LAMBDA : struct containing the Langrange and Kuhn-Tucker
        multipliers on the constraints, with fields:
        mu_l - lower (left-hand) limit on linear constraints
        mu_u - upper (right-hand) limit on linear constraints
        lower - lower bound on optimization variables
        upper - upper bound on optimization variables

Note the calling syntax is almost identical to that of QUADPROG
from MathWorks' Optimization Toolbox. The main difference is that
the linear constraints are specified with A, L, U instead of
A, B, Aeq, Beq.

Calling syntax options:
    [x, f, exitflag, output, lambda] = ...
        qps_bpmpd(H, c, A, l, u, xmin, xmax, x0, opt)

    x = qps_bpmpd(H, c, A, l, u)
    x = qps_bpmpd(H, c, A, l, u, xmin, xmax)
    x = qps_bpmpd(H, c, A, l, u, xmin, xmax, x0)
    x = qps_bpmpd(H, c, A, l, u, xmin, xmax, x0, opt)
    x = qps_bpmpd(problem), where problem is a struct with fields:
                    H, c, A, l, u, xmin, xmax, x0, opt
                    all fields except 'c', 'A' and 'l' or 'u' are optional
    x = qps_bpmpd(...)
    [x, f] = qps_bpmpd(...)
    [x, f, exitflag] = qps_bpmpd(...)
    [x, f, exitflag, output] = qps_bpmpd(...)
    [x, f, exitflag, output, lambda] = qps_bpmpd(...)

Example: (problem from from https://v8doc.sas.com/sashtml/iml/chap8/sect12.htm)
    H = [   1003.1  4.3     6.3     5.9;
            4.3     2.2     2.1     3.9;
            6.3     2.1     3.5     4.8;
            5.9     3.9     4.8     10  ];
    c = zeros(4,1);
    A = [   1       1       1       1;
            0.17    0.11    0.10    0.18    ];
    l = [1; 0.10];
    u = [1; Inf];
    xmin = zeros(4,1);
    x0 = [1; 0; 0; 1];
    opt = struct('verbose', 2);
    [x, f, s, out, lambda] = qps_bpmpd(H, c, A, l, u, xmin, [], x0, opt);
See BPMPD_MEX, http://www.pserc.cornell.edu/bpmpd/.