casadi 3.7.2__cp314-none-manylinux2014_i686.whl

casadi/include/proxsuite/linalg/dense/core.hpp

@@ -0,0 +1,863 @@
+/** \file */
+//
+// Copyright (c) 2022 INRIA
+//
+#ifndef PROXSUITE_LINALG_DENSE_LDLT_CORE_HPP
+#define PROXSUITE_LINALG_DENSE_LDLT_CORE_HPP
+
+#include <proxsuite/linalg/veg/util/dbg.hpp>
+#include <proxsuite/linalg/veg/util/assert.hpp>
+#include <proxsuite/linalg/veg/memory/dynamic_stack.hpp>
+
+#if !(defined(__aarch64__) || defined(__PPC64__) || defined(__ppc64__) ||      \
+      defined(_ARCH_PPC64))
+#include <immintrin.h>
+#endif
+
+#ifdef PROXSUITE_VECTORIZE
+#include <cmath> // to avoid error of the type no member named 'isnan' in namespace 'std';
+#include <simde/x86/avx2.h>
+#include <simde/x86/fma.h>
+#endif
+
+#include <Eigen/Core>
+
+#define LDLT_ID(id) __VEG_PP_CAT(id, __LINE__)
+
+#define __LDLT_TEMP_VEC_IMPL(Type, Name, Rows, Stack, Make)                    \
+  auto LDLT_ID(vec_storage) = (Stack).Make(                                    \
+    ::proxsuite::linalg::veg::Tag<__VEG_PP_REMOVE_PAREN(Type)>{},              \
+    (Rows),                                                                    \
+    ::proxsuite::linalg::dense::_detail::align<__VEG_PP_REMOVE_PAREN(          \
+      Type)>());                                                               \
+  auto Name /* NOLINT */ = ::Eigen::Map<                                       \
+    ::Eigen::Matrix<__VEG_PP_REMOVE_PAREN(Type), ::Eigen::Dynamic, 1>,         \
+    ::Eigen::Unaligned,                                                        \
+    ::Eigen::Stride<::Eigen::Dynamic, 1>>{                                     \
+    LDLT_ID(vec_storage).ptr_mut(),                                            \
+    LDLT_ID(vec_storage).len(),                                                \
+    ::Eigen::Stride<::Eigen::Dynamic, 1>{                                      \
+      LDLT_ID(vec_storage).len(),                                              \
+      1,                                                                       \
+    },                                                                         \
+  };                                                                           \
+  static_assert(true, ".")
+
+#define __LDLT_TEMP_MAT_IMPL(Type, Name, Rows, Cols, Stack, Make)              \
+  ::proxsuite::linalg::veg::isize LDLT_ID(rows) = (Rows);                      \
+  ::proxsuite::linalg::veg::isize LDLT_ID(cols) = (Cols);                      \
+  ::proxsuite::linalg::veg::isize LDLT_ID(stride) =                            \
+    ::proxsuite::linalg::dense::_detail::adjusted_stride<                      \
+      __VEG_PP_REMOVE_PAREN(Type)>(LDLT_ID(rows));                             \
+  auto LDLT_ID(vec_storage) = (Stack).Make(                                    \
+    ::proxsuite::linalg::veg::Tag<__VEG_PP_REMOVE_PAREN(Type)>{},              \
+    LDLT_ID(stride) * LDLT_ID(cols),                                           \
+    ::proxsuite::linalg::dense::_detail::align<__VEG_PP_REMOVE_PAREN(          \
+      Type)>());                                                               \
+  auto Name /* NOLINT */ =                                                     \
+    ::Eigen::Map<::Eigen::Matrix<__VEG_PP_REMOVE_PAREN(Type),                  \
+                                 ::Eigen::Dynamic,                             \
+                                 ::Eigen::Dynamic,                             \
+                                 ::Eigen::ColMajor>,                           \
+                 ::Eigen::Unaligned,                                           \
+                 ::Eigen::Stride<::Eigen::Dynamic, 1>>{                        \
+      LDLT_ID(vec_storage).ptr_mut(),                                          \
+      LDLT_ID(rows),                                                           \
+      LDLT_ID(cols),                                                           \
+      ::Eigen::Stride<::Eigen::Dynamic, 1>{                                    \
+        LDLT_ID(stride),                                                       \
+        1,                                                                     \
+      },                                                                       \
+    };                                                                         \
+  static_assert(true, ".")
+
+#define LDLT_TEMP_VEC(Type, Name, Rows, Stack)                                 \
+  __LDLT_TEMP_VEC_IMPL(Type, Name, Rows, Stack, make_new)
+#define LDLT_TEMP_VEC_UNINIT(Type, Name, Rows, Stack)                          \
+  __LDLT_TEMP_VEC_IMPL(Type, Name, Rows, Stack, make_new_for_overwrite)
+
+#define LDLT_TEMP_MAT(Type, Name, Rows, Cols, Stack)                           \
+  __LDLT_TEMP_MAT_IMPL(Type, Name, Rows, Cols, Stack, make_new)
+#define LDLT_TEMP_MAT_UNINIT(Type, Name, Rows, Cols, Stack)                    \
+  __LDLT_TEMP_MAT_IMPL(Type, Name, Rows, Cols, Stack, make_new_for_overwrite)
+
+namespace proxsuite {
+namespace linalg {
+namespace dense {
+using proxsuite::linalg::veg::i32;
+using proxsuite::linalg::veg::isize;
+using proxsuite::linalg::veg::u32;
+using proxsuite::linalg::veg::usize;
+using f32 = float;
+using f64 = double;
+
+namespace _detail {
+namespace _simd {
+
+#ifdef __clang__
+#define DENSE_LDLT_FP_PRAGMA _Pragma("STDC FP_CONTRACT ON")
+#else
+#define DENSE_LDLT_FP_PRAGMA
+#endif
+
+static_assert(static_cast<unsigned char>(-1) == 255, "char should have 8 bits");
+static_assert(sizeof(f32) == 4, "f32 should be 32 bits");
+static_assert(sizeof(f64) == 8, "f64 should be 64 bits");
+
+#define LDLT_FN_IMPL3(Fn, Prefix, Suffix)                                      \
+  VEG_INLINE static auto Fn(Pack a, Pack b, Pack c) noexcept -> Pack           \
+  {                                                                            \
+    return Pack{ simde_mm##Prefix##_##Fn##_##Suffix(                           \
+      a.inner, b.inner, c.inner) };                                            \
+  }                                                                            \
+  VEG_NOM_SEMICOLON
+
+#define LDLT_ARITHMETIC_IMPL(Prefix, Suffix)                                   \
+  LDLT_FN_IMPL3(fmadd, Prefix, Suffix);  /* (a * b + c) */                     \
+  LDLT_FN_IMPL3(fnmadd, Prefix, Suffix); /* (-a * b + c) */
+
+#define LDLT_LOAD_STORE(Prefix, Suffix)                                        \
+  VEG_INLINE static auto load_unaligned(ScalarType const* ptr) noexcept        \
+    -> Pack                                                                    \
+  {                                                                            \
+    return Pack{ simde_mm##Prefix##_loadu_##Suffix(ptr) };                     \
+  }                                                                            \
+  VEG_INLINE static auto broadcast(ScalarType value) noexcept -> Pack          \
+  {                                                                            \
+    return Pack{ simde_mm##Prefix##_set1_##Suffix(value) };                    \
+  }                                                                            \
+  VEG_INLINE void store_unaligned(ScalarType* ptr) const noexcept              \
+  {                                                                            \
+    simde_mm##Prefix##_storeu_##Suffix(ptr, inner);                            \
+  }                                                                            \
+  VEG_NOM_SEMICOLON
+
+template<typename T, usize N>
+struct Pack;
+
+template<typename T>
+struct Pack<T, 1>
+{
+  using ScalarType = T;
+
+  T inner;
+
+  VEG_INLINE static auto fmadd(Pack a, Pack b, Pack c) noexcept -> Pack
+  {
+    DENSE_LDLT_FP_PRAGMA
+    return { a.inner * b.inner + c.inner };
+  }
+  VEG_INLINE static auto fnmadd(Pack a, Pack b, Pack c) noexcept -> Pack
+  {
+    return fmadd({ -a.inner }, b, c);
+  }
+  VEG_INLINE static auto load_unaligned(ScalarType const* ptr) noexcept -> Pack
+  {
+    return { *ptr };
+  }
+  VEG_INLINE static auto broadcast(ScalarType value) noexcept -> Pack
+  {
+    return { value };
+  }
+  VEG_INLINE void store_unaligned(ScalarType* ptr) const noexcept
+  {
+    *ptr = inner;
+  }
+};
+
+#ifdef PROXSUITE_VECTORIZE
+template<>
+struct Pack<f32, 4>
+{
+  using ScalarType = f32;
+
+  simde__m128 inner;
+  LDLT_ARITHMETIC_IMPL(, ps)
+  LDLT_LOAD_STORE(, ps);
+};
+
+template<>
+struct Pack<f32, 8>
+{
+  using ScalarType = f32;
+
+  simde__m256 inner;
+  LDLT_ARITHMETIC_IMPL(256, ps)
+  LDLT_LOAD_STORE(256, ps);
+};
+
+#ifdef __AVX512F__
+template<>
+struct Pack<f32, 16>
+{
+  using ScalarType = f32;
+
+  __m512 inner;
+  VEG_INLINE static auto fmadd(Pack a, Pack b, Pack c) noexcept -> Pack
+  {
+    DENSE_LDLT_FP_PRAGMA
+    return { _mm512_fmadd_ps(a.inner, b.inner, c.inner) };
+  }
+  VEG_INLINE static auto fnmadd(Pack a, Pack b, Pack c) noexcept -> Pack
+  {
+    return { _mm512_fnmadd_ps(a.inner, b.inner, c.inner) };
+  }
+  VEG_INLINE static auto load_unaligned(ScalarType const* ptr) noexcept -> Pack
+  {
+    return { _mm512_loadu_ps(ptr) };
+  }
+  VEG_INLINE static auto broadcast(ScalarType value) noexcept -> Pack
+  {
+    return { _mm512_set1_ps(value) };
+  }
+  VEG_INLINE void store_unaligned(ScalarType* ptr) const noexcept
+  {
+    _mm512_storeu_ps(ptr, inner);
+  }
+};
+#endif
+
+template<>
+struct Pack<f64, 2>
+{
+  using ScalarType = f64;
+
+  simde__m128d inner;
+  LDLT_ARITHMETIC_IMPL(, pd)
+  LDLT_LOAD_STORE(, pd);
+};
+template<>
+struct Pack<f64, 4>
+{
+  using ScalarType = f64;
+
+  simde__m256d inner;
+  LDLT_ARITHMETIC_IMPL(256, pd)
+  LDLT_LOAD_STORE(256, pd);
+};
+
+#ifdef __AVX512F__
+template<>
+struct Pack<f64, 8>
+{
+  using ScalarType = f64;
+
+  __m512d inner;
+  VEG_INLINE static auto fmadd(Pack a, Pack b, Pack c) noexcept -> Pack
+  {
+    DENSE_LDLT_FP_PRAGMA
+    return { _mm512_fmadd_pd(a.inner, b.inner, c.inner) };
+  }
+  VEG_INLINE static auto fnmadd(Pack a, Pack b, Pack c) noexcept -> Pack
+  {
+    return { _mm512_fnmadd_pd(a.inner, b.inner, c.inner) };
+  }
+  VEG_INLINE static auto load_unaligned(ScalarType const* ptr) noexcept -> Pack
+  {
+    return { _mm512_loadu_pd(ptr) };
+  }
+  VEG_INLINE static auto broadcast(ScalarType value) noexcept -> Pack
+  {
+    return { _mm512_set1_pd(value) };
+  }
+  VEG_INLINE void store_unaligned(ScalarType* ptr) const noexcept
+  {
+    _mm512_storeu_pd(ptr, inner);
+  }
+};
+#endif
+
+#endif
+
+template<typename T>
+struct NativePackInfo
+{
+  static constexpr usize N = 1;
+  using Type = Pack<f32, N>;
+};
+
+#ifdef PROXSUITE_VECTORIZE
+template<>
+struct NativePackInfo<f32>
+{
+  static constexpr usize N = SIMDE_NATURAL_VECTOR_SIZE / 32;
+  using Type = Pack<f32, N>;
+};
+template<>
+struct NativePackInfo<f64>
+{
+  static constexpr usize N = SIMDE_NATURAL_VECTOR_SIZE / 64;
+  using Type = Pack<f64, N>;
+};
+#endif
+
+template<typename T>
+using NativePack = typename NativePackInfo<T>::Type;
+} // namespace _simd
+} // namespace _detail
+
+namespace _detail {
+using proxsuite::linalg::veg::uncvref_t;
+template<bool COND, typename T>
+using const_if = proxsuite::linalg::veg::meta::if_t<COND, T const, T>;
+
+template<typename T>
+using ptr_is_const = proxsuite::linalg::veg::meta::bool_constant<VEG_CONCEPT(
+  const_type<proxsuite::linalg::veg::meta::unptr_t<T>>)>;
+
+template<typename T>
+constexpr auto
+round_up(T a, T b) noexcept -> T
+{
+  return a + (b - 1) / b * b;
+}
+
+#ifdef PROXSUITE_VECTORIZE
+template<typename T>
+using should_vectorize =
+  proxsuite::linalg::veg::meta::bool_constant<VEG_CONCEPT(same<T, f32>) ||
+                                              VEG_CONCEPT(same<T, f64>)>;
+#else
+template<typename T>
+using should_vectorize = proxsuite::linalg::veg::meta::bool_constant<false>;
+#endif
+
+template<typename T>
+auto
+adjusted_stride(isize n) noexcept -> isize
+{
+#ifndef SIMDE_NATURAL_FLOAT_VECTOR_SIZE
+  isize simd_stride = 1;
+#else
+  isize simd_stride =
+    (SIMDE_NATURAL_VECTOR_SIZE / CHAR_BIT) / isize{ sizeof(T) };
+#endif
+  return _detail::should_vectorize<T>::value ? _detail::round_up(n, simd_stride)
+                                             : n;
+}
+template<typename T>
+auto
+align() noexcept -> isize
+{
+  return isize{ alignof(T) } * _detail::adjusted_stride<T>(1);
+}
+
+struct NoCopy
+{
+  NoCopy() = default;
+  ~NoCopy() = default;
+
+  NoCopy(NoCopy const&) = delete;
+  NoCopy(NoCopy&&) = delete;
+  auto operator=(NoCopy const&) -> NoCopy& = delete;
+  auto operator=(NoCopy&&) -> NoCopy& = delete;
+};
+
+namespace nb {
+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
+VEG_NIEBLOID(min2);
+VEG_NIEBLOID(max2);
+
+template<typename T>
+void
+set_zero(T* dest, usize n)
+{
+  for (usize i = 0; i < n; ++i) {
+    *dest = 0;
+  }
+}
+
+template<typename T>
+using OwnedMatrix =
+  Eigen::Matrix<typename T::Scalar,
+                Eigen::Dynamic,
+                Eigen::Dynamic,
+                bool(T::IsRowMajor) ? Eigen::RowMajor : Eigen::ColMajor>;
+
+template<typename T>
+using OwnedAll =
+  Eigen::Matrix<typename T::Scalar,
+                T::RowsAtCompileTime,
+                T::ColsAtCompileTime,
+                bool(T::IsRowMajor) ? Eigen::RowMajor : Eigen::ColMajor>;
+
+template<typename T>
+using OwnedRows =
+  Eigen::Matrix<typename T::Scalar,
+                Eigen::Dynamic,
+                T::ColsAtCompileTime,
+                bool(T::IsRowMajor) ? Eigen::RowMajor : Eigen::ColMajor>;
+
+template<typename T>
+using OwnedCols =
+  Eigen::Matrix<typename T::Scalar,
+                T::RowsAtCompileTime,
+                Eigen::Dynamic,
+                bool(T::IsRowMajor) ? Eigen::RowMajor : Eigen::ColMajor>;
+
+template<typename T>
+using OwnedColVector = Eigen::Matrix< //
+  typename T::Scalar,
+  Eigen::Dynamic,
+  1,
+  Eigen::ColMajor>;
+template<typename T>
+using OwnedRowVector = Eigen::Matrix< //
+  typename T::Scalar,
+  1,
+  Eigen::Dynamic,
+  Eigen::RowMajor>;
+
+template<bool ROWMAJOR>
+struct ElemAddrImpl;
+
+template<>
+struct ElemAddrImpl<false>
+{
+  template<typename T>
+  static auto fn(T* ptr,
+                 isize row,
+                 isize col,
+                 isize outer_stride,
+                 isize inner_stride) noexcept -> T*
+  {
+    return ptr + (inner_stride * row + outer_stride * col);
+  }
+};
+template<>
+struct ElemAddrImpl<true>
+{
+  template<typename T>
+  static auto fn(T* ptr,
+                 isize row,
+                 isize col,
+                 isize outer_stride,
+                 isize inner_stride) noexcept -> T*
+  {
+    return ptr + (outer_stride * row + inner_stride * col);
+  }
+};
+
+template<bool COLMAJOR>
+struct RowColAccessImpl;
+
+template<>
+struct RowColAccessImpl<true>
+{
+  template<typename T>
+  using Col =
+    Eigen::Map<const_if<ptr_is_const<decltype(VEG_DECLVAL(T &&).data())>::value,
+                        OwnedColVector<uncvref_t<T>>>,
+               Eigen::Unaligned,
+               Eigen::InnerStride<uncvref_t<T>::InnerStrideAtCompileTime>>;
+  template<typename T>
+  using Row =
+    Eigen::Map<const_if<ptr_is_const<decltype(VEG_DECLVAL(T &&).data())>::value,
+                        OwnedRowVector<uncvref_t<T>>>,
+               Eigen::Unaligned,
+               Eigen::InnerStride<uncvref_t<T>::OuterStrideAtCompileTime>>;
+
+  template<typename T>
+  static auto col(T&& mat, isize col_idx) noexcept -> Col<T>
+  {
+    return {
+      mat.data() + col_idx * mat.outerStride(),
+      mat.rows(),
+      1,
+      Eigen::InnerStride<uncvref_t<T>::InnerStrideAtCompileTime>{
+        mat.innerStride(),
+      },
+    };
+  }
+  template<typename T>
+  static auto row(T&& mat, isize row_idx) noexcept -> Row<T>
+  {
+    return {
+      mat.data() + row_idx * mat.innerStride(),
+      1,
+      mat.cols(),
+      Eigen::InnerStride<uncvref_t<T>::OuterStrideAtCompileTime>{
+        mat.outerStride(),
+      },
+    };
+  }
+};
+template<>
+struct RowColAccessImpl<false>
+{
+  template<typename T>
+  using Col =
+    Eigen::Map<const_if<ptr_is_const<decltype(VEG_DECLVAL(T &&).data())>::value,
+                        OwnedColVector<uncvref_t<T>>>,
+               Eigen::Unaligned,
+               Eigen::InnerStride<uncvref_t<T>::OuterStrideAtCompileTime>>;
+  template<typename T>
+  using Row =
+    Eigen::Map<const_if<ptr_is_const<decltype(VEG_DECLVAL(T &&).data())>::value,
+                        OwnedRowVector<uncvref_t<T>>>,
+               Eigen::Unaligned,
+               Eigen::InnerStride<uncvref_t<T>::InnerStrideAtCompileTime>>;
+
+  template<typename T>
+  static auto col(T&& mat, isize col_idx) noexcept -> Col<T>
+  {
+    return {
+      mat.data() + col_idx * mat.innerStride(),
+      mat.rows(),
+      1,
+      Eigen::InnerStride<uncvref_t<T>::OuterStrideAtCompileTime>{
+        mat.outerStride(),
+      },
+    };
+  }
+  template<typename T>
+  static auto row(T&& mat, isize row_idx) noexcept -> Row<T>
+  {
+    return {
+      mat.data() + row_idx * mat.outerStride(),
+      1,
+      mat.cols(),
+      Eigen::InnerStride<uncvref_t<T>::InnerStrideAtCompileTime>{
+        mat.innerStride(),
+      },
+    };
+  }
+};
+template<typename T>
+using StrideOf = Eigen::Stride< //
+  T::OuterStrideAtCompileTime,
+  T::InnerStrideAtCompileTime>;
+} // namespace _detail
+
+namespace util {
+template<bool COLMAJOR, typename T>
+auto
+elem_addr(T* ptr,
+          isize row,
+          isize col,
+          isize outer_stride,
+          isize inner_stride) noexcept -> T*
+{
+  return _detail::ElemAddrImpl<!COLMAJOR>::fn(
+    ptr, row, col, outer_stride, inner_stride);
+}
+
+template<typename Mat>
+auto
+matrix_elem_addr(Mat&& mat, isize row, isize col) noexcept
+  -> decltype(mat.data())
+{
+  return util::elem_addr<!bool(
+    proxsuite::linalg::veg::uncvref_t<Mat>::IsRowMajor)>( //
+    mat.data(),
+    row,
+    col,
+    mat.outerStride(),
+    mat.innerStride());
+}
+
+template<typename T>
+auto
+col(T&& mat, isize col_idx) noexcept -> typename _detail::RowColAccessImpl<
+  !bool(proxsuite::linalg::veg::uncvref_t<T>::IsRowMajor)>::template Col<T>
+{
+  return _detail::RowColAccessImpl<!bool(
+    proxsuite::linalg::veg::uncvref_t<T>::IsRowMajor)>::col(mat, col_idx);
+}
+template<typename T>
+auto
+row(T&& mat, isize row_idx) noexcept -> typename _detail::RowColAccessImpl<
+  !bool(proxsuite::linalg::veg::uncvref_t<T>::IsRowMajor)>::template Row<T>
+{
+  return _detail::RowColAccessImpl<!bool(
+    proxsuite::linalg::veg::uncvref_t<T>::IsRowMajor)>::row(mat, row_idx);
+}
+
+template<typename Mat>
+auto
+trans(Mat&& mat) noexcept -> Eigen::Map< //
+  _detail::const_if<_detail::ptr_is_const<decltype(mat.data())>::value,
+                    Eigen::Matrix< //
+                      typename proxsuite::linalg::veg::uncvref_t<Mat>::Scalar,
+                      proxsuite::linalg::veg::uncvref_t<Mat>::ColsAtCompileTime,
+                      proxsuite::linalg::veg::uncvref_t<Mat>::RowsAtCompileTime,
+                      bool(proxsuite::linalg::veg::uncvref_t<Mat>::IsRowMajor)
+                        ? Eigen::ColMajor
+                        : Eigen::RowMajor>>,
+  Eigen::Unaligned,
+  _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    mat.data(),
+    mat.cols(),
+    mat.rows(),
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+template<typename Mat>
+auto
+diagonal(Mat&& mat) noexcept -> Eigen::Map< //
+  _detail::const_if<_detail::ptr_is_const<decltype(mat.data())>::value,
+                    Eigen::Matrix< //
+                      typename proxsuite::linalg::veg::uncvref_t<Mat>::Scalar,
+                      Eigen::Dynamic,
+                      1,
+                      Eigen::ColMajor>>,
+  Eigen::Unaligned,
+  Eigen::InnerStride<Eigen::Dynamic>>
+{
+  VEG_DEBUG_ASSERT( //
+    mat.rows() == mat.cols());
+  return { mat.data(),
+           mat.rows(),
+           1,
+           Eigen::InnerStride<Eigen::Dynamic>{ mat.outerStride() + 1 } };
+}
+
+template<typename Mat>
+auto
+submatrix(Mat&& mat,
+          isize row_start,
+          isize col_start,
+          isize nrows,
+          isize ncols) noexcept
+  -> Eigen::Map<_detail::const_if<
+                  _detail::ptr_is_const<decltype(mat.data())>::value,
+                  _detail::OwnedMatrix<proxsuite::linalg::veg::uncvref_t<Mat>>>,
+                Eigen::Unaligned,
+                _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    util::elem_addr<!bool(proxsuite::linalg::veg::uncvref_t<Mat>::IsRowMajor)>(
+      mat.data(), row_start, col_start, mat.outerStride(), mat.innerStride()),
+    nrows,
+    ncols,
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+template<typename Mat>
+auto
+to_view(Mat&& mat) noexcept -> Eigen::Map<
+  _detail::const_if<_detail::ptr_is_const<decltype(mat.data())>::value,
+                    _detail::OwnedAll<proxsuite::linalg::veg::uncvref_t<Mat>>>,
+  Eigen::Unaligned,
+  _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    mat.data(),
+    mat.rows(),
+    mat.cols(),
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+template<typename Mat>
+auto
+to_view_dyn_rows(Mat&& mat) noexcept -> Eigen::Map<
+  _detail::const_if<_detail::ptr_is_const<decltype(mat.data())>::value,
+                    _detail::OwnedRows<proxsuite::linalg::veg::uncvref_t<Mat>>>,
+  Eigen::Unaligned,
+  _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    mat.data(),
+    mat.rows(),
+    mat.cols(),
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+template<typename Mat>
+auto
+to_view_dyn_cols(Mat&& mat) noexcept -> Eigen::Map<
+  _detail::const_if<_detail::ptr_is_const<decltype(mat.data())>::value,
+                    _detail::OwnedCols<proxsuite::linalg::veg::uncvref_t<Mat>>>,
+  Eigen::Unaligned,
+  _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    mat.data(),
+    mat.rows(),
+    mat.cols(),
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+template<typename Mat>
+auto
+to_view_dyn(Mat&& mat) noexcept
+  -> Eigen::Map<_detail::const_if<
+                  _detail::ptr_is_const<decltype(mat.data())>::value,
+                  _detail::OwnedMatrix<proxsuite::linalg::veg::uncvref_t<Mat>>>,
+                Eigen::Unaligned,
+                _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    mat.data(),
+    mat.rows(),
+    mat.cols(),
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+template<typename Mat>
+auto
+subrows(Mat&& mat, isize row_start, isize nrows) noexcept -> Eigen::Map<
+  _detail::const_if<_detail::ptr_is_const<decltype(mat.data())>::value,
+                    _detail::OwnedRows<proxsuite::linalg::veg::uncvref_t<Mat>>>,
+  Eigen::Unaligned,
+  _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    util::elem_addr<!bool(proxsuite::linalg::veg::uncvref_t<Mat>::IsRowMajor)>(
+      mat.data(), row_start, 0, mat.outerStride(), mat.innerStride()),
+    nrows,
+    mat.cols(),
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+template<typename Mat>
+auto
+subcols(Mat&& mat, isize col_start, isize ncols) noexcept -> Eigen::Map<
+  _detail::const_if<_detail::ptr_is_const<decltype(mat.data())>::value,
+                    _detail::OwnedCols<proxsuite::linalg::veg::uncvref_t<Mat>>>,
+  Eigen::Unaligned,
+  _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>>
+{
+  return {
+    util::elem_addr<!bool(proxsuite::linalg::veg::uncvref_t<Mat>::IsRowMajor)>(
+      mat.data(), 0, col_start, mat.outerStride(), mat.innerStride()),
+    mat.rows(),
+    ncols,
+    _detail::StrideOf<proxsuite::linalg::veg::uncvref_t<Mat>>{
+      mat.outerStride(),
+      mat.innerStride(),
+    },
+  };
+}
+
+} // namespace util
+namespace _detail {
+template<typename Dst, typename Lhs, typename Rhs, typename T>
+void
+noalias_mul_add_impl(Dst dst, Lhs lhs, Rhs rhs, T factor)
+{
+  VEG_ASSERT_ALL_OF(dst.rows() == lhs.rows(),
+                    dst.cols() == rhs.cols(),
+                    lhs.cols() == rhs.rows());
+
+  isize nrows = dst.rows();
+  isize ncols = dst.cols();
+  isize depth = lhs.cols();
+
+  if (nrows == 0 || ncols == 0 || depth == 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 !EIGEN_VERSION_AT_LEAST(3, 3, 8)
+  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 Mat =
+      Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor, 20, 20>;
+    using MapMut =
+      Eigen::Map<Mat, Eigen::Unaligned, Eigen::OuterStride<Eigen::Dynamic>>;
+
+    auto dst_ =
+      MapMut(dst.data(), dst.rows(), dst.cols(), { dst.outerStride() });
+    dst_.noalias().operator+=(factor * LAZY_PRODUCT(lhs, rhs));
+  } else
+#endif
+  {
+    dst.noalias().operator+=(factor * LAZY_PRODUCT(lhs, rhs));
+  }
+
+#undef LAZY_PRODUCT
+}
+} // namespace _detail
+namespace util {
+template<typename Dst, typename Lhs, typename Rhs, typename T>
+void
+noalias_mul_add(Dst&& dst, Lhs const& lhs, Rhs const& rhs, T factor)
+{
+  _detail::noalias_mul_add_impl(
+    util::submatrix(dst, 0, 0, dst.rows(), dst.cols()),
+    util::submatrix(lhs, 0, 0, lhs.rows(), lhs.cols()),
+    util::submatrix(rhs, 0, 0, rhs.rows(), rhs.cols()),
+    factor);
+}
+} // namespace util
+template<typename T>
+auto
+temp_mat_req(proxsuite::linalg::veg::Tag<T> /*tag*/,
+             isize rows,
+             isize cols) noexcept -> proxsuite::linalg::veg::dynstack::StackReq
+{
+  return {
+    _detail::adjusted_stride<T>(rows) * cols * isize{ sizeof(T) },
+    _detail::align<T>(),
+  };
+}
+
+template<typename T>
+auto
+temp_vec_req(proxsuite::linalg::veg::Tag<T> /*tag*/, isize rows) noexcept
+  -> proxsuite::linalg::veg::dynstack::StackReq
+{
+  return {
+    rows * isize{ sizeof(T) },
+    _detail::align<T>(),
+  };
+}
+} // namespace dense
+} // namespace linalg
+} // namespace proxsuite
+
+#endif /* end of include guard PROXSUITE_LINALG_DENSE_LDLT_CORE_HPP */