casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

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

@@ -0,0 +1,37 @@
+#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

@@ -0,0 +1,27 @@
+#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

@@ -0,0 +1,27 @@
+#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

@@ -0,0 +1,23 @@
+#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

@@ -0,0 +1,24 @@
+#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

@@ -0,0 +1,64 @@
+#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

@@ -0,0 +1,32 @@
+#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

@@ -0,0 +1,9 @@
+#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

@@ -0,0 +1,70 @@
+#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

@@ -0,0 +1,25 @@
+#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

@@ -0,0 +1,97 @@
+#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

@@ -0,0 +1,43 @@
+#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

@@ -0,0 +1,68 @@
+#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

@@ -0,0 +1,47 @@
+#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

@@ -0,0 +1,15 @@
+#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

@@ -0,0 +1,12 @@
+#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