add settings as input of cleanup results method + rename Qp as qp in tests and examples

Author: Bambade

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,9 @@ 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,13 @@ 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,10 @@ 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

@@ -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,30 +12,30 @@ 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.settings.initial_guess = InitialGuessStatus::NO_INITIAL_GUESS;
-  Qp.init(qp.H,
-          qp.g,
-          qp.A,
-          qp.b,
-          qp.C,
-          qp.u,
-          qp.l,
+  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();
+  // 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>());
 }

examples/cpp/overview-simple.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;
@@ -16,15 +16,15 @@ 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);
 
   // load PROXQP solver with dense backend and solve the problem
-  dense::QP<T> Qp(dim, n_eq, n_in);
-  Qp.init(qp.H, qp.g, qp.A, qp.b, qp.C, qp.u, qp.l);
-  Qp.solve();
+  dense::QP<T> qp(dim, n_eq, n_in);
+  qp.init(qp_random.H, qp_random.g, qp_random.A, qp_random.b, qp_random.C, qp_random.u, qp_random.l);
+  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/solve_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;
@@ -14,19 +14,19 @@ main()
   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
-  Qp.solve(); // solve the problem without warm start
+  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
+  qp.solve(); // solve the problem without warm start
   auto x_wm = utils::rand::vector_rand<T>(dim);
   auto y_wm = utils::rand::vector_rand<T>(n_eq);
   auto z_wm = utils::rand::vector_rand<T>(n_in);
-  Qp.solve(x_wm, y_wm,
+  qp.solve(x_wm, y_wm,
            z_wm); // if you have a warm start, put it here
   // 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/solve_dense_qp_with_setting.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,16 +13,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.init(qp.H, qp.g, qp.A, qp.b, qp.C, qp.u, qp.l); // initialize the model
-  Qp.settings.eps_abs = T(1.E-9); // set accuracy threshold to 1.e-9
-  Qp.settings.verbose = true;     // print some intermediary results
-  Qp.solve();                     // solve the problem with previous settings
+  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
+  qp.settings.eps_abs = T(1.E-9); // set accuracy threshold to 1.e-9
+  qp.settings.verbose = true;     // print some intermediary results
+  qp.solve();                     // solve the problem with previous settings
   // 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/solve_without_api.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include "proxsuite/proxqp/sparse/sparse.hpp" // get the sparse backend of ProxQP
 #include "proxsuite/proxqp/dense/dense.hpp"   // get the dense backend 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;

examples/cpp/solve_without_api_and_option.cpp

@@ -1,7 +1,7 @@
 #include <iostream>
 #include <proxsuite/proxqp/sparse/sparse.hpp> // get the sparse backend of ProxQP
 #include <proxsuite/proxqp/dense/dense.hpp>   // get the dense backend 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;

examples/cpp/update_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,21 +13,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(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
-  Qp.solve();                                        // solve the problem
-                                                     // a new Qp problem
+  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
+  qp.solve();                                        // solve the problem
+                                                     // a new qp problem
   dense::Model<T> qp2 = utils::dense_strongly_convex_qp(
     dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
   // re update the model
-  Qp.update(qp2.H, qp2.g, qp2.A, qp2.b, qp2.C, qp2.u, qp2.l);
+  qp.update(qp2.H, qp2.g, qp2.A, qp2.b, qp2.C, qp2.u, qp2.l);
   // solve it
-  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;
 }