Problems¶

group Problems

Classes for defining optimization problems.

Functions

template<class Problem> auto problem_with_counters(Problem &&p)¶

Wraps the given problem into a ProblemWithCounters and keeps track of how many times each function is called, and how long these calls took.

The wrapper has its own copy of the given problem. Making copies of the wrapper also copies the underlying problem, but does not copy the evaluation counters, all copies share the same counters.

template<class Problem> auto problem_with_counters_ref(Problem &p)¶

Wraps the given problem into a ProblemWithCounters and keeps track of how many times each function is called, and how long these calls took.

The wrapper keeps only a reference to the given problem, it is the responsibility of the caller to make sure that the wrapper does not outlive the original problem. Making copies of the wrapper does not copy the evaluation counters, all copies share the same counters.

template<Config Conf> void print_provided_functions(std::ostream &os, const TypeErasedProblem<Conf> &problem)¶

template<Config Conf> class BoxConstrProblem

#include <alpaqa/problem/box-constr-problem.hpp>

Implements common problem functions for minimization problems with box constraints.

Meant to be used as a base class for custom problem implementations. Supports optional \( \ell_1 \)-regularization.

Public Types

using Box = alpaqa::Box<config_t>

Public Functions

inline BoxConstrProblem(length_t num_variables, length_t num_constraints)

Create a problem with inactive boxes \( (-\infty, +\infty) \), with no \( \ell_1 \)-regularization, and all general constraints handled using ALM.

Parameters:

num_variables – Number of decision variables
num_constraints – Number of constraints

inline BoxConstrProblem(std::tuple<length_t, length_t> dims)

Create a problem with inactive boxes \( (-\infty, +\infty) \), with no \( \ell_1 \)-regularization, and all general constraints handled using ALM.

Parameters:: dims – Number of variables and number of constraints.

inline BoxConstrProblem(Box variable_bounds, Box general_bounds, vec l1_reg = vec(0), index_t penalty_alm_split = 0)

inline void resize(length_t num_variables, length_t num_constraints)

Change the dimensions of the problem (number of decision variables and number of constraints).

Destructive: resizes and/or resets the members variable_bounds, general_bounds, l1_reg and penalty_alm_split.

Parameters:

num_variables – Number of decision variables
num_constraints – Number of constraints

BoxConstrProblem(const BoxConstrProblem&) = default

BoxConstrProblem &operator=(const BoxConstrProblem&) = default

BoxConstrProblem(BoxConstrProblem&&) noexcept = default

BoxConstrProblem &operator=(BoxConstrProblem&&) noexcept = default

inline length_t get_num_variables() const: Number of decision variables \( n \), num_variables.

inline length_t get_num_constraints() const: Number of constraints \( m \), num_constraints.

inline real_t eval_proximal_gradient_step(real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p) const

See also

eval_proximal_gradient_step

inline void eval_projecting_difference_constraints(crvec z, rvec p) const

See also

eval_projecting_difference_constraints

inline void eval_projection_multipliers(rvec y, real_t M) const

See also

eval_projection_multipliers

inline const Box &get_variable_bounds() const

See also

get_variable_bounds

inline const Box &get_general_bounds() const

See also

get_general_bounds

inline bool provides_get_variable_bounds() const

Only supported if the ℓ₁-regularization term is zero.

See also

provides_get_variable_bounds

inline index_t eval_inactive_indices_res_lna(real_t γ, crvec x, crvec grad_ψ, rindexvec J) const

See also

eval_inactive_indices_res_lna

inline void check() const

See also

check

inline std::string get_name() const

See also

get_name

Public Members

length_t num_variables: Number of decision variables, dimension of x.

length_t num_constraints: Number of constraints, dimension of g(x) and z.

Box variable_bounds = {this->num_variables}: Constraints of the decision variables, \( x \in C \).

Box general_bounds = {this->num_constraints}: Other constraints, \( g(x) \in D \).

vec l1_reg = {}

\( \ell_1 \) (1-norm) regularization parameter.

Possible dimensions are: \( 0 \) (no regularization), \( 1 \) (a single scalar factor), or \( n \) (a different factor for each variable).

