casadi 3.6.4__cp312-none-manylinux2014_x86_64.whl → 3.6.5__cp312-none-manylinux2014_x86_64.whl

casadi/include/include/proxsuite/proxqp/settings.hpp

@@ -1,302 +0,0 @@
-//
-// Copyright (c) 2022 INRIA
-//
-/**
- * @file settings.hpp
- */
-#ifndef PROXSUITE_PROXQP_SETTINGS_HPP
-#define PROXSUITE_PROXQP_SETTINGS_HPP
-
-#include <Eigen/Core>
-#include <proxsuite/proxqp/status.hpp>
-#include <proxsuite/proxqp/dense/views.hpp>
-#include <proxsuite/proxqp/sparse/fwd.hpp>
-
-namespace proxsuite {
-namespace proxqp {
-
-// Sparse backend specifications
-enum struct SparseBackend
-{
-  Automatic,      // the solver will select the appropriate sparse backend.
-  SparseCholesky, // sparse cholesky backend.
-  MatrixFree,     // iterative matrix free sparse backend.
-};
-
-inline std::ostream&
-operator<<(std::ostream& os, const SparseBackend& sparse_backend)
-{
-  if (sparse_backend == SparseBackend::Automatic)
-    os << "Automatic";
-  else if (sparse_backend == SparseBackend::SparseCholesky) {
-    os << "SparseCholesky";
-  } else {
-    os << "MatrixFree";
-  }
-  return os;
-}
-
-///
-/// @brief This class defines the settings of PROXQP solvers with sparse and
-/// dense backends.
-///
-/*!
- * Settings class, which defines the parameters used by the dense and sparse
- * solver (and its preconditioner).
- */
-template<typename T>
-struct Settings
-{
-
-  T default_rho;
-  T default_mu_eq;
-  T default_mu_in;
-
-  T alpha_bcl;
-  T beta_bcl;
-
-  T refactor_dual_feasibility_threshold;
-  T refactor_rho_threshold;
-
-  T mu_min_eq;
-  T mu_min_in;
-  T mu_max_eq_inv;
-  T mu_max_in_inv;
-
-  T mu_update_factor;
-  T mu_update_inv_factor;
-
-  T cold_reset_mu_eq;
-  T cold_reset_mu_in;
-  T cold_reset_mu_eq_inv;
-  T cold_reset_mu_in_inv;
-  T eps_abs;
-  T eps_rel;
-
-  isize max_iter;
-  isize max_iter_in;
-  isize safe_guard;
-  isize nb_iterative_refinement;
-  T eps_refact;
-
-  bool verbose;
-  InitialGuessStatus initial_guess;
-  bool update_preconditioner;
-  bool compute_preconditioner;
-  bool compute_timings;
-
-  bool check_duality_gap;
-  T eps_duality_gap_abs;
-  T eps_duality_gap_rel;
-
-  isize preconditioner_max_iter;
-  T preconditioner_accuracy;
-  T eps_primal_inf;
-  T eps_dual_inf;
-  bool bcl_update;
-
-  SparseBackend sparse_backend;
-  /*!
-   * Default constructor.
-   * @param default_rho default rho parameter of result class
-   * @param default_mu_eq default mu_eq parameter of result class
-   * @param default_mu_in default mu_in parameter of result class
-   * @param alpha_bcl alpha parameter of the BCL algorithm.
-   * @param beta_bcl beta parameter of the BCL algorithm.
-   * @param refactor_dual_feasibility_threshold threshold above which
-   * refactorization is performed to change rho parameter.
-   * @param refactor_rho_threshold new rho parameter used if the
-   * refactor_dual_feasibility_threshold_ condition has been satisfied.
-   * @param mu_min_eq minimal authorized value for mu_eq.
-   * @param mu_min_in minimal authorized value for mu_in.
-   * @param mu_max_eq_inv maximal authorized value for the inverse of
-   * mu_eq_inv.
-   * @param mu_max_in_inv maximal authorized value for the inverse of
-   * mu_in_inv.
-   * @param mu_update_factor update factor used for updating mu_eq and mu_in.
-   * @param mu_update_inv_factor update factor used for updating mu_eq_inv and
-   * mu_in_inv.
-   * @param cold_reset_mu_eq value used for cold restarting mu_eq.
-   * @param cold_reset_mu_in value used for cold restarting mu_in.
-   * @param cold_reset_mu_eq_inv value used for cold restarting mu_eq_inv.
-   * @param cold_reset_mu_in_inv value used for cold restarting mu_in_inv.
-   * @param eps_abs asbolute stopping criterion of the solver.
-   * @param eps_rel relative stopping criterion of the solver.
-   * @param max_iter maximal number of authorized iteration.
-   * @param max_iter_in maximal number of authorized iterations for an inner
-   * loop.
-   * @param nb_iterative_refinement number of iterative refinements.
-   * @param eps_refact threshold value for refactorizing the ldlt factorization
-   * in the iterative refinement loop.
-   * @param safe_guard safeguard parameter ensuring global convergence of ProxQP
-   * scheme.
-   * @param VERBOSE if set to true, the solver prints information at each loop.
-   * @param initial_guess sets the initial guess option for initilizing x, y
-   * and z.
-   * @param update_preconditioner If set to true, the preconditioner will be
-   * re-derived with the update method.
-   * @param compute_preconditioner If set to true, the preconditioner will be
-   * derived with the init method.
-   * @param compute_timings If set to true, timings will be computed by the
-   * solver (setup time, solving time, and run time = setup time + solving
-   * time).
-   * @param check_duality_gap If set to true, duality gap will be calculated and
-   * included in the stopping criterion.
-   * @param eps_duality_gap_abs absolute duality-gap stopping criterion.
-   * @param eps_duality_gap_rel relative duality-gap stopping criterion.
-   * @param preconditioner_max_iter maximal number of authorized iterations for
-   * the preconditioner.
-   * @param preconditioner_accuracy accuracy level of the preconditioner.
-   * @param eps_primal_inf threshold under which primal infeasibility is
-   * detected.
-   * @param eps_dual_inf threshold under which dual infeasibility is detected.
-   * @param bcl_update if set to true, BCL strategy is used for calibrating
-   * mu_eq and mu_in. If set to false, a strategy developped by Martinez & al is
-   * used.
-   * @param sparse_backend Default automatic. User can choose between sparse
-   * cholesky or iterative matrix free sparse backend.
-   */
-
-  Settings(
-    T default_rho = 1.E-6,
-    T default_mu_eq = 1.E-3,
-    T default_mu_in = 1.E-1,
-    T alpha_bcl = 0.1,
-    T beta_bcl = 0.9,
-    T refactor_dual_feasibility_threshold = 1e-2,
-    T refactor_rho_threshold = 1e-7,
-    T mu_min_eq = 1e-9,
-    T mu_min_in = 1e-8,
-    T mu_max_eq_inv = 1e9,
-    T mu_max_in_inv = 1e8,
-    T mu_update_factor = 0.1,
-    T mu_update_inv_factor = 10,
-    T cold_reset_mu_eq = 1. / 1.1,
-    T cold_reset_mu_in = 1. / 1.1,
-    T cold_reset_mu_eq_inv = 1.1,
-    T cold_reset_mu_in_inv = 1.1,
-    T eps_abs = 1.e-5,
-    T eps_rel = 0,
-    isize max_iter = 10000,
-    isize max_iter_in = 1500,
-    isize safe_guard = 1.E4,
-    isize nb_iterative_refinement = 10,
-    T eps_refact = 1.e-6, // before eps_refact_=1.e-6
-    bool verbose = false,
-    InitialGuessStatus initial_guess = InitialGuessStatus::
-      EQUALITY_CONSTRAINED_INITIAL_GUESS, // default to
-                                          // EQUALITY_CONSTRAINED_INITIAL_GUESS,
-                                          // as most often we run only
-                                          // once a problem
-    bool update_preconditioner = true,
-    bool compute_preconditioner = true,
-    bool compute_timings = false,
-    bool check_duality_gap = false,
-    T eps_duality_gap_abs = 1.e-4,
-    T eps_duality_gap_rel = 0,
-    isize preconditioner_max_iter = 10,
-    T preconditioner_accuracy = 1.e-3,
-    T eps_primal_inf = 1.E-4,
-    T eps_dual_inf = 1.E-4,
-    bool bcl_update = true,
-    SparseBackend sparse_backend = SparseBackend::Automatic)
-    : default_rho(default_rho)
-    , default_mu_eq(default_mu_eq)
-    , default_mu_in(default_mu_in)
-    , alpha_bcl(alpha_bcl)
-    , beta_bcl(beta_bcl)
-    , refactor_dual_feasibility_threshold(refactor_dual_feasibility_threshold)
-    , refactor_rho_threshold(refactor_rho_threshold)
-    , mu_min_eq(mu_min_eq)
-    , mu_min_in(mu_min_in)
-    , mu_max_eq_inv(mu_max_eq_inv)
-    , mu_max_in_inv(mu_max_in_inv)
-    , mu_update_factor(mu_update_factor)
-    , mu_update_inv_factor(mu_update_inv_factor)
-    , cold_reset_mu_eq(cold_reset_mu_eq)
-    , cold_reset_mu_in(cold_reset_mu_in)
-    , cold_reset_mu_eq_inv(cold_reset_mu_eq_inv)
-    , cold_reset_mu_in_inv(cold_reset_mu_in_inv)
-    , eps_abs(eps_abs)
-    , eps_rel(eps_rel)
-    , max_iter(max_iter)
-    , max_iter_in(max_iter_in)
-    , safe_guard(safe_guard)
-    , nb_iterative_refinement(nb_iterative_refinement)
-    , eps_refact(eps_refact)
-    , verbose(verbose)
-    , initial_guess(initial_guess)
-    , update_preconditioner(update_preconditioner)
-    , compute_preconditioner(compute_preconditioner)
-    , compute_timings(compute_timings)
-    , check_duality_gap(check_duality_gap)
-    , eps_duality_gap_abs(eps_duality_gap_abs)
-    , eps_duality_gap_rel(eps_duality_gap_rel)
-    , preconditioner_max_iter(preconditioner_max_iter)
-    , preconditioner_accuracy(preconditioner_accuracy)
-    , eps_primal_inf(eps_primal_inf)
-    , eps_dual_inf(eps_dual_inf)
-    , bcl_update(bcl_update)
-    , sparse_backend(sparse_backend)
-  {
-  }
-};
-
-template<typename T>
-bool
-operator==(const Settings<T>& settings1, const Settings<T>& settings2)
-{
-  bool value =
-    settings1.default_rho == settings2.default_rho &&
-    settings1.default_mu_eq == settings2.default_mu_eq &&
-    settings1.default_mu_in == settings2.default_mu_in &&
-    settings1.alpha_bcl == settings2.alpha_bcl &&
-    settings1.alpha_bcl == settings2.alpha_bcl &&
-    settings1.refactor_dual_feasibility_threshold ==
-      settings2.refactor_dual_feasibility_threshold &&
-    settings1.refactor_rho_threshold == settings2.refactor_rho_threshold &&
-    settings1.mu_min_eq == settings2.mu_min_eq &&
-    settings1.mu_min_in == settings2.mu_min_in &&
-    settings1.mu_max_eq_inv == settings2.mu_max_eq_inv &&
-    settings1.mu_max_in_inv == settings2.mu_max_in_inv &&
-    settings1.mu_update_factor == settings2.mu_update_factor &&
-    settings1.mu_update_factor == settings2.mu_update_factor &&
-    settings1.cold_reset_mu_eq == settings2.cold_reset_mu_eq &&
-    settings1.cold_reset_mu_in == settings2.cold_reset_mu_in &&
-    settings1.cold_reset_mu_eq_inv == settings2.cold_reset_mu_eq_inv &&
-    settings1.cold_reset_mu_in_inv == settings2.cold_reset_mu_in_inv &&
-    settings1.eps_abs == settings2.eps_abs &&
-    settings1.eps_rel == settings2.eps_rel &&
-    settings1.max_iter == settings2.max_iter &&
-    settings1.max_iter_in == settings2.max_iter_in &&
-    settings1.safe_guard == settings2.safe_guard &&
-    settings1.nb_iterative_refinement == settings2.nb_iterative_refinement &&
-    settings1.eps_refact == settings2.eps_refact &&
-    settings1.verbose == settings2.verbose &&
-    settings1.initial_guess == settings2.initial_guess &&
-    settings1.update_preconditioner == settings2.update_preconditioner &&
-    settings1.compute_preconditioner == settings2.compute_preconditioner &&
-    settings1.compute_timings == settings2.compute_timings &&
-    settings1.check_duality_gap == settings2.check_duality_gap &&
-    settings1.eps_duality_gap_abs == settings2.eps_duality_gap_abs &&
-    settings1.eps_duality_gap_rel == settings2.eps_duality_gap_rel &&
-    settings1.preconditioner_max_iter == settings2.preconditioner_max_iter &&
-    settings1.preconditioner_accuracy == settings2.preconditioner_accuracy &&
-    settings1.eps_primal_inf == settings2.eps_primal_inf &&
-    settings1.eps_dual_inf == settings2.eps_dual_inf &&
-    settings1.bcl_update == settings2.bcl_update &&
-    settings1.sparse_backend == settings2.sparse_backend;
-  return value;
-}
-
-template<typename T>
-bool
-operator!=(const Settings<T>& settings1, const Settings<T>& settings2)
-{
-  return !(settings1 == settings2);
-}
-
-} // namespace proxqp
-} // namespace proxsuite
-
-#endif /* end of include guard PROXSUITE_PROXQP_SETTINGS_HPP */

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

