casadi 3.6.4__cp39-none-manylinux2014_aarch64.whl → 3.6.6__cp39-none-manylinux2014_aarch64.whl

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

@@ -1,333 +0,0 @@
-/** \file */
-//
-// Copyright (c) 2022 INRIA
-//
-#ifndef PROXSUITE_LINALG_DENSE_LDLT_MODIFY_HPP
-#define PROXSUITE_LINALG_DENSE_LDLT_MODIFY_HPP
-
-#include "proxsuite/linalg/dense/core.hpp"
-#include "proxsuite/linalg/dense/update.hpp"
-#include "proxsuite/linalg/dense/factorize.hpp"
-#include <algorithm>
-#include <proxsuite/linalg/veg/memory/dynamic_stack.hpp>
-
-namespace proxsuite {
-namespace linalg {
-namespace dense {
-namespace _detail {
-
-template<typename Mat>
-void
-delete_rows_and_cols_triangular_impl(Mat mat, isize const* indices, isize r)
-{
-  isize n = mat.rows();
-
-  for (isize chunk_j = 0; chunk_j < r + 1; ++chunk_j) {
-    isize j_start = chunk_j == 0 ? 0 : indices[chunk_j - 1] + 1;
-    isize j_finish = chunk_j == r ? n : indices[chunk_j];
-
-    for (isize j = j_start; j < j_finish; ++j) {
-      for (isize chunk_i = chunk_j; chunk_i < r + 1; ++chunk_i) {
-        isize i_start = chunk_i == chunk_j ? j : indices[chunk_i - 1] + 1;
-        isize i_finish = chunk_i == r ? n : indices[chunk_i];
-
-        if (chunk_i != 0 || chunk_j != 0) {
-          std::move( //
-            util::matrix_elem_addr(mat, i_start, j),
-            util::matrix_elem_addr(mat, i_finish, j),
-            util::matrix_elem_addr( //
-              mat,
-              (i_start - chunk_i),
-              (j - chunk_j)));
-        }
-      }
-    }
-  }
-}
-// indices: rows and columns to delete, in strictly increasing order
-//          must have at least one element (excluding the end)
-// r: count of rows to delete
-template<typename Mat>
-void
-delete_rows_and_cols_triangular(Mat&& mat, isize const* indices, isize r)
-{
-  _detail::delete_rows_and_cols_triangular_impl(
-    util::to_view_dyn(mat), indices, r);
-}
-
-struct IndicesR
-{
-  isize current_col;
-  isize current_r;
-  isize r;
-  isize const* indices;
-  VEG_INLINE auto operator()() noexcept -> isize
-  {
-    if (current_r == r) {
-      return current_r;
-    }
-
-    while (current_col == indices[current_r] - current_r) {
-      ++current_r;
-      if (current_r == r) {
-        return current_r;
-      }
-    }
-    ++current_col;
-    return current_r;
-  }
-};
-template<typename Mat>
-void
-ldlt_delete_rows_and_cols_impl( //
-  Mat ld,
-  isize* indices,
-  isize r,
-  proxsuite::linalg::veg::dynstack::DynStackMut stack)
-{
-  std::sort(indices, indices + r);
-
-  using T = typename Mat::Scalar;
-
-  isize n = ld.rows();
-  isize first = indices[0];
-
-  auto w_stride = _detail::adjusted_stride<T>(n - first - r);
-
-  proxsuite::linalg::veg::Tag<T> tag;
-
-  auto _w = stack.make_new(tag, r * w_stride, _detail::align<T>());
-  auto _alpha = stack.make_new_for_overwrite(tag, r);
-
-  auto pw = _w.ptr_mut();
-  auto palpha = _alpha.ptr_mut();
-
-  for (isize k = 0; k < r; ++k) {
-    isize j = indices[k];
-    palpha[k] = ld(j, j);
-    auto pwk = pw + k * w_stride;
-
-    for (isize chunk_i = k + 1; chunk_i < r + 1; ++chunk_i) {
-      isize i_start = indices[chunk_i - 1] + 1;
-      isize i_finish = chunk_i == r ? n : indices[chunk_i];
-
-      std::move(util::matrix_elem_addr(ld, i_start, j),
-                util::matrix_elem_addr(ld, i_finish, j),
-                pwk + i_start - chunk_i - first);
-    }
-  }
-  _detail::delete_rows_and_cols_triangular(ld, indices, r);
-
-  _detail::rank_r_update_clobber_w_impl(
-    util::submatrix(ld, first, first, n - first - r, n - first - r),
-    pw,
-    w_stride,
-    palpha,
-    IndicesR{ first, 0, r, indices });
-}
-
-template<typename Mat, typename A_1>
-void
-ldlt_insert_rows_and_cols_impl(
-  Mat ld,
-  isize pos,
-  A_1 a_1,
-  proxsuite::linalg::veg::dynstack::DynStackMut stack)
-{
-  using T = typename Mat::Scalar;
-
-  proxsuite::linalg::veg::Tag<T> tag;
-
-  isize const new_n = ld.rows();
-  isize const r = a_1.cols();
-  isize const old_n = new_n - r;
-
-  isize current_col = old_n;
-  while (true) {
-    if (current_col == pos) {
-      break;
-    }
-    --current_col;
-
-    T* src_col_ptr = util::matrix_elem_addr(ld, 0, current_col);
-    T* dest_col_ptr = util::matrix_elem_addr(ld, 0, current_col + r);
-
-    std::move_backward( //
-      src_col_ptr + pos,
-      src_col_ptr + old_n,
-      dest_col_ptr + new_n);
-
-    std::move_backward( //
-      src_col_ptr,
-      src_col_ptr + pos,
-      dest_col_ptr + pos);
-  }
-
-  while (true) {
-    if (current_col == 0) {
-      break;
-    }
-    --current_col;
-
-    T* src_col_ptr = util::matrix_elem_addr(ld, 0, current_col);
-    T* dest_col_ptr = src_col_ptr;
-
-    std::move_backward( //
-      src_col_ptr + pos,
-      src_col_ptr + old_n,
-      dest_col_ptr + new_n);
-  }
-
-  auto rem = new_n - pos - r;
-
-  auto ld00 = util::submatrix(ld, 0, 0, pos, pos);
-  auto l10 = util::submatrix(ld, pos, 0, r, pos);
-  auto l20 = util::submatrix(ld, pos + r, 0, rem, pos);
-
-  auto ld11 = util::submatrix(ld, pos, pos, r, r);
-  auto l21 = util::submatrix(ld, pos + r, pos, rem, r);
-
-  auto ld22 = util::submatrix(ld, pos + r, pos + r, rem, rem);
-
-  auto d0 = util::diagonal(ld00).asDiagonal();
-
-  auto a01 = util::subrows(a_1, 0, pos);
-  auto a11 = util::subrows(a_1, pos, r);
-  auto a21 = util::subrows(a_1, pos + r, rem);
-
-  if (l10.cols() > 0) {
-    l10 = util::trans(a01);
-    util::trans(ld00) //
-      .template triangularView<Eigen::UnitUpper>()
-      .template solveInPlace<Eigen::OnTheRight>(l10);
-
-    l10 = l10 * d0.inverse();
-  }
-
-  {
-    isize tmp_stride = _detail::adjusted_stride<T>(pos);
-    auto _tmp = stack.make_new_for_overwrite( //
-      tag,
-      tmp_stride,
-      _detail::align<T>());
-    auto d0xl10T = Eigen::Map<Eigen::Matrix< //
-                                T,
-                                Eigen::Dynamic,
-                                A_1::ColsAtCompileTime>,
-                              Eigen::Unaligned,
-                              Eigen::OuterStride<Eigen::Dynamic>>{
-      _tmp.ptr_mut(),
-      pos,
-      r,
-      tmp_stride,
-    };
-
-    ld11.template triangularView<Eigen::Lower>() =
-      a11.template triangularView<Eigen::Lower>();
-
-    if (l10.cols() > 0) {
-      d0xl10T = d0 * util::trans(l10);
-      ld11.template triangularView<Eigen::Lower>() -= l10 * d0xl10T;
-    }
-
-    l21 = a21;
-    util::noalias_mul_add(l21, l20, d0xl10T, T(-1));
-  }
-
-  proxsuite::linalg::dense::factorize(ld11, stack);
-  util::trans(ld11) //
-    .template triangularView<Eigen::UnitUpper>()
-    .template solveInPlace<Eigen::OnTheRight>(l21);
-
-  auto d1 = util::diagonal(ld11).asDiagonal();
-  l21 = l21 * d1.inverse();
-
-  auto w_stride = _detail::adjusted_stride<T>(rem);
-  auto _w = stack.make_new(tag, r * w_stride, _detail::align<T>());
-  auto _alpha = stack.make_new_for_overwrite(tag, r);
-
-  auto pw = _w.ptr_mut();
-  auto palpha = _alpha.ptr_mut();
-
-  for (isize k = 0; k < r; ++k) {
-    palpha[k] = -ld11(k, k);
-    T const* src_ptr = util::matrix_elem_addr(l21, 0, k);
-    std::copy(src_ptr, src_ptr + rem, pw + k * w_stride);
-  }
-
-  _detail::rank_r_update_clobber_w_impl( //
-    ld22,
-    pw,
-    w_stride,
-    palpha,
-    _detail::ConstantR{ r });
-}
-} // namespace _detail
-
-template<typename T>
-auto
-ldlt_delete_rows_and_cols_req(proxsuite::linalg::veg::Tag<T> /*tag*/,
-                              isize n,
-                              isize r) noexcept
-  -> proxsuite::linalg::veg::dynstack::StackReq
-{
-
-  auto w_req = proxsuite::linalg::veg::dynstack::StackReq{
-    _detail::adjusted_stride<T>(n - r) * r * isize{ sizeof(T) },
-    _detail::align<T>(),
-  };
-  auto alpha_req = proxsuite::linalg::veg::dynstack::StackReq{
-    r * isize{ sizeof(T) },
-    alignof(T),
-  };
-  return w_req & alpha_req;
-}
-
-template<typename Mat>
-void
-ldlt_delete_rows_and_cols_sort_indices( //
-  Mat&& ld,
-  isize* indices,
-  isize r,
-  proxsuite::linalg::veg::dynstack::DynStackMut stack)
-{
-  _detail::ldlt_delete_rows_and_cols_impl(
-    util::to_view_dyn(ld), indices, r, stack);
-}
-
-template<typename T>
-auto
-ldlt_insert_rows_and_cols_req(proxsuite::linalg::veg::Tag<T> tag,
-                              isize n,
-                              isize r) noexcept
-  -> proxsuite::linalg::veg::dynstack::StackReq
-{
-  auto factorize_req = proxsuite::linalg::dense::factorize_req(tag, r);
-
-  auto w_req = proxsuite::linalg::veg::dynstack::StackReq{
-    _detail::adjusted_stride<T>(n) * r * isize{ sizeof(T) },
-    _detail::align<T>(),
-  };
-  auto alpha_req = proxsuite::linalg::veg::dynstack::StackReq{
-    r * isize{ sizeof(T) },
-    alignof(T),
-  };
-
-  return (w_req & alpha_req) | factorize_req;
-}
-
-template<typename Mat, typename A_1>
-void
-ldlt_insert_rows_and_cols(Mat&& ld,
-                          isize pos,
-                          A_1 const& a_1,
-                          proxsuite::linalg::veg::dynstack::DynStackMut stack)
-{
-  _detail::ldlt_insert_rows_and_cols_impl(
-    util::to_view_dyn(ld), pos, util::to_view_dyn_rows(a_1), stack);
-}
-} // namespace dense
-} // namespace linalg
-} // namespace proxsuite
-
-#endif /* end of include guard PROXSUITE_LINALG_DENSE_LDLT_MODIFY_HPP */

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

