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

casadi/include/alpaqa/implementation/problem/type-erased-problem.tpp

@@ -1,211 +0,0 @@
-#pragma once
-
-#include <alpaqa/problem/type-erased-problem.hpp>
-
-namespace alpaqa {
-
-template <Config Conf>
-auto ProblemVTable<Conf>::calc_ŷ_dᵀŷ(const void *self, rvec g_ŷ, crvec y, crvec Σ,
-                                     const ProblemVTable &vtable) -> real_t {
-    if (Σ.size() == 1) {
-        // ζ = g(x) + Σ⁻¹y
-        g_ŷ += (1 / Σ(0)) * y;
-        // d = ζ - Π(ζ, D)
-        vtable.eval_proj_diff_g(self, g_ŷ, g_ŷ);
-        // dᵀŷ, ŷ = Σ d
-        real_t dᵀŷ = Σ(0) * g_ŷ.dot(g_ŷ);
-        g_ŷ *= Σ(0);
-        return dᵀŷ;
-    } else {
-        // ζ = g(x) + Σ⁻¹y
-        g_ŷ += Σ.asDiagonal().inverse() * y;
-        // d = ζ - Π(ζ, D)
-        vtable.eval_proj_diff_g(self, g_ŷ, g_ŷ);
-        // dᵀŷ, ŷ = Σ d
-        real_t dᵀŷ = 0;
-        for (index_t i = 0; i < y.size(); ++i) {
-            dᵀŷ += g_ŷ(i) * Σ(i) * g_ŷ(i); // TODO: vectorize
-            g_ŷ(i) = Σ(i) * g_ŷ(i);
-        }
-        return dᵀŷ;
-    }
-}
-
-template <Config Conf>
-auto ProblemVTable<Conf>::default_eval_inactive_indices_res_lna(const void *, real_t, crvec, crvec,
-                                                                rindexvec, const ProblemVTable &)
-    -> index_t {
-    throw not_implemented_error("eval_inactive_indices_res_lna");
-}
-
-template <Config Conf>
-void ProblemVTable<Conf>::default_eval_jac_g(const void *, crvec, rindexvec, rindexvec, rvec,
-                                             const ProblemVTable &vtable) {
-    if (vtable.m != 0)
-        throw not_implemented_error("eval_jac_g");
-}
-
-template <Config Conf>
-auto ProblemVTable<Conf>::default_get_jac_g_num_nonzeros(const void *, const ProblemVTable &)
-    -> length_t {
-    return -1;
-}
-
-template <Config Conf>
-void ProblemVTable<Conf>::default_eval_grad_gi(const void *, crvec, index_t, rvec,
-                                               const ProblemVTable &) {
-    throw not_implemented_error("eval_grad_gi");
-}
-
-template <Config Conf>
-void ProblemVTable<Conf>::default_eval_hess_L_prod(const void *, crvec, crvec, real_t, crvec, rvec,
-                                                   const ProblemVTable &) {
-    throw not_implemented_error("eval_hess_L_prod");
-}
-
-template <Config Conf>
-void ProblemVTable<Conf>::default_eval_hess_L(const void *, crvec, crvec, real_t, rindexvec,
-                                              rindexvec, rvec, const ProblemVTable &) {
-    throw not_implemented_error("eval_hess_L");
-}
-
-template <Config Conf>
-auto ProblemVTable<Conf>::default_get_hess_L_num_nonzeros(const void *, const ProblemVTable &)
-    -> length_t {
-    return -1;
-}
-
-template <Config Conf>
-void ProblemVTable<Conf>::default_eval_hess_ψ_prod(const void *self, crvec x, crvec y, crvec,
-                                                   real_t scale, crvec v, rvec Hv,
-                                                   const ProblemVTable &vtable) {
-    if (y.size() == 0 && vtable.eval_hess_L_prod != ProblemVTable<Conf>::default_eval_hess_L_prod)
-        return vtable.eval_hess_L_prod(self, x, y, scale, v, Hv, vtable);
-    throw not_implemented_error("eval_hess_ψ_prod");
-}
-
-template <Config Conf>
-void ProblemVTable<Conf>::default_eval_hess_ψ(const void *self, crvec x, crvec y, crvec,
-                                              real_t scale, rindexvec inner_idx,
-                                              rindexvec outer_ptr, rvec H_values,
-                                              const ProblemVTable &vtable) {
-    if (y.size() == 0 && vtable.eval_hess_L != default_eval_hess_L)
-        return vtable.eval_hess_L(self, x, y, scale, inner_idx, outer_ptr, H_values, vtable);
-    throw not_implemented_error("eval_hess_ψ");
-}
-
-template <Config Conf>
-auto ProblemVTable<Conf>::default_get_hess_ψ_num_nonzeros(const void *, const ProblemVTable &)
-    -> length_t {
-    return 0;
-}
-
-/** @implementation{ProblemVTable<Conf>::default_eval_f_grad_f} */
-template <Config Conf>
-/* [ProblemVTable<Conf>::default_eval_f_grad_f] */
-auto ProblemVTable<Conf>::default_eval_f_grad_f(const void *self, crvec x, rvec grad_fx,
-                                                const ProblemVTable &vtable) -> real_t {
-    vtable.eval_grad_f(self, x, grad_fx);
-    return vtable.eval_f(self, x);
-}
-/* [ProblemVTable<Conf>::default_eval_f_grad_f] */
-
-/** @implementation{ProblemVTable<Conf>::default_eval_f_g} */
-template <Config Conf>
-/* [ProblemVTable<Conf>::default_eval_f_g] */
-auto ProblemVTable<Conf>::default_eval_f_g(const void *self, crvec x, rvec g,
-                                           const ProblemVTable &vtable) -> real_t {
-    vtable.eval_g(self, x, g);
-    return vtable.eval_f(self, x);
-}
-/* [ProblemVTable<Conf>::default_eval_f_g] */
-
-/** @implementation{ProblemVTable<Conf>::default_eval_grad_f_grad_g_prod} */
-template <Config Conf>
-/* [ProblemVTable<Conf>::default_eval_grad_f_grad_g_prod] */
-void ProblemVTable<Conf>::default_eval_grad_f_grad_g_prod(const void *self, crvec x, crvec y,
-                                                          rvec grad_f, rvec grad_gxy,
-                                                          const ProblemVTable &vtable) {
-    vtable.eval_grad_f(self, x, grad_f);
-    vtable.eval_grad_g_prod(self, x, y, grad_gxy);
-}
-/* [ProblemVTable<Conf>::default_eval_grad_f_grad_g_prod] */
-
-/** @implementation{ProblemVTable<Conf>::default_eval_grad_L} */
-template <Config Conf>
-/* [ProblemVTable<Conf>::default_eval_grad_L] */
-void ProblemVTable<Conf>::default_eval_grad_L(const void *self, crvec x, crvec y, rvec grad_L,
-                                              rvec work_n, const ProblemVTable &vtable) {
-    if (y.size() == 0) /* [[unlikely]] */
-        return vtable.eval_grad_f(self, x, grad_L);
-    vtable.eval_grad_f_grad_g_prod(self, x, y, grad_L, work_n, vtable);
-    grad_L += work_n;
-}
-/* [ProblemVTable<Conf>::default_eval_grad_L] */
-
-/** @implementation{ProblemVTable<Conf>::default_eval_ψ} */
-template <Config Conf>
-/* [ProblemVTable<Conf>::default_eval_ψ] */
-auto ProblemVTable<Conf>::default_eval_ψ(const void *self, crvec x, crvec y, crvec Σ, rvec ŷ,
-                                         const ProblemVTable &vtable) -> real_t {
-    if (y.size() == 0) /* [[unlikely]] */
-        return vtable.eval_f(self, x);
-
-    auto f   = vtable.eval_f_g(self, x, ŷ, vtable);
-    auto dᵀŷ = calc_ŷ_dᵀŷ(self, ŷ, y, Σ, vtable);
-    // ψ(x) = f(x) + ½ dᵀŷ
-    auto ψ = f + real_t(0.5) * dᵀŷ;
-    return ψ;
-}
-/* [ProblemVTable<Conf>::default_eval_ψ] */
-
-/** @implementation{ProblemVTable<Conf>::default_eval_grad_ψ} */
-template <Config Conf>
-/* [ProblemVTable<Conf>::default_eval_grad_ψ] */
-void ProblemVTable<Conf>::default_eval_grad_ψ(const void *self, crvec x, crvec y, crvec Σ,
-                                              rvec grad_ψ, rvec work_n, rvec work_m,
-                                              const ProblemVTable &vtable) {
-    if (y.size() == 0) /* [[unlikely]] */ {
-        vtable.eval_grad_f(self, x, grad_ψ);
-    } else {
-        vtable.eval_g(self, x, work_m);
-        (void)calc_ŷ_dᵀŷ(self, work_m, y, Σ, vtable);
-        vtable.eval_grad_L(self, x, work_m, grad_ψ, work_n, vtable);
-    }
-}
-/* [ProblemVTable<Conf>::default_eval_grad_ψ] */
-
-/** @implementation{ProblemVTable<Conf>::default_eval_ψ_grad_ψ} */
-template <Config Conf>
-/* [ProblemVTable<Conf>::default_eval_ψ_grad_ψ] */
-auto ProblemVTable<Conf>::default_eval_ψ_grad_ψ(const void *self, crvec x, crvec y, crvec Σ,
-                                                rvec grad_ψ, rvec work_n, rvec work_m,
-                                                const ProblemVTable &vtable) -> real_t {
-    if (y.size() == 0) /* [[unlikely]] */
-        return vtable.eval_f_grad_f(self, x, grad_ψ, vtable);
-
-    auto &ŷ = work_m;
-    // ψ(x) = f(x) + ½ dᵀŷ
-    auto f   = vtable.eval_f_g(self, x, ŷ, vtable);
-    auto dᵀŷ = calc_ŷ_dᵀŷ(self, ŷ, y, Σ, vtable);
-    auto ψ   = f + real_t(0.5) * dᵀŷ;
-    // ∇ψ(x) = ∇f(x) + ∇g(x) ŷ
-    vtable.eval_grad_L(self, x, ŷ, grad_ψ, work_n, vtable);
-    return ψ;
-}
-/* [ProblemVTable<Conf>::default_eval_ψ_grad_ψ] */
-
-template <Config Conf>
-auto ProblemVTable<Conf>::default_get_box_C(const void *, const ProblemVTable &) -> const Box & {
-    throw not_implemented_error("get_box_C");
-}
-
-template <Config Conf>
-auto ProblemVTable<Conf>::default_get_box_D(const void *, const ProblemVTable &) -> const Box & {
-    throw not_implemented_error("get_box_D");
-}
-
-template <Config Conf>
-void ProblemVTable<Conf>::default_check(const void *, const ProblemVTable &) {}
-
-} // namespace alpaqa

