remove sparse overload for dense backend

Author: Bambade

bindings/python/src/expose-qpobject.hpp

@@ -71,39 +71,6 @@ exposeQpObjectDense(pybind11::module_ m)
         "mu_eq", std::nullopt, "dual equality constraint proximal parameter"),
       pybind11::arg_v(
         "mu_in", std::nullopt, "dual inequality constraint proximal parameter"))
-
-    .def(
-      "init",
-      static_cast<void (dense::QP<T>::*)(std::optional<dense::SparseMat<T>>,
-                                         std::optional<dense::VecRef<T>>,
-                                         std::optional<dense::SparseMat<T>>,
-                                         std::optional<dense::VecRef<T>>,
-                                         std::optional<dense::SparseMat<T>>,
-                                         std::optional<dense::VecRef<T>>,
-                                         std::optional<dense::VecRef<T>>,
-                                         bool compute_preconditioner,
-                                         std::optional<T>,
-                                         std::optional<T>,
-                                         std::optional<T>)>(
-        &dense::QP<T>::init),
-      "function for initialize the QP model.",
-      pybind11::arg_v("H", std::nullopt, "quadratic cost"),
-      pybind11::arg_v("g", std::nullopt, "linear cost"),
-      pybind11::arg_v("A", std::nullopt, "equality constraint matrix"),
-      pybind11::arg_v("b", std::nullopt, "equality constraint vector"),
-      pybind11::arg_v("C", std::nullopt, "inequality constraint matrix"),
-      pybind11::arg_v("u", std::nullopt, "upper inequality constraint vector"),
-      pybind11::arg_v("l", std::nullopt, "lower inequality constraint vector"),
-      pybind11::arg_v("compute_preconditioner",
-                      true,
-                      "execute the preconditioner for reducing "
-                      "ill-conditioning and speeding up solver execution."),
-      pybind11::arg_v("rho", std::nullopt, "primal proximal parameter"),
-      pybind11::arg_v(
-        "mu_eq", std::nullopt, "dual equality constraint proximal parameter"),
-      pybind11::arg_v(
-        "mu_in", std::nullopt, "dual inequality constraint proximal parameter"))
-
     .def("solve",
          static_cast<void (dense::QP<T>::*)()>(&dense::QP<T>::solve),
          "function used for solving the QP problem, using default parameters.")
@@ -148,40 +115,6 @@ exposeQpObjectDense(pybind11::module_ m)
         "mu_eq", std::nullopt, "dual equality constraint proximal parameter"),
       pybind11::arg_v(
         "mu_in", std::nullopt, "dual inequality constraint proximal parameter"))
-    .def(
-      "update",
-      static_cast<void (dense::QP<T>::*)(
-        const std::optional<dense::SparseMat<T>>,
-        std::optional<dense::Vec<T>>,
-        const std::optional<dense::SparseMat<T>>,
-        std::optional<dense::Vec<T>>,
-        const std::optional<dense::SparseMat<T>>,
-        std::optional<dense::Vec<T>>,
-        std::optional<dense::Vec<T>>,
-        bool update_preconditioner,
-        std::optional<T>,
-        std::optional<T>,
-        std::optional<T>)>(&dense::QP<T>::update),
-      "function used for updating matrix or vector entry of the model using "
-      "sparse matrix entries.",
-      pybind11::arg_v("H", std::nullopt, "quadratic cost"),
-      pybind11::arg_v("g", std::nullopt, "linear cost"),
-      pybind11::arg_v("A", std::nullopt, "equality constraint matrix"),
-      pybind11::arg_v("b", std::nullopt, "equality constraint vector"),
-      pybind11::arg_v("C", std::nullopt, "inequality constraint matrix"),
-      pybind11::arg_v("u", std::nullopt, "upper inequality constraint vector"),
-      pybind11::arg_v("l", std::nullopt, "lower inequality constraint vector"),
-      pybind11::arg_v(
-        "update_preconditioner",
-        true,
-        "update the preconditioner considering new matrices entries for "
-        "reducing ill-conditioning and speeding up solver execution. If set up "
-        "to false, use previous derived preconditioner."),
-      pybind11::arg_v("rho", std::nullopt, "primal proximal parameter"),
-      pybind11::arg_v(
-        "mu_eq", std::nullopt, "dual equality constraint proximal parameter"),
-      pybind11::arg_v(
-        "mu_in", std::nullopt, "dual inequality constraint proximal parameter"))
     .def("cleanup",
          &dense::QP<T>::cleanup,
          "function used for cleaning the workspace and result "

bindings/python/src/expose-solve.hpp

@@ -84,72 +84,6 @@ solveDenseQp(pybind11::module_ m)
       "initial_guess",
       proxsuite::proxqp::InitialGuessStatus::EQUALITY_CONSTRAINED_INITIAL_GUESS,
       "maximum number of iteration."));