index_t penalty_alm_split = 0

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.

Public Static Functions

static inline real_t eval_proj_grad_step_box(const Box &C, real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p)

Projected gradient step for rectangular box C.

\[\begin{split} \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} \end{split}\]

static inline void eval_prox_grad_step_box_l1_impl(const Box &C, const auto &λ, real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p)

Proximal gradient step for rectangular box C with ℓ₁-regularization.

\[\begin{split} \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} \end{split}\]

static inline real_t eval_prox_grad_step_box_l1(const Box &C, const auto &λ, real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p)

Proximal gradient step for rectangular box C with ℓ₁-regularization.

static inline real_t eval_prox_grad_step_box_l1_scal(const Box &C, real_t λ, real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p)

Proximal gradient step for rectangular box C with ℓ₁-regularization.

static inline void eval_proj_multipliers_box(const Box &D, rvec y, real_t M, index_t penalty_alm_split)

template<Config Conf = DefaultConfig> class FunctionalProblem : public BoxConstrProblem<DefaultConfig>

#include <alpaqa/problem/functional-problem.hpp>

Problem class that allows specifying the basic functions as C++ std::functions.

Public Functions

inline real_t eval_objective(crvec x) const

inline void eval_objective_gradient(crvec x, rvec grad_fx) const

inline void eval_constraints(crvec x, rvec gx) const

inline void eval_constraints_gradient_product(crvec x, crvec y, rvec grad_gxy) const

inline void eval_grad_gi(crvec x, index_t i, rvec grad_gix) const

inline void eval_lagrangian_hessian_product(crvec x, crvec y, real_t scale, crvec v, rvec Hv) const

inline void eval_augmented_lagrangian_hessian_product(crvec x, crvec y, crvec Σ, real_t scale, crvec v, rvec Hv) const

inline void eval_constraints_jacobian(crvec x, rvec J_values) const

inline void eval_lagrangian_hessian(crvec x, crvec y, real_t scale, rvec H_values) const

inline void eval_augmented_lagrangian_hessian(crvec x, crvec y, crvec Σ, real_t scale, rvec H_values) const

inline bool provides_eval_grad_gi() const

See also

provides_eval_grad_gi

inline bool provides_eval_constraints_jacobian() const

See also

provides_eval_constraints_jacobian

inline bool provides_eval_lagrangian_hessian_product() const

inline bool provides_eval_lagrangian_hessian() const

See also

provides_eval_lagrangian_hessian

inline bool provides_eval_augmented_lagrangian_hessian_product() const

inline bool provides_eval_augmented_lagrangian_hessian() const

inline std::string get_name() const

See also

get_name

FunctionalProblem(const FunctionalProblem&) = default

FunctionalProblem &operator=(const FunctionalProblem&) = default

FunctionalProblem(FunctionalProblem&&) noexcept = default

FunctionalProblem &operator=(FunctionalProblem&&) noexcept = default

Public Members

std::function<real_t(crvec)> f

std::function<void(crvec, rvec)> grad_f

std::function<void(crvec, rvec)> g

std::function<void(crvec, crvec, rvec)> grad_g_prod

std::function<void(crvec, index_t, rvec)> grad_gi

std::function<void(crvec, rmat)> jac_g

std::function<void(crvec, crvec, real_t, crvec, rvec)> hess_L_prod

std::function<void(crvec, crvec, real_t, rmat)> hess_L

std::function<void(crvec, crvec, crvec, real_t, crvec, rvec)> hess_ψ_prod

std::function<void(crvec, crvec, crvec, real_t, rmat)> hess_ψ

template<Config Conf = DefaultConfig, class Allocator = std::allocator<std::byte>> class TypeErasedControlProblem : public guanaqo::TypeErased<ControlProblemVTable<DefaultConfig>, std::allocator<std::byte>>

#include <alpaqa/problem/ocproblem.hpp>

Nonlinear optimal control problem with finite horizon \( N \).

