casadi 3.6.5__cp312-none-macosx_11_0_arm64.whl → 3.6.6__cp312-none-macosx_11_0_arm64.whl

casadi/include/alpaqa/problem/unconstr-problem.hpp

@@ -1,37 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-
-namespace alpaqa {
-
-/// Implements common problem functions for minimization problems without
-/// constraints. Meant to be used as a base class for custom problem
-/// implementations.
-/// @ingroup grp_Problems
-template <Config Conf>
-class UnconstrProblem {
-  public:
-    USING_ALPAQA_CONFIG(Conf);
-    /// Number of constraints
-    length_t get_m() const { return 0; }
-
-    void eval_g(crvec, rvec) const {}
-    void eval_grad_g_prod(crvec, crvec, rvec grad) const { grad.setZero(); }
-    void eval_jac_g(crvec, rindexvec, rindexvec, rvec) const {}
-    void eval_grad_gi(crvec, index_t, rvec grad_gi) const { grad_gi.setZero(); }
-
-    /// @see @ref TypeErasedProblem::eval_prox_grad_step
-    real_t eval_prox_grad_step(real_t γ, crvec x, crvec grad_ψ, rvec x̂, rvec p) const {
-        p = -γ * grad_ψ;
-        x̂ = x + p;
-        return 0;
-    }
-
-    /// @see @ref TypeErasedProblem::eval_proj_diff_g
-    void eval_proj_diff_g(crvec, rvec) const {}
-
-    /// @see @ref TypeErasedProblem::eval_proj_multipliers
-    void eval_proj_multipliers(rvec, real_t) const {}
-};
-
-} // namespace alpaqa

casadi/include/alpaqa/structured-panoc-alm.hpp

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <alpaqa/inner/directions/panoc/structured-lbfgs.hpp>
-#include <alpaqa/inner/panoc.hpp>
-#include <alpaqa/outer/alm.hpp>
-
-namespace alpaqa {
-
-// clang-format off
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, StructuredLBFGSDirection<DefaultConfig>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, StructuredLBFGSDirection<EigenConfigf>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, StructuredLBFGSDirection<EigenConfigd>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, StructuredLBFGSDirection<EigenConfigl>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, StructuredLBFGSDirection<EigenConfigq>);
-#endif
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<StructuredLBFGSDirection<DefaultConfig>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<StructuredLBFGSDirection<EigenConfigf>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<StructuredLBFGSDirection<EigenConfigd>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<StructuredLBFGSDirection<EigenConfigl>>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<StructuredLBFGSDirection<EigenConfigq>>);
-#endif
-// clang-format on
-
-} // namespace alpaqa

casadi/include/alpaqa/structured-zerofpr-alm.hpp

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <alpaqa/inner/directions/panoc/structured-lbfgs.hpp>
-#include <alpaqa/inner/zerofpr.hpp>
-#include <alpaqa/outer/alm.hpp>
-
-namespace alpaqa {
-
-// clang-format off
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ZeroFPRSolver, StructuredLBFGSDirection<DefaultConfig>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ZeroFPRSolver, StructuredLBFGSDirection<EigenConfigf>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ZeroFPRSolver, StructuredLBFGSDirection<EigenConfigd>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ZeroFPRSolver, StructuredLBFGSDirection<EigenConfigl>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ZeroFPRSolver, StructuredLBFGSDirection<EigenConfigq>);
-#endif
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, ZeroFPRSolver<StructuredLBFGSDirection<DefaultConfig>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, ZeroFPRSolver<StructuredLBFGSDirection<EigenConfigf>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, ZeroFPRSolver<StructuredLBFGSDirection<EigenConfigd>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, ZeroFPRSolver<StructuredLBFGSDirection<EigenConfigl>>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, ZeroFPRSolver<StructuredLBFGSDirection<EigenConfigq>>);
-#endif
-// clang-format on
-
-} // namespace alpaqa

casadi/include/alpaqa/util/alloc-check.hpp

