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

casadi/include/alpaqa/outer/alm.hpp

@@ -1,190 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/export.hpp>
-#include <alpaqa/inner/internal/solverstatus.hpp>
-#include <alpaqa/outer/internal/alm-helpers.hpp>
-#include <alpaqa/problem/type-erased-problem.hpp>
-
-#include <chrono>
-#include <iostream>
-#include <string>
-
-namespace alpaqa {
-
-template <class InnerSolverStats>
-struct InnerStatsAccumulator;
-
-/// Parameters for the Augmented Lagrangian solver.
-template <Config Conf = DefaultConfig>
-struct ALPAQA_EXPORT ALMParams {
-    USING_ALPAQA_CONFIG(Conf);
-
-    /// Primal tolerance (used for stopping criterion of inner solver).
-    real_t tolerance = real_t(1e-5);
-    /// Dual tolerance (constraint violation and complementarity).
-    real_t dual_tolerance = real_t(1e-5);
-    /// Factor used in updating the penalty parameters.
-    real_t penalty_update_factor = 10;
-    /// Factor to reduce @ref penalty_update_factor when inner convergence fails.
-    real_t penalty_update_factor_lower = real_t(0.8);
-    /// Minimum value for @ref penalty_update_factor after reduction because of inner convergence
-    /// failure.
-    real_t min_penalty_update_factor = real_t(1.1);
-    /// Initial penalty parameter. When set to zero (which is the default),
-    /// it is computed automatically, based on the constraint violation in the
-    /// starting point and the parameter @ref initial_penalty_factor.
-    /// @todo Change default to 0.
-    real_t initial_penalty = 1;
-    /// Initial penalty parameter factor. Active if @ref initial_penalty is set
-    /// to zero.
-    real_t initial_penalty_factor = 20;
-    /// Factor to reduce the initial penalty factor by if convergence fails in
-    /// in the first iteration.
-    real_t initial_penalty_lower = real_t(0.6);
-    /// Initial primal tolerance.
-    real_t initial_tolerance = 1;
-    /// Factor to increase the initial primal tolerance if convergence fails in
-    /// the first iteration.
-    real_t initial_tolerance_increase = real_t(1.1);
-    /// Update factor for primal tolerance.
-    real_t tolerance_update_factor = real_t(1e-1);
-    /// Factor to increase the primal tolerance update factor by if convergence
-    /// fails.
-    real_t ρ_increase = real_t(2);
-    /// Maximum value of @ref tolerance_update_factor after increase because of inner convergence
-    /// failure.
-    real_t ρ_max = real_t(0.5);
-    /// Error tolerance for penalty increase
-    real_t rel_penalty_increase_threshold = real_t(0.1);
-    /// Lagrange multiplier bound.
-    real_t max_multiplier = real_t(1e9);
-    /// Maximum penalty factor.
-    real_t max_penalty = real_t(1e9);
-    /// Minimum penalty factor (used during initialization).
-    real_t min_penalty = real_t(1e-9);
-    /// Maximum number of outer ALM iterations.
-    unsigned int max_iter = 100;
-    /// Maximum duration.
-    std::chrono::nanoseconds max_time = std::chrono::minutes(5);
-
-    /// How many times can the initial penalty @ref initial_penalty or
-    /// @ref initial_penalty_factor and the initial primal tolerance @ref initial_tolerance
-    /// be reduced.
-    unsigned max_num_initial_retries = 0;
-    /// How many times can the penalty update factor @ref penalty_update_factor and the
-    /// primal tolerance factor @ref tolerance_update_factor be reduced.
-    unsigned max_num_retries = 0;
-    /// Combined limit for @ref max_num_initial_retries and
-    /// @ref max_num_retries.
-    unsigned max_total_num_retries = 0;
-
-    /// When to print progress. If set to zero, nothing will be printed.
-    /// If set to N != 0, progress is printed every N iterations.
-    unsigned print_interval = 0;
-    /// The precision of the floating point values printed by the solver.
-    int print_precision = std::numeric_limits<real_t>::max_digits10 / 2;
-
-    /// Use one penalty factor for all m constraints.
-    bool single_penalty_factor = false;
-};
-
-/// Augmented Lagrangian Method solver
-///
-/// @ingroup    grp_ALMSolver
-template <class InnerSolverT>
-class ALPAQA_EXPORT ALMSolver {
-  public:
-    USING_ALPAQA_CONFIG_TEMPLATE(InnerSolverT::config_t);
-
-    using Params      = ALMParams<config_t>;
-    using InnerSolver = InnerSolverT;
-    using Problem     = typename InnerSolver::Problem;
-
-    struct Stats {
-        /// Total number of outer ALM iterations (i.e. the number of times that
-        /// the inner solver was invoked).
-        unsigned outer_iterations = 0;
-        /// Total elapsed time.
-        std::chrono::nanoseconds elapsed_time{};
-        /// The number of times that the initial penalty factor was reduced by
-        /// @ref ALMParams::initial_penalty_lower and that the initial tolerance was
-        /// increased by @ref ALMParams::initial_tolerance_increase because the inner solver
-        /// failed to converge in the first ALM iteration. If this number is
-        /// greater than zero, consider lowering the initial penalty factor
-        /// @ref ALMParams::initial_penalty or @ref ALMParams::initial_penalty_factor or increasing the initial
-        /// tolerance @ref ALMParams::initial_tolerance (or both).
-        unsigned initial_penalty_reduced = 0;
-        /// The number of times that the penalty update factor @ref ALMParams::penalty_update_factor
-        /// was reduced, that the tolerance update factor @ref ALMParams::tolerance_update_factor was
-        /// increased, and that an ALM iteration had to be restarted with a
-        /// lower penalty factor and a higher tolerance because the inner solver
-        /// failed to converge (not applicable in the first ALM iteration).
-        /// If this number is greater than zero, consider lowerering the
-        /// penalty update factor @ref ALMParams::penalty_update_factor or increasing the tolerance
-        /// update factor (or both). Lowering the initial penalty factor could
-        /// help as well.
-        unsigned penalty_reduced = 0;
-        /// The total number of times that the inner solver failed to converge.
-        unsigned inner_convergence_failures = 0;
-        /// Final primal tolerance that was reached, depends on the stopping
-        /// criterion used by the inner solver, see for example
-        /// @ref PANOCStopCrit.
-        real_t ε = inf<config_t>;
-        /// Final dual tolerance or constraint violation that was reached:
-        /// @f[
-        /// \delta = \| \Pi_D\left(g(x^k) + \Sigma^{-1}y\right) \|_\infty
-        /// @f]
-        real_t δ = inf<config_t>;
-        /// 2-norm of the final penalty factors @f$ \| \Sigma \|_2 @f$.
-        real_t norm_penalty = 0;
-
-        /// Whether the solver converged or not.
-        /// @see @ref SolverStatus
-        SolverStatus status = SolverStatus::Busy;
-
-        /// The statistics of the inner solver invocations, accumulated over all
-        /// ALM iterations.
-        InnerStatsAccumulator<typename InnerSolver::Stats> inner;
-    };
-
-    ALMSolver(Params params, InnerSolver &&inner_solver)
-        : params(params),
-          inner_solver(std::forward<InnerSolver>(inner_solver)) {}
-    ALMSolver(Params params, const InnerSolver &inner_solver)
-        : params(params), inner_solver(inner_solver) {}
-
-    Stats operator()(const Problem &problem, rvec x, rvec y);
-    template <class P>
-    Stats operator()(const P &problem, rvec x, rvec y) {
-        return operator()(Problem::template make<P>(problem), x, y);
-    }
-
-    std::string get_name() const {
-        return "ALMSolver<" + inner_solver.get_name() + ">";
-    }
-
-    /// Abort the computation and return the result so far.
-    /// Can be called from other threads or signal handlers.
-    void stop() { inner_solver.stop(); }
-
-    const Params &get_params() const { return params; }
-
-  private:
-    Params params;
-    using Helpers = detail::ALMHelpers<config_t>;
-
-  public:
-    InnerSolver inner_solver;
-    std::ostream *os = &std::cout;
-};
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, ALMParams, DefaultConfig);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, ALMParams, EigenConfigf);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, ALMParams, EigenConfigd);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, ALMParams, EigenConfigl);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(struct, ALMParams, EigenConfigq);
-#endif
-
-} // namespace alpaqa