casadi/include/alpaqa/implementation/util/io/csv.tpp

@@ -1,120 +0,0 @@
-#include <alpaqa/util/io/csv.hpp>
-
-#include <algorithm>
-#include <cassert>
-#include <charconv>
-#include <ios>
-#include <iostream>
-
-#if !__cpp_lib_to_chars
-#include <cerrno>
-#include <cstdlib> // strtod
-#endif
-
-namespace alpaqa::csv {
-
-template <std::floating_point F>
-struct CSVReader {
-    static constexpr std::streamsize bufmaxsize = 64;
-    std::array<char, bufmaxsize + 1> s;
-    std::streamsize bufidx    = 0;
-    bool keep_reading         = true;
-    static constexpr char end = '\n';
-
-    [[nodiscard]] F read(std::istream &is, char sep) {
-        // Get some characters to process
-        if (keep_reading) {
-            if (!is.get(s.data() + bufidx, bufmaxsize - bufidx, end))
-                throw read_error("csv::read_row extraction failed: " +
-                                 std::to_string(is.bad()) + " " +
-                                 std::to_string(is.fail()) + " " +
-                                 std::to_string(is.eof()));
-            bufidx += is.gcount();
-            keep_reading = is.peek() != end && !is.eof();
-            assert(bufidx < bufmaxsize);
-        }
-        // Parse a number
-        F v;
-        char *bufend    = s.data() + bufidx;
-        const char *ptr = read_single(s.data(), bufend, v);
-        // Check separator
-        if (ptr != bufend && *ptr != sep)
-            throw read_error("csv::read_row unexpected character '" +
-                             std::string{*ptr} + "'");
-        // Shift the buffer over
-        if (ptr != bufend) {
-            std::copy(ptr + 1, static_cast<const char *>(bufend), s.data());
-            bufidx -= ptr + 1 - s.data();
-        } else {
-            bufidx = 0;
-        }
-        return v;
-    }
-
-#if __cpp_lib_to_chars
-    static const char *read_single(const char *bufbegin, const char *bufend,
-                                   F &v) {
-        if (bufbegin != bufend && *bufbegin == '+')
-            ++bufbegin;
-        const auto [ptr, ec] = std::from_chars(bufbegin, bufend, v);
-        const auto bufvw     = std::string_view(bufbegin, bufend);
-        if (ec != std::errc{})
-            throw read_error("csv::read_row conversion failed '" +
-                             std::string(bufvw) +
-                             "': " + std::make_error_code(ec).message());
-        return ptr;
-    }
-#else
-    static void strtod_ovl(const char *str, char **str_end, float &v) {
-        v = std::strtof(str, str_end);
-    }
-    static void strtod_ovl(const char *str, char **str_end, double &v) {
-        v = std::strtod(str, str_end);
-    }
-    static void strtod_ovl(const char *str, char **str_end, long double &v) {
-        v = std::strtold(str, str_end);
-    }
-    static const char *read_single(const char *bufbegin, char *bufend, F &v) {
-        *bufend = '\0';
-        char *ptr;
-        errno = 0;
-        strtod_ovl(bufbegin, &ptr, v);
-        if (errno || ptr == bufbegin)
-            throw read_error("csv::read_row conversion failed '" +
-                             std::string(bufbegin) +
-                             "': " + std::to_string(errno));
-        return ptr;
-    }
-#endif
-
-    void check_end(std::istream &is) const {
-        if (bufidx > 0 || (is.get() != end && is))
-            throw read_error("csv::read_row line not fully consumed");
-    }
-
-    [[nodiscard]] bool done(std::istream &is) const {
-        bool keep_reading = is.peek() != end && !is.eof();
-        return bufidx == 0 && !keep_reading;
-    }
-};
-
-template <std::floating_point F>
-void read_row_impl(std::istream &is, Eigen::Ref<Eigen::VectorX<F>> v,
-                   char sep) {
-    CSVReader<F> reader;
-    for (auto &vv : v)
-        vv = reader.read(is, sep);
-    reader.check_end(is);
-}
-
-template <std::floating_point F>
-std::vector<F> read_row_std_vector(std::istream &is, char sep) {
-    CSVReader<F> reader;
-    std::vector<F> v;
-    while (!reader.done(is))
-        v.push_back(reader.read(is, sep));
-    reader.check_end(is);
-    return v;
-}
-
-} // namespace alpaqa::csv

