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

casadi/include/alpaqa/inner/directions/panoc-ocp/ocp-vars.hpp

@@ -1,492 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/problem/ocproblem.hpp>
-#include <concepts>
-#include <numeric>
-
-namespace alpaqa {
-
-template <class V, class Conf>
-concept VectorRefLike =
-    std::convertible_to<V, rvec<Conf>> || std::convertible_to<V, crvec<Conf>>;
-
-template <Config Conf, VectorRefLike<Conf> V>
-constexpr auto const_or_mut_rvec(V &&v) {
-    if constexpr (Eigen::internal::is_lvalue<std::remove_reference_t<V>>::value)
-        return rvec<Conf>{v};
-    else
-        return crvec<Conf>{v};
-}
-
-template <Config Conf>
-struct OCPVariables {
-    USING_ALPAQA_CONFIG(Conf);
-
-    OCPVariables(
-        /// nx, nu, nh, nc
-        const std::array<index_t, 4> &sizes,
-        /// nx, nh, nc
-        const std::array<index_t, 3> &sizes_N,
-        /// Horizon length
-        length_t N)
-        : N{N} {
-        std::partial_sum(sizes.begin(), sizes.end(), indices.begin());
-        std::partial_sum(sizes_N.begin(), sizes_N.end(), indices_N.begin());
-    }
-    OCPVariables(const TypeErasedControlProblem<config_t> &prob)
-        : OCPVariables{
-              {prob.get_nx(), prob.get_nu(), prob.get_nh(), prob.get_nc()},
-              {prob.get_nx(), prob.get_nh_N(), prob.get_nc_N()},
-              prob.get_N(),
-          } {}
-
-    enum Indices {
-        i_u   = 0,
-        i_h   = 1,
-        i_c   = 2,
-        i_h_N = 0,
-        i_c_N = 1,
-    };
-    length_t N;
-    std::array<index_t, 4> indices;
-    std::array<index_t, 3> indices_N;
-    length_t size(size_t i) const { return indices[i + 1] - indices[i]; }
-    length_t size_N(size_t i) const { return indices_N[i + 1] - indices_N[i]; }
-    length_t nx() const { return indices[0]; }
-    length_t nu() const { return size(i_u); }
-    length_t nxu() const { return nx() + nu(); }
-    length_t nh() const { return size(i_h); }
-    length_t nc() const { return size(i_c); }
-    length_t nx_N() const { return indices_N[0]; }
-    length_t nh_N() const { return size_N(i_h_N); }
-    length_t nc_N() const { return size_N(i_c_N); }
-
-    vec create() const { return vec(N * indices.back() + indices_N.back()); }
-    auto xk(VectorRefLike<config_t> auto &&v, index_t t) const {
-        return const_or_mut_rvec<config_t>(v.segment(t * indices.back(), nx()));
-    }
-    auto x(crvec v) const {
-        return [v, this](index_t t) { return xk(v, t); };
-    }
-    auto xuk(VectorRefLike<config_t> auto &&v, index_t t) const {
-        return const_or_mut_rvec<config_t>(
-            v.segment(t * indices.back(), nxu()));
-    }
-    auto uk(VectorRefLike<config_t> auto &&v, index_t t) const {
-        assert(t < N);
-        return const_or_mut_rvec<config_t>(
-            v.segment(t * indices.back() + indices[0], nu()));
-    }
-    auto u(crvec v) const {
-        return [v, this](index_t t) { return uk(v, t); };
-    }
-    auto hk(VectorRefLike<config_t> auto &&v, index_t t) const {
-        return const_or_mut_rvec<config_t>(v.segment(
-            t * indices.back() + (t < N ? indices[i_h] : indices_N[i_h_N]),
-            (t < N ? nh() : nh_N())));
-    }
-    auto ck(VectorRefLike<config_t> auto &&v, index_t t) const {
-        return v.segment(t * indices.back() +
-                             (t < N ? indices[i_c] : indices_N[i_c_N]),
-                         (t < N ? nc() : nc_N()));
-    }
-
-    vec create_qr() const { return vec(N * nxu() + nx()); }
-    auto qk(VectorRefLike<config_t> auto &&v, index_t t) const {
-        assert(t <= N);
-        return const_or_mut_rvec<config_t>(v.segment(t * nxu(), nx()));
-    }
-    auto q(crvec v) const {
-        return [v, this](index_t t) { return qk(v, t); };
-    }
-    auto qN_mut(vec &v) const {
-        return [&v, this]() { return qk(v, N); };
-    }
-    auto rk(VectorRefLike<config_t> auto &&v, index_t t) const {
-        assert(t < N);
-        return const_or_mut_rvec<config_t>(v.segment(t * nxu() + nx(), nu()));
-    }
-    auto r(crvec v) const {
-        return [v, this](index_t t) { return rk(v, t); };
-    }
-    auto qrk(VectorRefLike<config_t> auto &&v, index_t t) const {
-        assert(t < N);
-        return const_or_mut_rvec<config_t>(v.segment(t * nxu(), nxu()));
-    }
-    auto qr(crvec v) const {
-        return [v, this](index_t t) { return qrk(v, t); };
-    }
-    auto qr_mut(vec &v) const {
-        return [&v, this](index_t t) { return qrk(v, t); };
-    }
-
-    mat create_AB() const { return mat(nx(), nxu() * N); }
-    rmat ABk(rmat AB, index_t t) const {
-        return AB.middleCols(t * nxu(), nxu());
-    }
-    auto ABk(mat &AB, index_t t) const {
-        return AB.middleCols(t * nxu(), nxu());
-    }
-    crmat ABk(crmat AB, index_t t) const {
-        return AB.middleCols(t * nxu(), nxu());
-    }
-    auto AB(crmat AB) const {
-        return [AB, this](index_t t) { return ABk(AB, t); };
-    }
-    rmat Ak(rmat AB, index_t t) const { return AB.middleCols(t * nxu(), nx()); }
-    crmat Ak(crmat AB, index_t t) const {
-        return AB.middleCols(t * nxu(), nx());
-    }
-    auto Ak(mat &AB, index_t t) const { return AB.middleCols(t * nxu(), nx()); }
-    auto A(crmat AB) const {
-        return [AB, this](index_t t) { return Ak(AB, t); };
-    }
-    rmat Bk(rmat AB, index_t t) const {
-        return AB.middleCols(t * nxu() + nx(), nu());
-    }
-    crmat Bk(crmat AB, index_t t) const {
-        return AB.middleCols(t * nxu() + nx(), nu());
-    }
-    auto Bk(mat &AB, index_t t) const {
-        return AB.middleCols(t * nxu() + nx(), nu());
-    }
-    auto B(crmat AB) const {
-        return [AB, this](index_t t) { return Bk(AB, t); };
-    }
-};
-
-template <Config Conf>
-struct OCPEvaluator {
-    USING_ALPAQA_CONFIG(Conf);
-    using OCPVars = OCPVariables<config_t>;
-    using Problem = TypeErasedControlProblem<config_t>;
-    using Box     = alpaqa::Box<config_t>;
-    const Problem *problem;
-    OCPVars vars;
-    mutable vec work_x{vars.nc() > 0 || vars.nc_N() ? vars.nx() : 0};
-    mutable vec work_λ{vars.nx()};
-    mutable vec work_c{std::max(vars.nc(), vars.nc_N())};
-    mutable vec work_R{problem->get_R_work_size()};
-    mutable vec work_S{problem->get_S_work_size()};
-
-    OCPEvaluator(const Problem &problem) : problem{&problem}, vars{problem} {}
-
-    length_t N() const { return vars.N; }
-
-    /// @pre x0 and u initialized
-    /// @post x, h and c updated
-    /// @return @f$ V(u) =
-    ///             \sum_{k=0}^{N-1} \ell(h_k(x_k, u_k)) + V_f(h_N(x_N)) @f$
-    real_t forward(rvec storage, const Box &D, const Box &D_N, crvec μ,
-                   crvec y) const {
-        real_t V  = 0;
-        auto N    = this->N();
-        auto nc   = vars.nc();
-        auto nc_N = vars.nc_N();
-        for (index_t t = 0; t < N; ++t) {
-            auto xk = vars.xk(storage, t);
-            auto uk = vars.uk(storage, t);
-            auto ck = vars.ck(storage, t);
-            if (vars.nh() > 0) {
-                auto hk = vars.hk(storage, t);
-                problem->eval_h(t, xk, uk, hk);
-                V += problem->eval_l(t, hk);
-            } else {
-                auto xuk = vars.xuk(storage, t);
-                V += problem->eval_l(t, xuk);
-            }
-            if (nc > 0) {
-                problem->eval_constr(t, xk, ck);
-                auto yk = y.segment(t * nc, nc);
-                auto μk = μ.segment(t * nc, nc);
-                auto ζ  = ck + μk.asDiagonal().inverse() * yk;
-                V += real_t(0.5) * dist_squared(ζ, D, μk);
-            }
-            problem->eval_f(t, xk, uk, vars.xk(storage, t + 1));
-        }
-        auto xN = vars.xk(storage, N);
-        auto cN = vars.ck(storage, N);
-        if (vars.nh_N() > 0) {
-            auto hN = vars.hk(storage, N);
-            problem->eval_h_N(xN, hN);
-            V += problem->eval_l_N(hN);
-        } else {
-            V += problem->eval_l_N(xN);
-        }
-        if (nc_N > 0) {
-            problem->eval_constr_N(xN, cN);
-            auto yN = y.segment(N * nc, nc_N);
-            auto μN = μ.segment(N * nc, nc_N);
-            auto ζ  = cN + μN.asDiagonal().inverse() * yN;
-            V += real_t(0.5) * dist_squared(ζ, D_N, μN);
-        }
-        return V;
-    }
-
-    /// @pre x0 and u initialized
-    /// @post x updated
-    void forward_simulate(rvec storage) const {
-        for (index_t t = 0; t < N(); ++t) {
-            auto xk = vars.xk(storage, t);
-            auto uk = vars.uk(storage, t);
-            auto ck = vars.ck(storage, t);
-            if (vars.nh() > 0) {
-                auto hk = vars.hk(storage, t);
-                problem->eval_h(t, xk, uk, hk);
-            }
-            if (vars.nc() > 0)
-                problem->eval_constr(t, xk, ck);
-            problem->eval_f(t, xk, uk, vars.xk(storage, t + 1));
-        }
-        auto xN = vars.xk(storage, N());
-        auto cN = vars.ck(storage, N());
-        if (vars.nh_N() > 0) {
-            auto hN = vars.hk(storage, N());
-            problem->eval_h_N(xN, hN);
-        }
-        if (vars.nc_N() > 0)
-            problem->eval_constr_N(xN, cN);
-    }
-
-    /// @pre x0 and u initialized
-    void forward_simulate(crvec u, rvec x) const {
-        assert(u.size() == vars.N * vars.nu());
-        assert(x.size() == vars.nx());
-        for (index_t t = 0; t < N(); ++t) {
-            auto uk = u.segment(t * vars.nu(), vars.nu());
-            problem->eval_f(t, x, uk, x);
-        }
-    }
-
-    /// @pre x, u, h and c initialized (i.e. forward was called)
-    void backward(rvec storage, rvec g, const auto &qr, const auto &q_N,
-                  const Box &D, const Box &D_N, crvec μ, crvec y) const {
-        auto N    = this->N();
-        auto nc   = vars.nc();
-        auto nc_N = vars.nc_N();
-        auto nu   = vars.nu();
-        auto nx   = vars.nx();
-        auto &w   = work_x;
-        auto &v   = work_c;
-        auto &λ   = work_λ;
-        assert((nc <= 0 && nc_N <= 0) || w.size() == nx);
-        assert((nc <= 0 && nc_N <= 0) || v.size() == std::max(nc, nc_N));
-        auto qN = q_N();
-        auto xN = vars.xk(storage, N);
-        auto hN = vars.hk(storage, N);
-        auto vN = v.topRows(nc_N);
-        auto vk = v.topRows(nc);
-        // λ ← ∇h(x)·∇l(h)
-        problem->eval_q_N(xN, hN, λ);
-        // λ ← ∇h(x)·∇l(h) + ∇c(x)·μ·(c(x) + μ⁻¹y - Π(c(x) + μ⁻¹y; D))
-        if (nc_N > 0) {
-            auto cN = vars.ck(storage, N);
-            auto yN = y.segment(N * nc, nc_N);
-            auto μN = μ.segment(N * nc, nc_N);
-            auto ζ  = cN + μN.asDiagonal().inverse() * yN;
-            vN      = μN.asDiagonal() * projecting_difference(ζ, D_N);
-            problem->eval_grad_constr_prod_N(xN, vN, w);
-            λ += w;
-        }
-        qN = λ;
-        for (index_t t = N; t-- > 0;) {
-            auto gt    = g.segment(t * nu, nu);
-            auto hk    = vars.hk(storage, t);
-            auto xuk   = vars.xuk(storage, t);
-            auto xk    = vars.xk(storage, t);
-            auto uk    = vars.uk(storage, t);
-            auto &&qrk = qr(t);
-            auto &&qk  = qrk.topRows(nx);
-            auto &&rk  = qrk.bottomRows(nu);
-            // /q\ ← /Aᵀ\ λ
-            // \r/   \Bᵀ/ λ
-            problem->eval_grad_f_prod(t, xk, uk, λ, qrk);
-            // λ ← Aᵀλ, ∇ψ ← Bᵀλ
-            λ  = qk;
-            gt = rk;
-            // /q\ ← ∇h(x,u)·∇l(h)
-            // \r/
-            problem->eval_qr(t, xuk, hk, qrk);
-            // q ← ∇h(x)·∇l(h) + ∇c(x)·μ·(c(x) + μ⁻¹y - Π(c(x) + μ⁻¹y; D))
-            if (nc > 0) {
-                auto ck = vars.ck(storage, t);
-                auto yk = y.segment(t * nc, nc);
-                auto μk = μ.segment(t * nc, nc);
-                auto ζ  = ck + μk.asDiagonal().inverse() * yk;
-                vk      = μk.asDiagonal() * projecting_difference(ζ, D);
-                problem->eval_grad_constr_prod(t, xk, vk, w);
-                qk += w;
-            }
-            // λ ← q + Aᵀλ, ∇ψ ← r + Bᵀλ
-            λ += qk;
-            gt += rk;
-        }
-    }
-
-    void Qk(crvec storage, crvec y, crvec μ, const Box &D, const Box &D_N,
-            index_t k, rmat out) const {
-        auto N       = this->N();
-        auto nc      = vars.nc();
-        auto nc_N    = vars.nc_N();
-        auto work_cN = work_c.topRows(nc_N);
-        auto work_ck = work_c.topRows(nc);
-        check_finiteness(out.reshaped(), "Qk input");
-        auto hk  = vars.hk(storage, k);
-        auto xuk = vars.xuk(storage, k);
-        auto xk  = vars.xk(storage, k);
-        if (k < N)
-            problem->eval_add_Q(k, xuk, hk, out);
-        else
-            problem->eval_add_Q_N(xk, hk, out);
-        if (nc > 0 || nc_N > 0) {
-            auto ck = vars.ck(storage, k);
-            auto yk = y.segment(k * nc, k < N ? nc : nc_N);
-            auto μk = μ.segment(k * nc, k < N ? nc : nc_N);
-            auto ζ  = ck + μk.asDiagonal().inverse() * yk;
-            if (k < N) {
-                for (index_t i = 0; i < nc; ++i)
-                    work_ck(i) = μk(i) * (ζ(i) < D.lowerbound(i) ||
-                                          ζ(i) > D.upperbound(i));
-                problem->eval_add_gn_hess_constr(k, xk, work_ck, out);
-            } else {
-                for (index_t i = 0; i < nc_N; ++i)
-                    work_cN(i) = μk(i) * (ζ(i) < D_N.lowerbound(i) ||
-                                          ζ(i) > D_N.upperbound(i));
-                problem->eval_add_gn_hess_constr_N(xk, work_cN, out);
-            }
-        }
-        check_finiteness(out.reshaped(), "Qk output");
-    }
-    auto Q(crvec storage, crvec y, crvec μ, const Box &D,
-           const Box &D_N) const {
-        return [=, this, &D, &D_N](index_t k) {
-            return [=, this, &D, &D_N](rmat out) {
-                return Qk(storage, y, μ, D, D_N, k, out);
-            };
-        };
-    }
-
-    /// @post initialize work_R
-    void Rk(crvec storage, index_t k, crindexvec mask, rmat out) {
-        check_finiteness(out.reshaped(), "Rk input");
-        auto hk  = vars.hk(storage, k);
-        auto xuk = vars.xuk(storage, k);
-        problem->eval_add_R_masked(k, xuk, hk, mask, out, work_R);
-        check_finiteness(out.reshaped(), "Rk output");
-    }
-    auto R(crvec storage) {
-        return [=, this](index_t k) {
-            return [=, this](crindexvec mask, rmat out) {
-                return Rk(storage, k, mask, out);
-            };
-        };
-    }
-
-    /// @post initialize work_S
-    void Sk(crvec storage, index_t k, crindexvec mask, rmat out) {
-        check_finiteness(out.reshaped(), "Sk input");
-        auto hk  = vars.hk(storage, k);
-        auto xuk = vars.xuk(storage, k);
-        problem->eval_add_S_masked(k, xuk, hk, mask, out, work_S);
-        check_finiteness(out.reshaped(), "Sk output");
-    }
-    auto S(crvec storage) {
-        return [=, this](index_t k) {
-            return [=, this](crindexvec mask, rmat out) {
-                return Sk(storage, k, mask, out);
-            };
-        };
-    }
-
-    /// @pre initialized work_R
-    void Rk_prod(crvec storage, index_t k, crindexvec mask_J, crindexvec mask_K,
-                 crvec v, rvec out) const {
-
-        check_finiteness(v(mask_K), "Rk_prod input v");
-        check_finiteness(out.reshaped(), "Rk_prod input");
-        auto hk  = vars.hk(storage, k);
-        auto xuk = vars.xuk(storage, k);
-        problem->eval_add_R_prod_masked(k, xuk, hk, mask_J, mask_K, v, out,
-                                        work_R);
-        check_finiteness(out.reshaped(), "Rk_prod output");
-    }
-    auto R_prod(crvec storage) const {
-        return [=, this](index_t k) {
-            return [=, this](crindexvec mask_J, crindexvec mask_K, crvec v,
-                             rvec out) {
-                return Rk_prod(storage, k, mask_J, mask_K, v, out);
-            };
-        };
-    }
-
-    /// @pre initialized work_S
-    void Sk_prod(crvec storage, index_t k, crindexvec mask_K, crvec v,
-                 rvec out) const {
-        check_finiteness(v(mask_K), "Sk_prod input v");
-        check_finiteness(out.reshaped(), "Sk_prod input");
-        auto hk  = vars.hk(storage, k);
-        auto xuk = vars.xuk(storage, k);
-        problem->eval_add_S_prod_masked(k, xuk, hk, mask_K, v, out, work_S);
-        check_finiteness(out.reshaped(), "Sk_prod output");
-    }
-    auto S_prod(crvec storage) const {
-        return [=, this](index_t k) {
-            return [=, this](crindexvec mask_K, crvec v, rvec out) {
-                return Sk_prod(storage, k, mask_K, v, out);
-            };
-        };
-    }
-};
-
-namespace detail {
-
-template <Config Conf>
-void assign_interleave_xu(const OCPVariables<Conf> &dim, crvec<Conf> u,
-                          rvec<Conf> storage) {
-    for (index_t<Conf> t = 0; t < dim.N; ++t)
-        dim.uk(storage, t) = u.segment(t * dim.nu(), dim.nu());
-}
-template <Config Conf>
-void assign_interleave_xu(const OCPVariables<Conf> &dim, crvec<Conf> x,
-                          crvec<Conf> u, rvec<Conf> storage) {
-    for (index_t<Conf> t = 0; t < dim.N; ++t) {
-        dim.xk(storage, t) = x.segment(t * dim.nx(), dim.nx());
-        dim.uk(storage, t) = u.segment(t * dim.nu(), dim.nu());
-    }
-    dim.xk(storage, dim.N) = x.segment(dim.N * dim.nx(), dim.nx());
-}
-template <Config Conf>
-void assign_extract_u(const OCPVariables<Conf> &dim, crvec<Conf> storage,
-                      rvec<Conf> u) {
-    for (index_t<Conf> t = 0; t < dim.N; ++t)
-        u.segment(t * dim.nu(), dim.nu()) = dim.uk(storage, t);
-}
-template <Config Conf>
-void assign_extract_x(const OCPVariables<Conf> &dim, crvec<Conf> storage,
-                      rvec<Conf> x) {
-    for (index_t<Conf> t = 0; t < dim.N + 1; ++t)
-        x.segment(t * dim.nx(), dim.nx()) =
-            storage.segment(t * (dim.nx() + dim.nu()), dim.nx());
-}
-
-template <Config Conf>
-vec<Conf> extract_u(const TypeErasedControlProblem<Conf> &problem,
-                    crvec<Conf> xu) {
-    OCPVariables<Conf> dim{problem};
-    vec<Conf> u(dim.N * dim.nu());
-    assign_extract_u(dim, xu, u);
-    return u;
-}
-template <Config Conf>
-vec<Conf> extract_x(const TypeErasedControlProblem<Conf> &problem,
-                    crvec<Conf> xu) {
-    OCPVariables<Conf> dim{problem};
-    vec<Conf> x((dim.N + 1) * dim.nx());
-    assign_extract_x(dim, xu, x);
-    return x;
-}
-
-} // namespace detail
-
-} // namespace alpaqa

