Python Wrapper for Embedded Conic Solver (ECOS)

Warnings

• breaking Starting with version 2.0.8, the `ecos-python` wrapper officially dropped support for Python 2.7. Users on older Python versions must upgrade to Python 3 or use an older `ecos` version.
  Fix: Upgrade your Python environment to Python 3.x.
• gotcha The 2.0.7 release had issues with version syncing, leading to its removal and re-upload as a post-release (e.g., `2.0.7.post1`). Strict dependency pinning to `2.0.7` might fail.
  Fix: If pinning, use `ecos>=2.0.7` or explicitly `ecos==2.0.7.post1`. It's generally safer to use the latest stable release.
• gotcha Installing `ecos` from source on Windows can be challenging due to compiler requirements, especially for older Python versions. The official documentation suggests using Miniconda to minimize pain.
  Fix: Prefer `pip install ecos` to use pre-built wheels. If building from source on Windows, use Miniconda or ensure you have the correct Visual Studio compiler matching your Python version.
• gotcha The `CVXPY` library, which often uses ECOS as a solver, changed its default solver from ECOS to Clarabel in version 1.5 and plans to remove ECOS as a default dependency in 1.6. Users relying on ECOS via CVXPY should be aware.
  Fix: When using `CVXPY`, explicitly specify `solver=cvxpy.ECOS` in `prob.solve()`. Ensure `ecos` is installed in your environment if it's no longer a default dependency of `CVXPY`.
• gotcha The `ecos.solve` function expects sparse matrices `G` and `A` to be in `scipy.sparse.csr_matrix` format. While it attempts to convert other formats, providing them in CSR format is more efficient and avoids potential conversion overhead or unexpected behavior.
  Fix: Ensure that your `G` and `A` sparse matrices are created as `scipy.sparse.csr_matrix` instances (e.g., `from scipy import sparse; G = sparse.csr_matrix(...)`).

Install

• pip install ecos Install with pip

Imports

• ecos

  import ecos

Quickstart

This example demonstrates how to solve a basic Linear Program (a special case of SOCP) using `ecos.solve`. It minimizes `x[0] + x[1]` subject to non-negativity and a lower bound constraint.

import numpy as np
from scipy import sparse
import ecos

# Define a simple Linear Program (LP) as an SOCP
# Minimize: x[0] + x[1]
# Subject to: x[0] >= 0, x[1] >= 0, x[0] + x[1] >= 1

# Objective vector c: Minimize x[0] + x[1]
c = np.array([1., 1.])

# Inequality constraints Gx <= h (linear cone part)
# -x[0] <= 0
# -x[1] <= 0
# -x[0] - x[1] <= -1  (equivalent to x[0] + x[1] >= 1)
G = sparse.csr_matrix([
    [-1., 0.],
    [0., -1.],
    [-1., -1.]
])
h = np.array([0., 0., -1.])

# Dimensions of the cones
dims = {
    'l': 3,  # Number of linear inequality constraints
    'q': [], # List of second-order cone dimensions
    'e': 0   # Number of exponential cone constraints
}

# Solve the problem
solution = ecos.solve(c, G, h, dims)

# Print the optimal solution
print(f"Optimal x: {solution['x']}")
print(f"Optimal value: {solution['info']['pcost']}")