topic/osqp: Add the OSQP solver in ProxSuite

examples/cpp/osqp_initializing_with_none.cpp

@@ -0,0 +1,41 @@
+#include <iostream>
+#include "proxsuite/osqp/dense/dense.hpp"
+#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex qp
+
+using namespace proxsuite::proxqp;
+using T = double;
+namespace pod = proxsuite::osqp::dense;
+
+int
+main()
+{
+  dense::isize dim = 10;
+  dense::isize n_eq(0);
+  dense::isize n_in(0);
+  pod::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_random = utils::dense_strongly_convex_qp(
+    dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
+
+  qp.settings.default_mu_eq = T(1.E-2);
+  qp.settings.default_mu_in = T(1.E1);
+
+  qp.init(qp_random.H,
+          qp_random.g,
+          qp_random.A,
+          qp_random.b,
+          qp_random.C,
+          qp_random.l,
+          qp_random.u); // initialization with zero shape matrices
+  // it is equivalent to do qp.init(qp_random.H, qp_random.g,
+  // nullopt,nullopt,nullopt,nullopt,nullopt);
+  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;
+}

examples/cpp/osqp_initializing_with_none_without_api.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+#include "proxsuite/helpers/optional.hpp"
+#include "proxsuite/osqp/dense/dense.hpp"
+#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex qp
+
+using namespace proxsuite;
+using T = double;
+
+namespace pp = proxsuite::proxqp;
+namespace ppd = proxsuite::proxqp::dense;
+namespace pod = proxsuite::osqp::dense;
+
+int
+main()
+{
+  ppd::isize dim = 10;
+  ppd::isize n_eq(0);
+  ppd::isize n_in(0);
+  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.
+  ppd::Model<T> qp_random = pp::utils::dense_strongly_convex_qp(
+    dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
+
+  T eps_abs(1.E-5);
+  T eps_rel(0);
+  pp::Results<T> results = pod::solve<T>(qp_random.H,
+                                         qp_random.g,
+                                         qp_random.A,
+                                         qp_random.b,
+                                         qp_random.C,
+                                         qp_random.l,
+                                         qp_random.u,
+                                         nullopt,
+                                         nullopt,
+                                         nullopt,
+                                         eps_abs,
+                                         eps_rel,
+                                         nullopt,
+                                         T(1.E-2),
+                                         T(1.E-1));
+
+  // initialization with zero shape matrices
+  // it is equivalent to do dense::solve<T>(qp_random.H, qp_random.g,
+  // nullopt,nullopt,nullopt,nullopt,nullopt);
+  //  print an optimal solution x,y and z
+  std::cout << "optimal x: " << results.x << std::endl;
+  std::cout << "optimal y: " << results.y << std::endl;
+  std::cout << "optimal z: " << results.z << std::endl;
+}

examples/cpp/osqp_overview-simple.cpp

@@ -0,0 +1,47 @@
+#include <iostream>
+#include <proxsuite/osqp/dense/dense.hpp>
+#include <proxsuite/proxqp/dense/dense.hpp>
+#include <proxsuite/proxqp/utils/random_qp_problems.hpp> // used for generating a random convex qp
+
+#include <Eigen/Core>
+
+using namespace proxsuite::osqp;
+using T = double;
+
+namespace pp = proxsuite::proxqp;
+namespace ppd = proxsuite::proxqp::dense;
+namespace pod = proxsuite::osqp::dense;
+
+int
+main()
+{
+  T sparsity_factor = 0.15;
+  ppd::isize dim = 10;
+  ppd::isize n_eq(dim / 4);
+  ppd::isize n_in(dim / 4);
+  T strong_convexity_factor(1.e-2);
+
+  ppd::Model<T> qp_random = pp::utils::dense_strongly_convex_qp(
+    dim, n_eq, n_in, sparsity_factor, strong_convexity_factor);
+
+  pod::QP<T> qp(dim, n_eq, n_in);
+
+  qp.settings.default_mu_eq = T(1.E-2);
+  qp.settings.default_mu_in = T(1.E1);
+
+  qp.settings.update_mu = true;
+  qp.settings.polish = true;
+
+  qp.init(qp_random.H,
+          qp_random.g,
+          qp_random.A,
+          qp_random.b,
+          qp_random.C,
+          qp_random.l,
+          qp_random.u);
+  qp.solve();
+
+  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;
+}

include/proxsuite/linalg/dense/ldlt.hpp

@@ -11,6 +11,9 @@
 #include "proxsuite/linalg/dense/solve.hpp"
 #include <proxsuite/linalg/veg/vec.hpp>
 
+#include "proxsuite/proxqp/timings.hpp"
+#include <iostream>
+
 namespace proxsuite {
 namespace linalg {
 namespace dense {
@@ -718,29 +721,54 @@ struct Ldlt
   void factorize(Eigen::Ref<ColMat const> mat /* NOLINT */,
                  proxsuite::linalg::veg::dynstack::DynStackMut stack)
   {
+    // proxsuite::proxqp::Timer<double> timer;
+
     VEG_ASSERT(mat.rows() == mat.cols());
     isize n = mat.rows();
+    // timer.stop();
+    // timer.start();
     reserve_uninit(n);
+    // timer.stop();
+    // std::cout << "Time of reserve_unit: " << timer.elapsed().user <<
+    // std::endl; // Diff
 
+    // timer.start();
     perm.resize_for_overwrite(n);
     perm_inv.resize_for_overwrite(n);
     maybe_sorted_diag.resize_for_overwrite(n);
+    // timer.stop();
+    // std::cout << "Time of resize_for_overwrite: " << timer.elapsed().user <<
+    // std::endl; // Diff
 
+    // timer.start();
     proxsuite::linalg::dense::_detail::compute_permutation( //
       perm.ptr_mut(),
       perm_inv.ptr_mut(),
       util::diagonal(mat));
+    // timer.stop();
+    // std::cout << "Time of compute_permutation: " << timer.elapsed().user <<
+    // std::endl; // Diff
 
+    // timer.start();
     {
       LDLT_TEMP_MAT_UNINIT(T, work, n, n, stack);
       ld_col_mut() = mat;
       proxsuite::linalg::dense::_detail::apply_permutation_tri_lower(
         ld_col_mut(), work, perm.ptr());
     }
+    // timer.stop();
+    // std::cout << "Time of apply_permutation_tri_lower: " <<
+    // timer.elapsed().user << std::endl; // Same timer.start();
     for (isize i = 0; i < n; ++i) {
       maybe_sorted_diag[i] = ld_col()(i, i);
     }
+    // timer.stop();
+    // std::cout << "Time of ld_col: " << timer.elapsed().user << std::endl;
+    // timer.start();
     proxsuite::linalg::dense::factorize(ld_col_mut(), stack);
+    // timer.stop();
+    // std::cout << "Time of proxsuite::lialg::dense::factorize: " <<
+    // timer.elapsed().user << std::endl; // Diff
   }
 
   /*!

include/proxsuite/osqp/dense/dense.hpp

@@ -0,0 +1,13 @@
+//
+// Copyright (c) 2025 INRIA
+//
+/**
+ * @file dense.hpp
+ */
+
+#ifndef PROXSUITE_OSQP_DENSE_DENSE_HPP
+#define PROXSUITE_OSQP_DENSE_DENSE_HPP
+
+#include "proxsuite/osqp/dense/wrapper.hpp"
+
+#endif /* end of include guard PROXSUITE_OSQP_DENSE_DENSE_HPP */