casadi/include/alpaqa/outer/internal/alm-helpers.hpp

@@ -1,10 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-
-namespace alpaqa::detail {
-
-template <Config Conf>
-struct ALMHelpers;
-
-} // namespace alpaqa::detail

casadi/include/alpaqa/panoc-alm.hpp

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <alpaqa/inner/directions/panoc/lbfgs.hpp>
-#include <alpaqa/inner/panoc.hpp>
-#include <alpaqa/outer/alm.hpp>
-
-namespace alpaqa {
-
-// clang-format off
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, LBFGSDirection<DefaultConfig>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, LBFGSDirection<EigenConfigf>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, LBFGSDirection<EigenConfigd>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, LBFGSDirection<EigenConfigl>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, LBFGSDirection<EigenConfigq>);
-#endif
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<LBFGSDirection<DefaultConfig>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<LBFGSDirection<EigenConfigf>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<LBFGSDirection<EigenConfigd>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<LBFGSDirection<EigenConfigl>>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<LBFGSDirection<EigenConfigq>>);
-#endif
-// clang-format on
-
-} // namespace alpaqa

casadi/include/alpaqa/panoc-anderson-alm.hpp

@@ -1,27 +0,0 @@
-#pragma once
-
-#include <alpaqa/inner/directions/panoc/anderson.hpp>
-#include <alpaqa/inner/panoc.hpp>
-#include <alpaqa/outer/alm.hpp>
-
-namespace alpaqa {
-
-// clang-format off
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, AndersonDirection<DefaultConfig>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, AndersonDirection<EigenConfigf>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, AndersonDirection<EigenConfigd>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, AndersonDirection<EigenConfigl>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, PANOCSolver, AndersonDirection<EigenConfigq>);
-#endif
-
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<AndersonDirection<DefaultConfig>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<AndersonDirection<EigenConfigf>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<AndersonDirection<EigenConfigd>>);
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<AndersonDirection<EigenConfigl>>);
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-ALPAQA_EXPORT_EXTERN_TEMPLATE(class, ALMSolver, PANOCSolver<AndersonDirection<EigenConfigq>>);
-#endif
-// clang-format on
-
-} // namespace alpaqa