\[\begin{split}\newcommand\U{U} \newcommand\D{D} \newcommand\nnu{{n_u}} \newcommand\nnx{{n_x}} \newcommand\nny{{n_y}} \newcommand\xinit{x_\text{init}} \begin{equation}\label{eq:OCP} \tag{OCP}\hspace{-0.8em} \begin{aligned} &\minimize_{u,x} && \sum_{k=0}^{N-1} \ell_k\big(h_k(x^k, u^k)\big) + \ell_N\big(h_N(x^N)\big)\hspace{-0.8em} \\ &\subjto && u^k \in \U \\ &&& c_k(x^k) \in \D \\ &&& c_N(x^N) \in \D_N \\ &&& x^0 = \xinit \\ &&& x^{k+1} = f(x^k, u^k) \quad\quad (0 \le k \lt N) \end{aligned} \end{equation} \end{split}\]

The function \( f : \R^\nnx \times \R^\nnu \to \R^\nnx \) models the discrete-time, nonlinear dynamics of the system, which starts from an initial state \( \xinit \). The functions \( h_k : \R^\nnx \times \R^\nnu \to \R^{n_h} \) for \( 0 \le k \lt N \) and \( h_N : \R^\nnx \to \R^{n_h^N} \) can be used to represent the (possibly time-varying) output mapping of the system, and the convex functions \( \ell_k : \R^{n_h} \to \R \) and \( \ell_N : \R^{n_h^N} \to \R \) define the stage costs and the terminal cost respectively. Stage constraints and terminal constraints are represented by the functions \( c_k : \R^{n_x} \to \R^{n_c} \) and \( c_N : \R^{n_x} \to \R^{n_c^N} \), and the boxes \( D \) and \( D_N \).

Additional functions for computing Gauss-Newton approximations of the cost Hessian are included as well:

\[\begin{split} \begin{aligned} q^k &\defeq \tp{\jac_{h_k}^x\!(\barxuk)} \nabla \ell_k(\hhbar^k) \\ r^k &\defeq \tp{\jac_{h_k}^u\!(\barxuk)} \nabla \ell_k(\hhbar^k) \\ \Lambda_k &\defeq \partial^2 \ell_k(\hhbar^k) \\ Q_k &\defeq \tp{\jac_{h_k}^x\!(\barxuk)} \Lambda_k\, \jac_{h_k}^x\!(\barxuk) \\ S_k &\defeq \tp{\jac_{h_k}^u\!(\barxuk)} \Lambda_k\, \jac_{h_k}^x\!(\barxuk) \\ R_k &\defeq \tp{\jac_{h_k}^u\!(\barxuk)} \Lambda_k\, \jac_{h_k}^u\!(\barxuk). \\ \end{aligned} \end{split}\]

See [3] for more details.

Problem dimensions

inline length_t get_N() const: Horizon length.

inline length_t get_nu() const: Number of inputs.

inline length_t get_nx() const: Number of states.

inline length_t get_nh() const: Number of outputs.

inline length_t get_nh_N() const

inline length_t get_nc() const: Number of constraints.

inline length_t get_nc_N() const

inline Dim get_dim() const: All dimensions.

inline length_t get_num_variables() const: Total number of variables.

inline length_t get_num_constraints() const: Total number of constraints.

Projections onto constraint sets

inline void eval_projecting_difference_constraints(crvec z, rvec e) const

[Required] Function that evaluates the difference between the given point \( z \) and its projection onto the constraint set \( D \).

Note

z and e can refer to the same vector.

Parameters:

z – [in] Slack variable, \( z \in \R^m \)
e – [out] The difference relative to its projection, \( e = z - \Pi_D(z) \in \R^m \)

inline void eval_projection_multipliers(rvec y, real_t M) const

[Required] Function that projects the Lagrange multipliers for ALM.

Parameters:

y – [inout] Multipliers, \( y \leftarrow \Pi_Y(y) \in \R^m \)
M – [in] The radius/size of the set \( Y \). See max_multiplier.

Constraint sets

inline void get_U(Box &U) const: Input box constraints \( U \).

inline void get_D(Box &D) const: Stage box constraints \( D \).

inline void get_D_N(Box &D) const: Terminal box constraints \( D_N \).

Dynamics and initial state

inline void get_x_init(rvec x_init) const: Initial state \( x_\text{init} \).