@@ -1,23 +0,0 @@
-#pragma once
-
-#include <Eigen/Core>
-
-namespace alpaqa {
-
-#ifdef EIGEN_RUNTIME_NO_MALLOC
-template <bool Allow>
-struct ScopedMallocChecker {
-    ScopedMallocChecker() : prev(Eigen::internal::is_malloc_allowed()) {
-        Eigen::internal::set_is_malloc_allowed(Allow);
-    }
-    ~ScopedMallocChecker() { Eigen::internal::set_is_malloc_allowed(prev); }
-    bool prev;
-};
-#else
-template <bool>
-struct [[maybe_unused]] ScopedMallocChecker {};
-#endif
-struct [[maybe_unused]] ScopedMallocBlocker : ScopedMallocChecker<false> {};
-struct [[maybe_unused]] ScopedMallocAllower : ScopedMallocChecker<true> {};
-
-} // namespace alpaqa

casadi/include/alpaqa/util/atomic-stop-signal.hpp

@@ -1,24 +0,0 @@
-#pragma once
-
-#include <atomic>
-
-namespace alpaqa {
-
-class AtomicStopSignal {
-  public:
-    AtomicStopSignal() = default;
-    AtomicStopSignal(const AtomicStopSignal &) : AtomicStopSignal() {}
-    AtomicStopSignal &operator=(const AtomicStopSignal &) = delete;
-    AtomicStopSignal(AtomicStopSignal &&) : AtomicStopSignal() {}
-    AtomicStopSignal &operator=(AtomicStopSignal &&) { return *this; }
-
-    void stop() { stop_flag.store(true, std::memory_order_relaxed); }
-    bool stop_requested() const {
-        return stop_flag.load(std::memory_order_relaxed);
-    }
-
-  private:
-    std::atomic<bool> stop_flag{false};
-};
-
-} // namespace alpaqa

casadi/include/alpaqa/util/check-dim.hpp

@@ -1,64 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <optional>
-#include <stdexcept>
-#include <string>
-
-namespace alpaqa::util {
-
-template <Config Conf>
-void check_dim_msg(crvec<Conf> v, auto sz, std::string msg) {
-    if (v.size() != sz) {
-        msg += "\n(should be ";
-        msg += std::to_string(sz);
-        msg += ", got ";
-        msg += std::to_string(v.size());
-        msg += ")";
-        throw std::invalid_argument(msg);
-    }
-}
-
-template <Config Conf>
-void check_dim_msg(std::optional<vec<Conf>> &v, auto sz, std::string msg) {
-    if (!v) {
-        v = vec<Conf>::Zero(sz);
-    } else if (v->size() != sz) {
-        msg += "\n(should be ";
-        msg += std::to_string(sz);
-        msg += ", got ";
-        msg += std::to_string(v->size());
-        msg += ")";
-        throw std::invalid_argument(msg);
-    }
-}
-
-template <Config Conf, class V>
-void check_dim(std::string name, V &&v, auto sz) {
-    name += ": dimension mismatch";
-    check_dim_msg<Conf>(std::forward<V>(v), sz, name);
-}
-
-template <Config Conf>
-void check_dim_msg(crmat<Conf> m, auto rows, auto cols, std::string msg) {
-    if (m.cols() != cols || m.rows() != rows) {
-        msg += "\n(should be ";
-        msg += std::to_string(rows);
-        msg += "×";
-        msg += std::to_string(cols);
-        msg += ", got ";
-        msg += std::to_string(m.rows());
-        msg += "×";
-        msg += std::to_string(m.cols());
-        msg += ")";
-        throw std::invalid_argument(msg);
-    }
-}
-
-template <Config Conf>
-void check_dim(std::string name, crmat<Conf> m, auto rows, auto cols) {
-    name += ": dimension mismatch";
-    check_dim_msg<Conf>(m, rows, cols, name);
-}
-
-} // namespace alpaqa::util

casadi/include/alpaqa/util/copyable_unique_ptr.hpp

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <memory>
-
-namespace alpaqa::util {
-
-template <class T>
-struct copyable_unique_ptr {
-    copyable_unique_ptr(std::unique_ptr<T> ptr) : ptr{std::move(ptr)} {}
-    copyable_unique_ptr() = default;
-    copyable_unique_ptr(const copyable_unique_ptr &o)
-        : ptr{o.ptr ? std::make_unique<T>(*o.ptr) : nullptr} {}
-    copyable_unique_ptr &operator=(const copyable_unique_ptr &o) {
-        this->ptr = o.ptr ? std::make_unique<T>(*o.ptr) : nullptr;
-        return *this;
-    }
-    copyable_unique_ptr(copyable_unique_ptr &&) noexcept            = default;
-    copyable_unique_ptr &operator=(copyable_unique_ptr &&) noexcept = default;
-
-    operator std::unique_ptr<T> &() & { return ptr; }
-    operator const std::unique_ptr<T> &() const & { return ptr; }
-    operator std::unique_ptr<T> &&() && { return std::move(ptr); }
-
-    std::unique_ptr<T> &operator->() { return ptr; }
-    const std::unique_ptr<T> &operator->() const { return ptr; }
-    auto &operator*() { return *ptr; }
-    auto &operator*() const { return *ptr; }
-
-    std::unique_ptr<T> ptr;
-};
-
-} // namespace alpaqa::util