casadi/include/alpaqa/params/params.hpp

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/export.hpp>
-
-#include <optional>
-#include <span>
-#include <stdexcept>
-#include <string_view>
-#include <tuple>
-
-namespace alpaqa::params {
-
-/// Represents a parameter value encoded as a string in the format
-/// `abc.def.key=value`.
-struct ALPAQA_EXPORT ParamString {
-    /// Full key string, used for diagnostics.
-    std::string_view full_key;
-    /// The subkey to resolve next.
-    std::string_view key;
-    /// The value of the parameter to store.
-    std::string_view value;
-};
-
-/// Custom parameter parsing exception.
-struct ALPAQA_EXPORT invalid_param : std::invalid_argument {
-    using std::invalid_argument::invalid_argument;
-};
-
-/// Split the string @p full on the first occurrence of @p tok.
-/// Returns (s, "") if tok was not found.
-inline auto split_key(std::string_view full, char tok = '.') {
-    auto tok_pos = full.find(tok);
-    if (tok_pos == full.npos)
-        return std::make_tuple(full, std::string_view{});
-    std::string_view key{full.begin(), full.begin() + tok_pos};
-    std::string_view rem{full.begin() + tok_pos + 1, full.end()};
-    return std::make_tuple(key, rem);
-}
-
-/// Update/overwrite the first argument based on the option in @p s.
-template <class T>
-void ALPAQA_EXPORT set_param(T &, ParamString); /* deliberately undefined */
-
-/// Overwrites @p t based on the @p options that start with @p prefix.
-/// If @p used is not `nullopt`, sets corresponding flag of the options that
-/// were used.
-template <class T>
-void ALPAQA_EXPORT set_params(
-    T &t, std::string_view prefix, std::span<const std::string_view> options,
-    std::optional<std::span<bool>> used = std::nullopt);
-
-template <Config Conf>
-struct ALPAQA_EXPORT vec_from_file {
-    USING_ALPAQA_CONFIG(Conf);
-    length_t expected_size;
-    std::optional<vec> value = std::nullopt;
-};
-
-} // namespace alpaqa::params

casadi/include/alpaqa/problem/box-constr-problem.hpp

