Hubbry Logo
search
logo
Second-order cone programming avatar
Second-order cone programming
Second-order cone programming
current hub
S

Second-order cone programming

logo
Community Hub0 Subscribers
Read side by side
Second-order cone programming
View on Wikipedia
from Wikipedia

A second-order cone program (SOCP) is a convex optimization problem of the form

minimize
subject to

where the problem parameters are , and . is the optimization variable. is the Euclidean norm and indicates transpose.[1]

The name "second-order cone programming" comes from the nature of the individual constraints, which are each of the form:

These each define a subspace that is bounded by an inequality based on a second-order polynomial function defined on the optimization variable ; this can be shown to define a convex cone, hence the name "second-order cone".[2] By the definition of convex cones, their intersection can also be shown to be a convex cone, although not necessarily one that can be defined by a single second-order inequality. See below for a more detailed treatment.

SOCPs can be solved by interior point methods[3] and in general, can be solved more efficiently than semidefinite programming (SDP) problems.[4] Some engineering applications of SOCP include filter design, antenna array weight design, truss design, and grasping force optimization in robotics.[5] Applications in quantitative finance include portfolio optimization; some market impact constraints, because they are not linear, cannot be solved by quadratic programming but can be formulated as SOCP problems.[6][7][8]

Second-order cones

[edit]

The standard or unit second-order cone of dimension is defined as

.

The second-order cone is also known by the names quadratic cone or ice-cream cone or Lorentz cone. For example, the standard second-order cone in is

.

The set of points satisfying a second-order cone constraint is the inverse image of the unit second-order cone under an affine mapping:

and hence is convex.

The second-order cone can be embedded in the cone of the positive semidefinite matrices since

i.e., a second-order cone constraint is equivalent to a linear matrix inequality. The nomenclature here can be confusing; here means is a semidefinite matrix: that is to say

which is not a linear inequality in the conventional sense.

Similarly, we also have,

.

Relation with other optimization problems

[edit]
A hierarchy of convex optimization problems. (LP: linear program, QP: quadratic program, SOCP second-order cone program, SDP: semidefinite program, CP: cone program.)

When for , the SOCP reduces to a linear program. When for , the SOCP is equivalent to a convex quadratically constrained linear program.

Convex quadratically constrained quadratic programs can also be formulated as SOCPs by reformulating the objective function as a constraint.[5] Semidefinite programming subsumes SOCPs as the SOCP constraints can be written as linear matrix inequalities (LMI) and can be reformulated as an instance of semidefinite program.[5] The converse, however, is not valid: there are positive semidefinite cones that do not admit any second-order cone representation.[4]

Any closed convex semialgebraic set in the plane can be written as a feasible region of a SOCP,.[9] However, it is known that there exist convex semialgebraic sets of higher dimension that are not representable by SDPs; that is, there exist convex semialgebraic sets that can not be written as the feasible region of a SDP (nor, a fortiori, as the feasible region of a SOCP).[10]

Examples

[edit]

Quadratic constraint

[edit]

Consider a convex quadratic constraint of the form

This is equivalent to the SOCP constraint

Stochastic linear programming

[edit]

Consider a stochastic linear program in inequality form

minimize
subject to

where the parameters are independent Gaussian random vectors with mean and covariance and . This problem can be expressed as the SOCP

minimize
subject to

where is the inverse normal cumulative distribution function.[1]

Stochastic second-order cone programming

[edit]

We refer to second-order cone programs as deterministic second-order cone programs since data defining them are deterministic. Stochastic second-order cone programs are a class of optimization problems that are defined to handle uncertainty in data defining deterministic second-order cone programs.[11]

Other examples

[edit]

Other modeling examples are available at the MOSEK modeling cookbook.[12]

Solvers and scripting (programming) languages

[edit]
Name License Brief info
ALGLIB free/commercial A dual-licensed C++/C#/Java/Python numerical analysis library with parallel SOCP solver.
AMPL commercial An algebraic modeling language with SOCP support
Artelys Knitro commercial
CPLEX commercial
FICO Xpress commercial
Gurobi Optimizer commercial
MATLAB commercial The coneprog function solves SOCP problems[13] using an interior-point algorithm[14]
MOSEK commercial parallel interior-point algorithm
NAG Numerical Library commercial General purpose numerical library with SOCP solver

See also

[edit]
  • Power cones are generalizations of quadratic cones to powers other than 2.[15]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Second-order cone programming

View on Grokipedia
from Grokipedia
Second-order cone programming (SOCP) is a class of convex optimization problems that involves minimizing a linear objective function subject to constraints defined by second-order (Lorentz) cones, which are sets of the form {(x,t)∈Rn×R:t≥∥x∥2}\{ (x, t) \in \mathbb{R}^n \times \mathbb{R} : t \geq \|x\|_2 \}, along with possible linear equality constraints.[1][2] The standard primal formulation is min⁡cTx\min c^T x subject to ∥Aix+bi∥2≤ciTx+di\|A_i x + b_i\|_2 \leq c_i^T x + d_i for i=1,…,mi = 1, \dots, m and Ax=bAx = b, where the constraints ensure the feasible region is the intersection of an affine set and a product of second-order cones.[3][2] SOCP generalizes linear programming (LP) and convex quadratically constrained quadratic programming (QCQP), as these can be expressed as special cases by setting certain matrices to zero or using quadratic objectives without cross terms.[1][3] It is also a subclass of semidefinite programming (SDP), since second-order cone constraints can be reformulated as linear matrix inequalities, though SOCP is computationally less demanding due to the simpler cone structure.[2][3] Problems in this framework are solvable in polynomial time using interior-point methods, which achieve theoretical iteration complexity of O(rlog⁡(1/ϵ))O(\sqrt{r} \log(1/\epsilon)) where rr is the number of cones and ϵ\epsilon is the desired accuracy, often converging in 5–50 iterations in practice.[1][2] Notable applications of SOCP span engineering and operations research, including filter and antenna array design, truss topology optimization, robotics force allocation, and robust linear regression.[2] In finance, it supports portfolio optimization under uncertainty, while in control theory, it aids in designing robust controllers.[3] The development of efficient solvers, such as those based on primal-dual path-following algorithms leveraging the self-dual properties of second-order cones, has made SOCP a practical tool for large-scale problems since the late 1990s.[1][2]

Problem Formulation

Standard Form

