coneprog

Second-order cone programming solver

Since R2020b

collapse all in page

Syntax

x = coneprog(f,socConstraints)

x = coneprog(f,socConstraints,A,b,Aeq,beq)

x = coneprog(f,socConstraints,A,b,Aeq,beq,lb,ub)

x = coneprog(f,socConstraints,A,b,Aeq,beq,lb,ub,options)

x = coneprog(problem)

[x,fval] = coneprog(___)

[x,fval,exitflag,output] = coneprog(___)

[x,fval,exitflag,output,lambda] = coneprog(___)

Description

The coneprog function is a second-order cone programming solver that finds the minimum of a problem specified by

$\min_{x} f^{T} x$

subject to the constraints

$\begin{matrix} ‖ A_{sc} (i) \cdot x - b_{sc} (i) ‖ \leq d_{sc}^{T} (i) \cdot x - γ (i) \\ A \cdot x \leq b \\ Aeq \cdot x = beq \\ lb \leq x \leq ub . \end{matrix}$

f, x, b, beq, lb, and ub are vectors, and A and Aeq are matrices. For each i, the matrix A_sc(i), vectors d_sc(i) and b_sc(i), and scalar γ(i) are in a second-order cone constraint that you create using secondordercone.

For more details about cone constraints, see Second-Order Cone Constraint.

x = coneprog(f,socConstraints) solves the second-order cone programming problem with the constraints in socConstraints encoded as

A_sc(i) = socConstraints(i).A
b_sc(i) = socConstraints(i).b
d_sc(i) = socConstraints(i).d
γ(i) = socConstraints(i).gamma

example

x = coneprog(f,socConstraints,A,b,Aeq,beq) solves the problem subject to the inequality constraints A*x ≤ b and equality constraints Aeq*x = beq. Set A = [] and b = [] if no inequalities exist.

example

x = coneprog(f,socConstraints,A,b,Aeq,beq,lb,ub) defines a set of lower and upper bounds on the design variables, x so that the solution is always in the range lb ≤ x ≤ ub. Set Aeq = [] and beq = [] if no equalities exist.

example

x = coneprog(f,socConstraints,A,b,Aeq,beq,lb,ub,options) minimizes using the optimization options specified by options. Use optimoptions to set these options.

example

x = coneprog(problem) finds the minimum for problem, a structure described in problem.

example

[x,fval] = coneprog(___) also returns the objective function value at the solution fval = f'*x, using any of the input argument combinations in previous syntaxes.

example

[x,fval,exitflag,output] = coneprog(___) additionally returns a value exitflag that describes the exit condition, and a structure output that contains information about the optimization process.

example

[x,fval,exitflag,output,lambda] = coneprog(___) additionally returns a structure lambda whose fields contain the dual variables at the solution x.

example

Examples

collapse all

Single Cone Constraint

Open Live Script

To set up a problem with a second-order cone constraint, create a second-order cone constraint object.

A = diag([1,1/2,0]);
b = zeros(3,1);
d = [0;0;1];
gamma = 0;
socConstraints = secondordercone(A,b,d,gamma);

Create an objective function vector.

f = [-1,-2,0];

The problem has no linear constraints. Create empty matrices for these constraints.

Aineq = [];
bineq = [];
Aeq = [];
beq = [];

Set upper and lower bounds on x(3).

lb = [-Inf,-Inf,0];
ub = [Inf,Inf,2];

Solve the problem by using the coneprog function.

[x,fval] = coneprog(f,socConstraints,Aineq,bineq,Aeq,beq,lb,ub)

Optimal solution found.

fval = 
-8.2462

The solution component x(3) is at its upper bound. The cone constraint is active at the solution:

norm(A*x-b) - d'*x % Near 0 when the constraint is active

ans = 
-2.5677e-08

Several Cone Constraints

Open Live Script

To set up a problem with several second-order cone constraints, create an array of constraint objects. To save time and memory, create the highest-index constraint first.

A = diag([1,2,0]);
b = zeros(3,1);
d = [0;0;1];
gamma = -1;
socConstraints(3) = secondordercone(A,b,d,gamma);

A = diag([3,0,1]);
d = [0;1;0];
socConstraints(2) = secondordercone(A,b,d,gamma);

