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

casadi/include/alpaqa/implementation/casadi/CasADiProblem.tpp

@@ -0,0 +1,425 @@
+#pragma once
+
+#include <alpaqa/casadi/CasADiFunctionWrapper.hpp>
+#include <alpaqa/casadi/CasADiProblem.hpp>
+#include <alpaqa/util/io/csv.hpp>
+#include <alpaqa/util/not-implemented.hpp>
+#include "CasADiLoader-util.hpp"
+
+#include <casadi/core/external.hpp>
+
+#include <algorithm>
+#include <filesystem>
+#include <fstream>
+#include <memory>
+#include <optional>
+#include <stdexcept>
+#include <type_traits>
+
+namespace alpaqa {
+
+namespace fs = std::filesystem;
+
+namespace casadi_loader {
+
+template <Config Conf>
+struct CasADiFunctionsWithParam {
+    USING_ALPAQA_CONFIG(Conf);
+    CasADiFunctionEvaluator<Conf, 2, 1> f;
+    CasADiFunctionEvaluator<Conf, 2, 2> f_grad_f;
+    // CasADiFunctionEvaluator<6, 1> grad_ψ;
+    CasADiFunctionEvaluator<Conf, 6, 2> ψ_grad_ψ;
+    struct ConstrFun {
+        CasADiFunctionEvaluator<Conf, 2, 1> g;
+        CasADiFunctionEvaluator<Conf, 3, 1> grad_L;
+        CasADiFunctionEvaluator<Conf, 6, 2> ψ;
+    };
+    std::optional<ConstrFun> constr = std::nullopt;
+    std::optional<CasADiFunctionEvaluator<Conf, 5, 1>> hess_L_prod =
+        std::nullopt;
+    std::optional<CasADiFunctionEvaluator<Conf, 4, 1>> hess_L = std::nullopt;
+    std::optional<CasADiFunctionEvaluator<Conf, 8, 1>> hess_ψ_prod =
+        std::nullopt;
+    std::optional<CasADiFunctionEvaluator<Conf, 7, 1>> hess_ψ = std::nullopt;
+    std::optional<CasADiFunctionEvaluator<Conf, 2, 1>> jac_g  = std::nullopt;
+    indexvec inner_H{}, outer_H{};
+    indexvec inner_J{}, outer_J{};
+};
+
+} // namespace casadi_loader
+
+namespace detail {
+
+template <Config Conf>
+auto casadi_to_index(casadi_int i) -> index_t<Conf> {
+    return static_cast<index_t<Conf>>(i);
+}
+} // namespace detail
+
+template <Config Conf>
+CasADiProblem<Conf>::CasADiProblem(const std::string &so_name)
+    : BoxConstrProblem<Conf>{0, 0} {
+    using namespace casadi_loader;
+    length_t n = 0, m = 0, p = 0;
+    auto load_g_unknown_dims =
+        [&]() -> std::optional<CasADiFunctionEvaluator<Conf, 2, 1>> {
+        casadi::Function gfun = casadi::external("g", so_name);
+        using namespace std::literals::string_literals;
+        if (gfun.n_in() != 2)
+            throw std::invalid_argument(
+                "Invalid number of input arguments: got "s +
+                std::to_string(gfun.n_in()) + ", should be 2.");
+        if (gfun.n_out() > 1)
+            throw std::invalid_argument(
+                "Invalid number of output arguments: got "s +
+                std::to_string(gfun.n_in()) + ", should be 0 or 1.");
+        if (gfun.size2_in(0) != 1)
+            throw std::invalid_argument(
+                "First input argument should be a column vector.");
+        if (gfun.size2_in(1) != 1)
+            throw std::invalid_argument(
+                "Second input argument should be a column vector.");
+        if (gfun.n_out() == 1 && gfun.size2_out(0) != 1)
+            throw std::invalid_argument(
+                "First output argument should be a column vector.");
+        n = static_cast<length_t>(gfun.size1_in(0));
+        if (gfun.n_out() == 1)
+            m = static_cast<length_t>(gfun.size1_out(0));
+        p = static_cast<length_t>(gfun.size1_in(1));
+        if (gfun.n_out() == 0) {
+            if (m != 0)
+                throw std::invalid_argument(
+                    "Function g has no outputs but m != 0");
+            return std::nullopt;
+        }
+        CasADiFunctionEvaluator<Conf, 2, 1> g{std::move(gfun)};
+        g.validate_dimensions({dim(n, 1), dim(p, 1)}, {dim(m, 1)});
+        return std::make_optional(std::move(g));
+    };
+
+    auto g = wrap_load(so_name, "g", load_g_unknown_dims);
+
+    this->n     = n;
+    this->m     = m;
+    this->param = vec::Constant(p, alpaqa::NaN<Conf>);
+    this->C     = Box<config_t>{n};
+    this->D     = Box<config_t>{m};
+
+    impl = std::make_unique<CasADiFunctionsWithParam<Conf>>(
+        CasADiFunctionsWithParam<Conf>{
+            .f        = wrapped_load<CasADiFunctionEvaluator<Conf, 2, 1>>( //
+                so_name, "f", dims(n, p), dims(1)),
+            .f_grad_f = wrapped_load<CasADiFunctionEvaluator<Conf, 2, 2>>( //
+                so_name, "f_grad_f", dims(n, p), dims(1, n)),
+            // .grad_ψ = wrapped_load<CasADiFunctionEvaluator<6, 1>>( //
+            //     so_name, "grad_psi", dims(n, p, m, m, m, m), dims(n)),
+            .ψ_grad_ψ = wrapped_load<CasADiFunctionEvaluator<Conf, 6, 2>>( //
+                so_name, "psi_grad_psi", dims(n, p, m, m, m, m), dims(1, n)),
+        });
+
+    if (g)
+        impl->constr = {
+            std::move(*g),
+            wrapped_load<CasADiFunctionEvaluator<Conf, 3, 1>>( //
+                so_name, "grad_L", dims(n, p, m), dims(n)),
+            wrapped_load<CasADiFunctionEvaluator<Conf, 6, 2>>( //
+                so_name, "psi", dims(n, p, m, m, m, m), dims(1, m)),
+        };
+
+    impl->hess_L_prod = try_load<CasADiFunctionEvaluator<Conf, 5, 1>>( //
+        so_name, "hess_L_prod", dims(n, p, m, 1, n), dims(n));
+    impl->hess_L      = try_load<CasADiFunctionEvaluator<Conf, 4, 1>>( //
+        so_name, "hess_L", dims(n, p, m, 1), dims(dim(n, n)));
+    impl->hess_ψ_prod = try_load<CasADiFunctionEvaluator<Conf, 8, 1>>( //
+        so_name, "hess_psi_prod", dims(n, p, m, m, 1, m, m, n), dims(n));
+    impl->hess_ψ      = try_load<CasADiFunctionEvaluator<Conf, 7, 1>>( //
+        so_name, "hess_psi", dims(n, p, m, m, 1, m, m), dims(dim(n, n)));
+    impl->jac_g       = try_load<CasADiFunctionEvaluator<Conf, 2, 1>>( //
+        so_name, "jacobian_g", dims(n, p), dims(dim(m, n)));
+
+    auto data_filepath = fs::path{so_name}.replace_extension("csv");
+    if (fs::exists(data_filepath))
+        load_numerical_data(data_filepath);
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::load_numerical_data(
+    const std::filesystem::path &filepath, char sep) {
+    // Open data file
+    std::ifstream data_file{filepath};
+    if (!data_file)
+        throw std::runtime_error("Unable to open data file \"" +
+                                 filepath.string() + '"');
+
+    // Helper function for reading single line of (float) data
+    index_t line        = 0;
+    auto wrap_data_load = [&](std::string_view name, auto &v, bool fixed_size) {
+        try {
+            ++line;
+            if (data_file.peek() == '\n') // Ignore empty lines
+                return static_cast<void>(data_file.get());
+            if (fixed_size) {
+                csv::read_row(data_file, v, sep);
+            } else { // Dynamic size
+                auto s = csv::read_row_std_vector<real_t>(data_file, sep);
+                v      = cmvec{s.data(), static_cast<index_t>(s.size())};
+            }
+        } catch (csv::read_error &e) {
+            // Transform any errors in something more readable
+            throw std::runtime_error("Unable to read " + std::string(name) +
+                                     " from data file \"" + filepath.string() +
+                                     ':' + std::to_string(line) +
+                                     "\": " + e.what());
+        }
+    };
+    // Helper function for reading a single value
+    auto read_single = [&](std::string_view name, auto &v) {
+        data_file >> v;
+        if (!data_file)
+            throw std::runtime_error("Unable to read " + std::string(name) +
+                                     " from data file \"" + filepath.string() +
+                                     ':' + std::to_string(line) + '"');
+    };
+    // Read the bounds, parameter value, and regularization
+    wrap_data_load("C.lowerbound", this->C.lowerbound, true);
+    wrap_data_load("C.upperbound", this->C.upperbound, true);
+    wrap_data_load("D.lowerbound", this->D.lowerbound, true);
+    wrap_data_load("D.upperbound", this->D.upperbound, true);
+    wrap_data_load("param", this->param, true);
+    wrap_data_load("l1_reg", this->l1_reg, false);
+    // Penalty/ALM split is a single integer
+    read_single("penalty_alm_split", this->penalty_alm_split);
+}
+
+template <Config Conf>
+CasADiProblem<Conf>::CasADiProblem(const CasADiProblem &) = default;
+template <Config Conf>
+CasADiProblem<Conf> &
+CasADiProblem<Conf>::operator=(const CasADiProblem &) = default;
+template <Config Conf>
+CasADiProblem<Conf>::CasADiProblem(CasADiProblem &&) noexcept = default;
+template <Config Conf>
+CasADiProblem<Conf> &
+CasADiProblem<Conf>::operator=(CasADiProblem &&) noexcept = default;
+
+template <Config Conf>
+CasADiProblem<Conf>::~CasADiProblem() = default;
+
+template <Config Conf>
+auto CasADiProblem<Conf>::eval_f(crvec x) const -> real_t {
+    real_t f;
+    impl->f({x.data(), param.data()}, {&f});
+    return f;
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_grad_f(crvec x, rvec grad_fx) const {
+    real_t f;
+    impl->f_grad_f({x.data(), param.data()}, {&f, grad_fx.data()});
+}
+
+template <Config Conf>
+auto CasADiProblem<Conf>::eval_f_grad_f(crvec x, rvec grad_fx) const -> real_t {
+    real_t f;
+    impl->f_grad_f({x.data(), param.data()}, {&f, grad_fx.data()});
+    return f;
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_g(crvec x, rvec g) const {
+    if (impl->constr)
+        impl->constr->g({x.data(), param.data()}, {g.data()});
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_grad_g_prod(crvec, crvec, rvec) const {
+    throw not_implemented_error("CasADiProblem::eval_grad_g_prod"); // TODO
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_grad_ψ(crvec x, crvec y, crvec Σ, rvec grad_ψ,
+                                      rvec, rvec) const {
+#if 0
+    impl->grad_ψ({x.data(), param.data(), y.data(), Σ.data(),
+                  this->D.lowerbound.data(), this->D.upperbound.data()},
+                 {grad_ψ.data()});
+#else
+    // This seems to be faster than having a specialized function. Possibly
+    // cache-related?
+    real_t ψ;
+    impl->ψ_grad_ψ({x.data(), param.data(), y.data(), Σ.data(),
+                    this->D.lowerbound.data(), this->D.upperbound.data()},
+                   {&ψ, grad_ψ.data()});
+#endif
+}
+
+template <Config Conf>
+typename CasADiProblem<Conf>::real_t
+CasADiProblem<Conf>::eval_ψ_grad_ψ(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec,
+                                   rvec) const {
+    real_t ψ;
+    impl->ψ_grad_ψ({x.data(), param.data(), y.data(), Σ.data(),
+                    this->D.lowerbound.data(), this->D.upperbound.data()},
+                   {&ψ, grad_ψ.data()});
+    return ψ;
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_grad_L(crvec x, crvec y, rvec grad_L,
+                                      rvec) const {
+    if (impl->constr)
+        impl->constr->grad_L({x.data(), param.data(), y.data()},
+                             {grad_L.data()});
+    else
+        eval_f_grad_f(x, grad_L);
+}
+
+template <Config Conf>
+typename CasADiProblem<Conf>::real_t
+CasADiProblem<Conf>::eval_ψ(crvec x, crvec y, crvec Σ, rvec ŷ) const {
+    real_t ψ;
+    if (impl->constr)
+        impl->constr->ψ({x.data(), param.data(), y.data(), Σ.data(),
+                         this->D.lowerbound.data(), this->D.upperbound.data()},
+                        {&ψ, ŷ.data()});
+    else
+        impl->f({x.data(), param.data()}, {&ψ});
+    return ψ;
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_grad_gi(crvec, index_t, rvec) const {
+    throw not_implemented_error("CasADiProblem::eval_grad_gi"); // TODO
+}
+
+template <Config Conf>
+auto CasADiProblem<Conf>::get_jac_g_num_nonzeros() const -> length_t {
+    if (!impl->jac_g.has_value())
+        return -1;
+    auto &&sparsity = impl->jac_g->fun.sparsity_out(0);
+    return sparsity.is_dense() ? -1 : static_cast<length_t>(sparsity.nnz());
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_jac_g(crvec x, rindexvec inner_idx,
+                                     rindexvec outer_ptr, rvec J_values) const {
+    assert(impl->jac_g.has_value());
+    if (J_values.size() > 0) {
+        (*impl->jac_g)({x.data(), param.data()}, {J_values.data()});
+    } else {
+        auto &&sparsity = impl->jac_g->fun.sparsity_out(0);
+        using detail::casadi_to_index;
+        if (!sparsity.is_dense()) {
+            std::transform(sparsity.row(), sparsity.row() + sparsity.nnz(),
+                           inner_idx.begin(), casadi_to_index<config_t>);
+            std::transform(sparsity.colind(),
+                           sparsity.colind() + this->get_n() + 1,
+                           outer_ptr.begin(), casadi_to_index<config_t>);
+        }
+    }
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_hess_L_prod(crvec x, crvec y, real_t scale,
+                                           crvec v, rvec Hv) const {
+    assert(impl->hess_L_prod.has_value());
+    (*impl->hess_L_prod)({x.data(), param.data(), y.data(), &scale, v.data()},
+                         {Hv.data()});
+}
+
+template <Config Conf>
+auto CasADiProblem<Conf>::get_hess_L_num_nonzeros() const -> length_t {
+    if (!impl->hess_L.has_value())
+        return -1;
+    auto &&sparsity = impl->hess_L->fun.sparsity_out(0);
+    return sparsity.is_dense() ? -1 : static_cast<length_t>(sparsity.nnz());
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_hess_L(crvec x, crvec y, real_t scale,
+                                      rindexvec inner_idx, rindexvec outer_ptr,
+                                      rvec H_values) const {
+    assert(impl->hess_L.has_value());
+    if (H_values.size() > 0) {
+        (*impl->hess_L)({x.data(), param.data(), y.data(), &scale},
+                        {H_values.data()});
+    } else {
+        auto &&sparsity = impl->hess_L->fun.sparsity_out(0);
+        using detail::casadi_to_index;
+        if (!sparsity.is_dense()) {
+            std::transform(sparsity.row(), sparsity.row() + sparsity.nnz(),
+                           inner_idx.begin(), casadi_to_index<config_t>);
+            std::transform(sparsity.colind(),
+                           sparsity.colind() + this->get_n() + 1,
+                           outer_ptr.begin(), casadi_to_index<config_t>);
+        }
+    }
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_hess_ψ_prod(crvec x, crvec y, crvec Σ,
+                                           real_t scale, crvec v,
+                                           rvec Hv) const {
+    assert(impl->hess_ψ_prod.has_value());
+    (*impl->hess_ψ_prod)({x.data(), param.data(), y.data(), Σ.data(), &scale,
+                          this->D.lowerbound.data(), this->D.upperbound.data(),
+                          v.data()},
+                         {Hv.data()});
+}
+
+template <Config Conf>
+auto CasADiProblem<Conf>::get_hess_ψ_num_nonzeros() const -> length_t {
+    if (!impl->hess_ψ.has_value())
+        return 0;
+    auto &&sparsity = impl->hess_ψ->fun.sparsity_out(0);
+    return sparsity.is_dense() ? 0 : static_cast<length_t>(sparsity.nnz());
+}
+
+template <Config Conf>
+void CasADiProblem<Conf>::eval_hess_ψ(crvec x, crvec y, crvec Σ, real_t scale,
+                                      rindexvec inner_idx, rindexvec outer_ptr,
+                                      rvec H_values) const {
+    assert(impl->hess_ψ.has_value());
+    if (H_values.size() > 0) {
+        (*impl->hess_ψ)({x.data(), param.data(), y.data(), Σ.data(), &scale,
+                         this->D.lowerbound.data(), this->D.upperbound.data()},
+                        {H_values.data()});
+    } else {
+        auto &&sparsity = impl->hess_ψ->fun.sparsity_out(0);
+        using detail::casadi_to_index;
+        if (!sparsity.is_dense()) {
+            std::transform(sparsity.row(), sparsity.row() + sparsity.nnz(),
+                           inner_idx.begin(), casadi_to_index<config_t>);
+            std::transform(sparsity.colind(),
+                           sparsity.colind() + this->get_n() + 1,
+                           outer_ptr.begin(), casadi_to_index<config_t>);
+        }
+    }
+}
+
+template <Config Conf>
+bool CasADiProblem<Conf>::provides_eval_grad_gi() const {
+    return false; // TODO
+}
+template <Config Conf>
+bool CasADiProblem<Conf>::provides_eval_jac_g() const {
+    return impl->jac_g.has_value();
+}
+template <Config Conf>
+bool CasADiProblem<Conf>::provides_eval_hess_L_prod() const {
+    return impl->hess_L_prod.has_value();
+}
+template <Config Conf>
+bool CasADiProblem<Conf>::provides_eval_hess_L() const {
+    return impl->hess_L.has_value();
+}
+template <Config Conf>
+bool CasADiProblem<Conf>::provides_eval_hess_ψ_prod() const {
+    return impl->hess_ψ_prod.has_value();
+}
+template <Config Conf>
+bool CasADiProblem<Conf>::provides_eval_hess_ψ() const {
+    return impl->hess_ψ.has_value();
+}
+
+} // namespace alpaqa

casadi/include/alpaqa/implementation/inner/directions/panoc/structured-lbfgs.tpp

@@ -0,0 +1,164 @@
+#pragma once
+
+#include <alpaqa/implementation/inner/panoc-helpers.tpp>
+#include <alpaqa/inner/directions/panoc/structured-lbfgs.hpp>
+
+namespace alpaqa {
+
+template <Config Conf>
+void StructuredLBFGSDirection<Conf>::initialize(
+    const Problem &problem, crvec y, 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) {
+    if (!problem.provides_eval_inactive_indices_res_lna())
+        throw std::invalid_argument(
+            "Structured L-BFGS requires eval_inactive_indices_res_lna()");
+    if (direction_params.hessian_vec_factor != 0 &&
+        !direction_params.hessian_vec_finite_differences &&
+        !direction_params.full_augmented_hessian &&
+        !problem.provides_eval_hess_L_prod())
+        throw std::invalid_argument(
+            "Structured L-BFGS requires eval_hess_L_prod(). Alternatively, set "
+            "hessian_vec_factor = 0 or hessian_vec_finite_differences = true.");
+    if (direction_params.hessian_vec_factor != 0 &&
+        !direction_params.hessian_vec_finite_differences &&
+        direction_params.full_augmented_hessian &&
+        !(problem.provides_eval_hess_L_prod() ||
+          problem.provides_eval_hess_ψ_prod()))
+        throw std::invalid_argument(
+            "Structured L-BFGS requires _eval_hess_ψ_prod() or "
+            "eval_hess_L_prod(). Alternatively, set "
+            "hessian_vec_factor = 0 or hessian_vec_finite_differences = true.");
+    if (direction_params.hessian_vec_factor != 0 &&
+        !direction_params.hessian_vec_finite_differences &&
+        direction_params.full_augmented_hessian &&
+        !problem.provides_eval_hess_ψ_prod() &&
+        !(problem.provides_get_box_D() && problem.provides_eval_grad_gi()))
+        throw std::invalid_argument(
+            "Structured L-BFGS requires either eval_hess_ψ_prod() or "
+            "get_box_D() and eval_grad_gi(). Alternatively, set "
+            "hessian_vec_factor = 0, hessian_vec_finite_differences = true, or "
+            "full_augmented_hessian = false.");
+    // Store references to problem and ALM variables
+    this->problem = &problem;
+    this->y.emplace(y);
+    this->Σ.emplace(Σ);
+    // Allocate workspaces
+    const auto n = problem.get_n();
+    const auto m = problem.get_m();
+    lbfgs.resize(n);
+    J_sto.resize(n);
+    HqK.resize(n);
+    if (direction_params.hessian_vec_finite_differences) {
+        work_n.resize(n);
+        work_n2.resize(n);
+        work_m.resize(m);
+    } else if (direction_params.full_augmented_hessian) {
+        work_n.resize(n);
+        work_m.resize(m);
+    }
+}
+
+template <Config Conf>
+bool StructuredLBFGSDirection<Conf>::apply(real_t γₖ, crvec xₖ,
+                                           [[maybe_unused]] crvec x̂ₖ, crvec pₖ,
+                                           crvec grad_ψxₖ, rvec qₖ) const {
+    const auto n = problem->get_n();
+
+    // Find inactive indices J
+    auto nJ = problem->eval_inactive_indices_res_lna(γₖ, xₖ, grad_ψxₖ, J_sto);
+    auto J = J_sto.topRows(nJ);
+
+    // There are no inactive indices J
+    if (nJ == 0) {
+        // No free variables, no Newton step possible
+        return false; // Simply use the projection step
+    }
+    // There are inactive indices J
+    if (J.size() == n) { // There are no active indices K
+        // If all indices are free, we can use standard L-BFGS,
+        qₖ = (real_t(1) / γₖ) * pₖ;
+        return lbfgs.apply(qₖ, γₖ);
+    }
+    // There are active indices K
+    qₖ = pₖ;
+    if (direction_params.hessian_vec_factor != 0) {
+        qₖ(J).setZero();
+        approximate_hessian_vec_term(xₖ, grad_ψxₖ, qₖ, J);
+        // Compute right-hand side of 6.1c
+        qₖ(J) = (real_t(1) / γₖ) * pₖ(J) -
+                direction_params.hessian_vec_factor * HqK(J);
+    } else {
+        qₖ(J) = (real_t(1) / γₖ) * pₖ(J);
+    }
+    // If there are active indices, we need the specialized version
+    // that only applies L-BFGS to the inactive indices
+    bool success = lbfgs.apply_masked(qₖ, γₖ, J);
+    if (success)
+        return true;
+    // If L-BFGS application failed, qₖ(J) still contains
+    // -∇ψ(x)(J) - HqK(J) or -∇ψ(x)(J), which is not a valid step.
+    // A good alternative is to use H₀ = γI as an L-BFGS estimate.
+    // This seems to perform better in practice than just falling back to a
+    // projected gradient step.
+    switch (direction_params.failure_policy) {
+        case DirectionParams::FallbackToProjectedGradient: return success;
+        case DirectionParams::UseScaledLBFGSInput:
+            if (nJ == n)
+                qₖ *= γₖ;
+            else
+                qₖ(J) *= γₖ;
+            return true;
+        default: return false;
+    }
+}
+
+template <Config Conf>
+void StructuredLBFGSDirection<Conf>::approximate_hessian_vec_term(
+    crvec xₖ, crvec grad_ψxₖ, rvec qₖ, crindexvec J) const {
+    const auto m = problem->get_m();
+    // Either compute the Hessian-vector product using finite differences
+    if (direction_params.hessian_vec_finite_differences) {
+        Helpers::calc_augmented_lagrangian_hessian_prod_fd(
+            *problem, xₖ, *y, *Σ, grad_ψxₖ, qₖ, HqK, work_n, work_n2, work_m);
+    }
+    // Or using an exact AD
+    else {
+        if (!direction_params.full_augmented_hessian) {
+            // Compute the product with the Hessian of the Lagrangian
+            problem->eval_hess_L_prod(xₖ, *y, 1, qₖ, HqK);
+        } else {
+            if (problem->provides_eval_hess_ψ_prod()) {
+                // Compute the product with the Hessian of the augmented
+                // Lagrangian
+                problem->eval_hess_ψ_prod(xₖ, *y, *Σ, 1, qₖ, HqK);
+            } else {
+                // Compute the product with the Hessian of the Lagrangian
+                problem->eval_hess_L_prod(xₖ, *y, 1, qₖ, HqK);
+                // And then add the Hessian of the penalty terms, to get the
+                // Hessian of the full augmented Lagrangian (if required)
+                if (direction_params.full_augmented_hessian) {
+                    assert(m == 0 || problem->provides_eval_grad_gi());
+                    const auto &D = problem->get_box_D();
+                    auto &g       = work_m;
+                    problem->eval_g(xₖ, g);
+                    for (index_t i = 0; i < m; ++i) {
+                        real_t ζ = g(i) + (*y)(i) / (*Σ)(i);
+                        bool inactive =
+                            D.lowerbound(i) < ζ && ζ < D.upperbound(i);
+                        if (not inactive) {
+                            problem->eval_grad_gi(xₖ, i, work_n);
+                            auto t = (*Σ)(i)*work_n.dot(qₖ);
+                            // TODO: the dot product is more work than
+                            //       strictly necessary (only over K)
+                            for (auto j : J)
+                                HqK(j) += work_n(j) * t;
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+} // namespace alpaqa