Second-order cone programming (SOCP) is a class of convex optimization problems that involves minimizing a linear objective function subject to linear equality constraints and second-order cone inequalities.[4] The problem assumes familiarity with basic linear algebra and the Euclidean vector norm ∥⋅∥2\|\cdot\|_2, defined as ∥u∥2=uTu\|u\|_2 = \sqrt{u^T u} for a vector uu.00115-8) In its canonical form, an SOCP is formulated as
min⁡xcTxsubject toAx=b,∥Fix+gi∥2≤hiTx+di,i=1,…,m, \begin{align*} \min_{x} &\quad c^T x \\ \text{subject to} &\quad Ax = b, \\ &\quad \|F_i x + g_i\|_2 \leq h_i^T x + d_i, \quad i = 1, \dots, m, \end{align*}
where x∈Rnx \in \mathbb{R}^n is the optimization variable, c∈Rnc \in \mathbb{R}^n is the objective coefficient vector, A∈Rp×nA \in \mathbb{R}^{p \times n} and b∈Rpb \in \mathbb{R}^p define the affine equalities, and for each cone constraint ii, Fi∈Rqi×nF_i \in \mathbb{R}^{q_i \times n}, gi∈Rqig_i \in \mathbb{R}^{q_i}, hi∈Rnh_i \in \mathbb{R}^n, and di∈Rd_i \in \mathbb{R} are given data ensuring the right-hand side is scalar.[4] This form integrates the cones through affine transformations of xx, where each constraint ∥zi∥2≤ti\|z_i\|_2 \leq t_i has zi=Fix+giz_i = F_i x + g_i and ti=hiTx+dit_i = h_i^T x + d_i.00115-8) An equivalent representation uses the direct product of second-order cones without explicit affine shifts, expressed as minimizing ∑i=1rciTxi\sum_{i=1}^r c_i^T x_i subject to ∑i=1rAixi=b\sum_{i=1}^r A_i x_i = b and xi∈Qnix_i \in \mathcal{Q}^{n_i} for i=1,…,ri=1,\dots,r, where each Qni={(t;z)∈R×Rni−1:∥z∥2≤t}\mathcal{Q}^{n_i} = \{ (t; z) \in \mathbb{R} \times \mathbb{R}^{n_i-1} : \|z\|_2 \leq t \} is a second-order cone of dimension nin_i, and x=(x1;… ;xr)x = (x_1; \dots; x_r) stacks the block variables xi∈Rnix_i \in \mathbb{R}^{n_i}.[4] SOCPs can also incorporate rotated quadratic cone constraints, which are equivalent under affine transformations and defined by inequalities of the form xy≥∥z∥22x y \geq \|z\|_2^2 with x≥0x \geq 0 and y≥0y \geq 0, where x,y∈Rx, y \in \mathbb{R} and z∈Rkz \in \mathbb{R}^k.00115-8) The rotated cone Q^k+2={(x;y;z)∈R×R×Rk:2xy≥∥z∥22,x≥0,y≥0}\hat{\mathcal{Q}}^{k+2} = \{ (x; y; z) \in \mathbb{R} \times \mathbb{R} \times \mathbb{R}^k : 2 x y \geq \|z\|_2^2, x \geq 0, y \geq 0 \} provides a hyperbolic form useful for modeling products in constraints like uTu≤tsu^T u \leq t s with t,s≥0t, s \geq 0.[4]

Second-Order Cones

The second-order cone, also known as the Lorentz cone, quadratic cone, or ice-cream cone, is a fundamental convex set in optimization defined for dimension n≥2n \geq 2 as
Qn={(x,t)∈Rn×R  |  ∥x∥2≤t, t≥0}, Q^n = \left\{ (x, t) \in \mathbb{R}^n \times \mathbb{R} \;\middle|\; \|x\|_2 \leq t,\ t \geq 0 \right\},
where ∥x∥2=x12+⋯+xn2\|x\|_2 = \sqrt{x_1^2 + \cdots + x_n^2} denotes the Euclidean norm.[5][2] This set consists of all points where the scalar tt is at least as large as the norm of the vector xx, forming the region above a hyperboloid boundary in Rn+1\mathbb{R}^{n+1}. The second-order cone possesses several key geometric properties that make it suitable for convex optimization. It is a proper cone, meaning it is closed, convex, pointed (with apex at the origin and containing no lines through the origin), and solid (with nonempty interior).[6][5] Additionally, under the standard Euclidean inner product, it is self-dual, satisfying Qn=(Qn)∗={(y,s)∈Rn×R∣y⊤x+st≥0 ∀(x,t)∈Qn}Q^n = (Q^n)^* = \{ (y, s) \in \mathbb{R}^n \times \mathbb{R} \mid y^\top x + s t \geq 0\ \forall (x,t) \in Q^n \}.[6][5] In second-order cone programming, constraints are typically imposed over the Cartesian product of multiple second-order cones, possibly including rotated variants of the form {(x,y,z)∈Rn×Rm×R∣∥(x,y)∥2≤z, z≥0}\{(x,y,z) \in \mathbb{R}^{n} \times \mathbb{R}^{m} \times \mathbb{R} \mid \|(x,y)\|_2 \leq z,\ z \geq 0\}, intersected with an affine subspace.[2] Geometrically, the second-order cone resembles an ice-cream cone in low dimensions. In R2\mathbb{R}^2 (for n=1n=1), it appears as the region above a pair of lines forming a V-shape with vertex at the origin. In R3\mathbb{R}^3 (for n=2n=2), it takes the form of a circular cone with a rounded tip, where cross-sections parallel to the base are disks whose radius increases linearly with the height tt.[2][6] The second-order cone was introduced in the optimization literature during the 1990s, notably through extensions of interior-point methods to quadratic constraints by researchers including Alizadeh, Goldfarb, and Nesterov-Nemirovski, positioning it as a bridge between quadratic programming and semidefinite programming.[5]

Theoretical Foundations

Convexity and Duality