casadi/include/alpaqa/implementation/util/print.tpp

@@ -1,151 +0,0 @@
-#pragma once
-
-#include <alpaqa/util/print.hpp>
-
-#include <cassert>
-#include <charconv>
-#include <cmath>
-#include <limits>
-#include <ostream>
-#include <string_view>
-
-namespace alpaqa {
-
-inline std::string_view float_to_str_vw_snprintf(auto &&print, auto &buf,
-                                                 std::floating_point auto value,
-                                                 int precision,
-                                                 const char *fmt) {
-    int n = print(buf.data(), buf.size(), fmt, precision, value);
-    assert((size_t)n < buf.size());
-    return {buf.data(), (size_t)n};
-}
-
-#if __cpp_lib_to_chars
-template <std::floating_point F>
-std::string_view
-float_to_str_vw(auto &buf, F value,
-                int precision = std::numeric_limits<F>::max_digits10) {
-    auto begin = buf.data();
-    if (!std::signbit(value))
-        *begin++ = '+';
-    auto [end, _] = std::to_chars(begin, buf.data() + buf.size(), value,
-                                  std::chars_format::scientific, precision);
-    return std::string_view{buf.data(), end};
-}
-#else
-#pragma message "Using std::snprintf as a fallback to replace std::to_chars"
-
-inline std::string_view
-float_to_str_vw(auto &buf, double value,
-                int precision = std::numeric_limits<double>::max_digits10) {
-    return float_to_str_vw_snprintf(std::snprintf, buf, value, precision,
-                                    "%+-#.*e");
-}
-inline std::string_view
-float_to_str_vw(auto &buf, float value,
-                int precision = std::numeric_limits<float>::max_digits10) {
-    return float_to_str_vw(buf, static_cast<double>(value), precision);
-}
-inline std::string_view float_to_str_vw(
-    auto &buf, long double value,
-    int precision = std::numeric_limits<long double>::max_digits10) {
-    return float_to_str_vw_snprintf(std::snprintf, buf, value, precision,
-                                    "%+-#.*Le");
-}
-#endif
-
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-std::string_view
-float_to_str_vw(auto &buf, __float128 value,
-                int precision = std::numeric_limits<__float128>::max_digits10) {
-    return float_to_str_vw_snprintf(quadmath_snprintf, buf, value, precision,
-                                    "%+-#.*Qe");
-}
-#endif
-
-template <std::floating_point F>
-std::string float_to_str(F value, int precision) {
-    std::array<char, 64> buf;
-    return std::string{float_to_str_vw(buf, value, precision)};
-}
-
-template <std::floating_point F>
-void print_elem(auto &buf, F value, std::ostream &os) {
-    os << float_to_str_vw(buf, value);
-}
-
-template <std::floating_point F>
-void print_elem(auto &buf, std::complex<F> value, std::ostream &os) {
-    os << float_to_str_vw(buf, value.real()) << " + "
-       << float_to_str_vw(buf, value.imag()) << 'j';
-}
-
-template <class T>
-std::ostream &print_csv_impl(std::ostream &os, const T &M, std::string_view sep,
-                             std::string_view begin, std::string_view end) {
-    std::array<char, 64> buf;
-    if (M.cols() == 1) {
-        os << begin;
-        for (decltype(M.rows()) r{}; r < M.rows(); ++r) {
-            print_elem(buf, M(r, 0), os);
-            if (r != M.rows() - 1)
-                os << sep;
-        }
-        return os << end;
-    } else {
-        for (decltype(M.rows()) r{}; r < M.rows(); ++r) {
-            os << begin;
-            for (decltype(M.cols()) c{}; c < M.cols(); ++c) {
-                print_elem(buf, M(r, c), os);
-                if (c != M.cols() - 1)
-                    os << sep;
-            }
-            os << end;
-        }
-        return os;
-    }
-}
-
-template <class T>
-std::ostream &print_matlab_impl(std::ostream &os, const T &M,
-                                std::string_view end) {
-    if (M.cols() == 1) {
-        return print_csv_impl<T>(os, M, " ", "[", "]") << end;
-    } else {
-        os << '[';
-        std::array<char, 64> buf;
-        for (decltype(M.rows()) r{}; r < M.rows(); ++r) {
-            for (decltype(M.cols()) c{}; c < M.cols(); ++c) {
-                print_elem(buf, M(r, c), os);
-                if (c != M.cols() - 1)
-                    os << ' ';
-            }
-            if (r != M.rows() - 1)
-                os << ";\n ";
-        }
-        return os << ']' << end;
-    }
-}
-
-template <class T>
-std::ostream &print_python_impl(std::ostream &os, const T &M,
-                                std::string_view end) {
-    if (M.cols() == 1) {
-        return print_csv_impl<T>(os, M, ", ", "[", "]") << end;
-    } else {
-        os << "[[";
-        std::array<char, 64> buf;
-        for (decltype(M.rows()) r{}; r < M.rows(); ++r) {
-            for (decltype(M.cols()) c{}; c < M.cols(); ++c) {
-                print_elem(buf, M(r, c), os);
-                if (c != M.cols() - 1)
-                    os << ", ";
-            }
-            if (r != M.rows() - 1)
-                os << "],\n [";
-        }
-        return os << "]]" << end;
-    }
-}
-
-} // namespace alpaqa