inline void eval_f(index_t timestep, crvec x, crvec u, rvec fxu) const: Discrete-time dynamics \( x^{k+1} = f_k(x^k, u^k) \).

inline void eval_jac_f(index_t timestep, crvec x, crvec u, rmat J_fxu) const: Jacobian of discrete-time dynamics \( \jac_f(x^k, u^k) \).

inline void eval_grad_f_prod(index_t timestep, crvec x, crvec u, crvec p, rvec grad_fxu_p) const: Gradient-vector product of discrete-time dynamics \( \nabla f(x^k, u^k)\,p \).

Output mapping

inline void eval_h(index_t timestep, crvec x, crvec u, rvec h) const: Stage output mapping \( h_k(x^k, u^k) \).

inline void eval_h_N(crvec x, rvec h) const: Terminal output mapping \( h_N(x^N) \).

Stage and terminal cost

inline real_t eval_l(index_t timestep, crvec h) const: Stage cost \( \ell_k(\hbar^k) \).

inline real_t eval_l_N(crvec h) const: Terminal cost \( \ell_N(\hbar^N) \).

Gauss-Newton approximations

inline void eval_qr(index_t timestep, crvec xu, crvec h, rvec qr) const

Cost gradients w.r.t.

states and inputs \( q^k = \tp{\jac_{h_k}^x\!(\barxuk)} \nabla \ell_k(\hbar^k) \) and \( r^k = \tp{\jac_{h_k}^u\!(\barxuk)} \nabla \ell_k(\hbar^k) \).

inline void eval_q_N(crvec x, crvec h, rvec q) const

Terminal cost gradient w.r.t.

states \( q^N = \tp{\jac_{h_N}(\bar x^N)} \nabla \ell_k(\hbar^N) \).

inline void eval_add_Q(index_t timestep, crvec xu, crvec h, rmat Q) const

Cost Hessian w.r.t.

states \( Q_k = \tp{\jac_{h_k}^x\!(\barxuk)} \partial^2\ell_k(\hbar^k)\, \jac_{h_k}^x\!(\barxuk) \), added to the given matrix Q. \( Q \leftarrow Q + Q_k \).

inline void eval_add_Q_N(crvec x, crvec h, rmat Q) const

Terminal cost Hessian w.r.t.

states \( Q_N = \tp{\jac_{h_N}(\bar x^N)} \partial^2\ell_N(\hbar^N)\, \jac_{h_N}(\bar x^N) \), added to the given matrix Q. \( Q \leftarrow Q + Q_N \).

inline void eval_add_R_masked(index_t timestep, crvec xu, crvec h, crindexvec mask, rmat R, rvec work) const

Cost Hessian w.r.t.

inputs \( R_k = \tp{\jac_{h_k}^u\!(\barxuk)} \partial^2\ell_k(\hbar^k)\, \jac_{h_k}^u\!(\barxuk) \), keeping only rows and columns in the mask \( \mathcal J \), added to the given matrix R. \( R \leftarrow R + R_k[\mathcal J, \mathcal J] \). The size of work should be get_R_work_size().

inline void eval_add_S_masked(index_t timestep, crvec xu, crvec h, crindexvec mask, rmat S, rvec work) const

Cost Hessian w.r.t.

inputs and states \( S_k = \tp{\jac_{h_k}^u\!(\barxuk)} \partial^2\ell_k(\hbar^k)\, \jac_{h_k}^x\!(\barxuk) \), keeping only rows in the mask \( \mathcal J \), added to the given matrix S. \( S \leftarrow S + S_k[\mathcal J, \cdot] \). The size of work should be get_S_work_size().

inline 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

\( out \leftarrow out + R[\mathcal J, \mathcal K]\,v[\mathcal K] \).

Work should contain the contents written to it by a prior call to eval_add_R_masked() in the same point.

inline void eval_add_S_prod_masked(index_t timestep, crvec xu, crvec h, crindexvec mask_K, crvec v, rvec out, rvec work) const

\( out \leftarrow out + \tp{S[\mathcal K, \cdot]}\, v[\mathcal K] \).

Work should contain the contents written to it by a prior call to eval_add_S_masked() in the same point.