-  m.def(
-    "solve",
-    pybind11::overload_cast<std::optional<dense::SparseMat<T>>,
-                            std::optional<dense::VecRef<T>>,
-                            std::optional<dense::SparseMat<T>>,
-                            std::optional<dense::VecRef<T>>,
-                            std::optional<dense::SparseMat<T>>,
-                            std::optional<dense::VecRef<T>>,
-                            std::optional<dense::VecRef<T>>,
-                            std::optional<VecRef<T>>,
-                            std::optional<VecRef<T>>,
-                            std::optional<VecRef<T>>,
-                            std::optional<T>,
-                            std::optional<T>,
-                            std::optional<T>,
-                            std::optional<T>,
-                            std::optional<T>,
-                            std::optional<bool>,
-                            bool,
-                            bool,
-                            std::optional<isize>,
-                            proxsuite::proxqp::InitialGuessStatus>(
-      &dense::solve<T>),
-    "Function for solving a QP problem using PROXQP dense backend directly "
-    "without defining a QP object. It is possible to set up some of the solver "
-    "parameters (warm start, initial guess option, proximal step sizes, "
-    "absolute and relative accuracies, maximum number of iterations, "
-    "preconditioner execution).",
-    pybind11::arg_v("H", std::nullopt, "quadratic cost with dense format."),
-    pybind11::arg_v("g", std::nullopt, "linear cost"),
-    pybind11::arg_v(
-      "A", std::nullopt, "equality constraint matrix with dense format."),
-    pybind11::arg_v("b", std::nullopt, "equality constraint vector"),
-    pybind11::arg_v(
-      "C", std::nullopt, "inequality constraint matrix with dense format."),
-    pybind11::arg_v("u", std::nullopt, "upper inequality constraint vector"),
-    pybind11::arg_v("l", std::nullopt, "lower inequality constraint vector"),
-    pybind11::arg_v("x", std::nullopt, "primal warm start"),
-    pybind11::arg_v("y", std::nullopt, "dual equality warm start"),
-    pybind11::arg_v("z", std::nullopt, "dual inequality warm start"),
-    pybind11::arg_v(
-      "eps_abs",
-      std::nullopt,
-      "absolute accuracy level used for the solver stopping criterion."),
-    pybind11::arg_v("eps_rel",
-                    std::nullopt,
-                    "relative accuracy level used for the solver stopping "
-                    "criterion. Deactivated in standard settings."),
-    pybind11::arg_v("rho", std::nullopt, "primal proximal parameter"),
-    pybind11::arg_v(
-      "mu_eq", std::nullopt, "dual equality constraint proximal parameter"),
-    pybind11::arg_v(
-      "mu_in", std::nullopt, "dual inequality constraint proximal parameter"),
-    pybind11::arg_v("verbose",
-                    std::nullopt,
-                    "verbose option to print information at each iteration."),
-    pybind11::arg_v("compute_preconditioner",
-                    true,
-                    "executes the default preconditioner for reducing ill "
-                    "conditioning and speeding up the solver."),
-    pybind11::arg_v("compute_timings", true, "compute solver's timings."),
-    pybind11::arg_v("max_iter", std::nullopt, "maximum number of iteration."),
-    pybind11::arg_v(
-      "initial_guess",
-      proxsuite::proxqp::InitialGuessStatus::EQUALITY_CONSTRAINED_INITIAL_GUESS,
-      "maximum number of iteration."));
 }
 
 } // namespace python