casadi/include/alpaqa/inner/directions/panoc/anderson.hpp

@@ -1,98 +0,0 @@
-#pragma once
-
-#include <alpaqa/accelerators/anderson.hpp>
-#include <alpaqa/inner/directions/panoc-direction-update.hpp>
-#include <alpaqa/problem/type-erased-problem.hpp>
-
-namespace alpaqa {
-
-/// Parameters for the @ref AndersonDirection class.
-template <Config Conf>
-struct AndersonDirectionParams {
-    bool rescale_on_step_size_changes = false;
-};
-
-/// @ingroup grp_DirectionProviders
-template <Config Conf>
-struct AndersonDirection {
-    USING_ALPAQA_CONFIG(Conf);
-
-    using Problem           = TypeErasedProblem<config_t>;
-    using AndersonAccel     = alpaqa::AndersonAccel<config_t>;
-    using AcceleratorParams = typename AndersonAccel::Params;
-    using DirectionParams   = AndersonDirectionParams<config_t>;
-
-    mutable AndersonAccel anderson;
-
-    struct Params {
-        AcceleratorParams accelerator = {};
-        DirectionParams direction     = {};
-    };
-
-    AndersonDirection() = default;
-    AndersonDirection(const Params &params)
-        : anderson(params.accelerator), direction_params(params.direction) {}
-    AndersonDirection(const typename AndersonAccel::Params &params,
-                      const DirectionParams &directionparams = {})
-        : anderson(params), direction_params(directionparams) {}
-    AndersonDirection(const AndersonAccel &anderson,
-                      const DirectionParams &directionparams = {})
-        : anderson(anderson), direction_params(directionparams) {}
-    AndersonDirection(AndersonAccel &&anderson,
-                      const DirectionParams &directionparams = {})
-        : anderson(std::move(anderson)), direction_params(directionparams) {}
-
-    /// @see @ref PANOCDirection::initialize
-    void initialize(const Problem &problem, [[maybe_unused]] crvec y,
-                    [[maybe_unused]] crvec Σ, [[maybe_unused]] real_t γ_0,
-                    [[maybe_unused]] crvec x_0, [[maybe_unused]] crvec x̂_0,
-                    [[maybe_unused]] crvec p_0,
-                    [[maybe_unused]] crvec grad_ψx_0) {
-        anderson.resize(problem.get_n());
-        anderson.initialize(x̂_0, p_0);
-    }
-
-    /// @see @ref PANOCDirection::has_initial_direction
-    bool has_initial_direction() const { return false; }
-
-    /// @see @ref PANOCDirection::update
-    bool update([[maybe_unused]] real_t γₖ, [[maybe_unused]] real_t γₙₑₓₜ,
-                [[maybe_unused]] crvec xₖ, [[maybe_unused]] crvec xₙₑₓₜ,
-                [[maybe_unused]] crvec pₖ, [[maybe_unused]] crvec pₙₑₓₜ,
-                [[maybe_unused]] crvec grad_ψxₖ,
-                [[maybe_unused]] crvec grad_ψxₙₑₓₜ) {
-        return true;
-    }
-
-    /// @see @ref PANOCDirection::apply
-    bool apply([[maybe_unused]] real_t γₖ, [[maybe_unused]] crvec xₖ,
-               [[maybe_unused]] crvec x̂ₖ, crvec pₖ,
-               [[maybe_unused]] crvec grad_ψxₖ, rvec qₖ) const {
-        anderson.compute(x̂ₖ, pₖ, qₖ);
-        qₖ -= xₖ;
-        return true;
-    }
-
-    /// @see @ref PANOCDirection::changed_γ
-    void changed_γ(real_t γₖ, real_t old_γₖ) {
-        if (direction_params.rescale_on_step_size_changes)
-            anderson.scale_R(γₖ / old_γₖ);
-        else
-            anderson.reset();
-    }
-
-    /// @see @ref PANOCDirection::reset
-    void reset() { anderson.reset(); }
-
-    /// @see @ref PANOCDirection::get_name
-    std::string get_name() const {
-        return "AndersonDirection<" + std::string(config_t::get_name()) + '>';
-    }
-    auto get_params() const {
-        return std::tie(anderson.get_params(), direction_params);
-    }
-
-    DirectionParams direction_params;
-};
-
-} // namespace alpaqa

