ProxSuite is a collection of open-source, numerically robuste, precise and efficient numerical solvers (e.g., LPs, QPs, etc.) rooted on revisited primal-dual proximal algorithms. While the first targeted application is Robotics, ProxSuite can be used in other contextes without any limits. Through ProxSuite, we aim at offering to the community scalable optimizers which can deal with dense, sparse or matrix-free problems.

ProxSuite is actively developped and supported by the Willow and Sierra research groups, joint research teams between Inria, École Normale Supérieure de Paris and Centre National de la Recherche Scientifique.

ProxSuite is integrated into:

• CVXPY modeling language for convex optimization problems
• CasADi's symbolic framework for numerical optimization in general and optimal control. ProxQP is available in CasADi as plugin to solve quadratic programs.

Getting started

ProxSuite is distributed on many well-known package managers.

Quick install with :

   pip install proxsuite

This approach is only available on Linux and Mac OS X.

Quick install with :

   conda install proxsuite -c conda-forge

This approach is available on Linux, Windows and Mac OS X.

Quick install with :

   brew install proxsuite

This approach is available on Linux and Mac OS X.

Alternative approaches

Installation from source is presented here.

Compiling a program

For the fastest performance use the following command to enable vectorization

g++ -O3 -march=native -DNDEBUG -std=gnu++17 -DPROXSUITE_VECTORIZE examples/benchmark_dense_qp.cpp -o benchmark_dense_qp $(pkg-config --cflags proxsuite)

ProxSuite main features

Proxsuite is fast:

• C++ template library,
• cache friendly.

Proxsuite is versatile, offering through a unified API advanced algorithms specialized for efficiently exploiting problem structures:

• dense, sparse and matrix free matrix factorization backends,
• advanced warm-starting options (e.g., equality-constrained initial guess, warm-start or cold-start options from previous results).

Proxsuite is flexible:

• header only,
• C++ 14/17/20 compliant,
• Python and Julia bindings for easy code prototyping without sacrificing performances.

Proxsuite is extensible. Proxsuite is reliable and extensively tested, showing the best performances on the hardest problems of the literature. Proxsuite is supported and tested on Windows, Mac OS X, Unix and Linux.

ProxQP

The ProxQP algorithm is a numerical optimization approach for solving quadratic programming problems of the form:

$$ \begin{align} \min_{x} & ~\frac{1}{2}x^{T}Hx+g^{T}x \\ \text{s.t.} & ~A x = b \\ & ~l \leq C x \leq u \end{align} $$

where $x \in \mathbb{R}^n$ is the optimization variable. The objective function is defined by a positive semidefinite matrix $H \in \mathcal{S}^n_+$ and a vector $g \in \mathbb{R}^n$. The linear constraints are defined by the equality-contraint matrix $A \in \mathbb{R}^{n_\text{eq} \times n}$ and the inequality-constraint matrix $C \in \mathbb{R}^{n_\text{in} \times n}$ and the vectors $b \in \mathbb{R}^{n_\text{eq}}$, $l \in \mathbb{R}^{n_\text{in}}$ and $u \in \mathbb{R}^{n_\text{in}}$ so that $b_i \in \mathbb{R},~ \forall i = 1,...,n_\text{eq}$ and $l_i \in \mathbb{R} \cup { -\infty }$ and $u_i \in \mathbb{R} \cup { +\infty }, ~\forall i = 1,...,n_\text{in}$.

Citing ProxQP

If you are using ProxQP for your work, we encourage you to cite the related paper.

Numerical benchmarks

The numerical benchmarks of ProxQP against other commercial and open-source solvers are available here.

For dense Convex Quadratic Programs with inequality and equality constraints, when asking for a relatively high accuracy (e.g., 1e-6), one obtains the following results.

On the y-axis you can see timings in seconds, and on the x-axis dimension wrt to the primal variable of the random Quadratic problems generated (the number of constraints of the generated problem is half the size of its primal dimension). For every dimension, the problem is generated over different seeds and timings are obtained as averages over successive runs for the same problems. This chart shows for every benchmarked solvers and random Quadratic programs generated, barplots timings including median (as a dot) and minimal and maximal values obtained (defining the amplitude of the bar). You can see that ProxQP is always below over solvers, which means it is the quickest for this test.

For hard problems from the Maros Meszaros testset, when asking for a high accuracy (e.g., 1e-9), one obtains the results below.

This chart above reports performance profiles of different solvers. It is classic for benchmarking solvers. Performance profiles correspond to the fraction of problems solved (on y-axis) as a function of certain runtime (on x-axis, measured in terms of a multiple of the runtime of the fastest solver for that problem). So the higher on the chart the better. You can see that ProxQP solves the quickest over 60% of the problems (i.e., for $\tau=1$), and that for solving about 90% of the problems, it is at most 2 times slower than the fastest solvers solving these problems (i.e., for $\tau\approx2$).

Note: All these results have been obtained with a 11th Gen Intel(R) Core(TM) i7-11850H @ 2.50GHz CPU.

Installation procedure

Please follow the installation procedure here.

Documentation

The online ProxSuite documentation of the last release is available here.