doc/2-PROXQP_API/2-ProxQP_api.md

@@ -139,7 +139,7 @@ Once you have defined a Qp object, the init method enables you setting up the QP
   </tr>
 </table>
 
-Note that with its dense backend, ProxQP solver can manipulate both matrices in dense and sparse representations (in the example above the matrices are in sparse format). Note that if some elements of your QP model are not defined (for example a QP without linear cost or inequality constraints), you can either pass a None argument, or a matrix with zero shape for specifying it. We provide an example below in cpp and python (for the dense case, it is similar with sparse backend).
+Note that with its dense backend, ProxQP solver manipulates matrices in dense representations (in the same spirit, the solver with sparse backend manipulates entries in sparse format). In the example above the matrices are originally in sparse format, and eventually converted into dense format. Note that if some elements of your QP model are not defined (for example a QP without linear cost or inequality constraints), you can either pass a None argument, or a matrix with zero shape for specifying it. We provide an example below in cpp and python (for the dense case, it is similar with sparse backend).
 
 <table class="manual">
   <tr>

doc/3-ProxQP_solve.md

@@ -65,9 +65,9 @@ $$\begin{equation}\label{eq:approx_qp_sol_relative_criterion}
 
 \section OverviewAsingleSolveFunction A single solve function for dense and sparse backends
 
-If if you don't want to pass through [ProxQP API](2-ProxQP_api.md), it is also possible to use one single solve function. We will show how to do so with examples.
+If if you don't want to pass through [ProxQP API](2-ProxQP_api.md), it is also possible to use one single solve function. We will show how to do so with examples. 
 
-You just need to call a "solve" function with in entry the model of the convex QP you want to solve. We show you below examples in C++ and python for ProxQP sparse and dense backends.
+You just need to call a "solve" function with in entry the model of the convex QP you want to solve. We show you below examples in C++ and python for ProxQP sparse and dense backends. Note that the sparse and dense solvers take respectivaly entries in sparse and dense formats.
 
 <table class="manual">
   <tr>

examples/cpp/solve_without_api.cpp

@@ -32,7 +32,7 @@ main()
   std::cout << "optimal z from sparse solver: " << results_sparse_solver.z
             << std::endl;
   // Solve the problem using the dense backend
-  Results<T> results_dense_solver = dense::solve<T>(H, g, A, b, C, u, l);
+  Results<T> results_dense_solver = dense::solve<T>(dense::Mat<T>(H), g,dense::Mat<T>(A), b,dense::Mat<T>(C), u, l);
   // print an optimal solution x,y and z
   std::cout << "optimal x from dense solver: " << results_dense_solver.x
             << std::endl;

examples/cpp/solve_without_api_and_option.cpp

@@ -13,28 +13,32 @@ main()
   isize n_eq(n / 4);
   isize n_in(n / 4);
 