casadi/include/alpaqa/inner/directions/panoc/lbfgs.hpp

@@ -1,94 +0,0 @@
-#pragma once
-
-#include <alpaqa/accelerators/lbfgs.hpp>
-#include <alpaqa/inner/directions/panoc-direction-update.hpp>
-#include <alpaqa/problem/type-erased-problem.hpp>
-
-namespace alpaqa {
-
-/// Parameters for the @ref LBFGSDirection class.
-template <Config Conf>
-struct LBFGSDirectionParams {
-    bool rescale_on_step_size_changes = false;
-};
-
-/// @ingroup grp_DirectionProviders
-template <Config Conf>
-struct LBFGSDirection {
-    USING_ALPAQA_CONFIG(Conf);
-
-    using Problem           = TypeErasedProblem<config_t>;
-    using LBFGS             = alpaqa::LBFGS<config_t>;
-    using AcceleratorParams = typename LBFGS::Params;
-    using DirectionParams   = LBFGSDirectionParams<config_t>;
-
-    LBFGS lbfgs;
-
-    struct Params {
-        AcceleratorParams accelerator = {};
-        DirectionParams direction     = {};
-    };
-
-    LBFGSDirection() = default;
-    LBFGSDirection(const Params &params)
-        : lbfgs(params.accelerator), direction_params(params.direction) {}
-    LBFGSDirection(const typename LBFGS::Params &params,
-                   const DirectionParams &directionparams = {})
-        : lbfgs(params), direction_params(directionparams) {}
-    LBFGSDirection(const LBFGS &lbfgs,
-                   const DirectionParams &directionparams = {})
-        : lbfgs(lbfgs), direction_params(directionparams) {}
-    LBFGSDirection(LBFGS &&lbfgs, const DirectionParams &directionparams = {})
-        : lbfgs(std::move(lbfgs)), direction_params(directionparams) {}
-
-    /// @see @ref PANOCDirection::initialize
-    void initialize(const Problem &problem, [[maybe_unused]] crvec y,
-                    [[maybe_unused]] crvec Σ, [[maybe_unused]] real_t γ_0,
-                    [[maybe_unused]] crvec x_0, [[maybe_unused]] crvec x̂_0,
-                    [[maybe_unused]] crvec p_0,
-                    [[maybe_unused]] crvec grad_ψx_0) {
-        lbfgs.resize(problem.get_n());
-    }
-
-    /// @see @ref PANOCDirection::has_initial_direction
-    bool has_initial_direction() const { return false; }
-
-    /// @see @ref PANOCDirection::update
-    bool update([[maybe_unused]] real_t γₖ, [[maybe_unused]] real_t γₙₑₓₜ,
-                crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ,
-                [[maybe_unused]] crvec grad_ψxₖ,
-                [[maybe_unused]] crvec grad_ψxₙₑₓₜ) {
-        return lbfgs.update(xₖ, xₙₑₓₜ, pₖ, pₙₑₓₜ, LBFGS::Sign::Negative);
-    }
-
-    /// @see @ref PANOCDirection::apply
-    bool apply([[maybe_unused]] real_t γₖ, [[maybe_unused]] crvec xₖ,
-               [[maybe_unused]] crvec x̂ₖ, crvec pₖ,
-               [[maybe_unused]] crvec grad_ψxₖ, rvec qₖ) const {
-        qₖ = pₖ;
-        return lbfgs.apply(qₖ, γₖ);
-    }
-
-    /// @see @ref PANOCDirection::changed_γ
-    void changed_γ(real_t γₖ, real_t old_γₖ) {
-        if (direction_params.rescale_on_step_size_changes)
-            lbfgs.scale_y(γₖ / old_γₖ);
-        else
-            lbfgs.reset();
-    }
-
-    /// @see @ref PANOCDirection::reset
-    void reset() { lbfgs.reset(); }
-
-    /// @see @ref PANOCDirection::get_name
-    std::string get_name() const {
-        return "LBFGSDirection<" + std::string(config_t::get_name()) + '>';
-    }
-    auto get_params() const {
-        return std::tie(lbfgs.get_params(), direction_params);
-    }
-
-    DirectionParams direction_params;
-};
-
-} // namespace alpaqa