casadi 3.6.5__cp38-none-macosx_11_0_arm64.whl → 3.6.7__cp38-none-macosx_11_0_arm64.whl

casadi/include/alpaqa/util/print.hpp

@@ -1,78 +0,0 @@
-#pragma once
-
-#include <alpaqa/export.hpp>
-#include <alpaqa/util/float.hpp>
-
-#include <iosfwd>
-#include <limits>
-#include <string>
-#include <string_view>
-
-#include <Eigen/Core>
-
-namespace alpaqa {
-
-template <std::floating_point F>
-ALPAQA_EXPORT std::string
-float_to_str(F value, int precision = std::numeric_limits<F>::max_digits10);
-
-template <class T>
-ALPAQA_EXPORT std::ostream &
-print_csv_impl(std::ostream &os, const T &M, std::string_view sep = ",",
-               std::string_view begin = "", std::string_view end = "\n");
-
-template <class T>
-ALPAQA_EXPORT std::ostream &print_matlab_impl(std::ostream &os, const T &M,
-                                              std::string_view end = ";\n");
-
-template <class T>
-ALPAQA_EXPORT std::ostream &print_python_impl(std::ostream &os, const T &M,
-                                              std::string_view end = "\n");
-
-#define ALPAQA_PRINT_CSV_OVL_IMPL(type)                                        \
-    inline std::ostream &print_csv(                                            \
-        std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<type>> &M,     \
-        std::string_view sep, std::string_view begin, std::string_view end) {  \
-        return print_csv_impl(os, M, sep, begin, end);                         \
-    }                                                                          \
-    inline std::ostream &print_csv(                                            \
-        std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<type>> &M,     \
-        std::string_view sep, std::string_view begin) {                        \
-        return print_csv_impl(os, M, sep, begin);                              \
-    }                                                                          \
-    inline std::ostream &print_csv(                                            \
-        std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<type>> &M,     \
-        std::string_view sep) {                                                \
-        return print_csv_impl(os, M, sep);                                     \
-    }                                                                          \
-    inline std::ostream &print_csv(                                            \
-        std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<type>> &M) {   \
-        return print_csv_impl(os, M);                                          \
-    }
-#define ALPAQA_PRINT_OVL_IMPL(name, type)                                      \
-    inline std::ostream &print_##name(                                         \
-        std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<type>> &M,     \
-        std::string_view end) {                                                \
-        return print_##name##_impl(os, M, end);                                \
-    }                                                                          \
-    inline std::ostream &print_##name(                                         \
-        std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<type>> &M) {   \
-        return print_##name##_impl(os, M);                                     \
-    }
-#define ALPAQA_PRINT_OVL(type)                                                 \
-    ALPAQA_PRINT_CSV_OVL_IMPL(type)                                            \
-    ALPAQA_PRINT_OVL_IMPL(matlab, type)                                        \
-    ALPAQA_PRINT_OVL_IMPL(python, type)
-
-ALPAQA_PRINT_OVL(float)
-ALPAQA_PRINT_OVL(double)
-ALPAQA_PRINT_OVL(long double)
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_PRINT_OVL(__float128)
-#endif
-
-#undef ALPAQA_PRINT_OVL
-#undef ALPAQA_PRINT_OVL_IMPL
-#undef ALPAQA_PRINT_CSV_OVL_IMPL
-
-} // namespace alpaqa

casadi/include/alpaqa/util/quadmath/quadmath-print.hpp

@@ -1,20 +0,0 @@
-#pragma once
-
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-
-#include <alpaqa/util/quadmath/quadmath.hpp>
-
-#include <cassert>
-#include <ostream>
-
-namespace std {
-inline ostream &operator<<(ostream &os, __float128 f) {
-    char buf[128];
-    auto precision         = static_cast<int>(os.precision());
-    [[maybe_unused]] int n = quadmath_snprintf(buf, sizeof(buf), "%#.*Qg", precision, f);
-    assert((size_t)n < sizeof buf);
-    return os << buf;
-}
-} // namespace std
-
-#endif

casadi/include/alpaqa/util/quadmath/quadmath.hpp