casadi/include/alpaqa/util/demangled-typename.hpp

@@ -1,9 +0,0 @@
-#pragma once
-
-#include <alpaqa/export.hpp>
-
-#include <string>
-#include <typeinfo>
-
-/// Get the pretty name of the given type as a string.
-ALPAQA_EXPORT std::string demangled_typename(const std::type_info &t);

casadi/include/alpaqa/util/enumerate.hpp

@@ -1,70 +0,0 @@
-#pragma once
-
-#include <ranges>
-#include <utility>
-
-namespace alpaqa::util {
-
-template <class Rng>
-struct enumerate_t : std::ranges::view_interface<enumerate_t<Rng>> {
-    Rng rng;
-
-    // P2325R3: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2325r3.html
-    enumerate_t() = default;
-    enumerate_t(Rng rng) : rng{std::forward<Rng>(rng)} {}
-
-    using begin_t = decltype(std::ranges::begin(std::as_const(rng)));
-    using end_t   = decltype(std::ranges::end(std::as_const(rng)));
-
-    struct sentinel_t {
-        end_t it;
-    };
-
-    struct iter_t {
-        // P2325R3: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2325r3.html
-        iter_t() = default;
-        iter_t(begin_t &&it) : it{std::forward<begin_t>(it)} {}
-
-        using index_t = std::ranges::range_difference_t<Rng>;
-        index_t index{};
-        begin_t it;
-
-        using difference_type = std::ptrdiff_t;
-        using value_type      = std::tuple<index_t, decltype(*it)>;
-
-        bool operator!=(sentinel_t s) const { return s.it != it; }
-        bool operator==(sentinel_t s) const { return s.it == it; }
-        // 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++() {
-            ++it;
-            ++index;
-            return *this;
-        }
-        iter_t operator++(int) const {
-            auto tmp = *this;
-            ++*this;
-            return tmp;
-        }
-
-        value_type operator*() const { return {index, *it}; }
-    };
-
-    auto begin() const -> std::input_or_output_iterator auto{
-        return iter_t{std::ranges::begin(rng)};
-    }
-    auto end() const
-    // -> std::sentinel_for<iter_t> auto
-    {
-        return sentinel_t{std::ranges::end(rng)};
-    }
-};
-
-template <class Rng>
-auto enumerate(Rng &&rng) {
-    return enumerate_t<std::views::all_t<Rng>>{std::forward<Rng>(rng)};
-}
-
-} // namespace alpaqa::util

casadi/include/alpaqa/util/float.hpp

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <alpaqa/util/quadmath/quadmath.hpp>
-
-#include <cmath>
-#include <complex>
-#include <concepts>
-#include <type_traits>
-
-namespace alpaqa {
-
-template <typename T>
-struct is_complex_float : std::false_type {};
-
-template <std::floating_point T>
-struct is_complex_float<std::complex<T>> : std::true_type {};
-
-template <class T>
-inline constexpr bool is_complex_float_v = is_complex_float<T>::value;
-
-template <typename T>
-concept float_or_complex_float =
-    std::floating_point<T> || is_complex_float_v<T>;
-
-} // namespace alpaqa

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

