casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.7__cp312-none-win_amd64.whl

casadi/include/include/proxsuite/proxqp/dense/views.hpp

@@ -1,1466 +0,0 @@
-//
-// Copyright (c) 2022 INRIA
-//
-/**
- * @file views.hpp
- */
-#ifndef PROXSUITE_PROXQP_DENSE_VIEWS_HPP
-#define PROXSUITE_PROXQP_DENSE_VIEWS_HPP
-
-#include <proxsuite/linalg/veg/type_traits/core.hpp>
-#include <proxsuite/linalg/veg/util/dbg.hpp>
-#include <cstring>
-#include <type_traits>
-#include <Eigen/Core>
-
-#define LDLT_CONCEPT(...)                                                      \
-  VEG_CONCEPT_MACRO(::proxsuite::proxqp::concepts, __VA_ARGS__)
-#define LDLT_CHECK_CONCEPT(...)                                                \
-  VEG_CHECK_CONCEPT_MACRO(::proxqp::concepts, __VA_ARGS__)
-
-namespace proxsuite {
-namespace proxqp {
-
-using usize = decltype(sizeof(0));
-namespace detail {
-template<typename Fn>
-struct FnInfo;
-template<typename Ret_, typename... Args>
-struct FnInfo<auto(Args...)->Ret_>
-{
-  template<usize I>
-  using Arg = proxsuite::linalg::veg::ith<I, Args...>;
-  using Ret = Ret_;
-};
-} // namespace detail
-
-#define LDLT_IMPL_GET_PARAM(Fn, Idx)                                           \
-  typename ::proxsuite::proxqp::detail::FnInfo<                                \
-    decltype Fn /* NOLINT */>::template Arg<(Idx)>,
-
-#define LDLT_IMPL_GET_PARAMS_0(NParams, ...)                                   \
-  __VEG_PP_TUPLE_FOR_EACH(LDLT_IMPL_GET_PARAM,                                 \
-                          (__VA_ARGS__),                                       \
-                          __VEG_PP_MAKE_TUPLE(__VEG_IMPL_PP_DEC(NParams)))
-
-#define LDLT_IMPL_GET_PARAMS_1(NParams, ...)
-
-#define LDLT_IMPL_GET_PARAMS(NParams, ...)                                     \
-  __VEG_PP_CAT2(LDLT_IMPL_GET_PARAMS_, __VEG_IMPL_PP_IS_1(NParams))            \
-  (NParams, __VA_ARGS__)
-
-#define LDLT_EXPLICIT_TPL_DEF(NParams, ...)                                    \
-  template auto __VA_ARGS__(                                                   \
-    LDLT_IMPL_GET_PARAMS(NParams, __VA_ARGS__)                                 \
-      typename ::proxsuite::proxqp::detail::FnInfo<                            \
-        decltype(__VA_ARGS__)>::template Arg<(NParams)-1>)                     \
-    ->typename ::proxsuite::proxqp::detail::FnInfo<decltype(__VA_ARGS__)>::Ret
-#define LDLT_EXPLICIT_TPL_DECL(NParams, ...)                                   \
-  extern LDLT_EXPLICIT_TPL_DEF(NParams, __VA_ARGS__)
-
-using proxsuite::linalg::veg::i32;
-using proxsuite::linalg::veg::i64;
-using proxsuite::linalg::veg::isize;
-using proxsuite::linalg::veg::u32;
-using proxsuite::linalg::veg::u64;
-using proxsuite::linalg::veg::usize;
-using f32 = float;
-using f64 = double;
-namespace detail {
-
-struct NoCopy
-{
-  NoCopy() = default;
-  ~NoCopy() = default;
-
-  NoCopy(NoCopy const&) = delete;
-  NoCopy(NoCopy&&) = delete;
-  auto operator=(NoCopy const&) -> NoCopy& = delete;
-  auto operator=(NoCopy&&) -> NoCopy& = delete;
-};
-
-template<typename Fn>
-struct Defer /* NOLINT */
-{
-  Fn fn;
-  NoCopy _;
-
-  VEG_INLINE ~Defer() noexcept(noexcept(VEG_FWD(fn)())) { VEG_FWD(fn)(); }
-};
-
-namespace nb {
-struct defer
-{
-  template<typename Fn>
-  VEG_INLINE constexpr auto operator()(Fn fn) const -> Defer<Fn>
-  {
-    return { VEG_FWD(fn), {} };
-  }
-};
-struct max2
-{
-  template<typename T>
-  VEG_INLINE constexpr auto operator()(T const& a, T const& b) const -> T const&
-  {
-    return a > b ? a : b;
-  }
-};
-struct min2
-{
-  template<typename T>
-  VEG_INLINE constexpr auto operator()(T a, T b) const -> T
-  {
-    return (a < b) ? a : b;
-  }
-};
-
-} // namespace nb
-
-template<typename T>
-constexpr auto
-min_list_impl(T init, T const* arr, usize n) noexcept -> T
-{
-  return (n == 0)
-           ? init
-           : nb::min2{}(init, detail::min_list_impl(*arr, arr + 1, n - 1));
-}
-template<typename T, usize N>
-constexpr auto
-cx_min_list(T const (&arr)[N]) noexcept -> T
-{
-  return detail::min_list_impl( //
-    arr[0],
-    arr + 1,
-    N - 1);
-}
-
-namespace nb {
-struct max_list
-{
-  template<typename T>
-  VEG_INLINE auto operator()(std::initializer_list<T> list) const -> T
-  {
-    T const* data = list.begin();
-    isize len = isize(list.size());
-
-    T current_max = data[0];
-    for (isize i = 1; i < len; ++i) {
-      if (data[i] > current_max) {
-        current_max = data[i];
-      }
-    }
-    return current_max;
-  }
-};
-} // namespace nb
-VEG_NIEBLOID(defer);
-VEG_NIEBLOID(max2);
-VEG_NIEBLOID(min2);
-VEG_NIEBLOID(max_list);
-
-template<typename T, bool = std::is_floating_point<T>::value>
-struct SetZeroImpl
-{
-  static void fn(T* dest, usize n)
-  {
-    for (usize i = 0; i < n; ++i) {
-      *dest = 0;
-    }
-  }
-};
-
-template<typename T>
-struct SetZeroImpl<T, true>
-{
-  static void fn(T* dest, usize n)
-  {
-    // TODO: assert bit representation is zero
-    std::memset(dest, 0, n * sizeof(T));
-  }
-};
-
-template<typename T>
-void
-set_zero(T* dest, usize n)
-{
-  SetZeroImpl<T>::fn(dest, n);
-}
-
-constexpr auto
-round_up(isize n, isize k) noexcept -> isize
-{
-  return (n + k - 1) / k * k;
-}
-constexpr auto
-uround_up(usize n, usize k) noexcept -> usize
-{
-  return (n + k - 1) / k * k;
-}
-
-inline auto
-bytes_to_prev_aligned(void* ptr, usize align) noexcept -> isize
-{
-  using UPtr = std::uintptr_t;
-
-  UPtr mask = align - 1;
-  UPtr iptr = UPtr(ptr);
-  UPtr aligned_ptr = iptr & ~mask;
-  return isize(aligned_ptr - iptr);
-}
-inline auto
-bytes_to_next_aligned(void* ptr, usize align) noexcept -> isize
-{
-  using UPtr = std::uintptr_t;
-
-  UPtr mask = align - 1;
-  UPtr iptr = UPtr(ptr);
-  UPtr aligned_ptr = (iptr + mask) & ~mask;
-  return isize(aligned_ptr - iptr);
-}
-
-inline auto
-next_aligned(void* ptr, usize align) noexcept -> void*
-{
-  using BytePtr = unsigned char*;
-  using VoidPtr = void*;
-  return VoidPtr(BytePtr(ptr) + detail::bytes_to_next_aligned(ptr, align));
-}
-inline auto
-prev_aligned(void* ptr, usize align) noexcept -> void*
-{
-  using BytePtr = unsigned char*;
-  using VoidPtr = void*;
-  return VoidPtr(BytePtr(ptr) + detail::bytes_to_prev_aligned(ptr, align));
-}
-
-} // namespace detail
-
-enum struct Layout : unsigned char
-{
-  colmajor = 0,
-  rowmajor = 1,
-};
-
-constexpr Layout colmajor = Layout::colmajor;
-constexpr Layout rowmajor = Layout::rowmajor;
-
-constexpr auto
-flip_layout(Layout l) noexcept -> Layout
-{
-  return Layout(1 - u32(l));
-}
-constexpr auto
-to_eigen_layout(Layout l) -> int
-{
-  return l == colmajor ? Eigen::ColMajor : Eigen::RowMajor;
-}
-constexpr auto
-from_eigen_layout(int l) -> Layout
-{
-  return (unsigned(l) & Eigen::RowMajorBit) == Eigen::RowMajor ? rowmajor
-                                                               : colmajor;
-}
-
-static_assert(to_eigen_layout(from_eigen_layout(Eigen::ColMajor)) ==
-                Eigen::ColMajor,
-              ".");
-static_assert(to_eigen_layout(from_eigen_layout(Eigen::RowMajor)) ==
-                Eigen::RowMajor,
-              ".");
-
-namespace detail {
-template<Layout L>
-struct ElementAccess;
-
-template<>
-struct ElementAccess<Layout::colmajor>
-{
-  template<typename T>
-  VEG_INLINE static constexpr auto offset(T* ptr,
-                                          isize row,
-                                          isize col,
-                                          isize outer_stride) noexcept -> T*
-  {
-    return ptr + (usize(row) + usize(col) * usize(outer_stride));
-  }
-
-  using NextRowStride = Eigen::Stride<0, 0>;
-  using NextColStride = Eigen::InnerStride<Eigen::Dynamic>;
-  VEG_INLINE static auto next_row_stride(isize outer_stride) noexcept
-    -> NextRowStride
-  {
-    (void)outer_stride;
-    return NextRowStride{};
-  }
-  VEG_INLINE static auto next_col_stride(isize outer_stride) noexcept
-    -> NextColStride
-  {
-    return NextColStride /* NOLINT(modernize-return-braced-init-list) */ (
-      outer_stride);
-  }
-
-  template<typename T>
-  VEG_INLINE static void transpose_if_rowmajor(T* ptr,
-                                               isize dim,
-                                               isize outer_stride)
-  {
-    (void)ptr, (void)dim, (void)outer_stride;
-  }
-};
-
-template<>
-struct ElementAccess<Layout::rowmajor>
-{
-  template<typename T>
-  VEG_INLINE static constexpr auto offset(T* ptr,
-                                          isize row,
-                                          isize col,
-                                          isize outer_stride) noexcept -> T*
-  {
-    return ptr + (usize(col) + usize(row) * usize(outer_stride));
-  }
-
-  using NextColStride = Eigen::Stride<0, 0>;
-  using NextRowStride = Eigen::InnerStride<Eigen::Dynamic>;
-  VEG_INLINE static auto next_col_stride(isize outer_stride) noexcept
-    -> NextColStride
-  {
-    (void)outer_stride;
-    return NextColStride{};
-  }
-  VEG_INLINE static auto next_row_stride(isize outer_stride) noexcept
-    -> NextRowStride
-  {
-    return NextRowStride /* NOLINT(modernize-return-braced-init-list) */ (
-      outer_stride);
-  }
-
-  template<typename T>
-  VEG_INLINE static void transpose_if_rowmajor(T* ptr,
-                                               isize dim,
-                                               isize outer_stride)
-  {
-    Eigen::Map<                          //
-      Eigen::Matrix<                     //
-        T,                               //
-        Eigen::Dynamic,                  //
-        Eigen::Dynamic                   //
-        >,                               //
-      Eigen::Unaligned,                  //
-      Eigen::OuterStride<Eigen::Dynamic> //
-      >{
-      ptr,
-      dim,
-      dim,
-      Eigen::OuterStride<Eigen::Dynamic>(outer_stride),
-    }
-      .transposeInPlace();
-  }
-};
-} // namespace detail
-
-namespace detail {
-template<typename T>
-struct unlref
-{
-  using Type = T;
-};
-template<typename T>
-struct unlref<T&>
-{
-  using Type = T;
-};
-
-template<typename T>
-auto
-is_eigen_matrix_base_impl(Eigen::MatrixBase<T> const volatile*)
-  -> proxsuite::linalg::veg::meta::true_type;
-auto
-is_eigen_matrix_base_impl(void const volatile*)
-  -> proxsuite::linalg::veg::meta::false_type;
-
-template<typename T>
-auto
-is_eigen_owning_matrix_base_impl(Eigen::PlainObjectBase<T> const volatile*)
-  -> proxsuite::linalg::veg::meta::true_type;
-auto
-is_eigen_owning_matrix_base_impl(void const volatile*)
-  -> proxsuite::linalg::veg::meta::false_type;
-
-template<typename... Ts>
-using Void = void;
-
-template<typename Mat, typename T>
-using DataExpr = decltype(static_cast<T*>(VEG_DECLVAL(Mat&).data()));
-
-template<typename Dummy,
-         typename Fallback,
-         template<typename...>
-         class F,
-         typename... Ts>
-struct DetectedImpl : proxsuite::linalg::veg::meta::false_type
-{
-  using Type = Fallback;
-};
-
-template<typename Fallback, template<typename...> class F, typename... Ts>
-struct DetectedImpl<Void<F<Ts...>>, Fallback, F, Ts...>
-  : proxsuite::linalg::veg::meta::true_type
-{
-  using Type = F<Ts...>;
-};
-
-template<typename Fallback, template<typename...> class F, typename... Ts>
-using Detected = typename DetectedImpl<void, Fallback, F, Ts...>::Type;
-
-template<typename T>
-using CompTimeColsImpl =
-  proxsuite::linalg::veg::meta::constant<isize, isize(T::ColsAtCompileTime)>;
-template<typename T>
-using CompTimeRowsImpl =
-  proxsuite::linalg::veg::meta::constant<isize, isize(T::RowsAtCompileTime)>;
-template<typename T>
-using CompTimeInnerStrideImpl =
-  proxsuite::linalg::veg::meta::constant<isize,
-                                         isize(T::InnerStrideAtCompileTime)>;
-template<typename T>
-using LayoutImpl = proxsuite::linalg::veg::meta::
-  constant<Layout, (bool(T::IsRowMajor) ? rowmajor : colmajor)>;
-
-template<typename T, Layout L>
-using EigenMatMap = Eigen::Map<      //
-  Eigen::Matrix<                     //
-    T,                               //
-    Eigen::Dynamic,                  //
-    Eigen::Dynamic,                  //
-    (L == colmajor)                  //
-      ? Eigen::ColMajor              //
-      : Eigen::RowMajor              //
-    > const,                         //
-  Eigen::Unaligned,                  //
-  Eigen::OuterStride<Eigen::Dynamic> //
-  >;
-template<typename T, Layout L>
-using EigenMatMapMut = Eigen::Map<   //
-  Eigen::Matrix<                     //
-    T,                               //
-    Eigen::Dynamic,                  //
-    Eigen::Dynamic,                  //
-    (L == colmajor)                  //
-      ? Eigen::ColMajor              //
-      : Eigen::RowMajor              //
-    >,                               //
-  Eigen::Unaligned,                  //
-  Eigen::OuterStride<Eigen::Dynamic> //
-  >;
-
-template<typename T, typename Stride>
-using EigenVecMap = Eigen::Map< //
-  Eigen::Matrix<                //
-    T,                          //
-    Eigen::Dynamic,             //
-    1                           //
-    > const,                    //
-  Eigen::Unaligned,             //
-  Stride                        //
-  >;
-template<typename T, typename Stride>
-using EigenVecMapMut = Eigen::Map< //
-  Eigen::Matrix<                   //
-    T,                             //
-    Eigen::Dynamic,                //
-    1                              //
-    >,                             //
-  Eigen::Unaligned,                //
-  Stride                           //
-  >;
-
-template<typename T, Layout L>
-using ColToVec = EigenVecMap<T, typename ElementAccess<L>::NextRowStride>;
-template<typename T, Layout L>
-using RowToVec = EigenVecMap<T, typename ElementAccess<L>::NextColStride>;
-template<typename T, Layout L>
-using ColToVecMut = EigenVecMapMut<T, typename ElementAccess<L>::NextRowStride>;
-template<typename T, Layout L>
-using RowToVecMut = EigenVecMapMut<T, typename ElementAccess<L>::NextColStride>;
-
-template<typename T>
-using VecMap = EigenVecMap<T, Eigen::Stride<0, 0>>;
-template<typename T>
-using VecMapMut = EigenVecMapMut<T, Eigen::Stride<0, 0>>;
-
-} // namespace detail
-
-template<typename T>
-using unref = typename detail::unlref<T&>::Type;
-
-namespace eigen {
-template<typename T>
-using CompTimeCols =
-  detail::Detected<proxsuite::linalg::veg::meta::constant<isize, 0>,
-                   detail::CompTimeColsImpl,
-                   T>;
-template<typename T>
-using CompTimeRows =
-  detail::Detected<proxsuite::linalg::veg::meta::constant<isize, 0>,
-                   detail::CompTimeRowsImpl,
-                   T>;
-template<typename T>
-using CompTimeInnerStride =
-  detail::Detected<proxsuite::linalg::veg::meta::constant<isize, 0>,
-                   detail::CompTimeInnerStrideImpl,
-                   T>;
-template<typename T>
-using GetLayout =
-  detail::Detected<proxsuite::linalg::veg::meta::
-                     constant<Layout, Layout(static_cast<unsigned char>(-1))>,
-                   detail::LayoutImpl,
-                   T>;
-} // namespace eigen
-
-namespace concepts {
-VEG_DEF_CONCEPT(typename T, rvalue_ref, std::is_rvalue_reference<T>::value);
-VEG_DEF_CONCEPT(typename T, lvalue_ref, std::is_lvalue_reference<T>::value);
-VEG_DEF_CONCEPT((template<typename...> class F, typename... Ts),
-                detected,
-                detail::DetectedImpl<void, void, F, Ts...>::value);
-
-namespace aux {
-VEG_DEF_CONCEPT((typename Mat, typename T),
-                has_data_expr,
-                LDLT_CONCEPT(detected<detail::DataExpr, Mat, T>));
-
-VEG_DEF_CONCEPT((typename Mat),
-                matrix_base,
-                decltype(detail::is_eigen_matrix_base_impl(
-                  static_cast<Mat*>(nullptr)))::value);
-
-VEG_DEF_CONCEPT((typename Mat),
-                is_plain_object_base,
-                decltype(detail::is_eigen_owning_matrix_base_impl(
-                  static_cast<Mat*>(nullptr)))::value);
-
-VEG_DEF_CONCEPT((typename Mat),
-                tmp_matrix,
-                (LDLT_CONCEPT(aux::is_plain_object_base<unref<Mat>>) &&
-                 !LDLT_CONCEPT(lvalue_ref<Mat>)));
-} // namespace aux
-
-VEG_DEF_CONCEPT((typename Mat, typename T),
-                eigen_view,
-                (LDLT_CONCEPT(aux::matrix_base<unref<Mat>>) &&
-                 LDLT_CONCEPT(aux::has_data_expr<Mat, T const>)));
-
-VEG_DEF_CONCEPT((typename Mat, typename T),
-                eigen_view_mut,
-                (LDLT_CONCEPT(aux::matrix_base<unref<Mat>>) &&
-                 LDLT_CONCEPT(aux::has_data_expr<Mat, T>) &&
-                 !LDLT_CONCEPT(aux::tmp_matrix<Mat>)));
-
-VEG_DEF_CONCEPT((typename Mat, typename T),
-                eigen_strided_vector_view,
-                (LDLT_CONCEPT(eigen_view<Mat, T>) &&
-                 (eigen::CompTimeCols<unref<Mat>>::value == 1)));
-
-VEG_DEF_CONCEPT((typename Mat, typename T),
-                eigen_strided_vector_view_mut,
-                (LDLT_CONCEPT(eigen_view_mut<Mat, T>) &&
-                 (eigen::CompTimeCols<unref<Mat>>::value == 1)));
-
-VEG_DEF_CONCEPT((typename Mat, typename T),
-                eigen_vector_view,
-                (LDLT_CONCEPT(eigen_strided_vector_view<Mat, T>) &&
-                 (eigen::CompTimeInnerStride<unref<Mat>>::value == 1)));
-
-VEG_DEF_CONCEPT((typename Mat, typename T),
-                eigen_vector_view_mut,
-                (LDLT_CONCEPT(eigen_strided_vector_view_mut<Mat, T>) &&
-                 (eigen::CompTimeInnerStride<unref<Mat>>::value == 1)));
-} // namespace concepts
-
-inline namespace tags {
-VEG_TAG(from_ptr_size, FromPtrSize);
-VEG_TAG(from_ptr_size_stride, FromPtrSizeStride);
-VEG_TAG(from_ptr_rows_cols_stride, FromPtrRowsColsStride);
-VEG_TAG(from_eigen, FromEigen);
-} // namespace tags
-
-template<typename T>
-struct VectorView
-{
-  T const* data;
-  isize dim;
-
-  VEG_INLINE
-  VectorView(FromPtrSize /*tag*/, T const* _data, isize _dim) noexcept
-    : data(_data)
-    , dim(_dim)
-  {
-  }
-
-  VEG_TEMPLATE(typename Vec,
-               requires(LDLT_CONCEPT(eigen_vector_view<Vec, T>)),
-               VEG_INLINE VectorView,
-               (/*tag*/, FromEigen),
-               (vec, Vec const&))
-  noexcept
-    : data(vec.data())
-    , dim(vec.rows())
-  {
-  }
-
-  VEG_INLINE auto ptr(isize index) const noexcept -> T const*
-  {
-    return data + index;
-  }
-  VEG_INLINE auto operator()(isize index) const noexcept -> T const&
-  {
-    return *ptr(index);
-  }
-  VEG_INLINE auto segment(isize i, isize size) const noexcept -> VectorView
-  {
-    return {
-      from_ptr_size,
-      data + i,
-      size,
-    };
-  }
-  VEG_INLINE auto to_eigen() const -> detail::VecMap<T>
-  {
-    return detail::VecMap<T>(data, Eigen::Index(dim));
-  }
-};
-
-template<typename T>
-struct VectorViewMut
-{
-  T* data;
-  isize dim;
-
-  VEG_INLINE
-  VectorViewMut(FromPtrSize /*tag*/, T* _data, isize _dim) noexcept
-    : data(_data)
-    , dim(_dim)
-  {
-  }
-
-  VEG_TEMPLATE(typename Vec,
-               requires(LDLT_CONCEPT(eigen_vector_view_mut<Vec, T>)),
-               VEG_INLINE VectorViewMut,
-               (/*tag*/, FromEigen),
-               (vec, Vec&&))
-  noexcept
-    : data(vec.data())
-    , dim(vec.rows())
-  {
-  }
-
-  VEG_INLINE auto as_const() const noexcept -> VectorView<T>
-  {
-    return {
-      from_ptr_size,
-      data,
-      dim,
-    };
-  }
-  VEG_INLINE auto ptr(isize index) const noexcept -> T* { return data + index; }
-  VEG_INLINE auto operator()(isize index) const noexcept -> T&
-  {
-    return *ptr(index);
-  }
-  VEG_INLINE auto segment(isize i, isize size) const noexcept -> VectorViewMut
-  {
-    return {
-      from_ptr_size,
-      data + i,
-      size,
-    };
-  }
-  VEG_INLINE auto to_eigen() const -> detail::VecMapMut<T>
-  {
-    return detail::VecMapMut<T>(data, Eigen::Index(dim));
-  }
-};
-
-template<typename T>
-struct StridedVectorView
-{
-  T const* data;
-  isize dim;
-  isize stride;
-
-  VEG_INLINE
-  StridedVectorView(FromPtrSizeStride /*tag*/,
-                    T const* _data,
-                    isize _dim,
-                    isize _stride) noexcept
-    : data(_data)
-    , dim(_dim)
-    , stride(_stride)
-  {
-  }
-
-  VEG_TEMPLATE(typename Vec,
-               requires(LDLT_CONCEPT(eigen_strided_vector_view<Vec, T>)),
-               VEG_INLINE StridedVectorView,
-               (/*tag*/, FromEigen),
-               (vec, Vec const&))
-  noexcept
-    : data(vec.data())
-    , dim(vec.rows())
-    , stride(vec.innerStride())
-  {
-  }
-
-  VEG_INLINE auto ptr(isize index) const noexcept -> T const*
-  {
-    return data + stride * index;
-  }
-  VEG_INLINE auto operator()(isize index) const noexcept -> T const&
-  {
-    return *ptr(index);
-  }
-  VEG_INLINE auto segment(isize i, isize size) const noexcept
-    -> StridedVectorView
-  {
-    return {
-      from_ptr_size_stride,
-      data + stride * i,
-      size,
-      stride,
-    };
-  }
-  VEG_INLINE auto to_eigen() const
-    -> detail::EigenVecMap<T, Eigen::InnerStride<Eigen::Dynamic>>
-  {
-    return detail::EigenVecMap<T, Eigen::InnerStride<Eigen::Dynamic>>(
-      data,
-      Eigen::Index(dim),
-      Eigen::Index(1),
-      Eigen::InnerStride<Eigen::Dynamic>(Eigen::Index(stride)));
-  }
-};
-
-template<typename T>
-struct StridedVectorViewMut
-{
-  T* data;
-  isize dim;
-  isize stride;
-
-  VEG_INLINE
-  StridedVectorViewMut(FromPtrSizeStride /*tag*/,
-                       T* _data,
-                       isize _dim,
-                       isize _stride) noexcept
-    : data(_data)
-    , dim(_dim)
-    , stride(_stride)
-  {
-  }
-
-  VEG_TEMPLATE(typename Vec,
-               requires(LDLT_CONCEPT(eigen_strided_vector_view_mut<Vec, T>)),
-               VEG_INLINE StridedVectorViewMut,
-               (/*tag*/, FromEigen),
-               (vec, Vec&&))
-  noexcept
-    : data(vec.data())
-    , dim(vec.rows())
-    , stride(vec.innerStride())
-  {
-  }
-
-  VEG_INLINE auto as_const() const noexcept -> StridedVectorView<T>
-  {
-    return {
-      from_ptr_size_stride,
-      data,
-      dim,
-      stride,
-    };
-  }
-  VEG_INLINE auto ptr(isize index) const noexcept -> T*
-  {
-    return data + stride * index;
-  }
-  VEG_INLINE auto operator()(isize index) const noexcept -> T&
-  {
-    return *ptr(index);
-  }
-  VEG_INLINE auto segment(isize i, isize size) const noexcept
-    -> StridedVectorViewMut
-  {
-    return {
-      from_ptr_size_stride,
-      data + stride * i,
-      size,
-      stride,
-    };
-  }
-  VEG_INLINE auto to_eigen() const
-    -> detail::EigenVecMapMut<T, Eigen::InnerStride<Eigen::Dynamic>>
-  {
-    return detail::EigenVecMapMut<T, Eigen::InnerStride<Eigen::Dynamic>>(
-      data,
-      Eigen::Index(dim),
-      Eigen::Index(1),
-      Eigen::InnerStride<Eigen::Dynamic>(Eigen::Index(stride)));
-  }
-};
-
-template<typename T, Layout L>
-struct MatrixView
-{
-  T const* data;
-  isize rows;
-  isize cols;
-  isize outer_stride;
-
-  VEG_INLINE MatrixView(FromPtrRowsColsStride /*tag*/,
-                        T const* _data,
-                        isize _rows,
-                        isize _cols,
-                        isize _outer_stride) noexcept
-    : data(_data)
-    , rows(_rows)
-    , cols(_cols)
-    , outer_stride(_outer_stride)
-  {
-  }
-
-  VEG_TEMPLATE(typename Mat,
-               requires(LDLT_CONCEPT(eigen_view<Mat, T>) &&
-                        eigen::GetLayout<unref<Mat>>::value == L),
-               VEG_INLINE MatrixView,
-               (/*tag*/, FromEigen),
-               (mat, Mat const&))
-  noexcept
-    : data(mat.data())
-    , rows(mat.rows())
-    , cols(mat.cols())
-    , outer_stride(mat.outerStride())
-  {
-  }
-
-  VEG_INLINE auto ptr(isize row, isize col) const noexcept -> T const*
-  {
-    return detail::ElementAccess<L>::offset(data, row, col, outer_stride);
-  }
-  VEG_INLINE auto operator()(isize row, isize col) const noexcept -> T const&
-  {
-    return *ptr(row, col);
-  }
-  VEG_INLINE auto block(isize row,
-                        isize col,
-                        isize nrows,
-                        isize ncols) const noexcept -> MatrixView
-  {
-    return {
-      from_ptr_rows_cols_stride,
-      detail::ElementAccess<L>::offset(data, row, col, outer_stride),
-      nrows,
-      ncols,
-      outer_stride,
-    };
-  }
-
-private:
-  VEG_INLINE auto col_impl(
-    proxsuite::linalg::veg::meta::constant<Layout, colmajor> /*tag*/,
-    isize c) const noexcept -> VectorView<T>
-  {
-    return {
-      from_ptr_size,
-      data + c * outer_stride,
-      rows,
-    };
-  }
-  VEG_INLINE auto col_impl(
-    proxsuite::linalg::veg::meta::constant<Layout, rowmajor> /*tag*/,
-    isize c) const noexcept -> StridedVectorView<T>
-  {
-    return {
-      from_ptr_size_stride,
-      data + c,
-      rows,
-      outer_stride,
-    };
-  }
-
-public:
-  VEG_INLINE auto col(isize c) const noexcept -> proxsuite::linalg::veg::meta::
-    if_t<(L == colmajor), VectorView<T>, StridedVectorView<T>>
-  {
-    return col_impl(proxsuite::linalg::veg::meta::constant<Layout, L>{}, c);
-  }
-  VEG_INLINE auto row(isize r) const noexcept -> proxsuite::linalg::veg::meta::
-    if_t<(L == rowmajor), VectorView<T>, StridedVectorView<T>>
-  {
-    return trans().col(r);
-  }
-  VEG_INLINE auto trans() const noexcept
-    -> MatrixView<T, proxqp::flip_layout(L)>
-  {
-    return {
-      from_ptr_rows_cols_stride, data, cols, rows, outer_stride,
-    };
-  }
-  VEG_INLINE auto to_eigen() const noexcept -> detail::EigenMatMap<T, L>
-  {
-    return detail::EigenMatMap<T, L>(
-      data,
-      Eigen::Index(rows),
-      Eigen::Index(cols),
-      Eigen::OuterStride<Eigen::Dynamic>(Eigen::Index(outer_stride)));
-  }
-};
-
-template<typename T, Layout L>
-struct MatrixViewMut
-{
-  T* data;
-  isize rows;
-  isize cols;
-  isize outer_stride;
-
-  VEG_INLINE MatrixViewMut(FromPtrRowsColsStride /*tag*/,
-                           T* _data,
-                           isize _rows,
-                           isize _cols,
-                           isize _outer_stride) noexcept
-    : data(_data)
-    , rows(_rows)
-    , cols(_cols)
-    , outer_stride(_outer_stride)
-  {
-  }
-
-  VEG_TEMPLATE(typename Mat,
-               requires(LDLT_CONCEPT(eigen_view<Mat, T>) &&
-                        eigen::GetLayout<unref<Mat>>::value == L),
-               VEG_INLINE MatrixViewMut,
-               (/*tag*/, FromEigen),
-               (mat, Mat&&))
-  noexcept
-    : data(mat.data())
-    , rows(mat.rows())
-    , cols(mat.cols())
-    , outer_stride(mat.outerStride())
-  {
-  }
-
-  VEG_INLINE auto ptr(isize row, isize col) const noexcept -> T*
-  {
-    return detail::ElementAccess<L>::offset(data, row, col, outer_stride);
-  }
-  VEG_INLINE auto operator()(isize row, isize col) const noexcept -> T&
-  {
-    return *ptr(row, col);
-  }
-  VEG_INLINE auto block(isize row,
-                        isize col,
-                        isize nrows,
-                        isize ncols) const noexcept -> MatrixViewMut
-  {
-    return {
-      from_ptr_rows_cols_stride,
-      detail::ElementAccess<L>::offset(data, row, col, outer_stride),
-      nrows,
-      ncols,
-      outer_stride,
-    };
-  }
-
-private:
-  VEG_INLINE auto col_impl(
-    proxsuite::linalg::veg::meta::constant<Layout, colmajor> /*tag*/,
-    isize c) const noexcept -> VectorViewMut<T>
-  {
-    return {
-      from_ptr_size,
-      data + c * outer_stride,
-      rows,
-    };
-  }
-  VEG_INLINE auto col_impl(
-    proxsuite::linalg::veg::meta::constant<Layout, rowmajor> /*tag*/,
-    isize c) const noexcept -> StridedVectorViewMut<T>
-  {
-    return {
-      from_ptr_size_stride,
-      data + c,
-      rows,
-      outer_stride,
-    };
-  }
-
-public:
-  VEG_INLINE auto col(isize c) const noexcept -> proxsuite::linalg::veg::meta::
-    if_t<(L == colmajor), VectorViewMut<T>, StridedVectorViewMut<T>>
-  {
-    return col_impl(proxsuite::linalg::veg::meta::constant<Layout, L>{}, c);
-  }
-  VEG_INLINE auto row(isize r) const noexcept -> proxsuite::linalg::veg::meta::
-    if_t<(L == rowmajor), VectorViewMut<T>, StridedVectorViewMut<T>>
-  {
-    return trans().col(r);
-  }
-  VEG_INLINE auto trans() const noexcept
-    -> MatrixViewMut<T, proxqp::flip_layout(L)>
-  {
-    return {
-      from_ptr_rows_cols_stride, data, cols, rows, outer_stride,
-    };
-  }
-  VEG_INLINE auto to_eigen() const noexcept -> detail::EigenMatMapMut<T, L>
-  {
-    return detail::EigenMatMapMut<T, L>(
-      data,
-      Eigen::Index(rows),
-      Eigen::Index(cols),
-      Eigen::OuterStride<Eigen::Dynamic>(Eigen::Index(outer_stride)));
-  }
-  VEG_INLINE auto as_const() const noexcept -> MatrixView<T, L>
-  {
-    return {
-      from_ptr_rows_cols_stride, data, rows, cols, outer_stride,
-    };
-  }
-};
-
-template<typename T>
-struct LdltView
-{
-private:
-  MatrixView<T, colmajor> ld;
-
-public:
-  explicit LdltView(MatrixView<T, colmajor> ld) noexcept
-    : ld(ld)
-  {
-    VEG_DEBUG_ASSERT(ld.rows == ld.cols);
-  }
-
-  VEG_INLINE auto l() const noexcept -> MatrixView<T, colmajor> { return ld; }
-  VEG_INLINE auto d() const noexcept -> StridedVectorView<T>
-  {
-    return { from_ptr_size_stride, ld.data, ld.rows, ld.outer_stride + 1 };
-  }
-
-  VEG_INLINE auto head(isize k) const -> LdltView
-  {
-    return LdltView{ ld.block(0, 0, k, k) };
-  }
-  VEG_INLINE auto tail(isize k) const -> LdltView
-  {
-    isize n = ld.rows;
-    return LdltView{ ld.block(n - k, n - k, k, k) };
-  }
-};
-template<typename T>
-struct LdltViewMut
-{
-private:
-  MatrixViewMut<T, colmajor> ld;
-
-public:
-  explicit LdltViewMut(MatrixViewMut<T, colmajor> ld) noexcept
-    : ld(ld)
-  {
-    VEG_DEBUG_ASSERT(ld.rows == ld.cols);
-  }
-
-  VEG_INLINE auto l() const noexcept -> MatrixView<T, colmajor>
-  {
-    return ld.as_const();
-  }
-  VEG_INLINE auto l_mut() const noexcept -> MatrixViewMut<T, colmajor>
-  {
-    return ld;
-  }
-  VEG_INLINE auto d() const noexcept -> StridedVectorView<T>
-  {
-    return { from_ptr_size_stride, ld.data, ld.rows, ld.outer_stride + 1 };
-  }
-  VEG_INLINE auto d_mut() const noexcept -> StridedVectorViewMut<T>
-  {
-    return { from_ptr_size_stride, ld.data, ld.rows, ld.outer_stride + 1 };
-  }
-
-  VEG_INLINE auto as_const() const noexcept -> LdltView<T>
-  {
-    return LdltView<T>{ ld.as_const() };
-  }
-
-  VEG_INLINE auto head(isize k) const -> LdltViewMut
-  {
-    return LdltViewMut{ ld.block(0, 0, k, k) };
-  }
-  VEG_INLINE auto tail(isize k) const -> LdltViewMut
-  {
-    isize n = ld.rows;
-    return LdltViewMut{ ld.block(n - k, n - k, k, k) };
-  }
-};
-
-namespace detail {
-template<typename T>
-void
-noalias_mul_add(MatrixViewMut<T, colmajor> dst,
-                MatrixView<T, colmajor> lhs,
-                MatrixView<T, colmajor> rhs,
-                T factor)
-{
-
-  if ((dst.cols == 0) || (dst.rows == 0) || (lhs.cols == 0)) {
-    return;
-  }
-
-#if !EIGEN_VERSION_AT_LEAST(3, 3, 8)
-#define LAZY_PRODUCT(a, b) a.lazyProduct(b)
-#else
-#define LAZY_PRODUCT(a, b) a.operator*(b)
-#endif
-
-  if (dst.cols == 1 && dst.rows == 1) {
-    // dot
-    auto rhs_col = rhs.col(0);
-    auto lhs_row = lhs.row(0);
-    auto lhs_as_col = lhs.col(0);
-    lhs_as_col.dim = lhs_row.dim;
-    if (lhs_row.stride == 1) {
-      dst(0, 0) += factor * lhs_as_col.to_eigen().dot(rhs_col.to_eigen());
-    } else {
-      dst(0, 0) += factor * lhs_row.to_eigen().dot(rhs_col.to_eigen());
-    }
-  } else if (dst.cols == 1) {
-    // gemv
-    auto rhs_col = rhs.col(0);
-    auto dst_col = dst.col(0);
-    dst_col.to_eigen().noalias().operator+=(
-      factor * LAZY_PRODUCT(lhs.to_eigen(), rhs_col.to_eigen()));
-  }
-
-#if !EIGEN_VERSION_AT_LEAST(3, 3, 8)
-  else if ((dst.rows < 20) && (dst.cols < 20) && (rhs.rows < 20)) {
-    // gemm
-    // workaround for eigen 3.3.7 bug:
-    // https://gitlab.com/libeigen/eigen/-/issues/1562
-    using Stride = Eigen::OuterStride<Eigen::Dynamic>;
-    using Mat =
-      Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor, 20, 20>;
-    using MapMut = Eigen::Map<Mat, Eigen::Unaligned, Stride>;
-    using Map = Eigen::Map<Mat const, Eigen::Unaligned, Stride>;
-
-    MapMut(dst.data, dst.rows, dst.cols, Stride(dst.outer_stride))
-      .noalias()
-      .
-      operator+=(
-        factor *
-        LAZY_PRODUCT(
-          Map(lhs.data, lhs.rows, lhs.cols, Stride(lhs.outer_stride)),
-          Map(rhs.data, rhs.rows, rhs.cols, Stride(rhs.outer_stride))));
-  }
-#endif
-
-  else {
-    // gemm
-    dst.to_eigen().noalias().operator+=(
-      factor * LAZY_PRODUCT(lhs.to_eigen(), rhs.to_eigen()));
-  }
-
-#undef LAZY_PRODUCT
-}
-
-template<typename T>
-void
-noalias_mul_add_vec(VectorViewMut<T> dst,
-                    MatrixView<T, colmajor> lhs,
-                    VectorView<T> rhs,
-                    T factor)
-{
-  detail::noalias_mul_add<T>(
-    {
-      from_ptr_rows_cols_stride,
-      dst.data,
-      dst.dim,
-      1,
-      0,
-    },
-    lhs,
-    {
-      from_ptr_rows_cols_stride,
-      rhs.data,
-      rhs.dim,
-      1,
-      0,
-    },
-    VEG_FWD(factor));
-}
-
-template<typename T>
-auto
-dot(StridedVectorView<T> lhs, VectorView<T> rhs) -> T
-{
-  auto out = T(0);
-  detail::noalias_mul_add<T>(
-    {
-      from_ptr_rows_cols_stride,
-      std::addressof(out),
-      1,
-      1,
-      0,
-    },
-    {
-      from_ptr_rows_cols_stride,
-      lhs.data,
-      1,
-      lhs.dim,
-      lhs.stride,
-    },
-    {
-      from_ptr_rows_cols_stride,
-      rhs.data,
-      rhs.dim,
-      1,
-      0,
-    },
-    1);
-  return out;
-}
-template<typename T>
-void
-assign_cwise_prod(VectorViewMut<T> out,
-                  StridedVectorView<T> lhs,
-                  StridedVectorView<T> rhs)
-{
-  out.to_eigen() = lhs.to_eigen().cwiseProduct(rhs.to_eigen());
-}
-template<typename T>
-void
-assign_scalar_prod(VectorViewMut<T> out, T factor, VectorView<T> in)
-{
-  out.to_eigen() = in.to_eigen().operator*(factor);
-}
-
-template<typename T>
-void
-trans_tr_unit_up_solve_in_place_on_right(MatrixView<T, colmajor> tr,
-                                         MatrixViewMut<T, colmajor> rhs)
-{
-  if (rhs.cols == 1) {
-    tr.to_eigen()
-      .transpose()
-      .template triangularView<Eigen::UnitUpper>()
-      .template solveInPlace<Eigen::OnTheRight>(rhs.col(0).to_eigen());
-  } else {
-    tr.to_eigen()
-      .transpose()
-      .template triangularView<Eigen::UnitUpper>()
-      .template solveInPlace<Eigen::OnTheRight>(rhs.to_eigen());
-  }
-}
-
-template<typename T>
-void
-apply_diag_inv_on_right(MatrixViewMut<T, colmajor> out,
-                        StridedVectorView<T> d,
-                        MatrixView<T, colmajor> in)
-{
-  if (out.cols == 1) {
-    out.col(0).to_eigen() =
-      in.col(0).to_eigen().operator*(d.to_eigen().asDiagonal().inverse());
-  } else {
-    out.to_eigen() =
-      in.to_eigen().operator*(d.to_eigen().asDiagonal().inverse());
-  }
-}
-template<typename T>
-void
-apply_diag_on_right(MatrixViewMut<T, colmajor> out,
-                    StridedVectorView<T> d,
-                    MatrixView<T, colmajor> in)
-{
-  if (out.cols == 1) {
-    out.col(0).to_eigen() =
-      in.col(0).to_eigen().operator*(d.to_eigen().asDiagonal());
-  } else {
-    out.to_eigen() = in.to_eigen().operator*(d.to_eigen().asDiagonal());
-  }
-}
-
-template<typename T>
-void
-noalias_mul_sub_tr_lo(MatrixViewMut<T, colmajor> out,
-                      MatrixView<T, colmajor> lhs,
-                      MatrixView<T, rowmajor> rhs)
-{
-  if (lhs.cols == 1) {
-    out.to_eigen().template triangularView<Eigen::Lower>().operator-=(
-      lhs.col(0).to_eigen().operator*(
-        Eigen::Map<Eigen::Matrix<T, 1, Eigen::Dynamic> const>(
-          rhs.data, 1, rhs.cols)));
-  } else {
-    out.to_eigen().template triangularView<Eigen::Lower>().operator-=(
-      lhs.to_eigen().operator*(rhs.to_eigen()));
-  }
-}
-
-} // namespace detail
-} // namespace proxqp
-} // namespace proxsuite
-
-namespace proxsuite {
-namespace proxqp {
-
-namespace dense {
-
-struct EigenAllowAlloc
-{
-  bool alloc_was_allowed;
-  EigenAllowAlloc(EigenAllowAlloc&&) = delete;
-  EigenAllowAlloc(EigenAllowAlloc const&) = delete;
-  auto operator=(EigenAllowAlloc&&) -> EigenAllowAlloc& = delete;
-  auto operator=(EigenAllowAlloc const&) -> EigenAllowAlloc& = delete;
-
-#if defined(EIGEN_RUNTIME_NO_MALLOC)
-  EigenAllowAlloc() noexcept
-    : alloc_was_allowed(Eigen::internal::is_malloc_allowed())
-  {
-    Eigen::internal::set_is_malloc_allowed(true);
-  }
-  ~EigenAllowAlloc() noexcept
-  {
-    Eigen::internal::set_is_malloc_allowed(alloc_was_allowed);
-  }
-#else
-  EigenAllowAlloc() = default;
-#endif
-};
-
-template<typename T>
-struct QpView
-{
-
-  static constexpr Layout layout = rowmajor;
-
-  MatrixView<T, layout> H;
-  VectorView<T> g;
-
-  MatrixView<T, layout> A;
-  VectorView<T> b;
-  MatrixView<T, layout> C;
-  VectorView<T> d;
-};
-
-template<typename Scalar>
-struct QpViewBox
-{
-  static constexpr Layout layout = rowmajor;
-
-  MatrixView<Scalar, layout> H;
-  VectorView<Scalar> g;
-
-  MatrixView<Scalar, layout> A;
-  VectorView<Scalar> b;
-  MatrixView<Scalar, layout> C;
-  VectorView<Scalar> u;
-  VectorView<Scalar> l;
-};
-
-template<typename T>
-struct QpViewMut
-{
-  static constexpr Layout layout = rowmajor;
-
-  MatrixViewMut<T, layout> H;
-  VectorViewMut<T> g;
-
-  MatrixViewMut<T, layout> A;
-  VectorViewMut<T> b;
-  MatrixViewMut<T, layout> C;
-  VectorViewMut<T> d;
-
-  VEG_INLINE constexpr auto as_const() const noexcept -> QpView<T>
-  {
-    return {
-      H.as_const(), g.as_const(), A.as_const(),
-      b.as_const(), C.as_const(), d.as_const(),
-    };
-  }
-};
-
-template<typename Scalar>
-struct QpViewBoxMut
-{
-  static constexpr Layout layout = rowmajor;
-
-  MatrixViewMut<Scalar, layout> H;
-  VectorViewMut<Scalar> g;
-
-  MatrixViewMut<Scalar, layout> A;
-  VectorViewMut<Scalar> b;
-  MatrixViewMut<Scalar, layout> C;
-  VectorViewMut<Scalar> u;
-  VectorViewMut<Scalar> l;
-
-  VEG_INLINE constexpr auto as_const() const noexcept -> QpViewBox<Scalar>
-  {
-    return {
-      H.as_const(), g.as_const(), A.as_const(), b.as_const(),
-      C.as_const(), u.as_const(), l.as_const(),
-    };
-  }
-};
-
-namespace nb {
-struct pow
-{
-  template<typename T>
-  auto operator()(T x, T y) const -> T
-  {
-    using std::pow;
-    return pow(x, y);
-  }
-};
-struct infty_norm
-{
-  template<typename D>
-  auto operator()(Eigen::MatrixBase<D> const& mat) const -> typename D::Scalar
-  {
-    if (mat.rows() == 0 || mat.cols() == 0) {
-      return typename D::Scalar(0);
-    } else {
-      return mat.template lpNorm<Eigen::Infinity>();
-    }
-  }
-};
-struct sqrt
-{
-  template<typename T>
-  auto operator()(T x) const -> T
-  {
-    using std::sqrt;
-    return sqrt(x);
-  }
-};
-struct fabs
-{
-  template<typename T>
-  auto operator()(T x) const -> T
-  {
-    using std::fabs;
-    return fabs(x);
-  }
-};
-} // namespace nb
-VEG_NIEBLOID(fabs);
-VEG_NIEBLOID(sqrt);
-VEG_NIEBLOID(pow);
-VEG_NIEBLOID(infty_norm);
-} // namespace dense
-} // namespace proxqp
-} // namespace proxsuite
-
-#endif /* end of include guard PROXSUITE_PROXQP_DENSE_VIEWS_HPP */