casadi 3.7.2__cp314-none-manylinux2014_x86_64.whl

casadi/include/proxsuite/proxqp/sparse/workspace.hpp

@@ -0,0 +1,790 @@
+//
+// Copyright (c) 2022 INRIA
+//
+/** \file */
+
+#ifndef PROXSUITE_PROXQP_SPARSE_WORKSPACE_HPP
+#define PROXSUITE_PROXQP_SPARSE_WORKSPACE_HPP
+
+#include <proxsuite/linalg/dense/core.hpp>
+#include <proxsuite/linalg/sparse/core.hpp>
+#include <proxsuite/linalg/sparse/factorize.hpp>
+#include <proxsuite/linalg/sparse/update.hpp>
+#include <proxsuite/linalg/sparse/rowmod.hpp>
+#include <proxsuite/proxqp/timings.hpp>
+#include <proxsuite/proxqp/settings.hpp>
+#include <proxsuite/proxqp/dense/views.hpp>
+#include <proxsuite/linalg/veg/vec.hpp>
+#include "proxsuite/proxqp/sparse/views.hpp"
+#include "proxsuite/proxqp/sparse/model.hpp"
+#include "proxsuite/proxqp/results.hpp"
+#include "proxsuite/proxqp/sparse/utils.hpp"
+
+#include <memory>
+#include <Eigen/IterativeLinearSolvers>
+#include <unsupported/Eigen/IterativeSolvers>
+
+namespace proxsuite {
+namespace proxqp {
+namespace sparse {
+
+template<typename T, typename I>
+void
+refactorize(Workspace<T, I>& work,
+            Results<T> const& results,
+            proxsuite::linalg::sparse::MatMut<T, I> kkt_active,
+            proxsuite::linalg::veg::SliceMut<bool> active_constraints,
+            Model<T, I> const& data,
+            proxsuite::linalg::veg::dynstack::DynStackMut stack,
+            proxsuite::linalg::veg::Tag<T>& xtag)
+{
+  isize n_tot = kkt_active.nrows();
+  T mu_eq_neg = -results.info.mu_eq;
+  T mu_in_neg = -results.info.mu_in;
+
+  if (work.internal.do_ldlt) {
+    proxsuite::linalg::sparse::factorize_symbolic_non_zeros(
+      work.internal.ldl.nnz_counts.ptr_mut(),
+      work.internal.ldl.etree.ptr_mut(),
+      work.internal.ldl.perm_inv.ptr_mut(),
+      work.internal.ldl.perm.ptr_mut(),
+      kkt_active.symbolic(),
+      stack);
+
+    isize nnz = 0;
+    VEG_ONLY_USED_FOR_DEBUG(nnz);
+    for (usize j = 0; j < usize(kkt_active.ncols()); ++j) {
+      nnz += usize(kkt_active.col_end(j) - kkt_active.col_start(j));
+    }
+    VEG_ASSERT(kkt_active.nnz() == nnz);
+    auto _diag = stack.make_new_for_overwrite(xtag, n_tot);
+    T* diag = _diag.ptr_mut();
+
+    for (isize i = 0; i < data.dim; ++i) {
+      diag[i] = results.info.rho;
+    }
+    for (isize i = 0; i < data.n_eq; ++i) {
+      diag[data.dim + i] = mu_eq_neg;
+    }
+    for (isize i = 0; i < data.n_in; ++i) {
+      diag[(data.dim + data.n_eq) + i] =
+        active_constraints[i] ? mu_in_neg : T(1);
+    }
+
+    proxsuite::linalg::sparse::factorize_numeric(
+      work.internal.ldl.values.ptr_mut(),
+      work.internal.ldl.row_indices.ptr_mut(),
+      diag,
+      work.internal.ldl.perm.ptr_mut(),
+      work.internal.ldl.col_ptrs.ptr(),
+      work.internal.ldl.etree.ptr_mut(),
+      work.internal.ldl.perm_inv.ptr_mut(),
+      kkt_active.as_const(),
+      stack);
+  } else {
+    *work.internal.matrix_free_kkt = { { kkt_active.as_const(),
+                                         active_constraints.as_const(),
+                                         data.dim,
+                                         data.n_eq,
+                                         data.n_in,
+                                         results.info.rho,
+                                         results.info.mu_eq_inv,
+                                         results.info.mu_in_inv } };
+    (*work.internal.matrix_free_solver).compute(*work.internal.matrix_free_kkt);
+  }
+}
+
+template<typename T, typename I>
+struct Ldlt
+{
+  proxsuite::linalg::veg::Vec<I> etree;
+  proxsuite::linalg::veg::Vec<I> perm;
+  proxsuite::linalg::veg::Vec<I> perm_inv;
+  proxsuite::linalg::veg::Vec<I> col_ptrs;
+  proxsuite::linalg::veg::Vec<I> nnz_counts;
+  proxsuite::linalg::veg::Vec<I> row_indices;
+  proxsuite::linalg::veg::Vec<T> values;
+};
+
+template<typename T, typename I>
+struct Workspace
+{
+
+  struct /* NOLINT */
+  {
+    // temporary allocations
+    proxsuite::linalg::veg::Vec<proxsuite::linalg::veg::mem::byte>
+      storage; // memory of the stack with the requirements req which determines
+               // its size.
+    Ldlt<T, I> ldl;
+    bool do_ldlt;
+    bool do_symbolic_fact;
+    // persistent allocations
+
+    Eigen::Matrix<T, Eigen::Dynamic, 1> g_scaled;
+    Eigen::Matrix<T, Eigen::Dynamic, 1> b_scaled;
+    Eigen::Matrix<T, Eigen::Dynamic, 1> l_scaled;
+    Eigen::Matrix<T, Eigen::Dynamic, 1> u_scaled;
+    proxsuite::linalg::veg::Vec<I> kkt_nnz_counts;
+
+    // stored in unique_ptr because we need a stable address
+    std::unique_ptr<detail::AugmentedKkt<T, I>>
+      matrix_free_kkt; // view on active part of the KKT which includes the
+                       // regularizations
+    std::unique_ptr<Eigen::MINRES<detail::AugmentedKkt<T, I>,
+                                  Eigen::Upper | Eigen::Lower,
+                                  Eigen::IdentityPreconditioner>>
+      matrix_free_solver; // eigen based method which takes in entry vector, and
+                          // performs matrix vector products
+
+    auto stack_mut() -> proxsuite::linalg::veg::dynstack::DynStackMut
+    {
+      return {
+        proxsuite::linalg::veg::from_slice_mut,
+        storage.as_mut(),
+      };
+    } // exploits all available memory in storage
+
+    // Whether the workspace is dirty
+    bool dirty;
+    bool proximal_parameter_update;
+    bool is_initialized;
+
+  } internal;
+  VecBool active_set_up;
+  VecBool active_set_low;
+  proxsuite::linalg::veg::Vec<bool> active_inequalities;
+  isize lnnz;
+  /*!
+   * Constructor using the symbolic factorization.
+   * @param results solver's results.
+   * @param data solver's model.
+   * @param settings solver's settings.
+   * @param precond_req storage requirements for the solver's preconditioner.
+   * @param H symbolic structure of the quadratic cost input defining the QP
+   * model.
+   * @param A symbolic structure of the equality constraint matrix input
+   * defining the QP model.
+   * @param C symbolic structure of the inequality constraint matrix input
+   * defining the QP model.
+   */
+  void setup_symbolic_factorizaton(
+    Model<T, I>& data,
+    proxsuite::linalg::sparse::SymbolicMatRef<I> H,
+    proxsuite::linalg::sparse::SymbolicMatRef<I> AT,
+    proxsuite::linalg::sparse::SymbolicMatRef<I> CT)
+  {
+    auto& ldl = internal.ldl;
+
+    auto& storage = internal.storage;
+    auto& do_ldlt = internal.do_ldlt;
+    // persistent allocations
+
+    data.dim = H.nrows();
+    data.n_eq = AT.ncols();
+    data.n_in = CT.ncols();
+    data.H_nnz = H.nnz();
+    data.A_nnz = AT.nnz();
+    data.C_nnz = CT.nnz();
+
+    using namespace proxsuite::linalg::veg::dynstack;
+    using namespace proxsuite::linalg::sparse::util;
+    proxsuite::linalg::veg::Tag<I> itag;
+
+    isize n = H.nrows();
+    isize n_eq = AT.ncols();
+    isize n_in = CT.ncols();
+    isize n_tot = n + n_eq + n_in;
+
+    isize nnz_tot = H.nnz() + AT.nnz() + CT.nnz();
+
+    // form the full kkt matrix
+    // assuming H, AT, CT are sorted
+    // and H is upper triangular
+    {
+      data.kkt_col_ptrs.resize_for_overwrite(n_tot + 1); //
+      data.kkt_row_indices.resize_for_overwrite(nnz_tot);
+      data.kkt_values.resize_for_overwrite(nnz_tot);
+
+      I* kktp = data.kkt_col_ptrs.ptr_mut();
+      I* kkti = data.kkt_row_indices.ptr_mut();
+
+      kktp[0] = 0;
+      usize col = 0;
+      usize pos = 0;
+
+      auto insert_submatrix =
+        [&](proxsuite::linalg::sparse::SymbolicMatRef<I> m,
+            bool assert_sym_hi) -> void {
+        I const* mi = m.row_indices();
+        isize ncols = m.ncols();
+
+        for (usize j = 0; j < usize(ncols); ++j) {
+          usize col_start = m.col_start(j);
+          usize col_end = m.col_end(j);
+
+          kktp[col + 1] =
+            checked_non_negative_plus(kktp[col], I(col_end - col_start));
+          ++col;
+
+          for (usize p = col_start; p < col_end; ++p) {
+            usize i = zero_extend(mi[p]);
+            if (assert_sym_hi) {
+              VEG_ASSERT(i <= j);
+            }
+
+            kkti[pos] = proxsuite::linalg::veg::nb::narrow<I>{}(i);
+
+            ++pos;
+          }
+        }
+      };
+
+      insert_submatrix(H, true);
+      insert_submatrix(AT, false);
+      insert_submatrix(CT, false);
+    }
+
+    data.kkt_col_ptrs_unscaled = data.kkt_col_ptrs;
+    data.kkt_row_indices_unscaled = data.kkt_row_indices;
+
+    storage.resize_for_overwrite( //
+      (StackReq::with_len(itag, n_tot) &
+       proxsuite::linalg::sparse::factorize_symbolic_req( //
+         itag,                                            //
+         n_tot,                                           //
+         nnz_tot,                                         //
+         proxsuite::linalg::sparse::Ordering::amd))       //
+        .alloc_req()                                      //
+    );
+
+    ldl.col_ptrs.resize_for_overwrite(n_tot + 1);
+    ldl.perm_inv.resize_for_overwrite(n_tot);
+
+    DynStackMut stack = stack_mut();
+
+    bool overflow = false;
+    {
+      ldl.etree.resize_for_overwrite(n_tot);
+      auto etree_ptr = ldl.etree.ptr_mut();
+
+      using namespace proxsuite::linalg::veg::literals;
+      auto kkt_sym = proxsuite::linalg::sparse::SymbolicMatRef<I>{
+        proxsuite::linalg::sparse::from_raw_parts,
+        n_tot,
+        n_tot,
+        nnz_tot,
+        data.kkt_col_ptrs.ptr(),
+        nullptr,
+        data.kkt_row_indices.ptr(),
+      };
+      proxsuite::linalg::sparse::factorize_symbolic_non_zeros( //
+        ldl.col_ptrs.ptr_mut() +
+          1, // reimplements col counts to get the matrix free version as well
+        etree_ptr,
+        ldl.perm_inv.ptr_mut(),
+        static_cast<I const*>(nullptr),
+        kkt_sym,
+        stack);
+
+      auto pcol_ptrs = ldl.col_ptrs.ptr_mut();
+      pcol_ptrs[0] = I(0);
+
+      using proxsuite::linalg::veg::u64;
+      u64 acc = 0;
+
+      for (usize i = 0; i < usize(n_tot); ++i) {
+        acc += u64(zero_extend(pcol_ptrs[i + 1]));
+        if (acc != u64(I(acc))) {
+          overflow = true;
+        }
+        pcol_ptrs[(i + 1)] = I(acc);
+      }
+    }
+
+    lnnz = isize(zero_extend(ldl.col_ptrs[n_tot]));
+
+    // if ldlt is too sparse
+    // do_ldlt = !overflow && lnnz < (10000000);
+    do_ldlt = !overflow && lnnz < 10000000;
+
+    internal.do_symbolic_fact = false;
+  }
+  /*!
+   * Constructor.
+   * @param qp view on the qp problem.
+   * @param data solver's model.
+   * @param settings solver's settings.
+   * @param execute_or_not boolean option for execturing or not the
+   * preconditioner for scaling the problem (and reduce its ill conditioning).
+   * @param precond preconditioner chosen for the solver.
+   * @param precond_req storage requirements for the solver's preconditioner.
+   */
+  template<typename P>
+  void setup_impl(const QpView<T, I> qp,
+                  Model<T, I>& data,
+                  const Settings<T>& settings,
+                  bool execute_or_not,
+                  P& precond,
+                  proxsuite::linalg::veg::dynstack::StackReq precond_req)
+  {
+
+    auto& ldl = internal.ldl;
+
+    auto& storage = internal.storage;
+    auto& do_ldlt = internal.do_ldlt;
+    // persistent allocations
+
+    auto& g_scaled = internal.g_scaled;
+    auto& b_scaled = internal.b_scaled;
+    auto& l_scaled = internal.l_scaled;
+    auto& u_scaled = internal.u_scaled;
+    auto& kkt_nnz_counts = internal.kkt_nnz_counts;
+
+    // stored in unique_ptr because we need a stable address
+    auto& matrix_free_solver = internal.matrix_free_solver;
+    auto& matrix_free_kkt = internal.matrix_free_kkt;
+
+    data.dim = qp.H.nrows();
+    data.n_eq = qp.AT.ncols();
+    data.n_in = qp.CT.ncols();
+    data.H_nnz = qp.H.nnz();
+    data.A_nnz = qp.AT.nnz();
+    data.C_nnz = qp.CT.nnz();
+
+    data.g = qp.g.to_eigen();
+    data.b = qp.b.to_eigen();
+    data.l = qp.l.to_eigen();
+    data.u = qp.u.to_eigen();
+
+    using namespace proxsuite::linalg::veg::dynstack;
+    using namespace proxsuite::linalg::sparse::util;
+
+    using SR = StackReq;
+    proxsuite::linalg::veg::Tag<I> itag;
+    proxsuite::linalg::veg::Tag<T> xtag;
+
+    isize n = qp.H.nrows();
+    isize n_eq = qp.AT.ncols();
+    isize n_in = qp.CT.ncols();
+    isize n_tot = n + n_eq + n_in;
+
+    isize nnz_tot = qp.H.nnz() + qp.AT.nnz() + qp.CT.nnz();
+
+    if (internal.do_symbolic_fact) {
+
+      // form the full kkt matrix
+      // assuming H, AT, CT are sorted
+      // and H is upper triangular
+      {
+        data.kkt_col_ptrs.resize_for_overwrite(n_tot + 1);
+        data.kkt_row_indices.resize_for_overwrite(nnz_tot);
+        data.kkt_values.resize_for_overwrite(nnz_tot);
+
+        I* kktp = data.kkt_col_ptrs.ptr_mut();
+        I* kkti = data.kkt_row_indices.ptr_mut();
+        T* kktx = data.kkt_values.ptr_mut();
+
+        kktp[0] = 0;
+        usize col = 0;
+        usize pos = 0;
+
+        auto insert_submatrix = [&](proxsuite::linalg::sparse::MatRef<T, I> m,
+                                    bool assert_sym_hi) -> void {
+          I const* mi = m.row_indices();
+          T const* mx = m.values();
+          isize ncols = m.ncols();
+
+          for (usize j = 0; j < usize(ncols); ++j) {
+            usize col_start = m.col_start(j);
+            usize col_end = m.col_end(j);
+
+            kktp[col + 1] =
+              checked_non_negative_plus(kktp[col], I(col_end - col_start));
+            ++col;
+
+            for (usize p = col_start; p < col_end; ++p) {
+              usize i = zero_extend(mi[p]);
+              if (assert_sym_hi) {
+                VEG_ASSERT(i <= j);
+              }
+
+              kkti[pos] = proxsuite::linalg::veg::nb::narrow<I>{}(i);
+              kktx[pos] = mx[p];
+
+              ++pos;
+            }
+          }
+        };
+
+        insert_submatrix(qp.H, true);
+        insert_submatrix(qp.AT, false);
+        insert_submatrix(qp.CT, false);
+      }
+
+      data.kkt_col_ptrs_unscaled = data.kkt_col_ptrs;
+      data.kkt_row_indices_unscaled = data.kkt_row_indices;
+      data.kkt_values_unscaled = data.kkt_values;
+
+      storage.resize_for_overwrite( //
+        (StackReq::with_len(itag, n_tot) &
+         proxsuite::linalg::sparse::factorize_symbolic_req( //
+           itag,                                            //
+           n_tot,                                           //
+           nnz_tot,                                         //
+           proxsuite::linalg::sparse::Ordering::amd))       //
+          .alloc_req()                                      //
+      );
+
+      ldl.col_ptrs.resize_for_overwrite(n_tot + 1);
+      ldl.perm_inv.resize_for_overwrite(n_tot);
+
+      DynStackMut stack = stack_mut();
+
+      bool overflow = false;
+      {
+        ldl.etree.resize_for_overwrite(n_tot);
+        auto etree_ptr = ldl.etree.ptr_mut();
+
+        using namespace proxsuite::linalg::veg::literals;
+        auto kkt_sym = proxsuite::linalg::sparse::SymbolicMatRef<I>{
+          proxsuite::linalg::sparse::from_raw_parts,
+          n_tot,
+          n_tot,
+          nnz_tot,
+          data.kkt_col_ptrs.ptr(),
+          nullptr,
+          data.kkt_row_indices.ptr(),
+        };
+        proxsuite::linalg::sparse::factorize_symbolic_non_zeros( //
+          ldl.col_ptrs.ptr_mut() + 1,
+          etree_ptr,
+          ldl.perm_inv.ptr_mut(),
+          static_cast<I const*>(nullptr),
+          kkt_sym,
+          stack);
+
+        auto pcol_ptrs = ldl.col_ptrs.ptr_mut();
+        pcol_ptrs[0] = I(0); // pcol_ptrs +1: pointor towards the nbr of non
+                             // zero elts per column of the ldlt
+        // we need to compute its cumulative sum below to determine if there
+        // could be an overflow
+
+        using proxsuite::linalg::veg::u64;
+        u64 acc = 0;
+
+        for (usize i = 0; i < usize(n_tot); ++i) {
+          acc += u64(zero_extend(pcol_ptrs[i + 1]));
+          if (acc != u64(I(acc))) {
+            overflow = true;
+          }
+          pcol_ptrs[(i + 1)] = I(acc);
+        }
+      }
+
+      auto lnnz = isize(zero_extend(ldl.col_ptrs[n_tot]));
+
+      // if ldlt is too sparse
+      // do_ldlt = !overflow && lnnz < (10000000);
+      if (settings.sparse_backend == SparseBackend::Automatic) {
+        do_ldlt = !overflow && lnnz < 10000000;
+      } else if (settings.sparse_backend == SparseBackend::SparseCholesky) {
+        do_ldlt = true;
+      } else {
+        do_ldlt = false;
+      }
+
+    } else {
+      T* kktx = data.kkt_values.ptr_mut();
+      usize pos = 0;
+      auto insert_submatrix =
+        [&](proxsuite::linalg::sparse::MatRef<T, I> m) -> void {
+        T const* mx = m.values();
+        isize ncols = m.ncols();
+
+        for (usize j = 0; j < usize(ncols); ++j) {
+          usize col_start = m.col_start(j);
+          usize col_end = m.col_end(j);
+          for (usize p = col_start; p < col_end; ++p) {
+
+            kktx[pos] = mx[p];
+
+            ++pos;
+          }
+        }
+      };
+
+      insert_submatrix(qp.H);
+      insert_submatrix(qp.AT);
+      insert_submatrix(qp.CT);
+      data.kkt_values_unscaled = data.kkt_values;
+    }
+#define PROX_QP_ALL_OF(...)                                                    \
+  ::proxsuite::linalg::veg::dynstack::StackReq::and_(                          \
+    ::proxsuite::linalg::veg::init_list(__VA_ARGS__))
+#define PROX_QP_ANY_OF(...)                                                    \
+  ::proxsuite::linalg::veg::dynstack::StackReq::or_(                           \
+    ::proxsuite::linalg::veg::init_list(__VA_ARGS__))
+    //  ? --> if
+    auto refactorize_req =
+      do_ldlt
+        ? PROX_QP_ANY_OF({
+            proxsuite::linalg::sparse::factorize_symbolic_req( // symbolic ldl
+              itag,
+              n_tot,
+              nnz_tot,
+              proxsuite::linalg::sparse::Ordering::user_provided),
+            PROX_QP_ALL_OF({
+              SR::with_len(xtag, n_tot),                        // diag
+              proxsuite::linalg::sparse::factorize_numeric_req( // numeric ldl
+                xtag,
+                itag,
+                n_tot,
+                nnz_tot,
+                proxsuite::linalg::sparse::Ordering::user_provided),
+            }),
+          })
+        : PROX_QP_ALL_OF({
+            SR::with_len(itag, 0), // compute necessary space for storing n elts
+                                   // of type I (n = 0 here)
+            SR::with_len(xtag, 0), // compute necessary space for storing n elts
+                                   // of type T (n = 0 here)
+          });
+
+    auto x_vec = [&](isize n) noexcept -> StackReq {
+      return proxsuite::linalg::dense::temp_vec_req(xtag, n);
+    };
+
+    auto ldl_solve_in_place_req = PROX_QP_ALL_OF({
+      x_vec(n_tot), // tmp
+      x_vec(n_tot), // err
+      x_vec(n_tot), // work
+    });
+
+    auto unscaled_primal_dual_residual_req = x_vec(n); // Hx
+    auto line_search_req = PROX_QP_ALL_OF({
+      x_vec(2 * n_in), // alphas
+      x_vec(n),        // Cdx_active
+      x_vec(n_in),     // active_part_z
+      x_vec(n_in),     // tmp_lo
+      x_vec(n_in),     // tmp_up
+    });
+    // define memory needed for primal_dual_newton_semi_smooth
+    // PROX_QP_ALL_OF --> need to store all argument inside
+    // PROX_QP_ANY_OF --> au moins un de  ceux en entrée
+    auto primal_dual_newton_semi_smooth_req = PROX_QP_ALL_OF({
+      x_vec(n_tot), // dw
+      PROX_QP_ANY_OF({
+        ldl_solve_in_place_req,
+        PROX_QP_ALL_OF({
+          SR::with_len(proxsuite::linalg::veg::Tag<bool>{},
+                       n_in), // active_set_lo
+          SR::with_len(proxsuite::linalg::veg::Tag<bool>{},
+                       n_in), // active_set_up
+          SR::with_len(proxsuite::linalg::veg::Tag<bool>{},
+                       n_in), // new_active_constraints
+          (do_ldlt && n_in > 0) ? PROX_QP_ANY_OF({
+                                    proxsuite::linalg::sparse::add_row_req(
+                                      xtag, itag, n_tot, false, n, n_tot),
+                                    proxsuite::linalg::sparse::delete_row_req(
+                                      xtag, itag, n_tot, n_tot),
+                                  })
+                                : refactorize_req,
+        }),
+        PROX_QP_ALL_OF({
+          x_vec(n),    // Hdx
+          x_vec(n_eq), // Adx
+          x_vec(n_in), // Cdx
+          x_vec(n),    // ATdy
+          x_vec(n),    // CTdz
+        }),
+      }),
+      line_search_req,
+    });
+
+    auto iter_req = PROX_QP_ANY_OF({
+      PROX_QP_ALL_OF({ x_vec(n_eq), // primal_residual_eq_scaled
+                       x_vec(n_in), // primal_residual_in_scaled_lo
+                       x_vec(n_in), // primal_residual_in_scaled_up
+                       x_vec(n_in), // primal_residual_in_scaled_up
+                       x_vec(n),    // dual_residual_scaled
+                       PROX_QP_ANY_OF({
+                         unscaled_primal_dual_residual_req,
+                         PROX_QP_ALL_OF({
+                           x_vec(n),    // x_prev
+                           x_vec(n_eq), // y_prev
+                           x_vec(n_in), // z_prev
+                           primal_dual_newton_semi_smooth_req,
+                         }),
+                       }) }),
+      refactorize_req, // mu_update
+    });
+
+    auto req = //
+      PROX_QP_ALL_OF({
+        x_vec(n),    // g_scaled
+        x_vec(n_eq), // b_scaled
+        x_vec(n_in), // l_scaled
+        x_vec(n_in), // u_scaled
+        SR::with_len(proxsuite::linalg::veg::Tag<bool>{},
+                     n_in),        // active constr
+        SR::with_len(itag, n_tot), // kkt nnz counts
+        refactorize_req,
+        PROX_QP_ANY_OF({
+          precond_req,
+          PROX_QP_ALL_OF({
+            do_ldlt ? PROX_QP_ALL_OF({
+                        SR::with_len(itag, n_tot), // perm
+                        SR::with_len(itag, n_tot), // etree
+                        SR::with_len(itag, n_tot), // ldl nnz counts
+                        SR::with_len(itag, lnnz),  // ldl row indices
+                        SR::with_len(xtag, lnnz),  // ldl values
+                      })
+                    : PROX_QP_ALL_OF({
+                        SR::with_len(itag, 0),
+                        SR::with_len(xtag, 0),
+                      }),
+            iter_req,
+          }),
+        }),
+      });
+
+    storage.resize_for_overwrite(
+      req.alloc_req()); // defines the maximal storage size
+    // storage.resize(n): if it is done twice in a row, the second times it does
+    // nothing, as the same resize has been asked
+
+    // preconditioner
+    auto kkt = data.kkt_mut();
+    auto kkt_top_n_rows = detail::top_rows_mut_unchecked(
+      proxsuite::linalg::veg::unsafe,
+      kkt,
+      n); //  top_rows_mut_unchecked: take a view of sparse matrix for n first
+          //  lines ; the function assumes all others lines are zeros;
+    /*
+            H AT CT
+            A
+            C
+
+            here we store the upper triangular part below
+
+            tirSup(H) AT CT
+            0 0 0
+            0 0 0
+
+            proxsuite::linalg::veg::unsafe:  precises that the function has
+       undefined behavior if upper condition is not respected.
+    */
+
+    proxsuite::linalg::sparse::MatMut<T, I> H_scaled =
+      detail::middle_cols_mut(kkt_top_n_rows, 0, n, data.H_nnz);
+
+    proxsuite::linalg::sparse::MatMut<T, I> AT_scaled =
+      detail::middle_cols_mut(kkt_top_n_rows, n, n_eq, data.A_nnz);
+
+    proxsuite::linalg::sparse::MatMut<T, I> CT_scaled =
+      detail::middle_cols_mut(kkt_top_n_rows, n + n_eq, n_in, data.C_nnz);
+
+    g_scaled = data.g;
+    b_scaled = data.b;
+    u_scaled =
+      (data.u.array() <= T(1.E20))
+        .select(data.u,
+                Eigen::Matrix<T, Eigen::Dynamic, 1>::Zero(data.n_in).array() +
+                  T(1.E20));
+    l_scaled =
+      (data.l.array() >= T(-1.E20))
+        .select(data.l,
+                Eigen::Matrix<T, Eigen::Dynamic, 1>::Zero(data.n_in).array() -
+                  T(1.E20));
+
+    QpViewMut<T, I> qp_scaled = {
+      H_scaled,
+      { proxsuite::linalg::sparse::from_eigen, g_scaled },
+      AT_scaled,
+      { proxsuite::linalg::sparse::from_eigen, b_scaled },
+      CT_scaled,
+      { proxsuite::linalg::sparse::from_eigen, l_scaled },
+      { proxsuite::linalg::sparse::from_eigen, u_scaled },
+    };
+
+    DynStackMut stack = stack_mut();
+    precond.scale_qp_in_place(qp_scaled,
+                              execute_or_not,
+                              settings.preconditioner_max_iter,
+                              settings.preconditioner_accuracy,
+                              stack);
+    kkt_nnz_counts.resize_for_overwrite(n_tot);
+
+    proxsuite::linalg::sparse::MatMut<T, I> kkt_active = {
+      proxsuite::linalg::sparse::from_raw_parts,
+      n_tot,
+      n_tot,
+      data.H_nnz +
+        data.A_nnz, // these variables are not used for the matrix vector
+                    // product in augmented KKT with Min res algorithm (to be
+                    // exact, it should depend of the initial guess)
+      kkt.col_ptrs_mut(),
+      kkt_nnz_counts.ptr_mut(),
+      kkt.row_indices_mut(),
+      kkt.values_mut(),
+    };
+
+    using MatrixFreeSolver = Eigen::MINRES<detail::AugmentedKkt<T, I>,
+                                           Eigen::Upper | Eigen::Lower,
+                                           Eigen::IdentityPreconditioner>;
+    matrix_free_solver = std::unique_ptr<MatrixFreeSolver>{
+      new MatrixFreeSolver,
+    };
+    matrix_free_kkt = std::unique_ptr<detail::AugmentedKkt<T, I>>{
+      new detail::AugmentedKkt<T, I>{
+        {
+          kkt_active.as_const(),
+          {},
+          n,
+          n_eq,
+          n_in,
+          {},
+          {},
+          {},
+        },
+      }
+    };
+
+    auto zx = proxsuite::linalg::sparse::util::zero_extend; // ?
+    auto max_lnnz = isize(zx(ldl.col_ptrs[n_tot]));
+    isize ldlt_ntot = do_ldlt ? n_tot : 0;
+    isize ldlt_lnnz = do_ldlt ? max_lnnz : 0;
+
+    ldl.nnz_counts.resize_for_overwrite(ldlt_ntot);
+    ldl.row_indices.resize_for_overwrite(ldlt_lnnz);
+    ldl.values.resize_for_overwrite(ldlt_lnnz);
+
+    ldl.perm.resize_for_overwrite(ldlt_ntot);
+    if (do_ldlt) {
+      // compute perm from perm_inv
+      for (isize i = 0; i < n_tot; ++i) {
+        ldl.perm[isize(zx(ldl.perm_inv[i]))] = I(i);
+      }
+    }
+
+    internal.dirty = false;
+  }
+  Timer<T> timer;
+  Workspace() = default;
+
+  auto ldl_col_ptrs() const -> I const* { return internal.ldl.col_ptrs.ptr(); }
+  auto ldl_col_ptrs_mut() -> I* { return internal.ldl.col_ptrs.ptr_mut(); }
+  auto stack_mut() -> proxsuite::linalg::veg::dynstack::DynStackMut
+  {
+    return internal.stack_mut();
+  }
+
+  void set_dirty() { internal.dirty = true; }
+};
+
+} // namespace sparse
+} // namespace proxqp
+} // namespace proxsuite
+
+#endif /* end of include guard PROXSUITE_PROXQP_SPARSE_WORKSPACE_HPP */