Second-order cone programming (SOCP) problems are convex optimization problems, as their objective functions are linear and thus convex, while the feasible sets are defined by affine equality constraints and second-order cone inequalities, both of which describe convex sets. The linearity of the objective min⁡cTx\min c^T x ensures convexity, since linear functions satisfy the convexity inequality f(θx+(1−θ)y)=θf(x)+(1−θ)f(y)f(\theta x + (1-\theta)y) = \theta f(x) + (1-\theta) f(y) for 0≤θ≤10 \leq \theta \leq 1. Affine equality constraints Ax=bAx = b define affine subspaces, which are convex, and their intersections preserve convexity. Second-order cone constraints of the form ∥Fix+gi∥2≤hiTx+di\|F_i x + g_i\|_2 \leq h_i^T x + d_i, or equivalently (hiTx+di,Fix+gi)∈Qni+1(h_i^T x + d_i, F_i x + g_i) \in \mathcal{Q}^{n_i+1} where Qn+1={(t,z)∈R×Rn∣∥z∥2≤t}\mathcal{Q}^{n+1} = \{ (t, z) \in \mathbb{R} \times \mathbb{R}^n \mid \|z\|_2 \leq t \}, represent membership in the second-order (Lorentz) cone, a closed, convex, pointed, and self-dual cone. The intersection of these convex sets yields a convex feasible region, confirming that SOCP is a convex program.[7][8] To derive the Lagrangian dual, consider the standard SOCP primal in the form
\minimizecTxsubject toAx=b,∥Fix+gi∥2≤hiTx+di,i=1,…,m, \begin{align*} \minimize &\quad c^T x \\ \text{subject to} &\quad Ax = b, \\ &\quad \|F_i x + g_i\|_2 \leq h_i^T x + d_i, \quad i = 1, \dots, m, \end{align*}
where x∈Rnx \in \mathbb{R}^n, A∈Rp×nA \in \mathbb{R}^{p \times n}, b∈Rpb \in \mathbb{R}^p, and the cone constraints involve matrices Fi∈Rqi×nF_i \in \mathbb{R}^{q_i \times n}, vectors gi∈Rqig_i \in \mathbb{R}^{q_i}, hi∈Rnh_i \in \mathbb{R}^n, and scalars did_i. Each cone constraint corresponds to (hiTx+di,Fix+gi)∈Qqi+1(h_i^T x + d_i, F_i x + g_i) \in \mathcal{Q}^{q_i + 1}. The Lagrangian associates dual variables y∈Rpy \in \mathbb{R}^p with the equality constraints and cone dual variables (λi,ui)∈Qqi+1(\lambda_i, u_i) \in \mathcal{Q}^{q_i + 1} with each cone constraint:
L(x,y,λ,u)=cTx+yT(b−Ax)+∑i=1m[λi(hiTx+di)+uiT(Fix+gi)]. L(x, y, \lambda, u) = c^T x + y^T (b - Ax) + \sum_{i=1}^m \left[ \lambda_i (h_i^T x + d_i) + u_i^T (F_i x + g_i) \right].
The dual function is g(y,λ,u)=inf⁡xL(x,y,λ,u)g(y, \lambda, u) = \inf_x L(x, y, \lambda, u), which is concave as the pointwise infimum of affine functions in the dual variables. The dual problem maximizes this function over y∈Rpy \in \mathbb{R}^p and (λi,ui)∈Qqi+1(\lambda_i, u_i) \in \mathcal{Q}^{q_i + 1} for i=1,…,mi=1,\dots,m.[7][9] The explicit dual problem, obtained by setting the gradient with respect to xx to zero (stationarity), is
\maximizebTy+∑i=1m(diλi−giTui)subject toATy+∑i=1m(FiTui+hiλi)=c,λi≥∥ui∥2,i=1,…,m, \begin{align*} \maximize &\quad b^T y + \sum_{i=1}^m (d_i \lambda_i - g_i^T u_i) \\ \text{subject to} &\quad A^T y + \sum_{i=1}^m (F_i^T u_i + h_i \lambda_i) = c, \\ &\quad \lambda_i \geq \|u_i\|_2, \quad i = 1, \dots, m, \end{align*}
where the constraints λi≥∥ui∥2\lambda_i \geq \|u_i\|_2 (equivalent to (λi,ui)∈Qqi+1(\lambda_i, u_i) \in \mathcal{Q}^{q_i + 1}) enforce membership in the dual second-order cones, reflecting their self-duality. Weak duality holds, meaning the primal optimal value p∗≥d∗p^* \geq d^* (the dual optimal value), due to the nonnegativity of the duality gap at feasible points.[7][9] Under Slater's condition, strong duality obtains, equating the primal and dual optimal values p∗=d∗p^* = d^*. For SOCP, Slater's condition requires the existence of a strictly feasible point xx such that Ax=bAx = b and hiTx+di>∥Fix+gi∥2h_i^T x + d_i > \|F_i x + g_i\|_2 for all i=1,…,mi = 1, \dots, m, ensuring the relative interior of the feasible set is nonempty. This condition implies zero duality gap and attainment of the optimum in both problems, as SOCP constraints are qualified under strict feasibility. The proof follows from the general theory of convex conic programs, where strict feasibility separates the primal from its recession cone, guaranteeing no duality gap via the separating hyperplane theorem.[7][8] The dual variables provide sensitivity analysis through shadow prices, quantifying the marginal change in the optimal value with respect to perturbations in the problem data. Specifically, the optimal dual y∗y^* gives the shadow prices for the equality constraints: a unit increase in bjb_j improves the primal objective by yj∗y_j^*, reflecting the rate of change ∂p∗∂bj=yj∗\frac{\partial p^*}{\partial b_j} = y_j^*. For the cone constraints, the λi∗\lambda_i^* serve as shadow prices for the right-hand sides did_i, where ∂p∗∂di=λi∗\frac{\partial p^*}{\partial d_i} = \lambda_i^*, indicating the value of relaxing the ii-th cone bound. These interpretations hold under strong duality and differentiability assumptions, such as strict complementarity, and extend to conic programs where dual variables measure resource values in the primal.[7][10]

Computational Complexity

Second-order cone programming (SOCP) belongs to the class P of problems solvable in polynomial time, primarily through interior-point methods that achieve an iteration complexity of O(νlog⁡(1/ϵ))O(\sqrt{\nu} \log(1/\epsilon)) where ν\nu is the total barrier parameter (typically ν=∑i(qi+1)\nu = \sum_i (q_i + 1) for cones of dimensions qi+1q_i + 1) to achieve ϵ\epsilon-accuracy, and each iteration involves solving a linear system scaling with problem size.[11] This complexity arises from the structure of the second-order cone, which allows for efficient path-following algorithms that maintain feasibility and reduce the duality gap progressively. Seminal work by Alizadeh and Goldfarb in 2001 established these bounds by extending primal-dual interior-point techniques from linear and semidefinite programming to the conic setting of SOCP.[12] Central to these methods is the use of a self-concordant barrier function for the second-order cone, specifically −log⁡(t2−∥x∥2)-\log(t^2 - \|x\|^2) for the cone {(x,t)∣∥x∥≤t}\{(x, t) \mid \|x\| \leq t\}, which has a parameter ν=2\nu = 2 and enables Newton's method to converge quadratically near the central path while ensuring global polynomial-time performance.[13] This barrier facilitates the construction of a self-concordant function for the overall feasible set, leading to short-step or long-step path-following algorithms that require at most O(νlog⁡(1/ϵ))O(\sqrt{\nu} \log(1/\epsilon)) iterations, independent of problem-specific constants beyond the barrier parameter.[14] While convex SOCP remains tractable in polynomial time, nonconvex extensions—such as those involving quadratic objectives or constraints over nonconvex second-order cones—are NP-hard in general, as they encompass difficult problems like nonconvex quadratic optimization.[15] In contrast to semidefinite programming (SDP), where each interior-point iteration requires O(n3)O(n^3) arithmetic operations due to matrix factorizations, SOCP iterations scale as O(n2)O(n^2) by exploiting the vector-based structure of the cones, rendering SOCP significantly faster for large-scale instances with many variables.[1]

