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

casadi/include/alpaqa/implementation/inner/panoc-helpers.tpp

@@ -1,389 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/export.hpp>
-#include <alpaqa/inner/inner-solve-options.hpp>
-#include <alpaqa/inner/internal/panoc-stop-crit.hpp>
-#include <alpaqa/inner/internal/solverstatus.hpp>
-#include <alpaqa/problem/type-erased-problem.hpp>
-#include <alpaqa/util/atomic-stop-signal.hpp>
-#include <alpaqa/util/not-implemented.hpp>
-
-#include <stdexcept>
-
-namespace alpaqa::detail {
-
-template <Config Conf>
-struct PANOCHelpers {
-    USING_ALPAQA_CONFIG(Conf);
-    using Problem = alpaqa::TypeErasedProblem<config_t>;
-    using Box     = alpaqa::Box<config_t>;
-
-    /// Calculate the error between ẑ and g(x).
-    /// @f[ \hat{z}^k = \Pi_D\left(g(x^k) + \Sigma^{-1}y\right) @f]
-    static void calc_err_z(const Problem &p, ///< [in]  Problem description
-                           crvec x̂, ///< [in]  Decision variable @f$ \hat{x} @f$
-                           crvec y, ///< [in]  Lagrange multipliers @f$ y @f$
-                           crvec Σ, ///< [in]  Penalty weights @f$ \Sigma @f$
-                           rvec err_z ///< [out] @f$ g(\hat{x}) - \hat{z} @f$
-    ) {
-        if (p.get_m() == 0) /* [[unlikely]] */
-            return;
-
-        // g(x̂)
-        p.eval_g(x̂, err_z);
-        // ζ = g(x̂) + Σ⁻¹y
-        err_z += Σ.asDiagonal().inverse() * y;
-        // ẑ = Π(ζ, D)
-        p.eval_proj_diff_g(err_z, err_z);
-        // g(x) - ẑ
-        err_z -= Σ.asDiagonal().inverse() * y;
-        // TODO: catastrophic cancellation?
-    }
-
-    static bool stop_crit_requires_grad_ψx̂(PANOCStopCrit crit) {
-        switch (crit) {
-            case PANOCStopCrit::ApproxKKT: [[fallthrough]];
-            case PANOCStopCrit::ApproxKKT2: return true;
-            case PANOCStopCrit::ProjGradNorm: [[fallthrough]];
-            case PANOCStopCrit::ProjGradNorm2: [[fallthrough]];
-            case PANOCStopCrit::ProjGradUnitNorm: [[fallthrough]];
-            case PANOCStopCrit::ProjGradUnitNorm2: [[fallthrough]];
-            case PANOCStopCrit::FPRNorm: [[fallthrough]];
-            case PANOCStopCrit::FPRNorm2: return false;
-            case PANOCStopCrit::Ipopt: return true;
-            case PANOCStopCrit::LBFGSBpp: return false;
-            default:;
-        }
-        throw std::out_of_range("Invalid PANOCStopCrit");
-    }
-
-    /// Compute the ε from the stopping criterion, see @ref PANOCStopCrit.
-    static real_t calc_error_stop_crit(
-        const Problem &problem, ///< [in]  Problem description
-        PANOCStopCrit crit,     ///< [in]  What stoppint criterion to use
-        crvec pₖ,      ///< [in]  Projected gradient step @f$ \hat x^k - x^k @f$
-        real_t γ,      ///< [in]  Step size
-        crvec xₖ,      ///< [in]  Current iterate
-        crvec x̂ₖ,      ///< [in]  Current iterate after projected gradient step
-        crvec ŷₖ,      ///< [in]  Candidate Lagrange multipliers
-        crvec grad_ψₖ, ///< [in]  Gradient in @f$ x^k @f$
-        crvec grad_̂ψₖ, ///< [in]  Gradient in @f$ \hat x^k @f$
-        rvec work_n1,  ///<       Workspace of dimension n
-        rvec work_n2   ///<       Workspace of dimension n
-    ) {
-        switch (crit) {
-            case PANOCStopCrit::ApproxKKT: {
-                auto err = (1 / γ) * pₖ + (grad_ψₖ - grad_̂ψₖ);
-                // These parentheses     ^^^               ^^^     are important
-                // to prevent catastrophic cancellation when the step is small
-                return vec_util::norm_inf(err);
-            }
-            case PANOCStopCrit::ApproxKKT2: {
-                auto err = (1 / γ) * pₖ + (grad_ψₖ - grad_̂ψₖ);
-                // These parentheses     ^^^               ^^^     are important
-                // to prevent catastrophic cancellation when the step is small
-                return err.norm();
-            }
-            case PANOCStopCrit::ProjGradNorm: {
-                return vec_util::norm_inf(pₖ);
-            }
-            case PANOCStopCrit::ProjGradNorm2: {
-                return pₖ.norm();
-            }
-            case PANOCStopCrit::ProjGradUnitNorm: {
-                problem.eval_prox_grad_step(real_t(1), xₖ, grad_ψₖ, work_n1,
-                                            work_n2);
-                return vec_util::norm_inf(work_n2);
-            }
-            case PANOCStopCrit::ProjGradUnitNorm2: {
-                problem.eval_prox_grad_step(real_t(1), xₖ, grad_ψₖ, work_n1,
-                                            work_n2);
-                return work_n2.norm();
-            }
-            case PANOCStopCrit::FPRNorm: {
-                return vec_util::norm_inf(pₖ) / γ;
-            }
-            case PANOCStopCrit::FPRNorm2: {
-                return pₖ.norm() / γ;
-            }
-            case PANOCStopCrit::Ipopt: {
-                // work_n2 ← x̂ₖ - Π_C(x̂ₖ - ∇ψ(x̂ₖ))
-                problem.eval_prox_grad_step(real_t(1), x̂ₖ, grad_̂ψₖ, work_n1,
-                                            work_n2);
-                auto err = vec_util::norm_inf(work_n2);
-                auto n   = 2 * (ŷₖ.size() + x̂ₖ.size());
-                if (n == 0)
-                    return err;
-                // work_n2 ← x̂ₖ - ∇ψ(x̂ₖ) - Π_C(x̂ₖ - ∇ψ(x̂ₖ))
-                work_n2 -= grad_̂ψₖ;
-                auto C_lagr_mult   = vec_util::norm_1(work_n2);
-                auto D_lagr_mult   = vec_util::norm_1(ŷₖ);
-                const real_t s_max = 100;
-                const real_t s_n   = static_cast<real_t>(n);
-                real_t s_d =
-                    std::max(s_max, (C_lagr_mult + D_lagr_mult) / s_n) / s_max;
-                return err / s_d;
-            }
-            case PANOCStopCrit::LBFGSBpp: {
-                problem.eval_prox_grad_step(real_t(1), xₖ, grad_ψₖ, work_n1,
-                                            work_n2);
-                return vec_util::norm_inf(work_n2) /
-                       std::fmax(real_t(1), xₖ.norm());
-            }
-            default:;
-        }
-        throw std::out_of_range("Invalid PANOCStopCrit");
-    }
-
-    /// Increase the estimate of the Lipschitz constant of the objective gradient
-    /// and decrease the step size until quadratic upper bound or descent lemma is
-    /// satisfied:
-    /// @f[ \psi(x + p) \le \psi(x) + \nabla\psi(x)^\top p + \frac{L}{2} \|p\|^2 @f]
-    /// The projected gradient iterate @f$ \hat x^k @f$ and step @f$ p^k @f$ are
-    /// updated with the new step size @f$ \gamma^k @f$, and so are other quantities
-    /// that depend on them, such as @f$ \nabla\psi(x^k)^\top p^k @f$ and
-    /// @f$ \|p\|^2 @f$. The intermediate vector @f$ \hat y(x^k) @f$ can be used to
-    /// compute the gradient @f$ \nabla\psi(\hat x^k) @f$ or to update the Lagrange
-    /// multipliers.
-    ///
-    /// @return The original step size, before it was reduced by this function.
-    static real_t descent_lemma(
-        /// [in]  Problem description
-        const Problem &problem,
-        /// [in]    Tolerance used to ignore rounding errors when the function
-        ///         @f$ \psi(x) @f$ is relatively flat or the step size is very
-        ///         small, which could cause @f$ \psi(x^k) < \psi(\hat x^k) @f$,
-        ///         which is mathematically impossible but could occur in finite
-        ///         precision floating point arithmetic.
-        real_t rounding_tolerance,
-        /// [in]    Maximum allowed Lipschitz constant estimate (prevents infinite
-        ///         loop if function or derivatives are discontinuous, and keeps
-        ///         step size bounded away from zero).
-        real_t L_max,
-        /// [in]    Current iterate @f$ x^k @f$
-        crvec xₖ,
-        /// [in]    Objective function @f$ \psi(x^k) @f$
-        real_t ψₖ,
-        /// [in]    Gradient of objective @f$ \nabla\psi(x^k) @f$
-        crvec grad_ψₖ,
-        /// [in]    Lagrange multipliers @f$ y @f$
-        crvec y,
-        /// [in]    Penalty weights @f$ \Sigma @f$
-        crvec Σ,
-        /// [out]   Projected gradient iterate @f$ \hat x^k @f$
-        rvec x̂ₖ,
-        /// [out]   Projected gradient step @f$ p^k @f$
-        rvec pₖ,
-        /// [out]   Intermediate vector @f$ \hat y(\hat x^k) @f$
-        rvec ŷx̂ₖ,
-        /// [inout] Objective function @f$ \psi(\hat x^k) @f$
-        real_t &ψx̂ₖ,
-        /// [inout] Squared norm of the step @f$ \left\| p^k \right\|^2 @f$
-        real_t &norm_sq_pₖ,
-        /// [inout] Gradient of objective times step @f$ \nabla\psi(x^k)^\top p^k@f$
-        real_t &grad_ψₖᵀpₖ,
-        /// [inout] Lipschitz constant estimate @f$ L_{\nabla\psi}^k @f$
-        real_t &Lₖ,
-        /// [inout] Step size @f$ \gamma^k @f$
-        real_t &γₖ) {
-
-        real_t old_γₖ = γₖ;
-        real_t margin = (1 + std::abs(ψₖ)) * rounding_tolerance;
-        while (ψx̂ₖ - ψₖ > grad_ψₖᵀpₖ + real_t(0.5) * Lₖ * norm_sq_pₖ + margin) {
-            if (not(Lₖ * 2 <= L_max))
-                break;
-
-            Lₖ *= 2;
-            γₖ /= 2;
-
-            // Calculate x̂ₖ and pₖ (with new step size)
-            problem.eval_prox_grad_step(γₖ, xₖ, grad_ψₖ, /* in ⟹ out */ x̂ₖ, pₖ);
-            // Calculate ∇ψ(xₖ)ᵀpₖ and ‖pₖ‖²
-            grad_ψₖᵀpₖ = grad_ψₖ.dot(pₖ);
-            norm_sq_pₖ = pₖ.squaredNorm();
-
-            // Calculate ψ(x̂ₖ) and ŷ(x̂ₖ)
-            ψx̂ₖ = problem.eval_ψ(x̂ₖ, y, Σ, /* in ⟹ out */ ŷx̂ₖ);
-        }
-        return old_γₖ;
-    }
-
-    /// Check all stop conditions (required tolerance reached, out of time,
-    /// maximum number of iterations exceeded, interrupted by user,
-    /// infinite iterate, no progress made)
-    template <class ParamsT, class DurationT>
-    static SolverStatus check_all_stop_conditions(
-        /// [in]    Parameters including `max_iter`, `max_time` and `max_no_progress`
-        const ParamsT &params,
-        /// [in]    Options for the current solve
-        const InnerSolveOptions<config_t> &opts,
-        /// [in]    Time elapsed since the start of the algorithm
-        DurationT time_elapsed,
-        /// [in]    The current iteration number
-        unsigned iteration,
-        /// [in]    A stop signal for the user to interrupt the algorithm
-        const AtomicStopSignal &stop_signal,
-        /// [in]    Tolerance of the current iterate
-        real_t εₖ,
-        /// [in]    The number of successive iterations no progress was made
-        unsigned no_progress) {
-
-        auto max_time = params.max_time;
-        if (opts.max_time)
-            max_time = std::min(max_time, *opts.max_time);
-        auto tolerance   = opts.tolerance > 0 ? opts.tolerance : real_t(1e-8);
-        bool out_of_time = time_elapsed > max_time;
-        bool out_of_iter = iteration == params.max_iter;
-        bool interrupted = stop_signal.stop_requested();
-        bool not_finite  = not std::isfinite(εₖ);
-        bool converged   = εₖ <= tolerance;
-        bool max_no_progress = no_progress > params.max_no_progress;
-        return converged         ? SolverStatus::Converged
-               : out_of_time     ? SolverStatus::MaxTime
-               : out_of_iter     ? SolverStatus::MaxIter
-               : not_finite      ? SolverStatus::NotFinite
-               : max_no_progress ? SolverStatus::NoProgress
-               : interrupted     ? SolverStatus::Interrupted
-                                 : SolverStatus::Busy;
-    }
-
-    /// Compute the Hessian matrix of the augmented Lagrangian function multiplied
-    /// by the given vector, using finite differences.
-    /// @f[ \nabla^2_{xx} L_\Sigma(x, y)\, v \approx
-    ///     \frac{\nabla_x L_\Sigma(x+hv, y) - \nabla_x L_\Sigma(x, y)}{h} @f]
-    static void calc_augmented_lagrangian_hessian_prod_fd(
-        /// [in]    Problem description
-        const Problem &problem,
-        /// [in]    Current iterate @f$ x^k @f$
-        crvec xₖ,
-        /// [in]    Lagrange multipliers @f$ y @f$
-        crvec y,
-        /// [in]    Penalty weights @f$ \Sigma @f$
-        crvec Σ,
-        /// [in]    Gradient @f$ \nabla \psi(x^k) @f$
-        crvec grad_ψ,
-        /// [in]    Vector to multiply with the Hessian
-        crvec v,
-        /// [out]   Hessian-vector product
-        rvec Hv,
-        ///         Dimension n
-        rvec work_n1,
-        ///         Dimension n
-        rvec work_n2,
-        ///         Dimension m
-        rvec work_m) {
-
-        real_t cbrt_ε = std::cbrt(std::numeric_limits<real_t>::epsilon());
-        real_t h      = cbrt_ε * (1 + xₖ.norm());
-        rvec xₖh      = work_n1;
-        xₖh           = xₖ + h * v;
-        problem.eval_grad_ψ(xₖh, y, Σ, Hv, work_n2, work_m);
-        Hv -= grad_ψ;
-        Hv /= h;
-    }
-
-    /// Estimate the Lipschitz constant of the gradient @f$ \nabla \psi @f$ using
-    /// finite differences.
-    static real_t initial_lipschitz_estimate(
-        /// [in]    Problem description
-        const Problem &problem,
-        /// [in]    Current iterate @f$ x^k @f$
-        crvec x,
-        /// [in]    Lagrange multipliers @f$ y @f$
-        crvec y,
-        /// [in]    Penalty weights @f$ \Sigma @f$
-        crvec Σ,
-        /// [in]    Finite difference step size relative to x
-        real_t ε,
-        /// [in]    Minimum absolute finite difference step size
-        real_t δ,
-        /// [in]    Minimum allowed Lipschitz estimate.
-        real_t L_min,
-        /// [in]    Maximum allowed Lipschitz estimate.
-        real_t L_max,
-        /// [out]   @f$ \psi(x^k) @f$
-        real_t &ψ,
-        /// [out]   Gradient @f$ \nabla \psi(x^k) @f$
-        rvec grad_ψ,
-        ///         Dimension n
-        rvec work_x,
-        ///         Dimension n
-        rvec work_grad_ψ,
-        ///         Dimension n
-        rvec work_n,
-        ///         Dimension m
-        rvec work_m) {
-
-        // Calculate ψ(x₀), ∇ψ(x₀)
-        ψ = problem.eval_ψ_grad_ψ(x, y, Σ, /* in ⟹ out */ grad_ψ, work_n,
-                                  work_m);
-        // Select a small step h for finite differences
-        auto h        = grad_ψ.unaryExpr([&](real_t g) {
-            return g > 0 ? std::max(g * ε, δ) : std::min(g * ε, -δ);
-        });
-        work_x        = x - h;
-        real_t norm_h = h.norm();
-        // Calculate ∇ψ(x₀ - h)
-        problem.eval_grad_ψ(work_x, y, Σ, /* in ⟹ out */ work_grad_ψ, work_n,
-                            work_m);
-
-        // Estimate Lipschitz constant using finite differences
-        real_t L = (work_grad_ψ - grad_ψ).norm() / norm_h;
-        return std::clamp(L, L_min, L_max);
-    }
-
-    /// Estimate the Lipschitz constant of the gradient @f$ \nabla \psi @f$ using
-    /// finite differences.
-    static real_t initial_lipschitz_estimate(
-        /// [in]    Problem description
-        const Problem &problem,
-        /// [in]    Current iterate @f$ x^k @f$
-        crvec xₖ,
-        /// [in]    Lagrange multipliers @f$ y @f$
-        crvec y,
-        /// [in]    Penalty weights @f$ \Sigma @f$
-        crvec Σ,
-        /// [in]    Finite difference step size relative to xₖ
-        real_t ε,
-        /// [in]    Minimum absolute finite difference step size
-        real_t δ,
-        /// [in]    Minimum allowed Lipschitz estimate.
-        real_t L_min,
-        /// [in]    Maximum allowed Lipschitz estimate.
-        real_t L_max,
-        /// [out]   Gradient @f$ \nabla \psi(x^k) @f$
-        rvec grad_ψ,
-        ///         Dimension n
-        rvec work_n1,
-        ///         Dimension n
-        rvec work_n2,
-        ///         Dimension n
-        rvec work_n3,
-        ///         Dimension m
-        rvec work_m) {
-
-        auto h        = (xₖ * ε).cwiseAbs().cwiseMax(δ);
-        work_n1       = xₖ + h;
-        real_t norm_h = h.norm();
-        // Calculate ∇ψ(x_0 + h)
-        problem.eval_grad_ψ(work_n1, y, Σ, /* in ⟹ out */ work_n2, work_n3,
-                            work_m);
-        // Calculate ∇ψ(x_0)
-        problem.eval_grad_ψ(xₖ, y, Σ, /* in ⟹ out */ grad_ψ, work_n1, work_m);
-
-        // Estimate Lipschitz constant using finite differences
-        real_t L = (work_n2 - grad_ψ).norm() / norm_h;
-        return std::clamp(L, L_min, L_max);
-    }
-};
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, PANOCHelpers, DefaultConfig);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, PANOCHelpers, EigenConfigf);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, PANOCHelpers, EigenConfigd);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, PANOCHelpers, EigenConfigl);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, PANOCHelpers, EigenConfigq);
-#endif
-
-} // namespace alpaqa::detail