A = diag([0;1/2;1/2]);
d = [1;0;0];
socConstraints(1) = secondordercone(A,b,d,gamma);

Create the linear objective function vector.

f = [-1;-2;-4];

Solve the problem by using the coneprog function.

[x,fval] = coneprog(f,socConstraints)

Optimal solution found.

fval = 
-13.0089

Cone Programming with Linear Constraints

Open Live Script

Specify an objective function vector and a single second-order cone constraint.

f = [-4;-9;-2];
Asc = diag([1,4,0]);
b = [0;0;0];
d = [0;0;1];
gamma = 0;
socConstraints = secondordercone(Asc,b,d,gamma);

Specify a linear inequality constraint.

A = [1/4,1/9,1];
b = 5;

Solve the problem.

[x,fval] = coneprog(f,socConstraints,A,b)

Optimal solution found.

fval = 
-26.9225

Cone Programming with Nondefault Options

Open Live Script

To observe the iterations of the coneprog solver, set the Display option to 'iter'.

options = optimoptions('coneprog','Display','iter');

Create a second-order cone programming problem and solve it using options.

Asc = diag([1,1/2,0]);
b = zeros(3,1);
d = [0;0;1];
gamma = 0;
socConstraints = secondordercone(Asc,b,d,gamma);
f = [-1,-2,0];
Aineq = [];
bineq = [];
Aeq = [];
beq = [];
lb = [-Inf,-Inf,0];
ub = [Inf,Inf,2];
[x,fval] = coneprog(f,socConstraints,Aineq,bineq,Aeq,beq,lb,ub,options)

Iter           Fval  Primal Infeas    Dual Infeas    Duality Gap    Time
   0   0.000000e+00   0.000000e+00   5.714286e-01   2.000000e-01    0.08
   1  -7.558066e+00   0.000000e+00   7.151114e-02   2.502890e-02    0.14
   2  -7.366973e+00   0.000000e+00   1.075440e-02   3.764040e-03    0.15
   3  -8.243432e+00   0.000000e+00   5.191882e-05   1.817159e-05    0.15
   4  -8.246067e+00   0.000000e+00   2.430813e-06   8.507845e-07    0.15
   5  -8.246211e+00   0.000000e+00   6.154504e-09   2.154077e-09    0.15
Optimal solution found.

fval = 
-8.2462

Cone Programming with Problem Structure

Open Live Script

Create the elements of a second-order cone programming problem. To save time and memory, create the highest-index constraint first.

A = diag([1,2,0]);
b = zeros(3,1);
d = [0;0;1];
gamma = -1;
socConstraints(3) = secondordercone(A,b,d,gamma);
A = diag([3,0,1]);
d = [0;1;0];
socConstraints(2) = secondordercone(A,b,d,gamma);
A = diag([0;1/2;1/2]);
d = [1;0;0];
socConstraints(1) = secondordercone(A,b,d,gamma);
f = [-1;-2;-4];
options = optimoptions('coneprog','Display','iter');

Create a problem structure with the required fields, as described in problem.

problem = struct('f',f,...
    'socConstraints',socConstraints,...
    'Aineq',[],'bineq',[],...
    'Aeq',[],'beq',[],...
    'lb',[],'ub',[],...
    'solver','coneprog',...
    'options',options);

Solve the problem by calling coneprog.

[x,fval] = coneprog(problem)

Iter           Fval  Primal Infeas    Dual Infeas    Duality Gap    Time
   0   0.000000e+00   0.000000e+00   5.333333e-01   9.090909e-02    0.02
   1  -9.696012e+00   5.551115e-17   7.631901e-02   1.300892e-02    0.03
   2  -1.178942e+01   0.000000e+00   1.261803e-02   2.150800e-03    0.03
   3  -1.294426e+01   9.251859e-18   1.683078e-03   2.868883e-04    0.03
   4  -1.295217e+01   9.251859e-18   8.994595e-04   1.533170e-04    0.03
   5  -1.295331e+01   0.000000e+00   4.748841e-04   8.094615e-05    0.03
   6  -1.300753e+01   0.000000e+00   2.799942e-05   4.772628e-06    0.03
   7  -1.300671e+01   9.251859e-18   2.366136e-05   4.033187e-06    0.03
   8  -1.300850e+01   9.251859e-18   8.251573e-06   1.406518e-06    0.03
   9  -1.300842e+01   4.625929e-18   7.332583e-06   1.249872e-06    0.03
  10  -1.300866e+01   9.251859e-18   2.616719e-06   4.460317e-07    0.03
  11  -1.300892e+01   1.850372e-17   2.215835e-08   3.776991e-09    0.04