Connections to Other Optimization Problems

Linear and Quadratic Programming

Second-order cone programming (SOCP) generalizes linear programming (LP) by incorporating second-order cone constraints, where LP emerges as a special case when the cones degenerate into linear inequalities. Specifically, an LP constraint of the form ∥x∥∞≤t\|x\|_\infty \leq t, which bounds the maximum absolute value of the components of xx by tt, can be reformulated as an SOCP using multiple two-dimensional second-order cones, each representing ∣xi∣≤t|x_i| \leq t for individual components xix_i. This degeneration occurs because a second-order cone in two dimensions reduces to the linear inequalities −t≤xi≤t-t \leq x_i \leq t. Thus, standard LPs with only linear constraints and objectives fit seamlessly within the SOCP framework without requiring quadratic elements.[4][16] SOCP also extends quadratic programming (QP), particularly convex QP and quadratically constrained QP (QCQP), through representable quadratic forms. A convex QCQP with a single quadratic constraint ∥Ax+b∥2≤(c⊤x+d)2\|Ax + b\|^2 \leq (c^\top x + d)^2, assuming c⊤x+d≥0c^\top x + d \geq 0 for convexity, is SOCP-representable by rewriting it as ∥Ax+b∥≤c⊤x+d\|Ax + b\| \leq c^\top x + d, which directly matches a second-order cone constraint. More generally, any convex QP of the form min⁡x12x⊤Qx+c⊤x\min_x \frac{1}{2} x^\top Q x + c^\top x subject to linear constraints, where Q≻0Q \succ 0, can be reformulated as an SOCP by introducing auxiliary variables. This involves lifting the quadratic objective into the epigraph form t≥12x⊤Qx+c⊤xt \geq \frac{1}{2} x^\top Q x + c^\top x, which is equivalent to ∥Q1/2x∥≤2t\|Q^{1/2} x\| \leq \sqrt{2t} after a change of variables, representable using a rotated second-order cone ∥y∥2≤2tu\|y\|^2 \leq 2tu with u=1u = 1 and linear mappings y=Q1/2xy = Q^{1/2} x. The Schur complement plays a key role in verifying such equivalences, ensuring the quadratic structure aligns with cone constraints.[4][16] These reformulations highlight SOCP's advantages over pure LP or QP solvers, as it unifies the handling of norms, hyperbolic inequalities, and quadratic terms under a single convex framework solvable by efficient interior-point methods. Unlike LP, which is limited to polyhedral sets, or QP, which struggles with multiple quadratic constraints, SOCP enables broader modeling of norms and second-order structures while maintaining polynomial-time solvability. Historically, SOCP emerged in the 1990s as a bridge between LP solvers and quadratic extensions, with foundational interior-point algorithms developed by Nesterov and Nemirovski in 1994, followed by practical applications surveyed by Lobo et al. in 1998 and theoretical developments by Alizadeh and Goldfarb in 2003.[4][16]

Semidefinite Programming

Second-order cone programming (SOCP) can be embedded into semidefinite programming (SDP) through a straightforward reformulation of its constraints as linear matrix inequalities (LMIs). Specifically, the second-order cone constraint ∥x∥2≤t\|x\|_2 \leq t, where x∈Rnx \in \mathbb{R}^n and t∈Rt \in \mathbb{R}, is equivalent to the positive semidefiniteness condition on the (n+1)×(n+1)(n+1) \times (n+1) matrix
(tx⊤xtIn)⪰0, \begin{pmatrix} t & x^\top \\ x & t I_n \end{pmatrix} \succeq 0,
where InI_n denotes the n×nn \times n identity matrix.[2] This equivalence relies on the Schur complement lemma, which states that for a block matrix (AB⊤BC)⪰0\begin{pmatrix} A & B^\top \\ B & C \end{pmatrix} \succeq 0 with A>0A > 0, the condition holds if and only if C−BA−1B⊤⪰0C - B A^{-1} B^\top \succeq 0; applying it here yields tIn−xx⊤/t⪰0t I_n - x x^\top / t \succeq 0, or equivalently ∥x∥22≤t2\|x\|_2^2 \leq t^2 with t≥0t \geq 0.[17] Consequently, any SOCP problem, consisting of a linear objective minimized subject to linear equalities and second-order cone constraints, can be recast as an SDP by replacing each cone constraint with the corresponding LMI, while preserving the linear structure of the objective and equalities.[2] SDP serves as a strict generalization of SOCP, as every SOCP is an SDP but the converse does not hold.[2] SDP optimizes over spectrahedra—feasible sets defined by LMIs—allowing for more expressive convex constraints that capture matrix-valued uncertainties or spectral conditions not representable by quadratic cones alone. For instance, SDP can model constraints involving the eigenvalues of symmetric matrices directly, whereas SOCP is confined to rotated quadratic cones and their products, limiting its representational power to vector norms and hyperbolic inequalities.[1] This broader scope makes SDP applicable to problems in quantum information and control theory where full matrix positivity is required, but it comes at the cost of increased computational demands due to the higher dimensionality of matrix variables.[2] Under certain structural conditions, SDP problems can reduce to equivalent SOCPs via facial reduction techniques, which identify the minimal face of the semidefinite cone containing the feasible set and project the problem onto it. Facial reduction, originally developed for conic programs, iteratively finds exposing hyperplanes to eliminate redundant dimensions, often resulting in a lower-dimensional equivalent formulation. In particular, when the positive semidefinite constraints exhibit rank-one structure at optimality—meaning the optimal matrices factor as outer products X=xx⊤X = x x^\top with rank⁡(X)=1\operatorname{rank}(X) = 1—the SDP simplifies to an SOCP, as the LMI reduces to a second-order cone via the aforementioned Schur complement representation. Such rank-one solvability occurs in classes of SDPs arising in experimental design and sensor network localization, where the reduced form leverages SOCP's efficiency without loss of optimality.[18] Computationally, solving SOCPs directly is preferable to embedding them in SDP frameworks for cone-representable problems, as SOCP interior-point methods exhibit better scaling.[2] SDP solvers operate on matrix variables of size up to m×mm \times m, leading to iteration complexities of O(mlog⁡(1/ϵ))O(\sqrt{m} \log(1/\epsilon)) and per-iteration costs scaling with O(m6)O(m^6), whereas direct SOCP methods for kk cones in dimension nn achieve O(klog⁡(1/ϵ))O(\sqrt{k} \log(1/\epsilon)) iterations with O(n2)O(n^2) work per iteration, exploiting the lower dimensionality and simpler cone geometry. This trade-off favors SOCP for large-scale instances where the embedding inflates matrix sizes unnecessarily.[2] The representational interplay between SOCP and SDP bridges applications in robust optimization, where many SDP formulations can be reformulated as SOCPs to enhance solvability.[2] For example, robust counterparts of linear programs under ellipsoidal uncertainty yield SOCPs directly, but extensions involving matrix-norm bounded perturbations often start as SDPs that simplify to SOCPs when the uncertainty structure aligns with quadratic cones, improving efficiency in portfolio optimization and control design.[2] This reformulation preserves exactness while reducing solve times, making SOCP a practical choice for high-impact robust problems originally posed in SDP form.[19]