@@ -1,97 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <span>
-
-namespace alpaqa::detail {
-
-template <Config Conf>
-struct IndexSet {
-    USING_ALPAQA_CONFIG(Conf);
-
-    IndexSet(length_t N, length_t n) : N{N}, n{n}, storage{N + N * n} {}
-
-    length_t N;
-    length_t n;
-    indexvec storage;
-
-    auto sizes() { return storage.segment(0, N); }
-    auto sizes() const { return storage.segment(0, N); }
-    auto indices() { return storage.segment(N, N * n); }
-    auto indices() const { return storage.segment(N, N * n); }
-
-    crindexvec indices(index_t i) const {
-        length_t nJ = sizes()(i);
-        return indices().segment(n * i, nJ);
-    }
-
-    crindexvec compl_indices(index_t i) const {
-        length_t nJ = sizes()(i);
-        length_t nK = n - nJ;
-        return indices().segment(n * i + nJ, nK);
-    }
-
-    // Compute the complement of the index set `in`. Write the indices not in
-    // the input to 'out'.
-    static void compute_complement(std::span<const index_t> in,
-                                   std::span<index_t> out) {
-        compute_complement(in, out.data(),
-                           static_cast<length_t>(in.size() + out.size()));
-    }
-    static void compute_complement(std::span<const index_t> in,
-                                   std::span<index_t> out, length_t n) {
-        assert(in.size() + out.size() == static_cast<size_t>(n));
-        compute_complement(in, out.data(), n);
-    }
-    static void compute_complement(crindexvec in, rindexvec out, length_t n) {
-        assert(in.size() + out.size() == n);
-        compute_complement(std::span{in.data(), static_cast<size_t>(in.size())},
-                           out.data(), n);
-    }
-
-    template <class F>
-    void update(const F &condition) {
-        // Evaluate the condition for all indices in the given 'time_step',
-        // append the indices evaluating to true to 'out', and return the number
-        // of indices that were appended.
-        auto build_Jt = [&](index_t time_step, index_t *out) {
-            index_t j = 0; // index into the array of inactive indices
-            for (index_t c = 0; c < n; ++c) { // components within time step
-                if (condition(time_step, c))  // if the component is active,
-                    out[j++] = c; // append the index of this component to J
-            }
-            return j; // return the number of elements in J
-        };
-
-        auto sizes    = this->sizes();
-        auto *indices = this->indices().data();
-        for (index_t t = 0; t < N; ++t) { // time steps
-            // Generate the set of inactive indices, J
-            index_t num_J = build_Jt(t, indices);
-            sizes(t)      = num_J; // save number of inactive indices for later
-            std::span J{indices, static_cast<size_t>(num_J)};
-            // Generate the complement, the set of active indices, K
-            compute_complement(J, indices + num_J, n);
-            // Prepare for next time step
-            indices += n;
-        }
-    }
-
-  private:
-    static void compute_complement(std::span<const index_t> in, index_t *out,
-                                   length_t n) {
-        length_t c = 0; // components within time step
-        length_t k = 0; // index into the array of active indices
-        // iterate over the array with indices 'in'
-        for (index_t j : in) { //
-            for (; c < j; ++c) // for all indices not in J
-                out[k++] = c;  // append the index of this component
-            ++c;               // skip indices in J, i.e. c == j
-        }
-        // add final indices not in J
-        for (; c < n; ++c)
-            out[k++] = c;
-    }
-};
-
-} // namespace alpaqa::detail

casadi/include/alpaqa/util/io/csv.hpp

@@ -1,43 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/export.h>
-#include <iosfwd>
-#include <stdexcept>
-#include <vector>
-
-namespace alpaqa::csv {
-
-struct ALPAQA_EXPORT read_error : std::runtime_error {
-    using std::runtime_error::runtime_error;
-};
-
-template <std::floating_point F>
-void ALPAQA_EXPORT read_row_impl(std::istream &is,
-                                 Eigen::Ref<Eigen::VectorX<F>> v,
-                                 char sep = ',');
-
-template <std::floating_point F>
-std::vector<F> ALPAQA_EXPORT read_row_std_vector(std::istream &is,
-                                                 char sep = ',');
-
-#define ALPAQA_READ_ROW_OVL(type)                                              \
-    inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<type>> v, \
-                         char sep) {                                           \
-        return read_row_impl<type>(is, v, sep);                                \
-    }                                                                          \
-    inline void read_row(std::istream &is,                                     \
-                         Eigen::Ref<Eigen::VectorX<type>> v) {                 \
-        return read_row_impl<type>(is, v);                                     \
-    }
-
-ALPAQA_READ_ROW_OVL(float)
-ALPAQA_READ_ROW_OVL(double)
-ALPAQA_READ_ROW_OVL(long double)
-// #ifdef ALPAQA_WITH_QUAD_PRECISION
-// ALPAQA_READ_ROW_OVL(__float128)
-// #endif
-
-#undef ALPAQA_READ_ROW_OVL
-
-} // namespace alpaqa::csv

casadi/include/alpaqa/util/iter-adapter.hpp