@@ -1,38 +0,0 @@
-/** \file */
-//
-// Copyright (c) 2022 INRIA
-//
-#ifndef PROXSUITE_LINALG_DENSE_LDLT_SOLVE_HPP
-#define PROXSUITE_LINALG_DENSE_LDLT_SOLVE_HPP
-
-#include "proxsuite/linalg/dense/core.hpp"
-#include <Eigen/Core>
-
-namespace proxsuite {
-namespace linalg {
-namespace dense {
-namespace _detail {
-template<typename Mat, typename Rhs>
-void
-solve_impl(Mat ld, Rhs rhs)
-{
-  auto l = ld.template triangularView<Eigen::UnitLower>();
-  auto lt = util::trans(ld).template triangularView<Eigen::UnitUpper>();
-  auto d = util::diagonal(ld);
-
-  l.solveInPlace(rhs);
-  rhs = rhs.cwiseQuotient(d);
-  lt.solveInPlace(rhs);
-}
-} // namespace _detail
-template<typename Mat, typename Rhs>
-void
-solve(Mat const& mat, Rhs&& rhs)
-{
-  _detail::solve_impl(util::to_view(mat), util::to_view_dyn_rows(rhs));
-}
-} // namespace dense
-} // namespace linalg
-} // namespace proxsuite
-
-#endif /* end of include guard PROXSUITE_LINALG_DENSE_LDLT_SOLVE_HPP */

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