inline length_t get_R_work_size() const: Size of the workspace required by eval_add_R_masked() and eval_add_R_prod_masked().

inline length_t get_S_work_size() const: Size of the workspace required by eval_add_S_masked() and eval_add_S_prod_masked().

Constraints

inline void eval_constr(index_t timestep, crvec x, rvec c) const: Stage constraints \( c_k(x^k) \).

inline void eval_constr_N(crvec x, rvec c) const: Terminal constraints \( c_N(x^N) \).

inline void eval_grad_constr_prod(index_t timestep, crvec x, crvec p, rvec grad_cx_p) const: Gradient-vector product of stage constraints \( \nabla c_k(x^k)\, p \).

inline void eval_grad_constr_prod_N(crvec x, crvec p, rvec grad_cx_p) const: Gradient-vector product of terminal constraints \( \nabla c_N(x^N)\, p \).

inline void eval_add_gn_hess_constr(index_t timestep, crvec x, crvec M, rmat out) const: Gauss-Newton Hessian of stage constraints \( \tp{\jac_{c_k}}(x^k)\, \operatorname{diag}(M)\; \jac_{c_k}(x^k) \).

inline void eval_add_gn_hess_constr_N(crvec x, crvec M, rmat out) const: Gauss-Newton Hessian of terminal constraints \( \tp{\jac_{c_N}}(x^N)\, \operatorname{diag}(M)\; \jac_{c_N}(x^N) \).

Checks

inline void check() const

Check that the problem formulation is well-defined, the dimensions match, etc.

Throws an exception if this is not the case.

Querying specialized implementations

inline bool provides_get_D() const

inline bool provides_get_D_N() const

inline bool provides_eval_h() const

inline bool provides_eval_h_N() const

inline bool provides_eval_add_Q_N() const

inline bool provides_eval_add_R_prod_masked() const

inline bool provides_eval_add_S_prod_masked() const

inline bool provides_get_R_work_size() const

inline bool provides_get_S_work_size() const

inline bool provides_eval_constr() const

inline bool provides_eval_constr_N() const

inline bool provides_eval_grad_constr_prod() const

inline bool provides_eval_grad_constr_prod_N() const

inline bool provides_eval_add_gn_hess_constr() const

inline bool provides_eval_add_gn_hess_constr_N() const

Public Types

using VTable = ControlProblemVTable<config_t>

using allocator_type = Allocator

using Box = typename VTable::Box

using Dim = OCPDim<config_t>

using TypeErased = guanaqo::TypeErased<VTable, allocator_type>

Public Static Functions

template<class T, class ...Args> static inline TypeErasedControlProblem make(Args&&... args)

template<class Problem> struct ProblemWithCounters

#include <alpaqa/problem/problem-with-counters.hpp>

Problem wrapper that keeps track of the number of evaluations and the run time of each function.

You probably want to use problem_with_counters or problem_with_counters_ref instead of instantiating this class directly.

Note

The evaluation counters are stored using a std::shared_pointers, which means that different copies of a ProblemWithCounters instance all share the same counters. To opt out of this behavior, you can use the decouple_evaluations function.

Public Types

using Box = typename TypeErasedProblem<config_t>::Box

Public Functions

inline void eval_projecting_difference_constraints(crvec z, rvec e) const

inline void eval_projection_multipliers(rvec y, real_t M) const

inline real_t eval_proximal_gradient_step(real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p) const

inline index_t eval_inactive_indices_res_lna(real_t γ, crvec x, crvec grad_ψ, rindexvec J) const

inline real_t eval_objective(crvec x) const

inline void eval_objective_gradient(crvec x, rvec grad_fx) const

inline void eval_constraints(crvec x, rvec gx) const

inline void eval_constraints_gradient_product(crvec x, crvec y, rvec grad_gxy) const

inline void eval_grad_gi(crvec x, index_t i, rvec grad_gi) const

inline void eval_constraints_jacobian(crvec x, rvec J_values) const

inline Sparsity get_constraints_jacobian_sparsity() const

inline void eval_lagrangian_hessian_product(crvec x, crvec y, real_t scale, crvec v, rvec Hv) const

inline void eval_lagrangian_hessian(crvec x, crvec y, real_t scale, rvec H_values) const