@@ -1,137 +0,0 @@
-#pragma once
-
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-#pragma GCC system_header
-
-#include <quadmath.h>
-
-#include <alpaqa/export.h>
-
-#include <cmath>
-#include <iosfwd>
-#include <limits>
-
-namespace std {
-
-// From GCC 11's <limits>
-
-/// numeric_limits<__float128> specialization.
-template <>
-struct numeric_limits<__float128> {
-    static constexpr bool is_specialized = true;
-
-    static constexpr __float128 min() noexcept { return FLT128_MIN; }
-    static constexpr __float128 max() noexcept { return FLT128_MAX; }
-    static constexpr __float128 lowest() noexcept { return -FLT128_MAX; }
-
-    static constexpr int digits       = FLT128_MANT_DIG;
-    static constexpr int digits10     = FLT128_DIG;
-    static constexpr int max_digits10 = (2 + FLT128_MANT_DIG * 643L / 2136);
-    static constexpr bool is_signed   = true;
-    static constexpr bool is_integer  = false;
-    static constexpr bool is_exact    = false;
-    static constexpr int radix        = 2;
-
-    static constexpr __float128 epsilon() noexcept { return FLT128_EPSILON; }
-    static constexpr __float128 round_error() noexcept { return 0.5Q; }
-
-    static constexpr int min_exponent   = FLT128_MIN_EXP;
-    static constexpr int min_exponent10 = FLT128_MIN_10_EXP;
-    static constexpr int max_exponent   = FLT128_MAX_EXP;
-    static constexpr int max_exponent10 = FLT128_MAX_10_EXP;
-
-    static constexpr bool has_infinity             = true;
-    static constexpr bool has_quiet_NaN            = true;
-    static constexpr bool has_signaling_NaN        = has_quiet_NaN;
-    static constexpr float_denorm_style has_denorm = denorm_present;
-    static constexpr bool has_denorm_loss          = false;
-
-    static constexpr __float128 infinity() noexcept { return __builtin_huge_valq(); }
-    static constexpr __float128 quiet_NaN() noexcept { return __builtin_nanq(""); }
-    static constexpr __float128 signaling_NaN() noexcept { return __builtin_nansq(""); }
-    static constexpr __float128 denorm_min() noexcept { return FLT128_DENORM_MIN; }
-
-    static constexpr bool is_iec559 = has_infinity && has_quiet_NaN && has_denorm == denorm_present;
-    static constexpr bool is_bounded = true;
-    static constexpr bool is_modulo  = false;
-
-    static constexpr bool traps                    = false;
-    static constexpr bool tinyness_before          = false;
-    static constexpr float_round_style round_style = round_to_nearest;
-};
-
-// From GCC's quadmath.h
-
-inline __float128 acos(__float128 x) { return ::acosq(x); }
-inline __float128 acosh(__float128 x) { return ::acoshq(x); }
-inline __float128 asin(__float128 x) { return ::asinq(x); }
-inline __float128 asinh(__float128 x) { return ::asinhq(x); }
-inline __float128 atan(__float128 x) { return ::atanq(x); }
-inline __float128 atanh(__float128 x) { return ::atanhq(x); }
-inline __float128 atan2(__float128 x, __float128 y) { return ::atan2q(x, y); }
-inline __float128 cbrt(__float128 x) { return ::cbrtq(x); }
-inline __float128 ceil(__float128 x) { return ::ceilq(x); }
-inline __float128 copysign(__float128 x, __float128 y) { return ::copysignq(x, y); }
-inline __float128 cosh(__float128 x) { return ::coshq(x); }
-inline __float128 cos(__float128 x) { return ::cosq(x); }
-inline __float128 erf(__float128 x) { return ::erfq(x); }
-inline __float128 erfc(__float128 x) { return ::erfcq(x); }
-inline __float128 exp2(__float128 x) { return ::exp2q(x); }
-inline __float128 exp(__float128 x) { return ::expq(x); }
-inline __float128 expm1(__float128 x) { return ::expm1q(x); }
-inline __float128 fabs(__float128 x) { return ::fabsq(x); }
-inline __float128 fdim(__float128 x, __float128 y) { return ::fdimq(x, y); }
-inline int finite(__float128 x) { return ::finiteq(x); }
-inline __float128 floor(__float128 x) { return ::floorq(x); }
-inline __float128 fma(__float128 x, __float128 y, __float128 z) { return ::fmaq(x, y, z); }
-inline __float128 fmax(__float128 x, __float128 y) { return ::fmaxq(x, y); }
-inline __float128 fmin(__float128 x, __float128 y) { return ::fminq(x, y); }
-inline __float128 fmod(__float128 x, __float128 y) { return ::fmodq(x, y); }
-inline __float128 frexp(__float128 x, int *y) { return ::frexpq(x, y); }
-inline __float128 hypot(__float128 x, __float128 y) { return ::hypotq(x, y); }
-inline int isinf(__float128 x) { return ::isinfq(x); }
-inline int ilogb(__float128 x) { return ::ilogbq(x); }
-inline int isfinite(__float128 x) { return ::finiteq(x); }
-inline int isnan(__float128 x) { return ::isnanq(x); }
-inline int issignaling(__float128 x) { return ::issignalingq(x); }
-inline __float128 j0(__float128 x) { return ::j0q(x); }
-inline __float128 j1(__float128 x) { return ::j1q(x); }
-inline __float128 jn(int n, __float128 x) { return ::jnq(n, x); }
-inline __float128 ldexp(__float128 x, int y) { return ::ldexpq(x, y); }
-inline __float128 lgamma(__float128 x) { return ::lgammaq(x); }
-inline long long int llrint(__float128 x) { return ::llrintq(x); }
-inline long long int llround(__float128 x) { return ::llroundq(x); }
-inline __float128 logb(__float128 x) { return ::logbq(x); }
-inline __float128 log(__float128 x) { return ::logq(x); }
-inline __float128 log10(__float128 x) { return ::log10q(x); }
-inline __float128 log2(__float128 x) { return ::log2q(x); }
-inline __float128 log1p(__float128 x) { return ::log1pq(x); }
-inline long int lrint(__float128 x) { return ::lrintq(x); }
-inline long int lround(__float128 x) { return ::lroundq(x); }
-inline __float128 modf(__float128 x, __float128 *y) { return ::modfq(x, y); }
-// inline __float128 nan(const char *x) { return ::nanq(x); }
-inline __float128 nearbyint(__float128 x) { return ::nearbyintq(x); }
-inline __float128 nextafter(__float128 x, __float128 y) { return ::nextafterq(x, y); }
-inline __float128 pow(__float128 x, __float128 y) { return ::powq(x, y); }
-inline __float128 remainder(__float128 x, __float128 y) { return ::remainderq(x, y); }
-inline __float128 remquo(__float128 x, __float128 y, int *z) { return ::remquoq(x, y, z); }
-inline __float128 rint(__float128 x) { return ::rintq(x); }
-inline __float128 round(__float128 x) { return ::roundq(x); }
-inline __float128 scalbln(__float128 x, long int y) { return ::scalblnq(x, y); }
-inline __float128 scalbn(__float128 x, int y) { return ::scalbnq(x, y); }
-inline int signbit(__float128 x) { return ::signbitq(x); }
-inline void sincosq(__float128 x, __float128 *y, __float128 *z) { return ::sincosq(x, y, z); }
-inline __float128 sinh(__float128 x) { return ::sinhq(x); }
-inline __float128 sin(__float128 x) { return ::sinq(x); }
-inline __float128 sqrt(__float128 x) { return ::sqrtq(x); }
-inline __float128 tan(__float128 x) { return ::tanq(x); }
-inline __float128 tanh(__float128 x) { return ::tanhq(x); }
-inline __float128 tgamma(__float128 x) { return ::tgammaq(x); }
-inline __float128 trunc(__float128 x) { return ::truncq(x); }
-inline __float128 y0(__float128 x) { return ::y0q(x); }
-inline __float128 y1(__float128 x) { return ::y1q(x); }
-inline __float128 yn(int n, __float128 x) { return ::ynq(n, x); }
-
-} // namespace std
-
-#endif