@@ -1,330 +0,0 @@
-/** \file */
-//
-// Copyright (c) 2022 INRIA
-//
-#ifndef PROXSUITE_LINALG_DENSE_LDLT_UPDATE_HPP
-#define PROXSUITE_LINALG_DENSE_LDLT_UPDATE_HPP
-
-#include "proxsuite/linalg/dense/core.hpp"
-
-namespace proxsuite {
-namespace linalg {
-namespace dense {
-namespace _detail {
-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);
-}
-
-template<usize... Is, typename Fn>
-VEG_INLINE void
-unroll_impl(proxsuite::linalg::veg::meta::index_sequence<Is...> /*unused*/,
-            Fn fn)
-{
-  VEG_EVAL_ALL(fn(Is));
-}
-
-template<usize N, typename Fn>
-VEG_INLINE void
-unroll(Fn fn)
-{
-  _detail::unroll_impl(proxsuite::linalg::veg::meta::make_index_sequence<N>{},
-                       VEG_FWD(fn));
-}
-
-template<typename T, usize N>
-struct RankUpdateLoadW
-{
-  _simd::Pack<T, N>* p_wr;
-  T const* pw;
-  isize w_stride;
-
-  VEG_INLINE void operator()(usize i) const
-  {
-    p_wr[i] = _simd::Pack<T, N>::load_unaligned(pw + w_stride * isize(i));
-  }
-};
-
-template<typename T, usize N>
-struct RankUpdateUpdateWAndL
-{
-  _simd::Pack<T, N>* p_wr;
-  _simd::Pack<T, N>& p_in_l;
-  _simd::Pack<T, N> const* p_p;
-  _simd::Pack<T, N> const* p_mu;
-
-  VEG_INLINE void operator()(usize i) const
-  {
-    p_wr[i] = _simd::Pack<T, N>::fnmadd(p_p[i], p_in_l, p_wr[i]);
-    p_in_l = _simd::Pack<T, N>::fmadd(p_mu[i], p_wr[i], p_in_l);
-  }
-};
-
-template<typename T, usize N>
-struct RankUpdateStoreW
-{
-  _simd::Pack<T, N> const* p_wr;
-  T* pw;
-  isize w_stride;
-
-  VEG_INLINE void operator()(usize i) const
-  {
-    p_wr[i].store_unaligned(pw + w_stride * isize(i));
-  }
-};
-
-template<usize R, typename T, usize N>
-VEG_INLINE void
-rank_r_update_inner_loop_iter( //
-  _simd::Pack<T, N> const* p_p,
-  _simd::Pack<T, N> const* p_mu,
-  T* inout_l,
-  T* pw,
-  isize w_stride)
-{
-
-  _simd::Pack<T, N> p_wr[R];
-  _detail::unroll<R>(RankUpdateLoadW<T, N>{ p_wr, pw, w_stride });
-  _simd::Pack<T, N> p_in_l = _simd::Pack<T, N>::load_unaligned(inout_l);
-  _detail::unroll<R>(RankUpdateUpdateWAndL<T, N>{ p_wr, p_in_l, p_p, p_mu });
-  _detail::unroll<R>(RankUpdateStoreW<T, N>{ p_wr, pw, w_stride });
-
-  p_in_l.store_unaligned(inout_l);
-}
-
-template<bool VECTORIZABLE>
-struct RankRUpdateLoopImpl;
-
-template<typename T, usize N>
-struct RankUpdateLoadPMu
-{
-  _simd::Pack<T, N>* p_p;
-  _simd::Pack<T, N>* p_mu;
-  T const* p;
-  T const* mu;
-  VEG_INLINE void operator()(usize i) const
-  {
-    p_p[i] = _simd::Pack<T, N>::broadcast(p[i]);
-    p_mu[i] = _simd::Pack<T, N>::broadcast(mu[i]);
-  }
-};
-
-template<>
-struct RankRUpdateLoopImpl<false>
-{
-  template<usize R, typename T>
-  VEG_INLINE static void fn(isize n,
-                            T* inout_l,
-                            T* pw,
-                            isize w_stride,
-                            T const* p,
-                            T const* mu) noexcept
-  {
-    using Pack_ = _simd::Pack<T, 1>;
-    Pack_ p_p[R];
-    Pack_ p_mu[R];
-
-    _detail::unroll<R>(RankUpdateLoadPMu<T, 1>{ p_p, p_mu, p, mu });
-
-    auto inout_l_finish = inout_l + n;
-    while (inout_l < inout_l_finish) {
-      _detail::rank_r_update_inner_loop_iter<R>(
-        p_p, p_mu, inout_l, pw, w_stride);
-      ++inout_l;
-      ++pw;
-    }
-  }
-};
-
-template<>
-struct RankRUpdateLoopImpl<true>
-{
-  template<usize R, typename T>
-  VEG_INLINE static void fn(isize n,
-                            T* inout_l,
-                            T* pw,
-                            isize w_stride,
-                            T const* p,
-                            T const* mu) noexcept
-  {
-
-    // best perf if beginning of each pw is aligned
-    // should be enforced by the Ldlt class
-
-    using Info = _simd::NativePackInfo<T>;
-    constexpr usize N = Info::N;
-    auto inout_l_vectorized_end = inout_l + usize(n) / N * N;
-    auto inout_l_end = inout_l + usize(n);
-
-    {
-      using Pack = _simd::NativePack<T>;
-      Pack p_p[R];
-      Pack p_mu[R];
-
-      _detail::unroll<R>(RankUpdateLoadPMu<T, N>{ p_p, p_mu, p, mu });
-
-      while (inout_l < inout_l_vectorized_end) {
-        _detail::rank_r_update_inner_loop_iter<R>(
-          p_p, p_mu, inout_l, pw, w_stride);
-        inout_l += N;
-        pw += N;
-      }
-    }
-    {
-      using Pack_ = _simd::Pack<T, 1>;
-      Pack_ p_p[R];
-      Pack_ p_mu[R];
-
-      _detail::unroll<R>(RankUpdateLoadPMu<T, 1>{ p_p, p_mu, p, mu });
-
-      while (inout_l < inout_l_end) {
-        _detail::rank_r_update_inner_loop_iter<R>(
-          p_p, p_mu, inout_l, pw, w_stride);
-        ++inout_l;
-        ++pw;
-      }
-    }
-  }
-};
-
-template<usize R, typename T>
-VEG_INLINE void
-rank_r_update_inner_loop(isize n,
-                         T* inout_l,
-                         T* pw,
-                         isize w_stride,
-                         T const* p,
-                         T const* mu)
-{
-  RankRUpdateLoopImpl<should_vectorize<T>::value>::template fn<R>(
-    n, inout_l, pw, w_stride, p, mu);
-}
-
-template<typename LD, typename T, typename Fn>
-void
-rank_r_update_clobber_w_impl( //
-  LD ld,
-  T* pw,
-  isize w_stride,
-  T* palpha,
-  Fn r_fn)
-{
-  static_assert(LD::InnerStrideAtCompileTime == 1, ".");
-  static_assert(!bool(LD::IsRowMajor), ".");
-
-  isize n = ld.rows();
-
-  for (isize j = 0; j < n; ++j) {
-    isize r = r_fn();
-
-    isize r_done = 0;
-    if (!(r_done < r)) {
-      continue;
-    }
-
-    while (true) {
-      isize r_chunk = min2(isize(4), r - r_done);
-
-      T p_array[4];
-      T mu_array[4];
-
-      T dj = ld(j, j);
-      for (isize k = 0; k < r_chunk; ++k) {
-        auto& p = (+p_array)[k];
-        auto& mu = (+mu_array)[k];
-        auto& alpha = palpha[r_done + k];
-
-        p = pw[(r_done + k) * w_stride];
-        T new_dj = dj + (alpha * p) * p;
-        mu = (alpha * p) / new_dj;
-        alpha -= new_dj * (mu * mu);
-
-        dj = new_dj;
-      }
-      ld(j, j) = dj;
-
-      isize rem = n - j - 1;
-
-      using FnType = void (*)(isize, T*, T*, isize, T const*, T const*);
-      FnType fn_table[] = {
-        rank_r_update_inner_loop<1, T>,
-        rank_r_update_inner_loop<2, T>,
-        rank_r_update_inner_loop<3, T>,
-        rank_r_update_inner_loop<4, T>,
-      };
-
-      (*fn_table[r_chunk - 1])( //
-        rem,
-        util::matrix_elem_addr(ld, j + 1, j),
-        pw + 1 + r_done * w_stride,
-        w_stride,
-        p_array,
-        mu_array);
-
-      r_done += r_chunk;
-      if (!(r_done < r)) {
-        break;
-      }
-    }
-    ++pw;
-  }
-}
-struct ConstantR
-{
-  isize r;
-  VEG_INLINE auto operator()() const noexcept -> isize { return r; }
-};
-} // namespace _detail
-
-template<typename LD,
-         typename W,
-         typename T = typename proxsuite::linalg::veg::uncvref_t<LD>::Scalar>
-void
-rank_1_update_clobber_w(LD&& ld,
-                        W&& w,
-                        proxsuite::linalg::veg::DoNotDeduce<T> alpha)
-{
-  _detail::rank_r_update_clobber_w_impl( //
-    util::to_view_dyn(ld),
-    w.data(),
-    0,
-    proxsuite::linalg::veg::mem::addressof(alpha),
-    _detail::ConstantR{ 1 });
-}
-
-template<typename LD,
-         typename W,
-         typename A,
-         typename T = typename proxsuite::linalg::veg::uncvref_t<LD>::Scalar>
-void
-rank_r_update_clobber_inputs(LD&& ld, W&& w, A&& alpha)
-{
-  isize r = w.cols();
-  _detail::rank_r_update_clobber_w_impl( //
-    util::to_view_dyn(ld),
-    w.data(),
-    w.outerStride(),
-    alpha.data(),
-    _detail::ConstantR{ r });
-}
-} // namespace dense
-} // namespace linalg
-} // namespace proxsuite
-
-#endif /* end of include guard PROXSUITE_LINALG_DENSE_LDLT_UPDATE_HPP */