Merge branch 'devel' into topic/msvc

Author: jcarpent

.github/workflows/release.yml

@@ -12,7 +12,7 @@ jobs:
     name: Build ${{ matrix.os }} ${{ matrix.python-version }}
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10"]
+        python-version: ["3.7", "3.8", "3.9", "3.10"]
         os: [ubuntu-latest, macos-latest]
 
     steps:
@@ -58,17 +58,17 @@ jobs:
         run: |
           pip wheel . -w dist
 
-      - name: Keep only proxsuite in dist
+      - name: Move proxsuite to specific dist folder
         shell: bash -l {0}
         run: |
-          rm dist/cmeel*.whl
-          rm dist/tomli*.whl
+          mkdir -p dist_proxsuite
+          mv dist/proxsuite*.whl dist_proxsuite
 
       - name: Archive artifacts
         uses: actions/upload-artifact@v3
         with:
           name: dist
-          path: dist
+          path: dist_proxsuite
 
   release:
     needs: "build-wheel"

.pre-commit-config.yaml

@@ -11,7 +11,7 @@ repos:
     hooks:
     -   id: trailing-whitespace
 -   repo: https://github.com/psf/black
-    rev: 22.6.0
+    rev: 22.8.0
     hooks:
     -   id: black
 -   repo: https://github.com/cheshirekow/cmake-format-precommit

README.md