@@ -1,68 +0,0 @@
-#pragma once
-
-#include <concepts>
-#include <iterator>
-#include <ranges>
-#include <type_traits>
-#include <utility>
-
-#if defined(__clang_major__) && __clang_major__ <= 15 && !defined(__clangd__)
-#error "Better ranges support required"
-#endif
-
-namespace alpaqa::util {
-
-template <class It>
-struct iter_range_adapter {
-    // P2325R3: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2325r3.html
-    iter_range_adapter() = default;
-    iter_range_adapter(It it) : it{std::forward<It>(it)} {}
-    It it;
-
-    struct sentinel_t {};
-
-    struct iter_t : std::remove_cvref_t<It> {
-        // P2325R3: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2325r3.html
-        iter_t() = default;
-        iter_t(It it) : std::remove_cvref_t<It>{std::forward<It>(it)} {}
-
-        bool operator!=(sentinel_t) const { return static_cast<bool>(*this); }
-        bool operator==(sentinel_t) const { return !static_cast<bool>(*this); }
-        // 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++() {
-            this->std::remove_cvref_t<It>::operator++();
-            return *this;
-        }
-        iter_t operator++(int i) const {
-            this->std::remove_cvref_t<It>::operator++(i);
-            return *this;
-        }
-        const iter_t &operator*() const { return *this; }
-        using value_type      = iter_t;
-        using pointer         = iter_t *;
-        using reference       = iter_t &;
-        using difference_type = std::ptrdiff_t;
-    };
-
-    auto begin() const & -> std::input_or_output_iterator auto{
-        return iter_t{it};
-    }
-    auto begin() && -> std::input_or_output_iterator auto{
-        return iter_t{std::forward<It>(it)};
-    }
-    auto end() const -> std::sentinel_for<iter_t> auto{ return sentinel_t{}; }
-};
-
-} // namespace alpaqa::util
-
-// Make iter_range_adapter available as an std::ranges view.
-// Iterators remain valid even if the range is destroyed.
-// Assume that the user takes care of lifetime, similar to std::span.
-#ifndef DOXYGEN
-template <class It>
-inline constexpr bool ::std::ranges::enable_borrowed_range<
-    alpaqa::util::iter_range_adapter<It>> = true;
-#endif

casadi/include/alpaqa/util/max-history.hpp

@@ -1,47 +0,0 @@
-#pragma once
-
-#include <algorithm>
-#include <cstddef>
-#include <vector>
-
-namespace alpaqa {
-
-/// Keep track of the maximum value over a specified horizon length.
-template <class T>
-class MaxHistory {
-  public:
-    MaxHistory(size_t memory) : buffer(std::vector<T>(memory)) {}
-
-    void add(T newt) {
-        if (full) {
-            T oldt = std::move(*it);
-            *it    = std::move(newt);
-            if (*it > max_)
-                max_ = *it;
-            else if (oldt == max_)
-                max_ = *std::max_element(buffer.begin(), buffer.end());
-            ++it;
-            if (it == buffer.end())
-                it = buffer.begin();
-        } else {
-            if (it == buffer.begin() || newt > max_)
-                max_ = newt;
-            *it = std::move(newt);
-            ++it;
-            if (it == buffer.end()) {
-                it   = buffer.begin();
-                full = true;
-            }
-        }
-    }
-
-    const T &max() const { return max_; }
-
-  private:
-    std::vector<T> buffer;
-    bool full                   = false;
-    decltype(buffer.begin()) it = buffer.begin();
-    T max_{};
-};
-
-} // namespace alpaqa

casadi/include/alpaqa/util/noop-delete.hpp

@@ -1,15 +0,0 @@
-#pragma once
-
-namespace alpaqa::util {
-
-/// Deleter for `std::unique_ptr` that just destructs the object, without
-/// deallocating.
-template <class T>
-struct noop_delete {
-    constexpr noop_delete() noexcept = default;
-    template <class U>
-    constexpr noop_delete(const noop_delete<U> &) noexcept {}
-    constexpr void operator()(T *t) const noexcept { t->~T(); }
-};
-
-} // namespace alpaqa::util

casadi/include/alpaqa/util/not-implemented.hpp

@@ -1,12 +0,0 @@
-#pragma once
-
-#include <alpaqa/export.h>
-#include <stdexcept>
-
-namespace alpaqa {
-
-struct ALPAQA_EXPORT not_implemented_error : std::logic_error {
-    using std::logic_error::logic_error;
-};
-
-} // namespace alpaqa