Merge pull request #26 from Bambade/devel

Add default proximal step sizes

Author: jcarpent

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",

doc/2-PROXQP_API/2-ProxQP_api.md

@@ -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:

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;
@@ -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_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,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_timings.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_with_default_options.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.
+}

examples/cpp/initializing_with_none.cpp

@@ -1,5 +1,5 @@
 #include "proxsuite/proxqp/dense/dense.hpp"
-#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;
@@ -9,27 +9,27 @@ main()
   dense::isize dim = 10;
   dense::isize n_eq(0);
   dense::isize n_in(0);
-  dense::QP<T> Qp(dim, n_eq, n_in);
+  dense::QP<T> qp(dim, n_eq, n_in);
   T strong_convexity_factor(0.1);
   T sparsity_factor(0.15);
   // we generate a qp, so the function used from helpers.hpp is
   // in proxqp namespace. The qp is in dense eigen format and
   // you can control its sparsity ratio and strong convexity factor.
-  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);
 
-  Qp.init(qp.H,
-          qp.g,
-          qp.A,
-          qp.b,
-          qp.C,
-          qp.u,
-          qp.l); // initialization with zero shape matrices
-  // it is equivalent to do Qp.init(qp.H, qp.g,
+  qp.init(qp_random.H,
+          qp_random.g,
+          qp_random.A,
+          qp_random.b,
+          qp_random.C,
+          qp_random.u,
+          qp_random.l); // initialization with zero shape matrices
+  // it is equivalent to do qp.init(qp_random.H, qp_random.g,
   // std::nullopt,std::nullopt,std::nullopt,std::nullopt,std::nullopt);
-  Qp.solve();
+  qp.solve();
   // print an optimal solution x,y and z
-  std::cout << "optimal x: " << Qp.results.x << std::endl;
-  std::cout << "optimal y: " << Qp.results.y << std::endl;
-  std::cout << "optimal z: " << Qp.results.z << std::endl;
+  std::cout << "optimal x: " << qp.results.x << std::endl;
+  std::cout << "optimal y: " << qp.results.y << std::endl;
+  std::cout << "optimal z: " << qp.results.z << std::endl;
 }

examples/cpp/initializing_with_none_without_api.cpp

@@ -1,5 +1,5 @@
 #include "proxsuite/proxqp/dense/dense.hpp"
-#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;
@@ -14,18 +14,18 @@ main()
   // we generate a qp, so the function used from helpers.hpp is
   // in proxqp namespace. The qp is in dense eigen format and
   // you can control its sparsity ratio and strong convexity factor.
-  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);
 
   Results<T> results =
-    dense::solve<T>(qp.H,
-                    qp.g,
-                    qp.A,
-                    qp.b,
-                    qp.C,
-                    qp.u,
-                    qp.l); // initialization with zero shape matrices
-  // it is equivalent to do dense::solve<T>(qp.H, qp.g,
+    dense::solve<T>(qp_random.H,
+                    qp_random.g,
+                    qp_random.A,
+                    qp_random.b,
+                    qp_random.C,
+                    qp_random.u,
+                    qp_random.l); // initialization with zero shape matrices
+  // it is equivalent to do dense::solve<T>(qp_random.H, qp_random.g,
   // std::nullopt,std::nullopt,std::nullopt,std::nullopt,std::nullopt);
   //  print an optimal solution x,y and z
   std::cout << "optimal x: " << results.x << std::endl;

examples/cpp/loading_dense_qp.cpp

@@ -8,5 +8,5 @@ main()
   dense::isize dim = 10;
   dense::isize n_eq(dim / 4);
   dense::isize n_in(dim / 4);
-  dense::QP<T> Qp(dim, n_eq, n_in);
+  dense::QP<T> qp(dim, n_eq, n_in);
 }

examples/cpp/loading_sparse_qp.cpp

@@ -1,18 +1,18 @@
 #include <iostream>
 #include <proxsuite/proxqp/sparse/sparse.hpp> // get the sparse API of ProxQP
-#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;
 
 int
 main()
 {
-  // design a Qp object using QP problem dimensions
+  // design a qp object using QP problem dimensions
   isize n = 10;
   isize n_eq(n / 4);
   isize n_in(n / 4);
-  sparse::QP<T, isize> Qp(n, n_eq, n_in);
+  sparse::QP<T, isize> qp(n, n_eq, n_in);
 
   // assume you generate these matrices H, A and C for your QP problem
 
@@ -24,7 +24,7 @@ main()
   auto A = ::proxsuite::proxqp::utils::rand::sparse_matrix_rand<T>(n_eq, n, p);
   auto C = ::proxsuite::proxqp::utils::rand::sparse_matrix_rand<T>(n_in, n, p);
 
-  // design a Qp2 object using sparsity masks of H, A and C
-  proxsuite::proxqp::sparse::QP<T, isize> Qp2(
+  // design a qp2 object using sparsity masks of H, A and C
+  proxsuite::proxqp::sparse::QP<T, isize> qp2(
     H.cast<bool>(), A.cast<bool>(), C.cast<bool>());
 }