Optimal solution found.

fval = 
-13.0089

Examine `coneprog` Solution Process

Open Live Script

Create a second-order cone programming problem. To save time and memory, create the highest-index constraint first.

A = diag([1,2,0]);
b = zeros(3,1);
d = [0;0;1];
gamma = -1;
socConstraints(3) = secondordercone(A,b,d,gamma);
A = diag([3,0,1]);
d = [0;1;0];
socConstraints(2) = secondordercone(A,b,d,gamma);
A = diag([0;1/2;1/2]);
d = [1;0;0];
socConstraints(1) = secondordercone(A,b,d,gamma);
f = [-1;-2;-4];
options = optimoptions('coneprog','Display','iter');
A = [];
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];

Solve the problem, requesting information about the solution process.

[x,fval,exitflag,output] = coneprog(f,socConstraints,A,b,Aeq,beq,lb,ub,options)

Iter           Fval  Primal Infeas    Dual Infeas    Duality Gap    Time
   0   0.000000e+00   0.000000e+00   5.333333e-01   9.090909e-02    0.06
   1  -9.696012e+00   1.850372e-17   7.631901e-02   1.300892e-02    0.08
   2  -1.178942e+01   1.850372e-17   1.261803e-02   2.150800e-03    0.09
   3  -1.294426e+01   1.850372e-17   1.683078e-03   2.868883e-04    0.09
   4  -1.295217e+01   2.775558e-17   8.994595e-04   1.533170e-04    0.09
   5  -1.295331e+01   2.775558e-17   4.748841e-04   8.094615e-05    0.09
   6  -1.300753e+01   1.850372e-17   2.799942e-05   4.772628e-06    0.09
   7  -1.300671e+01   2.775558e-17   2.366136e-05   4.033187e-06    0.09
   8  -1.300850e+01   9.251859e-18   8.167602e-06   1.392205e-06    0.10
   9  -1.300843e+01   1.850372e-17   7.244794e-06   1.234908e-06    0.10
  10  -1.300865e+01   9.251859e-18   2.617163e-06   4.461074e-07    0.10
  11  -1.300892e+01   0.000000e+00   2.216272e-08   3.777737e-09    0.10
Optimal solution found.

fval = 
-13.0089

exitflag = 
1

output = struct with fields:
           iterations: 11
    primalfeasibility: 0
      dualfeasibility: 2.2163e-08
           dualitygap: 3.7777e-09
            algorithm: 'interior-point'
         linearsolver: 'augmented'
              message: 'Optimal solution found.'

Both the iterative display and the output structure show that coneprog used 12 iterations to arrive at the solution.
The exit flag value 1 and the output.message value 'Optimal solution found.' indicate that the solution is reliable.
The output structure shows that the infeasibilities tend to decrease through the solution process, as does the duality gap.
You can reproduce the fval output by multiplying f'*x.

f'*x

ans = 
-13.0089

Obtain `coneprog` Dual Variables

Open Live Script

Create a second-order cone programming problem. To save time and memory, create the highest-index constraint first.

A = diag([1,2,0]);
b = zeros(3,1);
d = [0;0;1];
gamma = -1;
socConstraints(3) = secondordercone(A,b,d,gamma);
A = diag([3,0,1]);
d = [0;1;0];
socConstraints(2) = secondordercone(A,b,d,gamma);
A = diag([0;1/2;1/2]);
d = [1;0;0];
socConstraints(1) = secondordercone(A,b,d,gamma);
f = [-1;-2;-4];

Solve the problem, requesting dual variables at the solution along with all other coneprog output..

[x,fval,exitflag,output,lambda] = coneprog(f,socConstraints);

Optimal solution found.

Examine the returned lambda structure. Because the only problem constraints are cone constraints, examine only the soc field in the lambda structure.

disp(lambda.soc)

    5.9426
    4.6039
    2.4624

The constraints have nonzero dual values, indicating the constraints are active at the solution.

Input Arguments

collapse all

`f` — Coefficient vector
real vector | real array

