OSQP: The Operator Splitting QP Solver

Warnings

• breaking Migration from v0.6.x to v1.0 introduced significant API changes, including modified `osqp_setup` function signature, new update functions (`osqp_update_data_vec`, `osqp_update_data_mat` replacing old vector/matrix updates), and renamed settings (e.g., `polish` to `polishing`, `warm_start` to `warm_starting`).
  Fix: Consult the official 'Migration guide from v0.6.x' for a complete list of changes and updated API calls. Update `setup`, `update` method calls, and setting parameters accordingly.
• gotcha Installing optional algebra backends (e.g., `osqp[mkl]` or `osqp[cu12]`) only installs the Python binding; it does NOT automatically install the underlying MKL or CUDA runtime libraries. These libraries must be installed separately and made available to your Python environment for the backends to function.
  Fix: Ensure MKL or CUDA runtime libraries are correctly installed and configured on your system or within your Python environment (e.g., via `conda install cudatoolkit` or manual installation and `LD_LIBRARY_PATH` setup).
• gotcha OSQP is designed for convex Quadratic Programs. While the solver includes heuristics to detect non-convexity, it might fail to reliably identify non-convex problems, especially those with slightly negative eigenvalues of P. Providing non-convex problems can lead to unexpected or incorrect results.
  Fix: Always verify that your problem formulation results in a convex QP before passing it to OSQP. Consider adding regularization if the convexity is borderline or uncertain.
• gotcha When updating problem matrices `P` or `A` using `m.update()`, only the *values* of existing nonzero entries can be changed. Their sparsity pattern (i.e., which entries are zero and non-zero) cannot be modified without a full problem re-setup.
  Fix: If the sparsity pattern of `P` or `A` needs to change, a new `osqp.OSQP()` object must be created and `m.setup()` called again with the new matrices.
• gotcha By default, the `problem.solve()` method in v1.x has `raise_error=False`. This means if the solver does not reach an optimal solution (e.g., due to reaching max iterations or being primal/dual infeasible), it will return a result object without raising an exception, potentially hiding issues.
  Fix: Set `raise_error=True` in `m.solve(raise_error=True)` to explicitly raise an exception if the solver status is not `OSQP_SOLVED`. Alternatively, always check `res.info.status` to inspect the solver's outcome.

Install

• pip install osqp Install OSQP

Imports

• osqp

  import osqp

• numpy

  import numpy as np

• sparse

  from scipy import sparse

Quickstart

This quickstart demonstrates how to define and solve a simple Quadratic Program using OSQP. It initializes problem matrices (P, A as sparse CSC matrices) and vectors (q, l, u as NumPy arrays), sets up the solver, and then solves the problem, printing the solution status and optimal variable `x`.

import osqp
import numpy as np
from scipy import sparse

# Define problem data
P = sparse.csc_matrix([[4, 1], [1, 2]])
q = np.array([1, 1])
A = sparse.csc_matrix([[1, 1], [1, 0], [0, 1]])
l = np.array([1, 0, 0])
u = np.array([1, 0.7, 0.7])

# Create an OSQP object
m = osqp.OSQP()

# Setup workspace
m.setup(P=P, q=q, A=A, l=l, u=u, verbose=False)

# Solve problem
res = m.solve()

# Print results
print(f"Problem status: {res.info.status}")
print(f"Optimal x: {res.x}")