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

casadi/include/alpaqa/casadi/CasADiControlProblem.hpp

@@ -1,185 +0,0 @@
-#pragma once
-
-#include <alpaqa/casadi-ocp-loader-export.hpp>
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/problem/box.hpp>
-#include <alpaqa/util/check-dim.hpp>
-#include <alpaqa/util/copyable_unique_ptr.hpp>
-#include <filesystem>
-
-namespace alpaqa {
-
-namespace casadi_loader {
-template <Config>
-struct CasADiControlFunctionsWithParam;
-} // namespace casadi_loader
-
-template <Config Conf>
-class CasADiControlProblem {
-  public:
-    USING_ALPAQA_CONFIG(Conf);
-    using Box = alpaqa::Box<config_t>;
-    length_t N, nx, nu, nh, nh_N, nc, nc_N;
-    vec x_init;
-    vec param;
-    Box U, D, D_N;
-    mutable vec work;
-
-    /// 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;
-    /// Same as @ref penalty_alm_split, but for the terminal constraint.
-    index_t penalty_alm_split_N = 0;
-
-    CasADiControlProblem(const std::string &so_name, length_t N);
-    ~CasADiControlProblem();
-
-    CasADiControlProblem(const CasADiControlProblem &);
-    CasADiControlProblem &operator=(const CasADiControlProblem &);
-    CasADiControlProblem(CasADiControlProblem &&) noexcept;
-    CasADiControlProblem &operator=(CasADiControlProblem &&) noexcept;
-
-    /// Load the numerical problem data (bounds and parameters) from a CSV file.
-    /// The file should contain 8 rows, with the following contents:
-    ///   1. @ref U lower bound [nu]
-    ///   2. @ref U upper bound [nu]
-    ///   3. @ref D lower bound [nc]
-    ///   4. @ref D upper bound [nc]
-    ///   5. @ref D_N lower bound [nc_N]
-    ///   6. @ref D_N upper bound [nc_N]
-    ///   7. @ref x_init [nx]
-    ///   8. @ref param [p]
-    ///
-    /// Line endings are encoded using a single line feed (`\n`), and the column
-    /// separator can be specified using the @p sep argument.
-    void load_numerical_data(const std::filesystem::path &filepath,
-                             char sep = ',');
-
-    void get_U(Box &U) const { U = this->U; }
-    void get_D(Box &D) const { D = this->D; }
-    void get_D_N(Box &D_N) const { D_N = this->D_N; }
-    void get_x_init(rvec x_init) const { x_init = this->x_init; }
-
-    void eval_f(index_t timestep, crvec x, crvec u, rvec fxu) const;
-    void eval_jac_f(index_t timestep, crvec x, crvec u, rmat J_fxu) const;
-    void eval_grad_f_prod(index_t timestep, crvec x, crvec u, crvec p,
-                          rvec grad_fxu_p) const;
-    void eval_h(index_t timestep, crvec x, crvec u, rvec h) const;
-    void eval_h_N(crvec x, rvec h) const;
-    [[nodiscard]] real_t eval_l(index_t timestep, crvec h) const;
-    [[nodiscard]] real_t eval_l_N(crvec h) const;
-    void eval_qr(index_t timestep, crvec xu, crvec h, rvec qr) const;
-    void eval_q_N(crvec x, crvec h, rvec q) const;
-    void eval_add_Q(index_t timestep, crvec xu, crvec h, rmat Q) const;
-    void eval_add_Q_N(crvec x, crvec h, rmat Q) const;
-    void eval_add_R_masked(index_t timestep, crvec xu, crvec h, crindexvec mask,
-                           rmat R, rvec work) const;
-    void eval_add_S_masked(index_t timestep, crvec xu, crvec h, crindexvec mask,
-                           rmat S, rvec work) const;
-    void eval_add_R_prod_masked(index_t timestep, crvec xu, crvec h,
-                                crindexvec mask_J, crindexvec mask_K, crvec v,
-                                rvec out, rvec work) const;
-    void eval_add_S_prod_masked(index_t timestep, crvec xu, crvec h,
-                                crindexvec mask_K, crvec v, rvec out,
-                                rvec work) const;
-    [[nodiscard]] length_t get_R_work_size() const;
-    [[nodiscard]] length_t get_S_work_size() const;
-    void eval_constr(index_t timestep, crvec x, rvec c) const;
-    void eval_grad_constr_prod(index_t timestep, crvec x, crvec p,
-                               rvec grad_cx_p) const;
-    void eval_add_gn_hess_constr(index_t timestep, crvec x, crvec M,
-                                 rmat out) const;
-    void eval_constr_N(crvec x, rvec c) const;
-    void eval_grad_constr_prod_N(crvec x, crvec p, rvec grad_cx_p) const;
-    void eval_add_gn_hess_constr_N(crvec x, crvec M, rmat out) const;
-
-    void check() const {
-        util::check_dim_msg<config_t>(U.lowerbound, nu,
-                                      "Length of problem.U.lowerbound does not "
-                                      "match problem size problem.nu");
-        util::check_dim_msg<config_t>(U.upperbound, nu,
-                                      "Length of problem.U.upperbound does not "
-                                      "match problem size problem.nu");
-        util::check_dim_msg<config_t>(D.lowerbound, nc,
-                                      "Length of problem.D.lowerbound does not "
-                                      "match problem size problem.nc");
-        util::check_dim_msg<config_t>(D.upperbound, nc,
-                                      "Length of problem.D.upperbound does not "
-                                      "match problem size problem.nc");
-        util::check_dim_msg<config_t>(D_N.lowerbound, nc_N,
-                                      "Length of problem.D_N.lowerbound does "
-                                      "not match problem size problem.nc_N");
-        util::check_dim_msg<config_t>(D_N.upperbound, nc_N,
-                                      "Length of problem.D_N.upperbound does "
-                                      "not match problem size problem.nc_N");
-        if (penalty_alm_split < 0 || penalty_alm_split > nc)
-            throw std::invalid_argument("Invalid penalty_alm_split");
-        if (penalty_alm_split_N < 0 || penalty_alm_split > nc_N)
-            throw std::invalid_argument("Invalid penalty_alm_split_N");
-    }
-
-    [[nodiscard]] length_t get_N() const { return N; }
-    [[nodiscard]] length_t get_nx() const { return nx; }
-    [[nodiscard]] length_t get_nu() const { return nu; }
-    [[nodiscard]] length_t get_nh() const { return nh; }
-    [[nodiscard]] length_t get_nh_N() const { return nh_N; }
-    [[nodiscard]] length_t get_nc() const { return nc; }
-    [[nodiscard]] length_t get_nc_N() const { return nc_N; }
-
-    /// @see @ref TypeErasedControlProblem::eval_proj_diff_g
-    void eval_proj_diff_g(crvec z, rvec e) const {
-        for (index_t t = 0; t < N; ++t)
-            e.segment(t * nc, nc) =
-                alpaqa::projecting_difference(z.segment(t * nc, nc), D);
-        e.segment(N * nc, nc_N) =
-            alpaqa::projecting_difference(z.segment(N * nc, nc_N), D_N);
-    }
-    /// @see @ref TypeErasedControlProblem::eval_proj_multipliers
-    void eval_proj_multipliers(rvec y, real_t M) const {
-        // 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);
-        };
-        for (index_t t = 0; t < N; ++t) {
-            auto num_alm    = nc - penalty_alm_split;
-            auto &&yt       = y.segment(t * nc, nc);
-            auto &&y_qpm    = yt.topRows(penalty_alm_split);
-            auto &&y_alm    = yt.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);
-        }
-        {
-            auto &&yt       = y.segment(N * nc, nc_N);
-            auto num_alm    = nc_N - penalty_alm_split_N;
-            auto &&y_qpm    = yt.topRows(penalty_alm_split_N);
-            auto &&y_alm    = yt.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);
-        }
-    }
-
-  private:
-    using Functions = casadi_loader::CasADiControlFunctionsWithParam<Conf>;
-    util::copyable_unique_ptr<Functions> impl;
-};
-
-CASADI_OCP_LOADER_EXPORT_EXTERN_TEMPLATE(class, CasADiControlProblem,
-                                         EigenConfigd);
-CASADI_OCP_LOADER_EXPORT_EXTERN_TEMPLATE(class, CasADiControlProblem,
-                                         DefaultConfig);
-
-} // namespace alpaqa