casadi/include/alpaqa/inner/directions/pantr/newton-tr.hpp

@@ -1,192 +0,0 @@
-#pragma once
-
-#include <alpaqa/accelerators/steihaugcg.hpp>
-#include <alpaqa/problem/type-erased-problem.hpp>
-#include <alpaqa/util/alloc-check.hpp>
-#include <alpaqa/util/index-set.hpp>
-#include <cmath>
-#include <limits>
-#include <optional>
-#include <stdexcept>
-
-namespace alpaqa {
-
-/// Parameters for the @ref NewtonTRDirection class.
-template <Config Conf>
-struct NewtonTRDirectionParams {
-    USING_ALPAQA_CONFIG(Conf);
-    bool rescale_on_step_size_changes = false;
-    real_t hessian_vec_factor         = real_t(0.5);
-    bool finite_diff                  = false;
-    real_t finite_diff_stepsize =
-        std::sqrt(std::numeric_limits<real_t>::epsilon());
-};
-
-/// @ingroup grp_DirectionProviders
-template <Config Conf>
-struct NewtonTRDirection {
-    USING_ALPAQA_CONFIG(Conf);
-
-    using Problem           = TypeErasedProblem<config_t>;
-    using AcceleratorParams = SteihaugCGParams<config_t>;
-    using DirectionParams   = NewtonTRDirectionParams<config_t>;
-
-    struct Params {
-        AcceleratorParams accelerator = {};
-        DirectionParams direction     = {};
-    };
-
-    NewtonTRDirection() = default;
-    NewtonTRDirection(const Params &params)
-        : steihaug(params.accelerator), direction_params(params.direction) {}
-    NewtonTRDirection(const AcceleratorParams &params,
-                      const DirectionParams &directionparams = {})
-        : steihaug(params), direction_params(directionparams) {}
-
-    /// @see @ref PANTRDirection::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) {
-        if (!direction_params.finite_diff &&
-            !problem.provides_eval_hess_ψ_prod())
-            throw std::invalid_argument("NewtonTR without finite differences "
-                                        "requires Problem::eval_hess_ψ_prod()");
-        if (!problem.provides_eval_inactive_indices_res_lna())
-            throw std::invalid_argument(
-                "NewtonTR requires "
-                "Problem::eval_inactive_indices_res_lna()");
-        // Store references to problem and ALM variables
-        this->problem = &problem;
-        this->y.emplace(y);
-        this->Σ.emplace(Σ);
-        // Resize workspaces
-        const auto n = problem.get_n(), m = problem.get_m();
-        JK_sto.resize(n);
-        rJ_sto.resize(n);
-        qJ_sto.resize(n);
-        work.resize(n);
-        work_2.resize(n);
-        steihaug.resize(n);
-        if (direction_params.finite_diff) {
-            work_n_fd.resize(n);
-            work_m_fd.resize(m);
-        }
-    }
-
-    /// @see @ref PANTRDirection::has_initial_direction
-    bool has_initial_direction() const { return true; }
-
-    /// @see @ref PANTRDirection::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 PANTRDirection::apply
-    real_t apply([[maybe_unused]] real_t γₖ, [[maybe_unused]] crvec xₖ,
-                 [[maybe_unused]] crvec x̂ₖ, crvec pₖ,
-                 [[maybe_unused]] crvec grad_ψxₖ, real_t radius,
-                 rvec qₖ) const {
-
-        if (!std::isfinite(radius))
-            throw std::logic_error("Invalid trust radius");
-        if (radius < std::numeric_limits<real_t>::epsilon())
-            throw std::logic_error("Trust radius too small");
-
-        // Newton with exact Hessian
-
-        // Find inactive and active constraints
-        const auto n = problem->get_n();
-        index_t nJ =
-            problem->eval_inactive_indices_res_lna(γₖ, xₖ, grad_ψxₖ, JK_sto);
-        crindexvec J = JK_sto.topRows(nJ);
-        rindexvec K  = JK_sto.bottomRows(n - nJ);
-        detail::IndexSet<config_t>::compute_complement(J, K, n);
-        auto rJ = rJ_sto.topRows(nJ);
-        auto qJ = qJ_sto.topRows(nJ);
-        rJ      = (-real_t(1) / γₖ) * pₖ(J);
-        qₖ(K)   = pₖ(K);
-        qₖ(J).setZero();
-        real_t norm_qK_sq = pₖ(K).squaredNorm();
-
-        // Hessian-vector term
-        if (direction_params.hessian_vec_factor != 0) {
-            if (direction_params.finite_diff) {
-                real_t ε = (1 + grad_ψxₖ.norm()) *
-                           direction_params.finite_diff_stepsize;
-                work = xₖ + ε * qₖ;
-                problem->eval_grad_ψ(work, *y, *Σ, work_2, work_n_fd,
-                                     work_m_fd);
-                rJ.noalias() += (work_2 - grad_ψxₖ)(J) *
-                                (direction_params.hessian_vec_factor / ε);
-            } else {
-                problem->eval_hess_ψ_prod(xₖ, *y, *Σ, 1, qₖ, work);
-                rJ.noalias() += work(J) * direction_params.hessian_vec_factor;
-            }
-        }
-
-        // Hessian-vector product on subset J
-        auto hess_vec_mult = [&](crvec p, rvec Bp) {
-            if (direction_params.finite_diff) {
-                real_t ε = (1 + grad_ψxₖ.norm()) *
-                           direction_params.finite_diff_stepsize;
-                work = xₖ;
-                work(J) += ε * p;
-                problem->eval_grad_ψ(work, *y, *Σ, work_2, work_n_fd,
-                                     work_m_fd);
-                Bp.topRows(nJ) = (work_2 - grad_ψxₖ)(J) / ε;
-            } else {
-                work.setZero();
-                work(J) = p;
-                problem->eval_hess_ψ_prod(xₖ, *y, *Σ, 1, work, work_2);
-                Bp.topRows(nJ) = work_2(J);
-            }
-        };
-
-        // Steihaug conjugate gradients
-        real_t qJ_model = steihaug.solve(rJ, hess_vec_mult, radius, qJ);
-        qₖ(J)           = qJ;
-        return qJ_model - norm_qK_sq / (2 * γₖ);
-    }
-
-    /// @see @ref PANTRDirection::changed_γ
-    void changed_γ([[maybe_unused]] real_t γₖ, [[maybe_unused]] real_t old_γₖ) {
-        if (direction_params.rescale_on_step_size_changes)
-            throw std::invalid_argument("NewtonTRDirection does not support "
-                                        "rescale_on_step_size_changes");
-    }
-
-    /// @see @ref PANTRDirection::reset
-    void reset() {}
-
-    /// @see @ref PANTRDirection::get_name
-    std::string get_name() const {
-        return "NewtonTRDirection<" + std::string(config_t::get_name()) + '>';
-    }
-
-    auto get_params() const {
-        return std::tie(steihaug.params, direction_params);
-    }
-
-    SteihaugCG<config_t> steihaug;
-    DirectionParams direction_params;
-    const Problem *problem = nullptr;
-#ifndef _WIN32
-    std::optional<crvec> y = std::nullopt;
-    std::optional<crvec> Σ = std::nullopt;
-#else
-    std::optional<vec> y = std::nullopt;
-    std::optional<vec> Σ = std::nullopt;
-#endif
-    mutable indexvec JK_sto;
-    mutable vec rJ_sto;
-    mutable vec qJ_sto;
-    mutable vec work, work_2, work_n_fd, work_m_fd;
-};
-
-} // namespace alpaqa