Solution Methods

Interior-Point Algorithms

Interior-point algorithms for second-order cone programming (SOCP) primarily rely on primal-dual path-following methods, which trace the central path defined by scaling the logarithmic barrier function associated with the second-order cones by a barrier parameter μ > 0. The central path consists of points (x(μ), y(μ), z(μ)) that satisfy the primal and dual constraints while achieving approximate complementarity through x_i ∘ z_i = μ e for each cone component, where ∘ denotes the Jordan algebra product for Lorentz cones. These methods solve a sequence of Newton systems to compute affine-scaling directions that move toward the central path, leveraging the self-concordance of the barrier function to ensure theoretical guarantees.[20][5] The barrier parameter μ is updated iteratively using a damping scheme, such as μ_k = σ θ μ_{k-1} + (1 - σ) ν_k, where ν_k approximates the current duality gap, σ ∈ (0,1) controls centering, and θ ≈ 1 promotes long steps in predictor-corrector variants to accelerate convergence. Newton directions are obtained by solving the Karush-Kuhn-Tucker (KKT) system in the form:
∑iAiΔxi=rP,AiTΔy+Δzi=rD,Wi−1Δzi+WiΔxi=rC, \begin{align*} \sum_i A_i \Delta x_i &= r_P, \\ A_i^T \Delta y + \Delta z_i &= r_D, \\ W_i^{-1} \Delta z_i + W_i \Delta x_i &= r_C, \end{align*}
where W_i is the scaling matrix derived from the cone structure, r_P, r_D, and r_C are residuals, and the system is reduced via the Schur complement exploiting the arrow matrix form of the cone Hessian, which has a block structure like (x0xˉTxˉx0I)\begin{pmatrix} x_0 & \bar{x}^T \\ \bar{x} & x_0 I \end{pmatrix} for efficient factorization. This arrow matrix property allows for specialized Cholesky decompositions, such as product-form methods, to handle the sparsity and conditioning of SOCP systems effectively.[20][5][21] Convergence of these algorithms is quadratic in the neighborhood of the optimum due to the second-order Taylor approximation in Newton steps, while globally, they achieve polynomial-time complexity bounded by O(√r \log(1/\epsilon)) iterations for an r-rank problem to reach ε-accuracy, relying on the self-concordance parameter of the barrier function. The Mehrotra predictor-corrector heuristic enhances practical efficiency by computing a predictor step to estimate the maximum affine-scaling direction, followed by an adaptive centering corrector step where σ is chosen as the square of the step length ratio, reducing the need for backtracking line searches; this approach is implemented in solvers like MOSEK and SeDuMi for robust performance on SOCP instances.[20][5][22] In the 2010s and beyond, enhancements include warm-starting techniques that initialize the algorithm near a previous solution using rounded Jordan frames to preserve centrality, enabling faster resolution of related SOCPs in iterative applications like robust optimization. Additionally, decomposition strategies, such as parallel block-angular decompositions, have been developed for large-scale SOCPs, distributing the Schur complement computation across multiple cones to scale to thousands of variables while maintaining polynomial convergence.[23][24][25]

First-Order and Other Methods

First-order methods for second-order cone programming (SOCP) primarily rely on projected gradient or subgradient descent, which iteratively update variables by taking steps along the negative gradient direction and projecting onto the feasible cone constraints. These methods are particularly suited for large-scale problems where computing exact projections is feasible due to the structure of second-order cones. The projection of a point (x,t)∈Rn×R(x, t) \in \mathbb{R}^n \times \mathbb{R} onto the second-order cone Qn+1={(x,t):∥x∥≤t}\mathcal{Q}^{n+1} = \{(x, t) : \|x\| \leq t\} admits a closed-form expression: projQ(x,t)=(x/α,∣t∣)\mathrm{proj}_{\mathcal{Q}}(x, t) = (x / \alpha, |t|), where α=max⁡(1,∥x∥/t)\alpha = \max(1, \|x\| / t) if t>0t > 0, and (0,0)(0, 0) otherwise; this can be computed efficiently without singular value decomposition for standard cones, though SVD may be used for more general quadratic cones. For nonsmooth objectives, subgradient methods extend this approach by using subgradients in place of gradients, maintaining the projection step to enforce feasibility.[26][27] Splitting techniques decompose SOCP into simpler subproblems, enabling parallel computation and scalability. The alternating direction method of multipliers (ADMM) is widely used in consensus formulations, where the problem is reformulated with auxiliary variables to enforce agreement across subproblems; updates follow the form xk+1=arg⁡min⁡x(L(x,zk,λk)+ρ2∥Ax−zk∥2)x^{k+1} = \arg\min_x \left( L(x, z^k, \lambda^k) + \frac{\rho}{2} \|Ax - z^k\|^2 \right), followed by analogous updates for dual and auxiliary variables, with ρ>0\rho > 0 as the penalty parameter. This approach converges linearly under suitable conditions and is effective for distributed SOCP arising in power systems or machine learning. Dual decomposition complements ADMM by relaxing coupling constraints via Lagrangian multipliers, particularly for distributed settings where each agent solves local SOCP subproblems and coordinates through dual updates; this leverages Lagrangian relaxation across cone constraints to obtain global optimality bounds.[28][29][30] For SOCP with nonsmooth objectives, such as those involving ℓ1\ell_1-regularization or max-type penalties, Nesterov smoothing approximates the nonsmooth part with a smooth surrogate, enabling accelerated first-order methods with optimal complexity O(1/ϵ)O(1/\epsilon) iterations to achieve ϵ\epsilon-accuracy in function value. The smoothing parameter is adaptively decreased to balance approximation error and optimization speed, making it suitable for composite SOCP where the smooth component is differentiable. Recent hybrid approaches integrate machine learning to tune parameters like step sizes or penalty ρ\rho in first-order iterations; for instance, neural networks trained on parametric convex problems, including SOCP instances, learn acceleration sequences that reduce iteration counts by up to 50% while certifying robustness to perturbations.[31][32] Despite their scalability, first-order and splitting methods exhibit slower convergence to high-precision solutions compared to interior-point algorithms, often requiring O(1/ϵ)O(1/\epsilon) iterations versus polylogarithmic dependence, though they excel on very large instances with millions of variables due to low per-iteration cost and easy parallelization.[33]