@@ -14,6 +14,8 @@ Through **ProxSuite**, we aim at offering to the community scalable optimizers w
 
 **ProxSuite** is actively developped and supported by the [Willow](https://www.di.ens.fr/willow/) and [Sierra](https://www.di.ens.fr/sierra/) research groups, joint research teams between [Inria](https://www.inria.fr/en), [École Normale Supérieure de Paris](https://www.ens.fr) and [Centre National de la Recherche Scientifique](https://www.cnrs.fr).
 
+**ProxSuite** is integrated into the [cvxpy](https://www.cvxpy.org/) modeling language for convex optimization problems.
+
 ## Quick install
 
 **ProxSuite** is distributed on many well-known package managers.
@@ -36,6 +38,28 @@ This approach is available on Linux, Windows and Mac OS X.
 
 Alternative installation procedures are presented in the [Installation Procedure](#installation-procedure) section.
 
+## 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++ 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:

bindings/python/src/expose-settings.hpp

@@ -28,6 +28,9 @@ exposeSettings(pybind11::module_ m)
 
   ::pybind11::class_<Settings<T>>(m, "Settings", pybind11::module_local())
     .def(::pybind11::init(), "Default constructor.") // constructor
+    .def_readwrite("default_rho", &Settings<T>::default_rho)
+    .def_readwrite("default_mu_eq", &Settings<T>::default_mu_eq)
+    .def_readwrite("default_mu_in", &Settings<T>::default_mu_in)
     .def_readwrite("alpha_bcl", &Settings<T>::alpha_bcl)
     .def_readwrite("beta_bcl", &Settings<T>::beta_bcl)
     .def_readwrite("refactor_dual_feasibility_threshold",

cmake-module

@@ -302,6 +302,9 @@ In this table you have on the three columns from left to right: the name of the
 | eps_abs                             | 1.E-3                          | Asbolute stopping criterion of the solver.
 | eps_rel                             | 0                              | Relative stopping criterion of the solver.
 | VERBOSE                             | False                          | If set to true, the solver prints information at each loop.
+| default_rho                         | 1.E-6                          | Default rho parameter of result class (i.e., for each initial guess, except WARM_START_WITH_PREVIOUS_RESULT, after a new solve or update, the solver initializes rho to this value).
+| default_mu_eq                       | 1.E-3                          | Default mu_eq parameter of result class (i.e., for each initial guess, except WARM_START_WITH_PREVIOUS_RESULT, after a new solve or update, the solver initializes mu_eq to this value).
+| default_mu_in                       | 1.E-1                          | Default mu_in parameter of result class (i.e., for each initial guess, except WARM_START_WITH_PREVIOUS_RESULT, after a new solve or update, the solver initializes mu_in to this value).
 | compute_timings                     | True                           | If set to true, timings will be computed by the solver (setup time, solving time, and run time = setup time + solving time).
 | max_iter                            | 1.E4                           | Maximal number of authorized outer iterations.
 | max_iter_in                         | 1500                           | Maximal number of authorized inner iterations.
@@ -430,6 +433,25 @@ In this table you have on the three columns from left to right: the name of the
 | pri_res                             | 0                              | The primal residual.
 | dua_res                             | 0                              | The dual residual.
 
+
+Note finally that when initializing a QP object, by default the proximal step sizes (i.e., rho, mu_eq and mu_in) are set up by the default values defined in the Setting class. Hence, when doing multiple solves, if not specified, their values are re-set respectively to default_rho, default_mu_eq and default_mu_in. A small example is given below in c++ and python.
+
+<table class="manual">
+  <tr>
+    <th>examples/cpp/init_with_default_options.cpp</th>
+    <th>examples/python/init_with_default_options.py</th>
+  </tr>
+  <tr>
+    <td valign="top">
+      \include init_with_default_options.cpp
+    </td>
+    <td valign="top">
+      \include init_with_default_options.py
+    </td>
+  </tr>
+</table>
+
+
 \subsection OverviewSolverStatus The solver's status
 
 The solver has four status:

doc/2-PROXQP_API/2-ProxQP_api.md

@@ -1,5 +1,5 @@
 #include <proxsuite/proxqp/dense/dense.hpp> // load the dense solver backend
-#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex Qp
+#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex qp
 
 using namespace proxsuite::proxqp;
 using T = double;
@@ -13,9 +13,15 @@ main()
   // generate a random qp
   T sparsity_factor(0.15);
   T strong_convexity_factor(1.e-2);
-  dense::Model<T> qp = utils::dense_strongly_convex_qp(
+  dense::Model<T> qp_random = utils::dense_strongly_convex_qp(
     dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
 
-  dense::QP<T> Qp(dim, n_eq, n_in);                  // create the QP object
-  Qp.init(qp.H, qp.g, qp.A, qp.b, qp.C, qp.u, qp.l); // initialize the model
+  dense::QP<T> qp(dim, n_eq, n_in); // create the QP object
+  qp.init(qp_random.H,
+          qp_random.g,
+          qp_random.A,
+          qp_random.b,
+          qp_random.C,
+          qp_random.u,
+          qp_random.l); // initialize the model
 }

examples/cpp/init_dense_qp.cpp

@@ -1,5 +1,5 @@
 #include <proxsuite/proxqp/dense/dense.hpp> // load the dense solver backend
-#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex Qp
+#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex qp
 
 using namespace proxsuite::proxqp;
 using T = double;
@@ -12,13 +12,21 @@ main()
   // generate a random qp
   T sparsity_factor(0.15);
   T strong_convexity_factor(1.e-2);
-  dense::Model<T> qp = utils::dense_strongly_convex_qp(
+  dense::Model<T> qp_random = utils::dense_strongly_convex_qp(
     dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
 
-  dense::QP<T> Qp(
+  dense::QP<T> qp(
     dim, n_eq, n_in); // create the QP
                       // initialize the model, along with another rho parameter
-  Qp.init(qp.H, qp.g, qp.A, qp.b, qp.C, qp.u, qp.l, true, /*rho*/ 1.e-7);
+  qp.init(qp_random.H,
+          qp_random.g,
+          qp_random.A,
+          qp_random.b,
+          qp_random.C,
+          qp_random.u,
+          qp_random.l,
+          true,
+          /*rho*/ 1.e-7);
   // in c++ you must follow the order speficied in the API for the parameters
   // if you don't want to change one parameter (here compute_preconditioner),
   // just let it be std::nullopt

examples/cpp/init_dense_qp_with_other_options.cpp

@@ -1,5 +1,5 @@
 #include <proxsuite/proxqp/dense/dense.hpp> // load the dense solver backend
-#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex Qp
+#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex qp
 
 using namespace proxsuite::proxqp;
 using T = double;
@@ -12,10 +12,16 @@ main()
   // generate a random qp
   T sparsity_factor(0.15);
   T strong_convexity_factor(1.e-2);
-  dense::Model<T> qp = utils::dense_strongly_convex_qp(
+  dense::Model<T> qp_random = utils::dense_strongly_convex_qp(
     dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
 
-  dense::QP<T> Qp(dim, n_eq, n_in);                  // create the QP object
-  Qp.settings.compute_timings = true;                // compute all timings
-  Qp.init(qp.H, qp.g, qp.A, qp.b, qp.C, qp.u, qp.l); // initialize the model
+  dense::QP<T> qp(dim, n_eq, n_in);   // create the QP object
+  qp.settings.compute_timings = true; // compute all timings
+  qp.init(qp_random.H,
+          qp_random.g,
+          qp_random.A,
+          qp_random.b,
+          qp_random.C,
+          qp_random.u,
+          qp_random.l); // initialize the model
 }

examples/cpp/init_dense_qp_with_timings.cpp

@@ -0,0 +1,42 @@
+#include <proxsuite/proxqp/dense/dense.hpp> // load the dense solver backend
+#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex qp
+
+using namespace proxsuite::proxqp;
+using T = double;
+int
+main()
+{
+  isize dim = 10;
+  isize n_eq(dim / 4);
+  isize n_in(dim / 4);
+  // generate a random qp
+  T sparsity_factor(0.15);
+  T strong_convexity_factor(1.e-2);
+  dense::Model<T> qp_random = utils::dense_strongly_convex_qp(
+    dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
+
+  dense::QP<T> qp(
+    dim, n_eq, n_in); // create the QP
+                      // initialize the model, along with another rho parameter
+  qp.settings.initial_guess = InitialGuessStatus::NO_INITIAL_GUESS;
+  qp.init(qp_random.H,
+          qp_random.g,
+          qp_random.A,
+          qp_random.b,
+          qp_random.C,
+          qp_random.u,
+          qp_random.l,
+          true,
+          /*rho*/ 1.e-7,
+          /*mu_eq*/ 1.e-4);
+  // Initializing rho sets in practive qp.settings.default_rho value,
+  // hence, after each solve or update method, the qp.results.info.rho value
+  // will be reset to qp.settings.default_rho value.
+  qp.solve();
+  // So if we redo a solve, qp.settings.default_rho value = 1.e-7, hence
+  // qp.results.info.rho restarts at 1.e-7 The same occurs for mu_eq.
+  qp.solve();
+  // There might be a different result with WARM_START_WITH_PREVIOUS_RESULT
+  // initial guess option, as by construction, it reuses the last proximal step
+  // sizes of the last solving method.
+}