@@ -1,220 +0,0 @@
-#pragma once
-
-#include <alpaqa/problem/box.hpp>
-#include <alpaqa/util/check-dim.hpp>
-
-namespace alpaqa {
-
-/// Implements common problem functions for minimization problems with box
-/// constraints. Meant to be used as a base class for custom problem
-/// implementations.
-/// @ingroup grp_Problems
-template <Config Conf>
-class BoxConstrProblem {
-  public:
-    USING_ALPAQA_CONFIG(Conf);
-    using Box = alpaqa::Box<config_t>;
-
-    /// Number of decision variables, dimension of x
-    length_t n;
-    /// Number of constraints, dimension of g(x) and z
-    length_t m;
-
-    /// Components of the constraint function with indices below this number are
-    /// handled using a quadratic penalty method rather than using an
-    /// augmented Lagrangian method. Specifically, the Lagrange multipliers for
-    /// these components (which determine the shifts in ALM) are kept at zero.
-    index_t penalty_alm_split = 0;
-
-    BoxConstrProblem(length_t n, ///< Number of decision variables
-                     length_t m) ///< Number of constraints
-        : n{n}, m{m} {}
-
-    BoxConstrProblem(Box C, Box D, vec l1_reg = vec(0))
-        : n{C.lowerbound.size()}, m{D.lowerbound.size()}, C{std::move(C)}, D{std::move(D)},
-          l1_reg{std::move(l1_reg)} {}
-
-    void resize(length_t n, length_t m) {
-        this->n = n;
-        this->m = m;
-        C       = Box{n};
-        D       = Box{m};
-    }
-
-    BoxConstrProblem(const BoxConstrProblem &)                = default;
-    BoxConstrProblem &operator=(const BoxConstrProblem &)     = default;
-    BoxConstrProblem(BoxConstrProblem &&) noexcept            = default;
-    BoxConstrProblem &operator=(BoxConstrProblem &&) noexcept = default;
-
-    /// Constraints of the decision variables, @f$ x \in C @f$
-    Box C{this->n};
-    /// Other constraints, @f$ g(x) \in D @f$
-    Box D{this->m};
-    /// @f$ \ell_1 @f$ (1-norm) regularization parameter.
-    /// Possible dimensions are: @f$ 0 @f$ (no regularization), @f$ 1 @f$ (a
-    /// single scalar factor), or @f$ n @f$ (a different factor for each
-    /// variable).
-    vec l1_reg{};
-
-    /// Number of decision variables, @ref n
-    length_t get_n() const { return n; }
-    /// Number of constraints, @ref m
-    length_t get_m() const { return m; }
-
-    /** Projected gradient step for rectangular box C.
-      * @f[ \begin{aligned} \hat x &= \Pi_C(x - \gamma\nabla\psi(x)) \\
-      * p &= \hat x - x \\
-      * &= \max(\underline x - x, \;\min(-\gamma\nabla\psi(x), \overline x - x)
-      * \end{aligned} @f] */
-    static real_t eval_proj_grad_step_box(const Box &C, real_t γ, crvec x, crvec grad_ψ, rvec x̂,
-                                          rvec p) {
-        p = (-γ * grad_ψ).cwiseMax(C.lowerbound - x).cwiseMin(C.upperbound - x);
-        x̂ = x + p;
-        return real_t(0);
-    }
-
-    /** Proximal gradient step for rectangular box C with ℓ₁-regularization.
-      * @f[ \begin{aligned} h(x) &= \|x\|_1 + \delta_C(x) \\
-      * \hat x &= \prox_{\gamma h}(x - \gamma\nabla\psi(x)) \\
-      * &= -\max\big(
-      *         x - \overline x,
-      *         \;\min\big(
-      *             x - \underline x,
-      *             \;\min\big(
-      *                 \gamma(\nabla\psi(x) + \lambda),
-      *                 \;\max\big(
-      *                     \gamma(\nabla\psi(x) - \lambda),
-      *                     x
-      *                 \big)
-      *             \big)
-      *         \big)
-      *     \big) \end{aligned} @f] */
-    static void eval_prox_grad_step_box_l1_impl(const Box &C, const auto &λ, real_t γ, crvec x,
-                                                crvec grad_ψ, rvec x̂, rvec p) {
-        p = -x.cwiseMax(γ * (grad_ψ - λ))
-                 .cwiseMin(γ * (grad_ψ + λ))
-                 .cwiseMin(x - C.lowerbound)
-                 .cwiseMax(x - C.upperbound);
-        x̂ = x + p;
-    }
-    /// @copydoc eval_prox_grad_step_box_l1_impl
-    static real_t eval_prox_grad_step_box_l1(const Box &C, const auto &λ, real_t γ, crvec x,
-                                             crvec grad_ψ, rvec x̂, rvec p) {
-        eval_prox_grad_step_box_l1_impl(C, λ, γ, x, grad_ψ, x̂, p);
-        return vec_util::norm_1(x̂.cwiseProduct(λ));
-    }
-
-    /// @copydoc eval_prox_grad_step_box_l1_impl
-    static real_t eval_prox_grad_step_box_l1_scal(const Box &C, real_t λ, real_t γ, crvec x,
-                                                  crvec grad_ψ, rvec x̂, rvec p) {
-        auto n     = x.size();
-        auto λ_vec = vec::Constant(n, λ);
-        eval_prox_grad_step_box_l1_impl(C, λ_vec, γ, x, grad_ψ, x̂, p);
-        return λ * vec_util ::norm_1(x̂);
-    }
-
-    /// @see @ref TypeErasedProblem::eval_prox_grad_step
-    real_t eval_prox_grad_step(real_t γ, crvec x, crvec grad_ψ, rvec x̂, rvec p) const {
-        if (l1_reg.size() == 0)
-            return eval_proj_grad_step_box(C, γ, x, grad_ψ, x̂, p);
-        else if (l1_reg.size() == 1)
-            return eval_prox_grad_step_box_l1_scal(C, l1_reg(0), γ, x, grad_ψ, x̂, p);
-        else
-            return eval_prox_grad_step_box_l1(C, l1_reg, γ, x, grad_ψ, x̂, p);
-    }
-
-    /// @see @ref TypeErasedProblem::eval_proj_diff_g
-    void eval_proj_diff_g(crvec z, rvec p) const { p = alpaqa::projecting_difference(z, D); }
-
-    static void eval_proj_multipliers_box(const Box &D, rvec y, real_t M,
-                                          index_t penalty_alm_split) {
-        // If there's no lower bound, the multipliers can only be positive
-        auto max_lb = [M](real_t y, real_t z_lb) {
-            real_t y_lb = z_lb == -alpaqa::inf<config_t> ? 0 : -M;
-            return std::max(y, y_lb);
-        };
-        // If there's no upper bound, the multipliers can only be negative
-        auto min_ub = [M](real_t y, real_t z_ub) {
-            real_t y_ub = z_ub == alpaqa::inf<config_t> ? 0 : M;
-            return std::min(y, y_ub);
-        };
-        auto num_alm    = y.size() - penalty_alm_split;
-        auto &&y_qpm    = y.topRows(penalty_alm_split);
-        auto &&y_alm    = y.bottomRows(num_alm);
-        auto &&z_alm_lb = D.lowerbound.bottomRows(num_alm);
-        auto &&z_alm_ub = D.upperbound.bottomRows(num_alm);
-        y_qpm.setZero();
-        y_alm = y_alm.binaryExpr(z_alm_lb, max_lb).binaryExpr(z_alm_ub, min_ub);
-    }
-
-    /// @see @ref TypeErasedProblem::eval_proj_multipliers
-    void eval_proj_multipliers(rvec y, real_t M) const {
-        eval_proj_multipliers_box(D, y, M, penalty_alm_split);
-    }
-
-    /// @see @ref TypeErasedProblem::get_box_C
-    const Box &get_box_C() const { return C; }
-    /// @see @ref TypeErasedProblem::get_box_D
-    const Box &get_box_D() const { return D; }
-
-    /// @see @ref TypeErasedProblem::eval_inactive_indices_res_lna
-    index_t eval_inactive_indices_res_lna(real_t γ, crvec x, crvec grad_ψ, rindexvec J) const {
-        index_t nJ = 0;
-        // Helper that adds i to index set J if x ∊ C
-        const auto add_to_J_if_in_box_interior = [&](real_t x_fw, index_t i) {
-            if (C.lowerbound(i) < x_fw && x_fw < C.upperbound(i))
-                J(nJ++) = i;
-        };
-        // Update the index set J for the general box + l1 case
-        const auto update_J_general = [&](real_t λ, real_t x_fw, index_t i) {
-            if (λ == 0) {
-                add_to_J_if_in_box_interior(x_fw, i);
-            } else {
-                if (x_fw > γ * λ)
-                    add_to_J_if_in_box_interior(x_fw - γ * λ, i);
-                else if (x_fw < -γ * λ)
-                    add_to_J_if_in_box_interior(x_fw + γ * λ, i);
-            }
-        };
-        const auto nλ     = l1_reg.size();
-        const bool λ_is_0 = nλ == 0 || (nλ == 1 && l1_reg(0) == 0);
-        // Only box constraints
-        if (λ_is_0)
-            for (index_t i = 0; i < n; ++i) {
-                real_t x_fw = x(i) - γ * grad_ψ(i);
-                add_to_J_if_in_box_interior(x_fw, i);
-            }
-        // Box constraints and l1
-        else
-            for (index_t i = 0; i < n; ++i) {
-                real_t λi   = nλ == 0 ? 0 : nλ == 1 ? l1_reg(0) : l1_reg(i);
-                real_t x_fw = x(i) - γ * grad_ψ(i);
-                update_J_general(λi, x_fw, i);
-            }
-        return nJ;
-    }
-
-    /// @see @ref TypeErasedProblem::check
-    void check() const {
-        util::check_dim_msg<config_t>(
-            C.lowerbound, n,
-            "Length of problem.C.lowerbound does not match problem size problem.n");
-        util::check_dim_msg<config_t>(
-            C.upperbound, n,
-            "Length of problem.C.upperbound does not match problem size problem.n");
-        util::check_dim_msg<config_t>(
-            D.lowerbound, m,
-            "Length of problem.D.lowerbound does not match problem size problem.m");
-        util::check_dim_msg<config_t>(
-            D.upperbound, m,
-            "Length of problem.D.upperbound does not match problem size problem.m");
-        if (l1_reg.size() > 1)
-            util::check_dim_msg<config_t>(
-                l1_reg, n,
-                "Length of problem.l1_reg does not match problem size problem.n, 1 or 0");
-        if (penalty_alm_split < 0 || penalty_alm_split > m)
-            throw std::invalid_argument("Invalid penalty_alm_split");
-    }
-};
-
-} // namespace alpaqa