Coefficient vector, specified as a real vector or real array. The coefficient vector represents the objective function f'*x. The notation assumes that f is a column vector, but you can use a row vector or array. Internally, coneprog converts f to the column vector f(:).

Example: f = [1,3,5,-6]

Data Types: double

`socConstraints` — Second-order cone constraints
vector of `SecondOrderConeConstraint` objects | cell array of `SecondOrderConeConstraint` objects

Second-order cone constraints, specified as vector or cell array of SecondOrderConeConstraint objects. Create these objects using the secondordercone function.

socConstraints encodes the constraints

$‖ A_{sc} (i) \cdot x - b_{sc} (i) ‖ \leq d_{sc}^{T} (i) \cdot x - γ (i)$

where the mapping between the array and the equation is as follows:

A_sc(i) = socConstraints.A(i)
b_sc(i) = socConstraints.b(i)
d_sc(i) = socConstraints.d(i)
γ(i) = socConstraints.gamma(i)

Example: Asc = diag([1 1/2 0]); bsc = zeros(3,1); dsc = [0;0;1]; gamma = -1; socConstraints = secondordercone(Asc,bsc,dsc,gamma);

`A` — Linear inequality constraints
real matrix

Linear inequality constraints, specified as a real matrix. A is an M-by-N matrix, where M is the number of inequalities, and N is the number of variables (length of f). For large problems, pass A as a sparse matrix.

A encodes the M linear inequalities

A*x <= b,

where x is the column vector of N variables x(:), and b is a column vector with M elements.

For example, consider these inequalities:

x₁ + 2x₂ ≤ 10
3x₁ + 4x₂ ≤ 20
5x₁ + 6x₂ ≤ 30.

Specify the inequalities by entering the following constraints.

A = [1,2;3,4;5,6];
b = [10;20;30];

Example: To specify that the x-components add up to 1 or less, take A = ones(1,N) and b = 1.

Data Types: double

`b` — Linear inequality constraints
real vector

Linear inequality constraints, specified as a real vector. b is an M-element vector related to the A matrix. If you pass b as a row vector, solvers internally convert b to the column vector b(:). For large problems, pass b as a sparse vector.

b encodes the M linear inequalities

A*x <= b,

where x is the column vector of N variables x(:), and A is a matrix of size M-by-N.

For example, consider these inequalities:

x₁ + 2x₂ ≤ 10
3x₁ + 4x₂ ≤ 20
5x₁ + 6x₂ ≤ 30.

Specify the inequalities by entering the following constraints.

A = [1,2;3,4;5,6];
b = [10;20;30];

Example: To specify that the x components sum to 1 or less, use A = ones(1,N) and b = 1.

Data Types: single | double

`Aeq` — Linear equality constraints
real matrix

Linear equality constraints, specified as a real matrix. Aeq is an Me-by-N matrix, where Me is the number of equalities, and N is the number of variables (length of f). For large problems, pass Aeq as a sparse matrix.

Aeq encodes the Me linear equalities

Aeq*x = beq,

where x is the column vector of N variables x(:), and beq is a column vector with Me elements.

For example, consider these equalities:

x₁ + 2x₂ + 3x₃ = 10
2x₁ + 4x₂ + x₃ = 20.

Specify the equalities by entering the following constraints.

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Example: To specify that the x-components sum to 1, take Aeq = ones(1,N) and beq = 1.

Data Types: double

`beq` — Linear equality constraints
real vector

Linear equality constraints, specified as a real vector. beq is an Me-element vector related to the Aeq matrix. If you pass beq as a row vector, solvers internally convert beq to the column vector beq(:). For large problems, pass beq as a sparse vector.

beq encodes the Me linear equalities

Aeq*x = beq,

where x is the column vector of N variables x(:), and Aeq is a matrix of size Me-by-N.

For example, consider these equalities:

x₁ + 2x₂ + 3x₃ = 10
2x₁ + 4x₂ + x₃ = 20.

Specify the equalities by entering the following constraints.

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Example: To specify that the x components sum to 1, use Aeq = ones(1,N) and beq = 1.

Data Types: single | double

`lb` — Lower bounds
real vector | real array

Lower bounds, specified as a real vector or real array. If the length of f is equal to the length of lb, then lb specifies that

x(i) >= lb(i) for all i.

