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

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

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

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

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

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

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