-  T p = 0.15;            // level of sparsity
-  T conditioning = 10.0; // conditioning level for H
-  auto H = ::proxsuite::proxqp::utils::rand::sparse_positive_definite_rand(
-    n, conditioning, p);
-  auto g = ::proxsuite::proxqp::utils::rand::vector_rand<T>(n);
-  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);
-  auto x_sol = ::proxsuite::proxqp::utils::rand::vector_rand<T>(n);
-  auto b = A * x_sol;
-  auto l = C * x_sol;
-  auto u = (l.array() + 10).matrix().eval();
+  //T p = 0.15;            // level of sparsity
+  //T conditioning = 10.0; // conditioning level for H
+  //auto H = ::proxsuite::proxqp::utils::rand::sparse_positive_definite_rand(
+  //  n, conditioning, p);
+  //auto g = ::proxsuite::proxqp::utils::rand::vector_rand<T>(n);
+  //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);
+  //auto x_sol = ::proxsuite::proxqp::utils::rand::vector_rand<T>(n);
+  //auto b = A * x_sol;
+  //auto l = C * x_sol;
+  //auto u = (l.array() + 10).matrix().eval();
+  T sparsity_factor(0.15);
+  T strong_convexity_factor(1.e-2);
+  dense::Model<T> qp_random = utils::dense_strongly_convex_qp(
+    n, n_eq, n_in, sparsity_factor, strong_convexity_factor);
   // Solve the problem using the dense backend
   // and suppose you want to change the accuracy to 1.E-9 and rho initial value
   // to 1.E-7
   proxsuite::proxqp::Results<T> results =
-    proxsuite::proxqp::dense::solve<T>(H,
-                                       g,
-                                       A,
-                                       b,
-                                       C,
-                                       u,
-                                       l,
+    proxsuite::proxqp::dense::solve<T>(qp_random.H,
+                                       qp_random.g,
+                                       qp_random.A,
+                                       qp_random.b,
+                                       qp_random.C,
+                                       qp_random.u,
+                                       qp_random.l,
                                        std::nullopt,
                                        std::nullopt,
                                        std::nullopt,

examples/python/init_dense_qp.py

@@ -20,13 +20,13 @@ def generate_mixed_qp(n, seed=1):
     P += (abs(s) + 1e-02) * spa.eye(n)
     P = spa.coo_matrix(P)
     q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc")
+    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
     v = np.random.randn(n)  # Fictitious solution
     delta = np.random.rand(m)  # To get inequality
     u = A @ v
     l = -1.0e20 * np.ones(m)
 
-    return P, q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
 
 
 # load a qp object using qp problem dimensions

examples/python/init_dense_qp_with_other_options.py

@@ -20,13 +20,13 @@ def generate_mixed_qp(n, seed=1):
     P += (abs(s) + 1e-02) * spa.eye(n)
     P = spa.coo_matrix(P)
     q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc")
+    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
     v = np.random.randn(n)  # Fictitious solution
     delta = np.random.rand(m)  # To get inequality
     u = A @ v
     l = -1.0e20 * np.ones(m)
 
-    return P, q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
 
 
 # load a qp object using qp problem dimensions

examples/python/init_dense_qp_with_timings.py

@@ -20,13 +20,13 @@ def generate_mixed_qp(n, seed=1):
     P += (abs(s) + 1e-02) * spa.eye(n)
     P = spa.coo_matrix(P)
     q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc")
+    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
     v = np.random.randn(n)  # Fictitious solution
     delta = np.random.rand(m)  # To get inequality
     u = A @ v
     l = -1.0e20 * np.ones(m)
 
-    return P, q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
 
 
 # load a qp object using qp problem dimensions

examples/python/init_with_default_options.py

@@ -20,13 +20,13 @@ def generate_mixed_qp(n, seed=1):
     P += (abs(s) + 1e-02) * spa.eye(n)
     P = spa.coo_matrix(P)
     q = np.random.randn(n)
-    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc")
+    A = spa.random(m, n, density=0.15, data_rvs=np.random.randn, format="csc").toarray()
     v = np.random.randn(n)  # Fictitious solution
     delta = np.random.rand(m)  # To get inequality
     u = A @ v
     l = -1.0e20 * np.ones(m)
 
-    return P, q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
+    return P.toarray(), q, A[:n_eq, :], u[:n_eq], A[n_in:, :], u[n_in:], l[n_in:]
 
 
 # load a qp object using qp problem dimensions