Quadratic Programming Solvers

4.11.0 · active · verified Mon Apr 13

qpsolvers is a Python library that provides a unified API to various quadratic programming (QP) solvers. It simplifies the process of solving convex QPs by abstracting away solver-specific APIs and matrix format requirements. Currently at version 4.11.0, the library maintains an active development pace with frequent minor releases to integrate new solvers and provide updates for existing ones.

Warnings

breaking The `solver` keyword argument became mandatory for `solve_qp` and `solve_ls` functions in v2.0.
Fix: Always provide the `solver` keyword argument when calling `solve_qp` or `solve_ls` (e.g., `solve_qp(..., solver="osqp")`).
breaking The minimum required Python version was bumped to 3.10.
Fix: Ensure your Python environment is version 3.10 or newer.
breaking The Gurobi interface was updated to a newer Gurobi API.
Fix: If using Gurobi through `qpsolvers`, ensure your Gurobi installation is compatible with the latest `qpsolvers` API. Review Gurobi-specific code for potential incompatibilities.
breaking The PIQP interface was updated to support the new PIQP v0.6.0 API.
Fix: If using PIQP, update your PIQP installation to v0.6.0 or newer to ensure compatibility with `qpsolvers` v4.8.0 and later.
gotcha Starting from v4.3.0, `pip install qpsolvers` no longer installs any default QP solvers alongside the library. Solvers must be installed separately.
Fix: Install `qpsolvers` with optional solver dependencies using extras, e.g., `pip install qpsolvers[open_source_solvers]` or `pip install qpsolvers[osqp]`.
gotcha The cost matrix `P` in a QP problem should always be symmetric. Many solvers assume this property and may return incorrect results if it's not. Some solvers also require `P` to be positive definite.
Fix: Explicitly symmetrize your cost matrix `P` (e.g., `P = 0.5 * (P + P.T)`). Check the documentation for your chosen solver regarding its requirements for `P` (positive (semi-)definite).
gotcha OSQP solver may issue deprecation warnings related to solver status or matrix conversion, particularly with certain versions of OSQP.
Fix: These warnings were partially addressed in `qpsolvers` v4.8.2. Ensure you are on the latest `qpsolvers` version and consider updating your OSQP installation to a version known to be compatible to mitigate these warnings.

Install

pip install qpsolvers Base library only (no solvers)
pip install qpsolvers[open_source_solvers] Library with common open-source solvers
pip install qpsolvers[clarabel,osqp,proxqp] Library with specific open-source solvers

Imports

solve_qp
```
from qpsolvers import solve_qp
```
solve_problem
```
from qpsolvers import solve_problem
```
available_solvers
```
from qpsolvers import available_solvers
```

Quickstart

This example demonstrates how to define a quadratic programming problem using NumPy arrays and solve it with an available backend solver. It automatically selects 'proxqp' if available, otherwise it tries the first available solver, or prompts the user to install one if no solvers are found. The problem is formulated in the standard quadratic program form.

import numpy as np
from qpsolvers import solve_qp, available_solvers

# Define the QP problem in standard form: minimize 0.5 * x.T * P * x + q.T * x 
# subject to G * x <= h, A * x == b, lb <= x <= ub

M = np.array([[1., 2., 0.], [-8., 3., 2.], [0., 1., 1.]])
P = M.T @ M  # This results in a positive definite matrix
q = np.array([3., 2., 3.]) @ M

G = np.array([[1., 2., 1.], [2., 0., 1.], [-1., 2., -1.]])
h = np.array([3., 2., -2.])

A = np.array([1., 1., 1.])
b = np.array([1.])

# Try to use a common open-source solver, or fallback if not available
solver_to_use = "proxqp" if "proxqp" in available_solvers else available_solvers[0] if available_solvers else None

if solver_to_use:
    print(f"Using solver: {solver_to_use}")
    x = solve_qp(P, q, G, h, A, b, solver=solver_to_use)
    print(f"QP solution: {x = }")
else:
    print("No QP solvers found. Please install one, e.g., pip install qpsolvers[proxqp]")

view raw JSON →