casadi 3.7.2__cp314-none-win_amd64.whl

casadi/include/alpaqa/outer/alm.hpp

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

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

casadi/include/alpaqa/panoc-alm.hpp

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

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

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

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

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