Applications and Examples

Engineering and Control Systems

Beamforming in signal processing leverages SOCP for optimal array design, particularly in robust downlink scenarios for MIMO wireless systems. The problem minimizes transmit power min⁡∥w∥22\min \|w\|_2^2 subject to signal-to-interference-plus-noise ratio (SINR) constraints ∣wHa(θ)∣≥1|w^H a(\theta)| \geq 1 for desired directions and ∥w∥2≤δ\|w\|_2 \leq \delta for power limits, where ww is the beamforming vector and a(θ)a(\theta) is the steering vector; uncertainties in channel estimates are incorporated via ellipsoidal sets, reformulated as SOC constraints like Re(hi∗wi)≥∑∣hi∗wj∣2+σ2\text{Re}(h_i^* w_i) \geq \sqrt{\sum |h_i^* w_j|^2 + \sigma^2}. This yields efficient solutions that maintain quality-of-service with high probability (e.g., 95% in simulations), converging in 5-10 iterations.[34] Structural design applications, such as truss optimization, employ SOCP to minimize material cost under stress constraints modeled as second-order cones. For instance, compliance minimization subject to volume bounds ∑lixi≤Vmax⁡\sum l_i x_i \leq V_{\max} and stress limits ∥σ∥2≤σyield\|\sigma\|_2 \leq \sigma_{\text{yield}} for cross-sectional areas xix_i and lengths lil_i is cast as min⁡fTK(x)−1f\min f^T K(x)^{-1} f with SOC representable elastic energy terms, enabling handling of multiple loads and worst-case scenarios via duality-based heuristics. Numerical examples demonstrate improved stiffness in ground structures with added members, solved efficiently using solvers like MOSEK.[35] Quadratic constraints in sensor network localization are directly addressed by SOCP, using range measurements between nodes as ∥xi−xj∥2≤dij\|x_i - x_j\|_2 \leq d_{ij} for positions xi,xjx_i, x_j and distances dijd_{ij}. The non-convex problem is relaxed to a convex SOCP by minimizing a bi-criterion objective approximating error variance via Jensen's inequality, with constraints like ∥Zk∥2≤tk\|Z_k\|_2 \leq t_k for auxiliary variables; this achieves higher accuracy (e.g., relative entropy of 0.2089 bits) and lower computational complexity than semidefinite programming (SDP) alternatives, using tools like SDPT3.[36] Early applications in the 1990s, such as minimax FIR filter design via SOCP, minimized maximum deviation tt subject to cone constraints on frequency responses like ∥t−aTx/bi∥<t+aTx/bi\|t - a^T x / b_i\| < t + a^T x / b_i, as explored in seminal works establishing SOCP's practicality for engineering. These foundations extended to modern robotics path planning, where SOCP coordinates large-scale teams in polygonal environments by minimizing total distance min⁡∑∥pk−qk∥2\min \sum \|p_k - q_k\|_2 subject to linear inequalities for obstacle avoidance, using two-phase methods for convex and non-convex spaces with complexity scaling as O(lm3)O(lm^3) practically.[2][37] SOCP offers advantages over SDP in real-time engineering systems due to lower computational complexity, with feasibility checks linear in dimension O(nm)O(n m) versus cubic O(m3)O(m^3) for SDP, and per-iteration costs O(n2∑ni)O(n^2 \sum n_i) compared to O(n2∑ni2)O(n^2 \sum n_i^2), enabling faster solutions for large-scale problems like dynamic control without embedding into higher-dimensional SDPs.[2] More recently, as of 2025, SOCP has been applied to co-optimization in integrated transmission-distribution optimal power flow (TD-OPF), facilitating efficient grid management under uncertainty.[38]

Finance and Stochastic Programming