@@ -1,58 +0,0 @@
-//
-// Copyright (c) 2022-2023 INRIA
-//
-/** \file */
-#ifndef PROXSUITE_PROXQP_SPARSE_FWD_HPP
-#define PROXSUITE_PROXQP_SPARSE_FWD_HPP
-
-#include <Eigen/Sparse>
-#include "proxsuite/linalg/veg/vec.hpp"
-#include "proxsuite/proxqp/dense/views.hpp"
-#include "proxsuite/helpers/common.hpp"
-
-namespace proxsuite {
-namespace proxqp {
-namespace sparse {
-
-using dense::infty_norm;
-using proxsuite::linalg::veg::i64;
-using proxsuite::linalg::veg::isize;
-using proxsuite::linalg::veg::usize;
-
-template<typename T>
-using DMat = Eigen::Matrix<T, -1, -1>;
-
-static constexpr auto DYN = Eigen::Dynamic;
-enum
-{
-  layout = Eigen::RowMajor
-};
-template<typename T, typename I>
-using SparseMat = Eigen::SparseMatrix<T, Eigen::ColMajor, I>;
-// using SparseMat = Eigen::SparseMatrix<T, Eigen::RowMajor, I>;
-template<typename T>
-using VecRef = Eigen::Ref<Eigen::Matrix<T, DYN, 1> const>;
-template<typename T>
-using MatRef = Eigen::Ref<Eigen::Matrix<T, DYN, DYN> const>;
-template<typename T>
-using Vec = Eigen::Matrix<T, DYN, 1>;
-
-template<typename T, typename I>
-using Mat = Eigen::SparseMatrix<T, Eigen::ColMajor, I>;
-// using Mat = Eigen::SparseMatrix<T, Eigen::RowMajor, I>;
-using VecBool = Eigen::Matrix<bool, DYN, 1>;
-
-///
-/// @brief This class defines the workspace of the sparse solver.
-///
-/*!
- * Workspace class of the sparse solver.
- */
-template<typename T, typename I>
-struct Workspace;
-
-} // namespace sparse
-} // namespace proxqp
-} // namespace proxsuite
-
-#endif /* end of include guard PROXSUITE_PROXQP_SPARSE_FWD_HPP */

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