casadi/include/alpaqa/util/required-method.hpp

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <alpaqa/util/type-erasure.hpp>
-#include <functional> // std::invoke
-
-#define ALPAQA_TE_REQUIRED_METHOD(vtable, type, member)                        \
-    do {                                                                       \
-        static_assert(                                                         \
-            requires { &type::member; },                                       \
-            "Missing required method '" #type "::" #member "'");               \
-        (vtable).member = util::type_erased_wrapped<type, &type::member>();    \
-    } while (0)
-#define ALPAQA_TE_OPTIONAL_METHOD(vtable, type, member, instance)              \
-    do {                                                                       \
-        if constexpr (requires { &type::member; }) {                           \
-            using vtable_t     = std::remove_cvref_t<decltype(vtable)>;        \
-            auto assign_vtable = [&] {                                         \
-                (vtable).member =                                              \
-                    util::type_erased_wrapped<type, &type::member,             \
-                                              const vtable_t &>();             \
-            };                                                                 \
-            if constexpr (requires { &type::provides_##member; }) {            \
-                if (std::invoke(&type::provides_##member, instance))           \
-                    assign_vtable();                                           \
-            } else {                                                           \
-                assign_vtable();                                               \
-            }                                                                  \
-        }                                                                      \
-    } while (0)

casadi/include/alpaqa/util/ringbuffer.hpp

@@ -1,212 +0,0 @@
-#pragma once
-
-#include <cstddef>
-#include <iterator>
-
-namespace alpaqa {
-
-template <class IndexT = size_t>
-struct CircularIndices {
-    using Index = IndexT;
-    CircularIndices(Index zerobased, Index circular)
-        : zerobased(zerobased), circular(circular) {}
-    Index zerobased;
-    Index circular;
-};
-/// @related    CircularIndices
-/// @note   Only valid for two indices in the same range.
-template <class IndexT>
-bool operator==(CircularIndices<IndexT> a, CircularIndices<IndexT> b) {
-    return a.zerobased == b.zerobased;
-}
-/// @related    CircularIndices
-/// @note   Only valid for two indices in the same range.
-template <class IndexT>
-bool operator!=(CircularIndices<IndexT> a, CircularIndices<IndexT> b) {
-    return !(a == b);
-}
-
-template <class IndexT = size_t>
-struct CircularIndexIterator {
-    using Index   = IndexT;
-    using Indices = CircularIndices<Index>;
-
-    CircularIndexIterator() : i{0, 0}, max{0} {}
-    CircularIndexIterator(Indices i, Index max) : i(i), max(max) {}
-
-    Indices i;
-    Index max;
-
-    using value_type        = Indices;
-    using reference         = value_type;
-    using difference_type   = std::ptrdiff_t; // This is required but not used
-    using pointer           = void;
-    using iterator_category = std::input_iterator_tag;
-
-    reference operator*() const { return i; }
-    CircularIndexIterator &operator++() {
-        assert(i.zerobased < max);
-        ++i.zerobased;
-        i.circular = i.circular + 1 == max ? Index{0} : i.circular + 1;
-        return *this;
-    }
-    CircularIndexIterator &operator--() {
-        assert(i.zerobased > 0);
-        --i.zerobased;
-        i.circular = i.circular == Index{0} ? max - 1 : i.circular - 1;
-        return *this;
-    }
-    CircularIndexIterator operator++(int) {
-        auto r = *this;
-        ++(*this);
-        return r;
-    }
-    CircularIndexIterator operator--(int) {
-        auto r = *this;
-        --(*this);
-        return r;
-    }
-};
-
-/// @related    CircularIndexIterator
-/// @note   Only valid for two indices in the same range.
-template <class IndexT>
-bool operator==(CircularIndexIterator<IndexT> a,
-                CircularIndexIterator<IndexT> b) {
-    assert(a.max == b.max);
-    return a.i == b.i;
-}
-/// @related    CircularIndexIterator
-/// @note   Only valid for two indices in the same range.
-template <class IndexT>
-bool operator!=(CircularIndexIterator<IndexT> a,
-                CircularIndexIterator<IndexT> b) {
-    return !(a == b);
-}
-
-template <class IndexT = size_t>
-struct ReverseCircularIndexIterator {
-    using ForwardIterator = CircularIndexIterator<IndexT>;
-    using Index           = typename ForwardIterator::Index;
-    using Indices         = typename ForwardIterator::Indices;
-
-    ReverseCircularIndexIterator() : forwardit() {}
-    ReverseCircularIndexIterator(Indices i, Index max) : forwardit(i, max) {}
-    ReverseCircularIndexIterator(ForwardIterator forwardit)
-        : forwardit(forwardit) {}
-
-    ForwardIterator forwardit;
-
-    using value_type        = Indices;
-    using reference         = value_type;
-    using difference_type   = std::ptrdiff_t; // This is required but not used
-    using pointer           = void;
-    using iterator_category = std::input_iterator_tag;
-
-    reference operator*() const {
-        auto tmp = forwardit;
-        return *(--tmp);
-    }
-    ReverseCircularIndexIterator &operator++() {
-        --forwardit;
-        return *this;
-    }
-    ReverseCircularIndexIterator &operator--() {
-        ++forwardit;
-        return *this;
-    }
-    ReverseCircularIndexIterator operator++(int) {
-        auto r = *this;
-        ++(*this);
-        return r;
-    }
-    ReverseCircularIndexIterator operator--(int) {
-        auto r = *this;
-        --(*this);
-        return r;
-    }
-};
-
-/// @related    ReverseCircularIndexIterator
-/// @note   Only valid for two indices in the same range.
-template <class IndexT>
-bool operator==(ReverseCircularIndexIterator<IndexT> a,
-                ReverseCircularIndexIterator<IndexT> b) {
-    return a.forwardit == b.forwardit;
-}
-/// @related    ReverseCircularIndexIterator
-/// @note   Only valid for two indices in the same range.
-template <class IndexT>
-bool operator!=(ReverseCircularIndexIterator<IndexT> a,
-                ReverseCircularIndexIterator<IndexT> b) {
-    return !(a == b);
-}
-
-template <class IndexT>
-class CircularRange {
-  public:
-    using Index   = IndexT;
-    using Indices = CircularIndices<Index>;
-
-    CircularRange(Index size, Index idx1, Index idx2, Index max)
-        : size(size), idx1(idx1), idx2(idx2), max(max) {}
-
-    using const_iterator = CircularIndexIterator<Index>;
-    using iterator       = const_iterator;
-
-    using const_reverse_iterator = ReverseCircularIndexIterator<Index>;
-    using reverse_iterator       = const_reverse_iterator;
-
-    iterator begin() const { return {{Index{0}, idx1}, max}; }
-    iterator end() const { return {{size, idx2}, max}; }
-    const_iterator cbegin() const { return begin(); }
-    const_iterator cend() const { return end(); }
-
-    reverse_iterator rbegin() const { return reverse_iterator{end()}; }
-    reverse_iterator rend() const { return reverse_iterator{begin()}; }
-    const_reverse_iterator crbegin() const {
-        return const_reverse_iterator{end()};
-    }
-    const_reverse_iterator crend() const {
-        return const_reverse_iterator{begin()};
-    }
-
-  private:
-    Index size;
-    Index idx1, idx2;
-    Index max;
-};
-
-template <class IndexT>
-class ReverseCircularRange {
-  public:
-    using ForwardRange = CircularRange<IndexT>;
-    using Index        = typename ForwardRange::Index;
-    using Indices      = typename ForwardRange::Indices;
-
-    ReverseCircularRange(const ForwardRange &forwardrange)
-        : forwardrange(forwardrange) {}
-    ReverseCircularRange(Index size, Index idx1, Index idx2, Index max)
-        : forwardrange(size, idx1, idx2, max) {}
-
-    using const_iterator = typename ForwardRange::const_reverse_iterator;
-    using iterator       = typename ForwardRange::reverse_iterator;
-
-    using const_reverse_iterator = typename ForwardRange::const_iterator;
-    using reverse_iterator       = typename ForwardRange::iterator;
-
-    iterator begin() const { return forwardrange.rbegin(); }
-    iterator end() const { return forwardrange.rend(); }
-    const_iterator cbegin() const { return forwardrange.crbegin(); }
-    const_iterator cend() const { return forwardrange.crend(); }
-
-    reverse_iterator rbegin() const { return forwardrange.begin(); }
-    reverse_iterator rend() const { return forwardrange.end(); }
-    const_reverse_iterator crbegin() const { return forwardrange.cbegin(); }
-    const_reverse_iterator crend() const { return forwardrange.cend(); }
-
-  private:
-    ForwardRange forwardrange;
-};
-
-} // namespace alpaqa

casadi/include/alpaqa/util/set-intersection.hpp

@@ -1,129 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <functional>
-#include <iterator>
-#include <ranges>
-
-namespace alpaqa::util {
-
-template <std::ranges::input_range R1, std::ranges::input_range R2,
-          class Comp = std::ranges::less, class Proj1 = std::identity,
-          class Proj2 = std::identity>
-    requires(std::ranges::view<R1> && std::ranges::view<R2>)
-struct set_intersection_iterable
-    : std::ranges::view_interface<
-          set_intersection_iterable<R1, R2, Comp, Proj1, Proj2>> {
-
-    R1 range1;
-    R2 range2;
-    Comp comp;
-    Proj1 proj1;
-    Proj2 proj2;
-
-    // P2325R3: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2325r3.html
-    set_intersection_iterable() = default;
-    set_intersection_iterable(R1 &&range1, R2 &&range2, Comp &&comp,
-                              Proj1 &&proj1, Proj2 &&proj2)
-        : range1{std::forward<R1>(range1)}, range2{std::forward<R2>(range2)},
-          comp{std::forward<Comp>(comp)}, proj1{std::forward<Proj1>(proj1)},
-          proj2{std::forward<Proj2>(proj2)} {}
-
-    struct sentinel_t {};
-    template <std::input_iterator I1, std::sentinel_for<I1> S1,
-              std::input_iterator I2, std::sentinel_for<I2> S2>
-    struct iter_t {
-        // P2325R3: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2325r3.html
-        iter_t() = default;
-        iter_t(I1 first1, S1 last1, I2 first2, S2 last2, Comp comp, Proj1 proj1,
-               Proj2 proj2)
-            : first1{std::move(first1)}, last1{std::move(last1)},
-              first2{std::move(first2)}, last2{std::move(last2)},
-              comp{std::move(comp)}, proj1{std::move(proj1)}, proj2{std::move(
-                                                                  proj2)} {}
-        I1 first1;
-        S1 last1;
-        I2 first2;
-        S2 last2;
-        Comp comp;
-        Proj1 proj1;
-        Proj2 proj2;
-
-        using difference_type = std::ptrdiff_t; // TODO
-        using value_type = std::tuple<decltype(*first1), decltype(*first2)>;
-
-        bool operator!=(sentinel_t) const {
-            return first1 != last1 && first2 != last2;
-        }
-        bool operator==(sentinel_t s) const { return !(*this != s); }
-        // TODO: For Clang bug
-        friend bool operator!=(sentinel_t s, const iter_t &i) { return i != s; }
-        friend bool operator==(sentinel_t s, const iter_t &i) { return i == s; }
-
-        iter_t &operator++() {
-            ++first1, ++first2;
-            advance();
-            return *this;
-        }
-        iter_t operator++(int) {
-            auto tmp = *this;
-            ++*this;
-            return tmp;
-        }
-        value_type operator*() const { return {*first1, *first2}; }
-        void advance() {
-            while (*this != sentinel_t{}) {
-                if (std::invoke(comp, std::invoke(proj1, *first1),
-                                std::invoke(proj2, *first2)))
-                    ++first1;
-                else if (std::invoke(comp, std::invoke(proj2, *first2),
-                                     std::invoke(proj1, *first1)))
-                    ++first2;
-                else
-                    break;
-            }
-        }
-    };
-
-  private:
-    template <class I1, class S1, class I2, class S2>
-    iter_t<I1, S1, I2, S2> iter(I1 first1, S1 last1, I2 first2,
-                                S2 last2) const {
-        return {first1, last1, first2, last2, comp, proj1, proj2};
-    }
-
-  public:
-    auto begin() const -> std::input_or_output_iterator auto{
-        auto it = iter(std::ranges::begin(range1), std::ranges::end(range1),
-                       std::ranges::begin(range2), std::ranges::end(range2));
-        it.advance();
-        return it;
-    }
-    auto end() const
-    // -> std::sentinel_for< decltype(std::declval<set_intersection_iterable>().begin())> auto
-    {
-        return sentinel_t{};
-    }
-};
-
-template <std::ranges::viewable_range R1, std::ranges::viewable_range R2,
-          class Comp = std::ranges::less, class Proj1 = std::identity,
-          class Proj2 = std::identity>
-set_intersection_iterable<std::ranges::views::all_t<R1>,
-                          std::ranges::views::all_t<R2>, Comp, Proj1, Proj2>
-iter_set_intersection(R1 &&r1, R2 &&r2, Comp comp = {}, Proj1 proj1 = {},
-                      Proj2 proj2 = {}) {
-    static_assert(
-        requires(set_intersection_iterable<std::ranges::views::all_t<R1>,
-                                           std::ranges::views::all_t<R2>, Comp,
-                                           Proj1, Proj2>
-                     s) {
-            { s.end() } -> std::sentinel_for<decltype(s.begin())>;
-        });
-    return {
-        std::forward<R1>(r1), std::forward<R2>(r2), std::move(comp),
-        std::move(proj1),     std::move(proj2),
-    };
-}
-
-} // namespace alpaqa::util