If numel(lb) < numel(f), then lb specifies that

x(i) >= lb(i) for 1 <= i <= numel(lb).

In this case, solvers issue a warning.

Example: To specify that all x-components are positive, use lb = zeros(size(f)).

Data Types: double

`ub` — Upper bounds
real vector | real array

Upper bounds, specified as a real vector or real array. If the length of f is equal to the length of ub, then ub specifies that

x(i) <= ub(i) for all i.

If numel(ub) < numel(f), then ub specifies that

x(i) <= ub(i) for 1 <= i <= numel(ub).

In this case, solvers issue a warning.

Example: To specify that all x-components are less than 1, use ub = ones(size(f)).

Data Types: double

`options` — Optimization options
output of `optimoptions`

Optimization options, specified as the output of optimoptions.

MATLAB Options
Option	Description
`ConstraintTolerance`	Feasibility tolerance for constraints, a nonnegative scalar. `ConstraintTolerance` measures primal feasibility tolerance. The default is `1e-6`.
`Display`	Level of display (see Iterative Display): `'final'` (default) displays only the final output. `'iter'` displays output at each iteration. `'off'` or `'none'` displays no output.
`LinearSolver`	Algorithm for solving one step in the iteration: `'auto'` (default) — `coneprog` chooses the step solver. If the problem is sparse, the step solver is `'prodchol'`. Otherwise, the step solver is `'augmented'`. `'augmented'` — Augmented form step solver. See [1]. `'normal'` — Normal form step solver. See [1]. `'normal-dense'` — Normal form step solver using dense linear algebra. `'prodchol'` — Product form Cholesky step solver. See [4] and [5]. `'schur'` — Schur complement method step solver. See [2]. If `'auto'` does not perform well, try these suggestions for `LinearSolver`: If the problem is sparse, try `'normal'`. If the problem is sparse with some dense columns or large cones, try `'prodchol'` or `'schur'`. If the problem is dense, use `'normal-dense'` or `'augmented'`. For a sparse example, see Compare Speeds of coneprog Algorithms.
`MaxIterations`	Maximum number of iterations allowed, a nonnegative integer. The default is `200`. See Tolerances and Stopping Criteria and Iterations and Function Counts.
`MaxTime`	Maximum amount of time in seconds that the algorithm runs, a nonnegative number or `Inf`. The default is `Inf`, which disables this stopping criterion.
`OptimalityTolerance`	Termination tolerance on the dual feasibility, a nonnegative scalar. The default is `1e-6`.
Code Generation
`ConstraintTolerance`	Feasibility tolerance for constraints, a nonnegative scalar. `ConstraintTolerance` measures primal feasibility tolerance. The default is `1e-6`.
`Display`	Level of display (see Iterative Display): `'off'`, `'none'`, and the default `'final'` all display no output. `'iter'` displays output at each iteration. Iterative display does not show a column for time in generated code.
`LinearSolver`	Algorithm for solving one step in the iteration: `'augmented'` (default) — Augmented form step solver. See [1]. `'normal'` or `'normal-dense'` — Normal form step solver. See [1]. For code generation, there is a limited set of choices of `LinearSolver`. You cannot change the value of the `LinearSolver` option after code generation. In other words, `coneprog` supports only a static value of the `LinearSolver` option for code generation.
`MaxIterations`	Maximum number of iterations allowed, a nonnegative integer. The default is `200`. See Tolerances and Stopping Criteria and Iterations and Function Counts.
`OptimalityTolerance`	Termination tolerance on the dual feasibility, a nonnegative scalar. The default is `1e-6`.

Code generation does not support the MaxTime option.

Example: optimoptions("coneprog",Display="iter",MaxIterations=100)

`problem` — Problem structure
structure

Problem structure, specified as a structure with the following fields.

Field Name	Entry
`f`	Linear objective function vector `f`
`socConstraints`	Structure array of second-order cone constraints
`Aineq`	Matrix of linear inequality constraints
`bineq`	Vector of linear inequality constraints
`Aeq`	Matrix of linear equality constraints
`beq`	Vector of linear equality constraints
`lb`	Vector of lower bounds
`ub`	Vector of upper bounds
`solver`	`'coneprog'`
`options`	Options created with `optimoptions`

Data Types: struct

Output Arguments

collapse all

`x` — Solution
real vector | real array