Second-order cone programming (SOCP) plays a prominent role in portfolio optimization, where it facilitates the minimization of risk subject to return and budget constraints. A classic formulation minimizes the standard deviation of portfolio returns, expressed as min⁡∥Σ1/2w∥2\min \| \Sigma^{1/2} w \|_2 subject to μTw≥r\mu^T w \geq r, 1Tw=11^T w = 1, and w≥0w \geq 0, with Σ\Sigma as the covariance matrix, μ\mu the expected returns vector, ww the weights, rr the minimum return, and the ℓ2\ell_2-norm capturing quadratic risk measures efficiently via SOCP solvers.[2] This approach extends mean-variance optimization by handling additional conic constraints like cardinality limits or robust adjustments, enabling scalable solutions for large asset universes. In stochastic programming, SOCP approximates chance-constrained linear programs under Gaussian uncertainty, transforming probabilistic guarantees into deterministic conic inequalities. For problems requiring P(Ax≤b)≥1−αP(Ax \leq b) \geq 1 - \alpha with Gaussian noise, the constraint simplifies to ∥Aix−bi∥2≤Φ−1(1−α)σ\| A_i x - b_i \|_2 \leq \Phi^{-1}(1 - \alpha) \sigma for each row ii, where Φ−1\Phi^{-1} is the inverse cumulative distribution function of the standard normal and σ\sigma the standard deviation, yielding a conservative SOCP reformulation that ensures feasibility with high probability.[39] This approximation is particularly useful in finance for robust decision-making under parameter uncertainty, such as in asset allocation with noisy estimates.[40] Stochastic SOCP extends these ideas to two-stage models with recourse, minimizing cTx+E[Q(x,ω)]c^T x + \mathbb{E}[Q(x, \omega)] where the recourse function Q(x,ω)Q(x, \omega) incorporates second-order cone constraints under random ω\omega, often Gaussian-distributed. In financial applications like multi-period portfolio selection, this captures uncertainty in returns or losses, with second-stage variables adjusting positions to meet risk limits, such as probability constraints on portfolio drawdowns reformulated as SOCP.[41] Such models balance first-stage commitments against expected recourse costs, providing tractable solutions for dynamic risk management.[42] SOCP also aids in option pricing, particularly for discretizations of the Black-Scholes partial differential equation or pricing American-style barrier options in incomplete markets. For instance, lower hedging prices for American contingent claims, including barriers with early exercise features, are computed via mixed-integer SOCP formulations that maximize superhedging values under risk measures like Sharpe ratio constraints.[43] These approaches leverage conic duality to bound prices without full distributional assumptions, enhancing computational efficiency over traditional finite-difference methods.[44] Value-at-risk (VaR) models in finance employ SOCP to impose second-order constraints on tail risks, approximating worst-case scenarios in portfolio losses. Robust VaR optimization minimizes max⁡∥Σ1/2w∥2\max \| \Sigma^{1/2} w \|_2 over uncertainty sets, subject to return thresholds, directly as an SOCP to control conditional tail expectations.[45] This formulation integrates quantile-based deviation measures, ensuring portfolios withstand extreme events while maintaining convexity.[46] Recent developments in the 2010s incorporate mixed-integer SOCP for portfolio rebalancing with transaction costs, especially in high-frequency trading contexts where fixed and linear costs necessitate discrete decisions. Models minimize risk plus cost penalties via MISOCP, with binary variables enforcing trade limits, as in multi-period optimizations balancing turnover against performance.[47]

Software Tools

Dedicated Solvers

Dedicated solvers for second-order cone programming (SOCP) are specialized software packages designed to efficiently solve SOCP problems, often supporting extensions like rotated quadratic cones and mixed-integer formulations. These tools vary in licensing, algorithmic approaches, and scalability, catering to different use cases from embedded systems to large-scale industrial applications.

Open-Source Solvers

SeDuMi is a free MATLAB toolbox for optimization over symmetric cones, including SOCP and rotated quadratic cones, employing an interior-point method based on self-dual embedding. It serves as a de facto standard for academic research due to its reliability on small to medium-sized problems but may exhibit numerical issues on ill-conditioned instances.[48] ECOS, an embedded conic solver, is an open-source interior-point method tailored for SOCP in resource-constrained environments like embedded systems.[49] It excels on small problems, solving them faster than many general-purpose solvers, and remains competitive for medium-sized instances up to about 20,000 variables, though it struggles with larger scales due to memory limits.[50] SCS (Splitting Conic Solver) is an open-source first-order primal-dual method using operator splitting (ADMM) for large-scale convex cone programs, including SOCP.[51] It supports scalable solving of problems with millions of variables by leveraging sparse linear algebra, providing approximate solutions quickly at the cost of lower precision compared to interior-point methods.[52]

Commercial Solvers

MOSEK is a high-performance commercial optimizer supporting SOCP, mixed-integer SOCP, and extensions like rotated quadratic and exponential cones (introduced in version 9 around 2018).[53] It uses advanced interior-point algorithms and is licensed for industrial use, with interfaces in multiple languages.[54] Gurobi is a commercial solver that integrates SOCP with mixed-integer programming, featuring a dedicated barrier method for second-order cones and rotated variants since version 5.0 (2012), with ongoing enhancements for multi-threaded parallelism in releases through the 2020s.[55] It handles quadratically constrained problems efficiently, combining SOCP capabilities with broad MIP support.[56]
SolverTypeKey FeaturesScalability
SeDuMiOpen-sourceInterior-point, MATLAB interface, rotated conesSmall-medium
ECOSOpen-sourceInterior-point, embedded focusSmall-medium
SCSOpen-sourceFirst-order ADMM, large-scaleLarge (millions of vars)
MOSEKCommercialInterior-point, MI-SOCP, exponential conesMedium-large
GurobiCommercialBarrier method, MIP integration, parallelismMedium-large

Performance Benchmarks

In benchmarks on DIMACS and CBLIB test sets, MOSEK demonstrates superior performance, solving medium-scale SOCP instances (e.g., up to 50,000 constraints) in seconds with a geometric mean time of about 1.35 seconds across 18 problems.[57] Comparisons show ECOS handling similar sizes but slower (e.g., 128 seconds mean time), while SCS trades speed for scalability on very large problems without timeouts.[57] SeDuMi and Gurobi perform reliably on NETLIB-derived SOCP sets, though Gurobi's parallelism accelerates mixed-integer variants in the 2020s releases.[58] Modern versions of these solvers, post-2015, handle extensions such as rotated quadratic cones in SeDuMi and ECOS, and exponential cones in MOSEK and SCS, enabling broader applications like power cone approximations.[59] In the 2020s, cloud-based options have emerged, such as the NEOS Server providing remote access to MOSEK and Gurobi for SOCP without local installation. Despite advances, dedicated SOCP solvers face scalability challenges for problems with millions of variables, often requiring decomposition techniques like ADMM in SCS to manage memory and computation without failure.[51]

Integration with Programming Languages