casadi/include/alpaqa/casadi/CasADiFunctionWrapper.hpp

@@ -1,104 +0,0 @@
-#pragma once
-
-#include <alpaqa/config/config.hpp>
-
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include <casadi/core/function.hpp>
-#include <casadi/mem.h>
-
-namespace alpaqa::casadi_loader {
-
-/// Class for evaluating CasADi functions, allocating the necessary workspace
-/// storage in advance for allocation-free evaluations.
-template <Config Conf, size_t N_in, size_t N_out>
-class CasADiFunctionEvaluator {
-  public:
-    USING_ALPAQA_CONFIG(Conf);
-    static_assert(std::is_same_v<real_t, casadi_real>);
-
-    using casadi_dim = std::pair<casadi_int, casadi_int>;
-
-    /// @throws std::invalid_argument
-    CasADiFunctionEvaluator(casadi::Function &&f)
-        : fun(std::move(f)), iwork(fun.sz_iw()), dwork(fun.sz_w()),
-          arg_work(fun.sz_arg()), res_work(fun.sz_res()) {
-        using namespace std::literals::string_literals;
-        if (N_in != fun.n_in())
-            throw std::invalid_argument(
-                "Invalid number of input arguments: got "s +
-                std::to_string(fun.n_in()) + ", should be " +
-                std::to_string(N_in) + ".");
-        if (N_out != fun.n_out())
-            throw std::invalid_argument(
-                "Invalid number of output arguments: got "s +
-                std::to_string(fun.n_out()) + ", should be " +
-                std::to_string(N_out) + ".");
-    }
-
-    /// @throws std::invalid_argument
-    CasADiFunctionEvaluator(casadi::Function &&f,
-                            const std::array<casadi_dim, N_in> &dim_in,
-                            const std::array<casadi_dim, N_out> &dim_out)
-        : CasADiFunctionEvaluator{std::move(f)} {
-        validate_dimensions(dim_in, dim_out);
-    }
-
-    /// @throws std::invalid_argument
-    void
-    validate_dimensions(const std::array<casadi_dim, N_in> &dim_in   = {},
-                        const std::array<casadi_dim, N_out> &dim_out = {}) {
-        using namespace std::literals::string_literals;
-        static constexpr std::array count{"first",   "second", "third",
-                                          "fourth",  "fifth",  "sixth",
-                                          "seventh", "eighth"};
-        static_assert(N_in <= count.size());
-        static_assert(N_out <= count.size());
-        auto to_string = [](casadi_dim d) {
-            return "(" + std::to_string(d.first) + ", " +
-                   std::to_string(d.second) + ")";
-        };
-        for (size_t n = 0; n < N_in; ++n) {
-            auto cs_n = static_cast<casadi_int>(n);
-            if (dim_in[n].first != 0 && dim_in[n] != fun.size_in(cs_n))
-                throw std::invalid_argument(
-                    "Invalid dimension of "s + count[n] +
-                    " input argument: got " + to_string(fun.size_in(cs_n)) +
-                    ", should be " + to_string(dim_in[n]) + ".");
-        }
-        for (size_t n = 0; n < N_out; ++n) {
-            auto cs_n = static_cast<casadi_int>(n);
-            if (dim_out[n].first != 0 && dim_out[n] != fun.size_out(cs_n))
-                throw std::invalid_argument(
-                    "Invalid dimension of "s + count[n] +
-                    " output argument: got " + to_string(fun.size_out(cs_n)) +
-                    ", should be " + to_string(dim_out[n]) + ".");
-        }
-    }
-
-  protected:
-    void operator()(const double *const *in, double *const *out) const {
-        std::copy_n(in, N_in, arg_work.begin());
-        std::copy_n(out, N_out, res_work.begin());
-        fun(arg_work.data(), res_work.data(), iwork.data(), dwork.data(), 0);
-    }
-
-  public:
-    void operator()(const double *const (&in)[N_in],
-                    double *const (&out)[N_out]) const {
-        this->operator()(&in[0], &out[0]);
-    }
-
-  public:
-    casadi::Function fun;
-
-  private:
-    mutable std::vector<casadi_int> iwork;
-    mutable std::vector<double> dwork;
-    mutable std::vector<const double *> arg_work;
-    mutable std::vector<double *> res_work;
-};
-
-} // namespace alpaqa::casadi_loader