Solution, returned as a real vector or real array. The size of x is the same as the size of f. The x output is empty (NaN for code generation) when the exitflag value is –2, –3, or –10.

`fval` — Objective function value at the solution
real number

Objective function value at the solution, returned as a real number. Generally, fval = f'*x. The fval output is empty (NaN for code generation) when the exitflag value is –2, –3, or –10.

`exitflag` — Reason `coneprog` stopped
integer

Reason coneprog stopped, returned as an integer.

Value	Description
`1`	The function converged to a solution `x`.
`0`	The number of iterations exceeded `options.MaxIterations`, or the solution time in seconds exceeded `options.MaxTime`.
`-2`	No feasible point was found.
`-3`	The problem is unbounded.
`-7`	The search direction became too small. No further progress could be made.
`-10`	The problem is numerically unstable.

Tip

If you get exit flag 0, -7, or -10, try using a different value of the LinearSolver option.

`output` — Information about optimization process
structure

Information about the optimization process, returned as a structure with these fields.

Field	Description
`algorithm`	`'interior point'`
`dualfeasibility`	Maximum of dual constraint violations
`dualitygap`	Duality gap
`iterations`	Number of iterations
`message`	Exit message — not available in code generation
`primalfeasibility`	Maximum of constraint violations
`linearsolver`	Internal step solver algorithm used

The output fields algorithm, dualfeasibility, dualitygap, linearsolver, and primalfeasibility are empty (numeric values are NaN for code generation) when the exitflag value is –2, –3, or –10.

The iterations field has int32 type for code generation, not double.

`lambda` — Dual variables at the solution
structure

Dual variables at the solution, returned as a structure with these fields.

Field	Description
`lower`	Lower bounds corresponding to `lb`
`upper`	Upper bounds corresponding to `ub`
`ineqlin`	Linear inequalities corresponding to `A` and `b`
`eqlin`	Linear equalities corresponding to `Aeq` and `beq`
`soc`	Second-order cone constraints corresponding to `socConstraints`

lambda is empty ([]) when the exitflag value is –2, –3, or –10.

The Lagrange multipliers (dual variables) are part of the following Lagrangian, which is stationary (zero gradient) at a solution:

$\begin{array}{l} f^{T} x + \sum_{i} λ_{soc} (i) (‖ A_{soc} (i) x - b_{soc} (i) ‖ - d_{soc}^{T} (i) x + gamma (i)) \\ + λ_{ineqlin}^{T} (A x - b) + λ_{eqlin}^{T} (Aeq x - beq) + λ_{upper}^{T} (x - ub) + λ_{lower}^{T} (lb - x) . \end{array}$

More About

collapse all

Second-Order Cone Constraint

Why is the constraint

$‖ A \cdot x - b ‖ \leq d^{T} \cdot x - γ$

called a second-order cone constraint? Consider a cone in 3-D space with elliptical cross-sections in the x-y plane, and a diameter proportional to the z coordinate. The y coordinate has scale ½, and the x coordinate has scale 1. The inequality defining the inside of this cone with its point at [0,0,0] is

$\sqrt{x^{2} + \frac{y^{2}}{4}} \leq z .$

In the coneprog syntax, this cone has the following arguments.

A = diag([1 1/2 0]);
b = [0;0;0];
d = [0;0;1];
gamma = 0;

Plot the boundary of the cone.

[X,Y] = meshgrid(-2:0.1:2);
Z = sqrt(X.^2 + Y.^2/4);
surf(X,Y,Z)
view(8,2)
xlabel 'x'
ylabel 'y'
zlabel 'z'

The b and gamma arguments move the cone. The A and d arguments rotate the cone and change its shape.

Algorithms

The algorithm uses an interior-point method. For details, see Second-Order Cone Programming Algorithm.

Alternative Functionality

App

The Optimize Live Editor task provides a visual interface for coneprog.

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