@@ -1,309 +0,0 @@
-//
-// Copyright (c) 2022 INRIA
-//
-/** \file */
-#ifndef PROXSUITE_PROXQP_SPARSE_HELPERS_HPP
-#define PROXSUITE_PROXQP_SPARSE_HELPERS_HPP
-
-#include <Eigen/Sparse>
-#include <proxsuite/helpers/optional.hpp>
-
-#include <proxsuite/linalg/veg/vec.hpp>
-#include <proxsuite/proxqp/sparse/fwd.hpp>
-
-namespace proxsuite {
-namespace proxqp {
-namespace sparse {
-
-/*!
- * Update the proximal parameters of the results object.
- *
- * @param rho_new primal proximal parameter
- * @param mu_eq_new dual equality proximal parameter
- * @param mu_in_new dual inequality proximal parameter
- * @param results solver result
- */
-template<typename T, typename I>
-void
-update_proximal_parameters(Settings<T>& settings,
-                           Results<T>& results,
-                           Workspace<T, I>& work,
-                           optional<T> rho_new,
-                           optional<T> mu_eq_new,
-                           optional<T> mu_in_new)
-{
-  if (rho_new != nullopt) {
-    settings.default_rho = rho_new.value();
-    results.info.rho = rho_new.value();
-    work.internal.proximal_parameter_update = true;
-  }
-  if (mu_eq_new != nullopt) {
-    settings.default_mu_eq = mu_eq_new.value();
-    results.info.mu_eq = mu_eq_new.value();
-    results.info.mu_eq_inv = T(1) / results.info.mu_eq;
-    work.internal.proximal_parameter_update = true;
-  }
-  if (mu_in_new != nullopt) {
-    settings.default_mu_in = mu_in_new.value();
-    results.info.mu_in = mu_in_new.value();
-    results.info.mu_in_inv = T(1) / results.info.mu_in;
-    work.internal.proximal_parameter_update = true;
-  }
-}
-/*!
- * Warm start the results primal and dual variables.
- *
- * @param x_wm primal proximal parameter
- * @param y_wm dual equality proximal parameter
- * @param z_wm dual inequality proximal parameter
- * @param results solver result
- * @param settings solver settings
- */
-template<typename T, typename I>
-void
-warm_start(optional<VecRef<T>> x_wm,
-           optional<VecRef<T>> y_wm,
-           optional<VecRef<T>> z_wm,
-           Results<T>& results,
-           Settings<T>& settings,
-           Model<T, I>& model)
-{
-  if (x_wm == nullopt && y_wm == nullopt && z_wm == nullopt)
-    return;
-
-  settings.initial_guess = InitialGuessStatus::WARM_START;
-
-  // first check problem dimensions
-  if (x_wm != nullopt) {
-    PROXSUITE_CHECK_ARGUMENT_SIZE(
-      x_wm.value().rows(),
-      model.dim,
-      "the dimension wrt primal variable x for warm start is not valid.");
-  }
-
-  if (y_wm != nullopt) {
-    PROXSUITE_CHECK_ARGUMENT_SIZE(y_wm.value().rows(),
-                                  model.n_eq,
-                                  "the dimension wrt equality constrained "
-                                  "variables for warm start is not valid.");
-  }
-
-  if (z_wm != nullopt) {
-    PROXSUITE_CHECK_ARGUMENT_SIZE(
-      z_wm.value().rows(),
-      model.n_in,
-      "the dimension wrt inequality constrained variables for warm start "
-      "is not valid.");
-  }
-
-  if (x_wm != nullopt) {
-    results.x = x_wm.value().eval();
-  }
-
-  if (y_wm != nullopt) {
-    results.y = y_wm.value().eval();
-  }
-
-  if (z_wm != nullopt) {
-    results.z = z_wm.value().eval();
-  }
-}
-
-/*!
- * Setups the QP solver model.
- *
- * @param qp view of the QP model.
- * @param work solver workspace.
- * @param settings solver settings.
- * @param data solver model.
- * @param results solver result.
- * @param precond preconditioner.
- * @param preconditioner_status bool variable for deciding whether executing the
- * preconditioning algorithm, or keeping previous preconditioning variables, or
- * using the identity preconditioner (i.e., no preconditioner).
- */
-template<typename T, typename I, typename P>
-void
-qp_setup(QpView<T, I> qp,
-         Results<T>& results,
-         Model<T, I>& data,
-         Workspace<T, I>& work,
-         Settings<T>& settings,
-         P& precond,
-         PreconditionerStatus& preconditioner_status)
-{
-  isize n = qp.H.nrows();
-  isize n_eq = qp.AT.ncols();
-  isize n_in = qp.CT.ncols();
-
-  if (results.x.rows() != n) {
-    results.x.resize(n);
-    results.x.setZero();
-  }
-  if (results.y.rows() != n_eq) {
-    results.y.resize(n_eq);
-    results.y.setZero();
-  }
-  if (results.z.rows() != n_in) {
-    results.z.resize(n_in);
-    results.z.setZero();
-  }
-  if (work.active_inequalities.len() != n_in) {
-    work.active_inequalities.resize(n_in);
-    for (isize i = 0; i < n_in; ++i) {
-      work.active_inequalities[i] = false;
-    }
-  }
-  if (work.active_set_up.rows() != n_in) {
-    work.active_set_up.resize(n_in);
-    for (isize i = 0; i < n_in; ++i) {
-      work.active_set_up[i] = false;
-    }
-  }
-  if (work.active_set_low.rows() != n_in) {
-    work.active_set_low.resize(n_in);
-    for (isize i = 0; i < n_in; ++i) {
-      work.active_set_low[i] = false;
-    }
-  }
-  bool execute_preconditioner_or_not = false;
-  switch (preconditioner_status) {
-    case PreconditionerStatus::EXECUTE:
-      execute_preconditioner_or_not = true;
-      break;
-    case PreconditionerStatus::IDENTITY:
-      execute_preconditioner_or_not = false;
-      break;
-    case PreconditionerStatus::KEEP:
-      // keep previous one
-      execute_preconditioner_or_not = false;
-      break;
-  }
-  // performs scaling according to options chosen + stored model value
-  work.setup_impl(
-    qp,
-    data,
-    settings,
-    execute_preconditioner_or_not,
-    precond,
-    P::scale_qp_in_place_req(proxsuite::linalg::veg::Tag<T>{}, n, n_eq, n_in));
-  switch (settings.initial_guess) { // the following is used when initiliazing
-                                    // the Qp object or updating it
-    case InitialGuessStatus::EQUALITY_CONSTRAINED_INITIAL_GUESS: {
-
-      if (work.internal.proximal_parameter_update) {
-        results.cleanup_all_except_prox_parameters();
-      } else {
-        results.cleanup(settings);
-      }
-      break;
-    }
-    case InitialGuessStatus::COLD_START_WITH_PREVIOUS_RESULT: {
-      // keep solutions but restart workspace and results
-
-      if (work.internal.proximal_parameter_update) {
-        results.cleanup_statistics();
-      } else {
-        results.cold_start(settings);
-      }
-      break;
-    }
-    case InitialGuessStatus::NO_INITIAL_GUESS: {
-
-      if (work.internal.proximal_parameter_update) {
-        results.cleanup_all_except_prox_parameters();
-      } else {
-        results.cleanup(settings);
-      }
-      break;
-    }
-    case InitialGuessStatus::WARM_START: {
-
-      if (work.internal.proximal_parameter_update) {
-        results.cleanup_all_except_prox_parameters();
-      } else {
-        results.cleanup(settings);
-      }
-      break;
-    }
-    case InitialGuessStatus::WARM_START_WITH_PREVIOUS_RESULT: {
-      // keep workspace and results solutions except statistics
-
-      results.cleanup_statistics(); // always keep prox parameters (changed or
-                                    // previous ones)
-      break;
-    }
-  }
-  // if user chose Automatic as sparse backend, store in results which backend
-  // of SparseCholesky or MatrixFree had been used
-  if (settings.sparse_backend == SparseBackend::Automatic) {
-    if (work.internal.do_ldlt) {
-      results.info.sparse_backend = SparseBackend::SparseCholesky;
-    } else {
-      results.info.sparse_backend = SparseBackend::MatrixFree;
-    }
-  }
-  // if user selected a specfic sparse backend, store it in results
-  else {
-    results.info.sparse_backend = settings.sparse_backend;
-  }
-}
-/*!
- * Checks whether matrix b has the same sparsity structure as matrix a.
- *
- * @param a matrix.
- * @param b matrix.
- */
-template<typename T, typename I>
-auto
-have_same_structure(proxsuite::linalg::sparse::MatRef<T, I> a,
-                    proxsuite::linalg::sparse::MatRef<T, I> b) -> bool
-{
-  if (a.nrows() != b.nrows())
-    return false;
-  if (a.ncols() != b.ncols())
-    return false;
-  for (usize j = 0; j < static_cast<usize>(a.ncols()); ++j) {
-    usize n_elems(a.col_end(j) - a.col_start(j));
-    usize n_elems_to_compare(b.col_end(j) - b.col_start(j));
-    if (n_elems != n_elems_to_compare)
-      return false;
-    for (usize p = 0; p < n_elems; ++p) {
-      isize i_a = a.row_indices()[a.col_start(j) + p];
-      isize i_b = b.row_indices()[b.col_start(j) + p];
-      if (i_a != i_b)
-        return false;
-    }
-  }
-  return true;
-}
-/*!
- * Copies matrix b elements into matrix a.
- *
- * @param a matrix.
- * @param b matrix.
- */
-template<typename T, typename I>
-void
-copy(proxsuite::linalg::sparse::MatMut<T, I> a,
-     proxsuite::linalg::sparse::MatRef<T, I> b)
-{
-  // assume same sparsity structure for a and b
-  // copy b into a
-  for (usize j = 0; j < static_cast<usize>(a.ncols()); ++j) {
-    auto a_start = a.values_mut() + a.col_start(j);
-    auto b_start = b.values() + b.col_start(j);
-
-    usize n_elems = static_cast<usize>(a.col_end(j) - a.col_start(j));
-
-    for (usize p = 0; p < n_elems; ++p) {
-      a_start[p] = b_start[p];
-    }
-  }
-}
-
-} // namespace sparse
-} // namespace proxqp
-} // namespace proxsuite
-
-#endif /* end of include guard PROXSUITE_PROXQP_SPARSE_HELPERS_HPP */