casadi/include/alpaqa/casadi/CasADiProblem.hpp

@@ -1,102 +0,0 @@
-#pragma once
-
-#include <alpaqa/casadi-loader-export.hpp>
-#include <alpaqa/config/config.hpp>
-#include <alpaqa/problem/box-constr-problem.hpp>
-#include <alpaqa/util/copyable_unique_ptr.hpp>
-#include <filesystem>
-
-namespace alpaqa {
-namespace casadi_loader {
-template <Config>
-struct CasADiFunctionsWithParam;
-} // namespace casadi_loader
-
-/// Problem definition for a CasADi problem, loaded from a DLL.
-/// @ingroup grp_Problems
-template <Config Conf = DefaultConfig>
-class CasADiProblem : public BoxConstrProblem<Conf> {
-  public:
-    USING_ALPAQA_CONFIG(Conf);
-    vec param;
-
-    /// Load a problem generated by CasADi (with parameters).
-    ///
-    /// @param  filename
-    ///         Filename of the shared library to load the functions from.
-    ///
-    /// The file should contain functions with the names `f`, `grad_f`, `g` and
-    /// `grad_g`. These functions evaluate the objective function, its gradient,
-    /// the constraints, and the constraint gradient times a vector respectively.
-    /// For second order solvers, additional functions `hess_L`, `hess_ψ`,
-    /// `hess_L_prod` and `hess_ψ_prod` can be provided to evaluate the
-    /// Hessian of the (augmented) Lagrangian and Hessian-vector products.
-    ///
-    /// @throws std::invalid_argument
-    ///         The dimensions of the loaded functions do not match.
-    CasADiProblem(const std::string &filename);
-    ~CasADiProblem();
-
-    CasADiProblem(const CasADiProblem &);
-    CasADiProblem &operator=(const CasADiProblem &);
-    CasADiProblem(CasADiProblem &&) noexcept;
-    CasADiProblem &operator=(CasADiProblem &&) noexcept;
-
-    /// Load the numerical problem data (bounds and parameters) from a CSV file.
-    /// The file should contain 7 rows, with the following contents:
-    ///   1. @ref C lower bound [n]
-    ///   2. @ref C upper bound [n]
-    ///   3. @ref D lower bound [m]
-    ///   4. @ref D upper bound [m]
-    ///   5. @ref param [p]
-    ///   6. @ref l1_reg [0, 1 or n]
-    ///   7. @ref penalty_alm_split [1]
-    ///
-    /// Line endings are encoded using a single line feed (`\n`), and the column
-    /// separator can be specified using the @p sep argument.
-    void load_numerical_data(const std::filesystem::path &filepath,
-                             char sep = ',');
-
-    // clang-format off
-    [[nodiscard]] real_t eval_f(crvec x) const;
-    void eval_grad_f(crvec x, rvec grad_fx) const;
-    real_t eval_f_grad_f(crvec x, rvec grad_fx) const; // NOLINT(*nodiscard)
-    void eval_g(crvec x, rvec g) const;
-    void eval_grad_g_prod(crvec x, crvec y, rvec grad_gxy) const;
-    void eval_grad_ψ(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const;
-    real_t eval_ψ_grad_ψ(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const; // NOLINT(*nodiscard)
-    void eval_grad_L(crvec x, crvec y, rvec grad_L, rvec work_n) const;
-    [[nodiscard]] real_t eval_ψ(crvec x, crvec y, crvec Σ, rvec ŷ) const;
-    void eval_grad_gi(crvec x, index_t i, rvec grad_i) const;
-    [[nodiscard]] length_t get_jac_g_num_nonzeros() const;
-    void eval_jac_g(crvec x, rindexvec inner_idx, rindexvec outer_ptr, rvec J_values) const;
-    void eval_hess_L_prod(crvec x, crvec y, real_t scale, crvec v, rvec Hv) const;
-    [[nodiscard]] length_t get_hess_L_num_nonzeros() const;
-    void eval_hess_L(crvec x, crvec y, real_t scale, rindexvec inner_idx, rindexvec outer_ptr, rvec H_values) const;
-    void eval_hess_ψ_prod(crvec x, crvec y, crvec Σ, real_t scale, crvec v, rvec Hv) const;
-    [[nodiscard]] length_t get_hess_ψ_num_nonzeros() const;
-    void eval_hess_ψ(crvec x, crvec y, crvec Σ, real_t scale, rindexvec inner_idx, rindexvec outer_ptr, rvec H_values) const;
-    // clang-format on
-
-    /// @see @ref TypeErasedProblem::provides_eval_grad_gi
-    [[nodiscard]] bool provides_eval_grad_gi() const;
-    /// @see @ref TypeErasedProblem::provides_eval_jac_g
-    [[nodiscard]] bool provides_eval_jac_g() const;
-    /// @see @ref TypeErasedProblem::provides_eval_hess_L_prod
-    [[nodiscard]] bool provides_eval_hess_L_prod() const;
-    /// @see @ref TypeErasedProblem::provides_eval_hess_L
-    [[nodiscard]] bool provides_eval_hess_L() const;
-    /// @see @ref TypeErasedProblem::provides_eval_hess_ψ_prod
-    [[nodiscard]] bool provides_eval_hess_ψ_prod() const;
-    /// @see @ref TypeErasedProblem::provides_eval_hess_ψ
-    [[nodiscard]] bool provides_eval_hess_ψ() const;
-
-  private:
-    using Functions = casadi_loader::CasADiFunctionsWithParam<Conf>;
-    util::copyable_unique_ptr<Functions> impl;
-};
-
-CASADI_LOADER_EXPORT_EXTERN_TEMPLATE(class, CasADiProblem, EigenConfigd);
-CASADI_LOADER_EXPORT_EXTERN_TEMPLATE(class, CasADiProblem, DefaultConfig);
-
-} // namespace alpaqa

casadi/include/alpaqa/casadi-loader-export.hpp

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <alpaqa/casadi-loader-export.h>
-
-#ifdef _WIN32
-#define CASADI_LOADER_EXPORT_EXTERN_TEMPLATE(strcls, name, ...)                \
-    extern template strcls name<__VA_ARGS__>
-#define CASADI_LOADER_EXPORT_TEMPLATE(strcls, name, ...)                       \
-    template strcls CASADI_LOADER_EXPORT name<__VA_ARGS__>
-#else
-#define CASADI_LOADER_EXPORT_EXTERN_TEMPLATE(strcls, name, ...)                \
-    extern template strcls CASADI_LOADER_EXPORT name<__VA_ARGS__>
-#define CASADI_LOADER_EXPORT_TEMPLATE(strcls, name, ...)                       \
-    template strcls name<__VA_ARGS__>
-#endif

casadi/include/alpaqa/casadi-ocp-loader-export.hpp

@@ -1,15 +0,0 @@
-#pragma once
-
-#include <alpaqa/casadi-ocp-loader-export.h>
-
-#ifdef _WIN32
-#define CASADI_OCP_LOADER_EXPORT_EXTERN_TEMPLATE(strcls, name, ...)            \
-    extern template strcls name<__VA_ARGS__>
-#define CASADI_OCP_LOADER_EXPORT_TEMPLATE(strcls, name, ...)                   \
-    template strcls CASADI_OCP_LOADER_EXPORT name<__VA_ARGS__>
-#else
-#define CASADI_OCP_LOADER_EXPORT_EXTERN_TEMPLATE(strcls, name, ...)            \
-    extern template strcls CASADI_OCP_LOADER_EXPORT name<__VA_ARGS__>
-#define CASADI_OCP_LOADER_EXPORT_TEMPLATE(strcls, name, ...)                   \
-    template strcls name<__VA_ARGS__>
-#endif

casadi/include/alpaqa/config/config.hpp

@@ -1,165 +0,0 @@
-#pragma once
-
-#include <alpaqa/util/quadmath/quadmath.hpp>
-
-#include <limits>
-#include <type_traits>
-
-#include <Eigen/Core>
-
-namespace alpaqa {
-
-template <class T>
-struct is_config : std::false_type {};
-template <class T>
-inline constexpr bool is_config_v = is_config<T>::value;
-
-template <class Conf>
-concept Config = is_config_v<Conf>;
-
-struct DefaultConfig;
-template <>
-struct is_config<DefaultConfig> : std::true_type {};
-
-#define USING_ALPAQA_CONFIG_NO_TYPENAME(Conf)                                  \
-    using real_t [[maybe_unused]]     = Conf::real_t;                          \
-    using vec [[maybe_unused]]        = Conf::vec;                             \
-    using mvec [[maybe_unused]]       = Conf::mvec;                            \
-    using cmvec [[maybe_unused]]      = Conf::cmvec;                           \
-    using rvec [[maybe_unused]]       = Conf::rvec;                            \
-    using crvec [[maybe_unused]]      = Conf::crvec;                           \
-    using mat [[maybe_unused]]        = Conf::mat;                             \
-    using mmat [[maybe_unused]]       = Conf::mmat;                            \
-    using cmmat [[maybe_unused]]      = Conf::cmmat;                           \
-    using rmat [[maybe_unused]]       = Conf::rmat;                            \
-    using crmat [[maybe_unused]]      = Conf::crmat;                           \
-    using length_t [[maybe_unused]]   = Conf::length_t;                        \
-    using index_t [[maybe_unused]]    = Conf::index_t;                         \
-    using indexvec [[maybe_unused]]   = Conf::indexvec;                        \
-    using rindexvec [[maybe_unused]]  = Conf::rindexvec;                       \
-    using crindexvec [[maybe_unused]] = Conf::crindexvec
-
-#define USING_ALPAQA_CONFIG(Conf) /** @cond CONFIG_TYPES */                    \
-    using config_t [[maybe_unused]] = Conf;                                    \
-    USING_ALPAQA_CONFIG_NO_TYPENAME(typename Conf) /** @endcond */
-
-#define USING_ALPAQA_CONFIG_TEMPLATE(Conf) /** @cond CONFIG_TYPES */           \
-    using config_t [[maybe_unused]] = typename Conf;                           \
-    USING_ALPAQA_CONFIG_NO_TYPENAME(typename Conf) /** @endcond */
-
-// clang-format off
-template <Config Conf = DefaultConfig> using real_t = typename Conf::real_t;
-template <Config Conf = DefaultConfig> using vec = typename Conf::vec;
-template <Config Conf = DefaultConfig> using mvec = typename Conf::mvec;
-template <Config Conf = DefaultConfig> using cmvec = typename Conf::cmvec;
-template <Config Conf = DefaultConfig> using rvec = typename Conf::rvec;
-template <Config Conf = DefaultConfig> using crvec = typename Conf::crvec;
-template <Config Conf = DefaultConfig> using mat = typename Conf::mat;
-template <Config Conf = DefaultConfig> using mmat = typename Conf::mmat;
-template <Config Conf = DefaultConfig> using cmmat = typename Conf::cmmat;
-template <Config Conf = DefaultConfig> using rmat = typename Conf::rmat;
-template <Config Conf = DefaultConfig> using crmat = typename Conf::crmat;
-template <Config Conf = DefaultConfig> using length_t = typename Conf::length_t;
-template <Config Conf = DefaultConfig> using index_t = typename Conf::index_t;
-template <Config Conf = DefaultConfig> using indexvec = typename Conf::indexvec;
-template <Config Conf = DefaultConfig> using rindexvec = typename Conf::rindexvec;
-template <Config Conf = DefaultConfig> using crindexvec = typename Conf::crindexvec;
-
-template <Config Conf>
-constexpr const auto inf = std::numeric_limits<real_t<Conf>>::infinity();
-template <Config Conf>
-constexpr const auto NaN = std::numeric_limits<real_t<Conf>>::quiet_NaN();
-// clang-format on
-
-template <class RealT>
-struct EigenConfig {
-    /// Real scalar element type.
-    using real_t = RealT;
-    /// Dynamic vector type.
-    using vec = Eigen::VectorX<real_t>;
-    /// Map of vector type.
-    using mvec = Eigen::Map<vec>;
-    /// Immutable map of vector type.
-    using cmvec = Eigen::Map<const vec>;
-    /// Reference to mutable vector.
-    using rvec = Eigen::Ref<vec>;
-    /// Reference to immutable vector.
-    using crvec = Eigen::Ref<const vec>;
-    /// Dynamic matrix type.
-    using mat = Eigen::MatrixX<real_t>;
-    /// Map of matrix type.
-    using mmat = Eigen::Map<mat>;
-    /// Immutable map of matrix type.
-    using cmmat = Eigen::Map<const mat>;
-    /// Reference to mutable matrix.
-    using rmat = Eigen::Ref<mat>;
-    /// Reference to immutable matrix.
-    using crmat = Eigen::Ref<const mat>;
-    /// Type for lengths and sizes.
-    using length_t = Eigen::Index;
-    /// Type for vector and matrix indices.
-    using index_t = Eigen::Index;
-    /// Dynamic vector of indices.
-    using indexvec = Eigen::VectorX<index_t>;
-    /// Reference to mutable index vector.
-    using rindexvec = Eigen::Ref<indexvec>;
-    /// Reference to immutable index vector.
-    using crindexvec = Eigen::Ref<const indexvec>;
-};
-
-/// Single-precision `float` configuration.
-struct EigenConfigf : EigenConfig<float> {
-    static constexpr const char *get_name() { return "EigenConfigf"; }
-};
-/// Double-precision `double` configuration.
-struct EigenConfigd : EigenConfig<double> {
-    static constexpr const char *get_name() { return "EigenConfigd"; }
-};
-/// `long double` configuration. (Quad precision on ARM64, 80-bit x87 floats
-/// on Intel/AMD x86)
-struct EigenConfigl : EigenConfig<long double> {
-    static constexpr const char *get_name() { return "EigenConfigl"; }
-};
-#ifdef ALPAQA_WITH_QUAD_PRECISION
-/// Quad-precision `__float128` configuration.
-struct EigenConfigq : EigenConfig<__float128> {
-    static constexpr const char *get_name() { return "EigenConfigq"; }
-};
-template <>
-struct is_config<EigenConfigq> : std::true_type {};
-#endif
-
-struct DefaultConfig : EigenConfigd {};
-
-template <>
-struct is_config<EigenConfigf> : std::true_type {};
-template <>
-struct is_config<EigenConfigd> : std::true_type {};
-template <>
-struct is_config<EigenConfigl> : std::true_type {};
-
-/// Global empty vector for convenience.
-template <Config Conf>
-inline const rvec<Conf> null_vec = mvec<Conf>{nullptr, 0};
-
-namespace vec_util {
-
-/// Get the maximum or infinity-norm of the given vector.
-/// @returns @f$ \left\|v\right\|_\infty @f$
-template <class Derived>
-    requires(Derived::ColsAtCompileTime == 1)
-auto norm_inf(const Eigen::MatrixBase<Derived> &v) {
-    return v.template lpNorm<Eigen::Infinity>();
-}
-
-/// Get the 1-norm of the given vector.
-/// @returns @f$ \left\|v\right\|_1 @f$
-template <class Derived>
-    requires(Derived::ColsAtCompileTime == 1)
-auto norm_1(const Eigen::MatrixBase<Derived> &v) {
-    return v.template lpNorm<1>();
-}
-
-} // namespace vec_util
-
-} // namespace alpaqa