Second-order cone programming (SOCP) problems can be modeled and solved efficiently using high-level libraries in various programming languages, which abstract the underlying mathematical constraints into intuitive syntax. In Python, the CVXPY library provides a domain-specific language for convex optimization, allowing users to specify SOCP constraints via the cp.SOC function. For instance, a basic SOCP minimizing $ c^\top x $ subject to $ |z| \leq t $ can be formulated as follows: 
import cvxpy as cp
x = cp.Variable(n)
z = cp.Variable(m)
t = cp.Variable()
objective = cp.Minimize(c @ x)
constraints = [cp.SOC(t, z), A @ x == b]
prob = cp.Problem(objective, constraints)
prob.solve(solver=cp.MOSEK)  # or ECOS for open-source
CVXPY interfaces with solvers like MOSEK for high-performance solving and ECOS for lightweight, open-source options, enabling seamless integration into data science workflows. In MATLAB, the YALMIP toolbox offers flexible modeling for SOCP by defining second-order cone constraints using the soc or rot_cone functions, which link to backend solvers such as SeDuMi for interior-point methods. Alternatively, the CVX toolbox provides a concise syntax for SOCP specification, where constraints like $ |Ax + b|_2 \leq c^\top x + d $ are written as norm(A*x + b) <= c'*x + d, automatically dispatching to compatible solvers like SeDuMi or SDPT3. These tools facilitate rapid prototyping in engineering and scientific computing environments. Julia's optimization ecosystem supports SOCP through the Convex.jl package, which builds on JuMP for declarative modeling and natively handles cone constraints via SOCConstraint. This allows formulations like minimizing a linear objective subject to rotated quadratic cones, with solvers such as Mosek.jl or ECOS.jl invoked transparently. Convex.jl's integration with Julia's just-in-time compilation makes it suitable for large-scale problems in scientific simulations. For lower-level control, languages like C++ and Fortran access SOCP capabilities through the MOSEK Optimization API, which exposes functions for defining conic constraints directly in code, such as MSK_rescone for second-order cones. This is ideal for embedding SOCP in performance-critical applications like real-time systems. In R, the CVXR package provides a domain-specific language for convex optimization, supporting SOCP via interfaces to solvers like MOSEK and ECOS, though it is less feature-rich for complex cones compared to Python or Julia counterparts.[60] Best practices for SOCP modeling in these languages emphasize exploiting problem structure to avoid unnecessary reformulations, such as lifting SOCP to semidefinite programming (SDP) only when required, as SDP solvers may scale less favorably. Users should leverage dual information from solvers to debug infeasible problems—for example, examining dual multipliers to identify violating constraints—and prefer disciplined convex programming rules to ensure solver compatibility. As of 2025, a notable trend is the integration of auto-differentiation for differentiable SOCP in machine learning pipelines, particularly via extensions in PyTorch that enable end-to-end optimization of hyperparameters in robust control or portfolio models, with libraries like cvxpylayers providing differentiation through convex optimization solves including SOCP.[61] Accessibility varies by tool: open-source options like CVXPY with ECOS or YALMIP with SeDuMi support academic and small-scale research at no cost, while commercial solvers like MOSEK offer free academic licenses but require paid subscriptions for industrial deployment, handling problems up to millions of variables.

References

  1. [PDF] Second-order cone programming - Department of Statistics
  2. [PDF] Applications of second-Order cone programming '
  3. [PDF] SOCP and SDP 6.1 Recap 6.2 Second-order Cone Optimization
  4. https://doi.org/10.1007/s10107-002-0339-5
  5. [PDF] Second-order cone programming
  6. [PDF] 2. Convex sets
  7. [PDF] Convex Optimization
  8. (PDF) Second-Order Cone Programming - ResearchGate
  9. 8 Duality in conic optimization — MOSEK Modeling Cookbook 3.4.0
  10. A Polynomial Primal-Dual Path-Following Algorithm for Second ...
  11. https://www.seas.ucla.edu/~vandenbe/publications/socp.pdf
  12. [PDF] A polynomial-time interior-point method for conic optimization, with ...
  13. [PDF] Second Order Cone Programming Relaxation of Nonconvex ...
  14. [PDF] Solving Second-Order Cone Programs Deterministically in Matrix ...
  15. [PDF] Quantum algorithms for Second-Order Cone Programming and ...
  16. https://doi.org/10.1016/S0024-3795(98
  17. [PDF] 1 Linear Programming - Princeton University
  18. A class of semidefinite programs with rank-one solutions
  19. [PDF] SDP reformulation for robust optimization problems based on ...
  20. Primal-Dual Interior-Point Methods for Self-Scaled Cones - SIAM.org
  21. (PDF) Primal-dual Interior-point Algorithms for Second-order Cone ...
  22. On Implementing Mehrotra's Predictor–Corrector Interior-Point ...
  23. [PDF] Warm-start of interior point methods for second order cone ...
  24. (PDF) Warm-start of interior point methods for second order cone ...
  25. A decomposition-based warm-start method for stochastic programming
  26. [PDF] Active Set Method for Second-Order Conic-Constrained Quadratic ...
  27. [2307.07290] Projecting onto a Capped Rotated Second-Order Cone
  28. [PDF] Accelerated Methods for the SOCP-relaxed Component-based ...
  29. [PDF] An Enhanced ADMM-based Interior Point Method for Linear ... - arXiv
  30. Accelerated Methods for the SOCP-Relaxed Component-Based ...
  31. [PDF] Smooth minimization of non-smooth functions
  32. [PDF] Learning Acceleration Algorithms for Fast Parametric Convex ... - arXiv
  33. [PDF] Conic Optimization: Interior-Point Methods and Beyond
  34. [PDF] A Tractable Method for Robust Downlink Beamforming in Wireless ...
  35. (PDF) Second-order cone programming formulations for a class of ...
  36. [PDF] Localization in Wireless Sensor Networks Using Quadratic ... - arXiv
  37. Second-Order Cone Programming (SOCP) Techniques for ...
  38. [PDF] Chance constrained optimization
  39. Convex Approximations of Chance Constrained Programs
  40. Stochastic second-order cone programming: Applications models
  41. Applications of stochastic mixed-integer second-order cone ...
  42. Mixed-integer second-order cone programming for lower hedging of ...
  43. [PDF] Some Applications of Symmetric Cone Programming in Financial ...
  44. [PDF] WORST-CASE VALUE-AT-RISK AND ROBUST PORTFOLIO ...
  45. [PDF] PORTFOLIO OPTIMIZATION USING SECOND ORDER CONIC ...
  46. [PDF] Portfolio optimization with linear and fixed transaction costs
  47. Mixed-Integer Second-Order Cone Programming - PubsOnLine
  48. OPTI Toolbox Solvers/SeDuMi - Control Engineering
  49. ECOS: An SOCP Solver for Embedded Systems
  50. [PDF] ECOS: An SOCP Solver for Embedded Systems - Stanford University
  51. SCS 3.2.9 documentation
  52. SCS (Splitting Conic Solver) - Neal Parikh
  53. 5 Exponential cone optimization — MOSEK Modeling Cookbook 3.4.0
  54. Mosek ApS
  55. Gurobi Optimizer Delivers Support for All Major Problem Types
  56. Gurobi Optimizer
  57. http://plato.asu.edu/ftp/socp.html
  58. Use Benchmarks to Find the Best Solver for Your Needs - Gurobi
  59. [PDF] Exponential cone in MOSEK - Documentation
User Avatar
No comments yet.