coneprog supports code generation using either the codegen (MATLAB Coder) function or the MATLAB^® Coder™ app. You must have a MATLAB Coder license to generate code.
The target hardware must support standard double-precision floating-point computations.
Code generation targets do not use the same math kernel libraries as MATLAB solvers. Therefore, code generation solutions can vary from solver solutions, especially for poorly conditioned problems.
coneprog does not support the problem argument for code generation.
```
[x,fval] = coneprog(problem) % Not supported
```
All coneprog input matrices such as A, Aeq, lb, and ub must be full, not sparse. You can convert sparse matrices to full by using the full function.
Pass cone constraints as a cell array of SecondOrderConeConstraint objects, not as an array of these objects. If you have no cone constraints, pass an empty cell {}.
The lb and ub arguments must have the same number of entries as the number of problem variables or must be empty [].
If your target hardware does not support infinite bounds, use optim.coder.infbound.
For advanced code optimization involving embedded processors, you also need an Embedded Coder^® license.
Code generation supports these options using optimoptions:
- ConstraintTolerance
- Display
- LinearSolver
- MaxIterations
- OptimalityTolerance

Generated code has limited error checking for options. The recommended way to update an option is to use dot notation, not optimoptions.

opts = optimoptions("coneprog",ConstraintTolerance=1e-4);
opts = optimoptions(opts,MaxIterations=1e4); % Not supported
opts.MaxIterations = 1e4; % Recommended

coneprog supports options passed into the solver, not only options created in the code.
If you specify an option that is not supported, the option is typically ignored during code generation. For reliable results, specify only supported options.

Version History

Introduced in R2020b

expand all

R2024b: Code generation

coneprog can generate C/C++ code. For details, see Code Generation for coneprog Background and Generate Code for coneprog. To accommodate code generation, you can now pass second order cone constraints as a cell array of SecondOrderConeConstraint objects, and this is the required syntax for code generation. See Language Limitations (MATLAB Coder).

R2024a: `'normal-dense'` linear solver for increased speed in dense problems

To gain speed in problems with dense data, set the LinearSolver option to 'normal-dense'. For an example, see Compare Speeds of coneprog Algorithms.

R2021a: Two `coneprog` `lambda` Structures Renamed

The coneprog lambda output argument fields lambda.eq and lambda.ineq have been renamed to lambda.eqlin and lambda.ineqlin, respectively. This change causes the coneprog lambda structure fields to have the same names as the corresponding fields in other solvers.

coneprog

Syntax

Description

Examples

Single Cone Constraint

Several Cone Constraints

Cone Programming with Linear Constraints

Cone Programming with Nondefault Options

Cone Programming with Problem Structure

Examine coneprog Solution Process

Obtain coneprog Dual Variables

Input Arguments

f — Coefficient vector real vector | real array

socConstraints — Second-order cone constraints vector of SecondOrderConeConstraint objects | cell array of SecondOrderConeConstraint objects

A — Linear inequality constraints real matrix

b — Linear inequality constraints real vector

Aeq — Linear equality constraints real matrix

beq — Linear equality constraints real vector

lb — Lower bounds real vector | real array

ub — Upper bounds real vector | real array

options — Optimization options output of optimoptions

problem — Problem structure structure

Output Arguments

x — Solution real vector | real array

fval — Objective function value at the solution real number

exitflag — Reason coneprog stopped integer

output — Information about optimization process structure

lambda — Dual variables at the solution structure

More About

Second-Order Cone Constraint

Algorithms

Alternative Functionality

App

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

Version History

R2024b: Code generation

R2024a: 'normal-dense' linear solver for increased speed in dense problems

R2021a: Two coneprog lambda Structures Renamed

See Also

Topics

Examine `coneprog` Solution Process

Obtain `coneprog` Dual Variables

`f` — Coefficient vector
real vector | real array

`socConstraints` — Second-order cone constraints
vector of `SecondOrderConeConstraint` objects | cell array of `SecondOrderConeConstraint` objects

`A` — Linear inequality constraints
real matrix

`b` — Linear inequality constraints
real vector

`Aeq` — Linear equality constraints
real matrix

`beq` — Linear equality constraints
real vector

`lb` — Lower bounds
real vector | real array

`ub` — Upper bounds
real vector | real array

`options` — Optimization options
output of `optimoptions`

`problem` — Problem structure
structure

`x` — Solution
real vector | real array

`fval` — Objective function value at the solution
real number

`exitflag` — Reason `coneprog` stopped
integer

`output` — Information about optimization process
structure

`lambda` — Dual variables at the solution
structure

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

R2024a: `'normal-dense'` linear solver for increased speed in dense problems

R2021a: Two `coneprog` `lambda` Structures Renamed