casadi/include/alpaqa/problem/box.hpp

@@ -1,82 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/util/float.hpp>
-
-namespace alpaqa {
-
-template <Config Conf = DefaultConfig>
-struct Box {
-    USING_ALPAQA_CONFIG(Conf);
-
-    Box() : Box{0} {}
-    Box(length_t n)
-        : lowerbound{vec::Constant(n, -inf<config_t>)}, upperbound{
-                                                            vec::Constant(n, +inf<config_t>)} {}
-
-    static Box NaN(length_t n) {
-        return Box{vec::Constant(n, alpaqa::NaN<config_t>),
-                   vec::Constant(n, alpaqa::NaN<config_t>)};
-    }
-    static Box from_lower_upper(vec lower, vec upper) {
-        return Box{std::move(lower), std::move(upper)};
-    }
-
-    vec lowerbound;
-    vec upperbound;
-
-  private:
-    Box(vec lower, vec upper) : lowerbound{std::move(lower)}, upperbound{std::move(upper)} {}
-};
-
-/// Project a vector onto a box.
-/// @f[ \Pi_C(v) @f]
-template <Config Conf>
-inline auto project(const auto &v,       ///< [in] The vector to project
-                    const Box<Conf> &box ///< [in] The box to project onto
-) {
-    USING_ALPAQA_CONFIG(Conf);
-    using binary_real_f = real_t (*)(real_t, real_t);
-    return v.binaryExpr(box.lowerbound, binary_real_f(std::fmax))
-        .binaryExpr(box.upperbound, binary_real_f(std::fmin));
-}
-
-/// Get the difference between the given vector and its projection.
-/// @f[ v - \Pi_C(v) @f]
-/// @warning    Beware catastrophic cancellation!
-template <Config Conf>
-inline auto                                //
-projecting_difference(const auto &v,       ///< [in] The vector to project
-                      const Box<Conf> &box ///< [in] The box to project onto
-) {
-    return v - project(v, box);
-}
-
-/// Get the distance squared between the given vector and its projection.
-/// @f[ \left\| v - \Pi_C(v) \right\|_2^2 @f]
-/// @warning    Beware catastrophic cancellation!
-
-template <Config Conf>
-inline auto dist_squared(const auto &v,       ///< [in] The vector to project
-                         const Box<Conf> &box ///< [in] The box to project onto
-) {
-    return projecting_difference(v, box).squaredNorm();
-}
-
-/// Get the distance squared between the given vector and its projection in the
-/// Σ norm.
-/// @f[ \left\| v - \Pi_C(v) \right\|_\Sigma^2
-/// = \left(v - \Pi_C(v)\right)^\top \Sigma \left(v - \Pi_C(v)\right) @f]
-/// @warning    Beware catastrophic cancellation!
-template <Config Conf>
-inline auto dist_squared(const auto &v,        ///< [in] The vector to project
-                         const Box<Conf> &box, ///< [in] The box to project onto
-                         const auto &Σ         ///< [in] Diagonal matrix defining norm
-                         ) -> real_t<Conf> {
-    // TODO: Does this allocate?
-    //       Does it have dangling references to temporaries?
-    auto d = v - project(v, box);
-    return d.dot(Σ.asDiagonal() * d);
-}
-
-} // namespace alpaqa