inline Sparsity get_lagrangian_hessian_sparsity() const

inline void eval_augmented_lagrangian_hessian_product(crvec x, crvec y, crvec Σ, real_t scale, crvec v, rvec Hv) const

inline void eval_augmented_lagrangian_hessian(crvec x, crvec y, crvec Σ, real_t scale, rvec H_values) const

inline Sparsity get_augmented_lagrangian_hessian_sparsity() const

inline real_t eval_objective_and_gradient(crvec x, rvec grad_fx) const

inline real_t eval_objective_and_constraints(crvec x, rvec g) const

inline void eval_objective_gradient_and_constraints_gradient_product(crvec x, crvec y, rvec grad_f, rvec grad_gxy) const

inline void eval_lagrangian_gradient(crvec x, crvec y, rvec grad_L, rvec work_n) const

inline real_t eval_augmented_lagrangian(crvec x, crvec y, crvec Σ, rvec ŷ) const

inline void eval_augmented_lagrangian_gradient(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const

inline real_t eval_augmented_lagrangian_and_gradient(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const

inline const Box &get_variable_bounds() const

inline const Box &get_general_bounds() const

inline void check() const

inline std::string get_name() const

inline bool provides_eval_grad_gi() const

inline bool provides_eval_inactive_indices_res_lna() const

inline bool provides_eval_constraints_jacobian() const

inline bool provides_get_constraints_jacobian_sparsity() const

inline bool provides_eval_lagrangian_hessian_product() const

inline bool provides_eval_lagrangian_hessian() const

inline bool provides_get_lagrangian_hessian_sparsity() const

inline bool provides_eval_augmented_lagrangian_hessian_product() const

inline bool provides_eval_augmented_lagrangian_hessian() const

inline bool provides_get_augmented_lagrangian_hessian_sparsity() const

inline bool provides_eval_objective_and_gradient() const

inline bool provides_eval_objective_and_constraints() const

inline bool provides_eval_objective_gradient_and_constraints_gradient_product() const

inline bool provides_eval_lagrangian_gradient() const

inline bool provides_eval_augmented_lagrangian() const

inline bool provides_eval_augmented_lagrangian_gradient() const

inline bool provides_eval_augmented_lagrangian_and_gradient() const

inline bool provides_get_variable_bounds() const

inline bool provides_get_general_bounds() const

inline bool provides_check() const

inline bool provides_get_name() const

inline length_t get_num_variables() const

inline length_t get_num_constraints() const

ProblemWithCounters() = default

template<class P> inline explicit ProblemWithCounters(P &&problem)

template<class ...Args> inline explicit ProblemWithCounters(std::in_place_t, Args&&... args)

inline void reset_evaluations()

Reset all evaluation counters and timers to zero.

Affects all instances that share the same evaluations. If you only want to reset the counters of this instance, use decouple_evaluations first.

inline void decouple_evaluations()

Give this instance its own evaluation counters and timers, decoupling it from any other instances they might have previously been shared with.

The evaluation counters and timers are preserved (a copy is made).

Public Members

std::shared_ptr<EvalCounter> evaluations = std::make_shared<EvalCounter>()

Problem problem

template<Config Conf = DefaultConfig, class Allocator = std::allocator<std::byte>> class TypeErasedProblem : public guanaqo::TypeErased<ProblemVTable<DefaultConfig>, std::allocator<std::byte>>

#include <alpaqa/problem/type-erased-problem.hpp>

The main polymorphic minimization problem interface.

This class wraps the actual problem implementation class, filling in the missing member functions with sensible defaults, and providing a uniform interface that is used by the solvers.

The problem implementations do not inherit from an abstract base class. Instead, structural typing is used. The ProblemVTable constructor uses reflection to discover which member functions are provided by the problem implementation. See Problem formulations for more information, and C++/CustomCppProblem/main.cpp for an example.

Problem dimensions

length_t get_num_variables() const: [Required] Number of decision variables.

length_t get_num_constraints() const: [Required] Number of constraints.

Required cost and constraint functions

real_t eval_objective(crvec x) const

[Required] Function that evaluates the cost, \( f(x) \)

Parameters:: x – [in] Decision variable \( x \in \R^n \)

void eval_objective_gradient(crvec x, rvec grad_fx) const

[Required] Function that evaluates the gradient of the cost, \( \nabla f(x) \)

Parameters:

x – [in] Decision variable \( x \in \R^n \)
grad_fx – [out] Gradient of cost function \( \nabla f(x) \in \R^n \)

void eval_constraints(crvec x, rvec gx) const

[Required] Function that evaluates the constraints, \( g(x) \)

Parameters:

x – [in] Decision variable \( x \in \R^n \)
gx – [out] Value of the constraints \( g(x) \in \R^m \)

void eval_constraints_gradient_product(crvec x, crvec y, rvec grad_gxy) const

[Required] Function that evaluates the gradient of the constraints times a vector, \( \nabla g(x)\,y = \tp{\jac_g(x)}y \)

Parameters:

x – [in] Decision variable \( x \in \R^n \)
y – [in] Vector \( y \in \R^m \) to multiply the gradient by
grad_gxy – [out] Gradient of the constraints \( \nabla g(x)\,y \in \R^n \)

Projections onto constraint sets and proximal mappings

void eval_projecting_difference_constraints(crvec z, rvec e) const

[Required] Function that evaluates the difference between the given point \( z \) and its projection onto the constraint set \( D \).

Note

z and e can refer to the same vector.

Parameters:

z – [in] Slack variable, \( z \in \R^m \)
e – [out] The difference relative to its projection, \( e = z - \Pi_D(z) \in \R^m \)

void eval_projection_multipliers(rvec y, real_t M) const

[Required] Function that projects the Lagrange multipliers for ALM.

Parameters:

y – [inout] Multipliers, \( y \leftarrow \Pi_Y(y) \in \R^m \)
M – [in] The radius/size of the set \( Y \). See max_multiplier.

real_t eval_proximal_gradient_step(real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p) const

[Required] Function that computes a proximal gradient step.

Note

The vector \( p \) is often used in stopping criteria, so its numerical accuracy is more important than that of \( \hat x \).

Parameters:

γ – [in] Step size, \( \gamma \in \R_{>0} \)
x – [in] Decision variable \( x \in \R^n \)
grad_ψ – [in] Gradient of the subproblem cost, \( \nabla\psi(x) \in \R^n \)
x̂ – [out] Next proximal gradient iterate, \( \hat x = T_\gamma(x) = \prox_{\gamma h}(x - \gamma\nabla\psi(x)) \in \R^n \)
p – [out] The proximal gradient step, \( p = \hat x - x \in \R^n \)

Returns:

The nonsmooth function evaluated at x̂, \( h(\hat x) \).

index_t eval_inactive_indices_res_lna(real_t γ, crvec x, crvec grad_ψ, rindexvec J) const

[Optional] Function that computes the inactive indices \( \mathcal J(x) \) for the evaluation of the linear Newton approximation of the residual, as in [4].

For example, in the case of box constraints, we have

\[ \mathcal J(x) \defeq \defset{i \in \N_{[0, n-1]}}{\underline x_i \lt x_i - \gamma\nabla_{\!x_i}\psi(x) \lt \overline x_i}. \]

Parameters:

γ – [in] Step size, \( \gamma \in \R_{>0} \)
x – [in] Decision variable \( x \in \R^n \)
grad_ψ – [in] Gradient of the subproblem cost, \( \nabla\psi(x) \in \R^n \)
J – [out] The indices of the components of \( x \) that are in the index set \( \mathcal J(x) \). In ascending order, at most n.

Returns:

The number of inactive constraints, \( \# \mathcal J(x) \).

Constraint sets

const Box &get_variable_bounds() const: [Optional] Get the rectangular constraint set of the decision variables, \( x \in C \).

const Box &get_general_bounds() const: [Optional] Get the rectangular constraint set of the general constraint function, \( g(x) \in D \).

Functions for second-order solvers

void eval_constraints_jacobian(crvec x, rvec J_values) const

[Optional] Function that evaluates the nonzero values of the Jacobian matrix of the constraints, \( \jac_g(x) \)