qps_clp

qps_clp(H, c, A, l, u, xmin, xmax, x0, opt)
qps_clp() - Quadratic Program Solver based on CLP - COIN-OR Linear Programming.
[X, F, EXITFLAG, OUTPUT, LAMBDA] = ...
    QPS_CLP(H, C, A, L, U, XMIN, XMAX, X0, OPT)
[X, F, EXITFLAG, OUTPUT, LAMBDA] = QPS_CLP(PROBLEM)
A wrapper function providing a standardized interface for using
CLP 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 (NOT USED)
    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
        clp_opt - options struct for CLP, 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, -1 - infeasible, -2 - unbounded
                -3 - max iterations/time exceeded
    OUTPUT : struct with fields
        exitflag - raw CLP exit flag: 0 - optimal, 1 - infeasible,
            2 - unbounded, 3 - max iterations/time exceeded
        status - string with explanation of exitflag
        (iter - depending on build of solver this may contain
                the number of iterations)
    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 CLP. 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_clp(H, c, A, l, u, xmin, xmax, x0, opt)

    x = qps_clp(H, c, A, l, u)
    x = qps_clp(H, c, A, l, u, xmin, xmax)
    x = qps_clp(H, c, A, l, u, xmin, xmax, x0)
    x = qps_clp(H, c, A, l, u, xmin, xmax, x0, opt)
    x = qps_clp(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_clp(...)
    [x, f] = qps_clp(...)
    [x, f, exitflag] = qps_clp(...)
    [x, f, exitflag, output] = qps_clp(...)
    [x, f, exitflag, output, lambda] = qps_clp(...)


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_clp(H, c, A, l, u, xmin, [], x0, opt);