C++ API Reference#
Note
The Doxygen documentation of the C++ API is often more readable.
- Accelerators
- Augmented Lagrangian solver
- Functions and operators
- Inner solvers
- Direction providers
- Parameters
AndersonAccelParamsCBFGSParamsLBFGSParamsSteihaugCGParamsAndersonDirectionParamsConvexNewtonRegularizationParamsConvexNewtonDirectionParamsLBFGSDirectionParamsStructuredLBFGSDirectionParamsStructuredNewtonRegularizationParamsStructuredNewtonDirectionParamsNewtonTRDirectionParamsFISTAParamsLipschitzEstimateParamsPANOCOCPParamsPANOCParamsPANTRParamsWolfeParamsZeroFPRParamsALMParamsLBFGSBParams
- Problems
Index#
-
namespace alpaqa#
Typedefs
-
using DefaultConfig = EigenConfigd#
-
template<Config Conf = DefaultConfig>
using real_t = typename Conf::real_t#
-
template<Config Conf = DefaultConfig>
using cplx_t = typename Conf::cplx_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 cmat = typename Conf::cmat#
-
template<Config Conf = DefaultConfig>
using mcmat = typename Conf::mcmat#
-
template<Config Conf = DefaultConfig>
using cmcmat = typename Conf::cmcmat#
-
template<Config Conf = DefaultConfig>
using rcmat = typename Conf::rcmat#
-
template<Config Conf = DefaultConfig>
using crcmat = typename Conf::crcmat#
-
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 = DefaultConfig>
using mindexvec = typename Conf::mindexvec#
-
template<Config Conf = DefaultConfig>
using cmindexvec = typename Conf::cmindexvec#
-
template<typename Tag, typename ...Args>
using tag_invoke_result = std::invoke_result<decltype(::alpaqa::alpaqa_tag_invoke), Tag, Args...>#
-
template<typename Tag, typename ...Args>
using tag_invoke_result_t = std::invoke_result_t<decltype(::alpaqa::alpaqa_tag_invoke), Tag, Args...>#
-
using function_dict_t = alpaqa_function_dict_t#
-
using problem_register_t = alpaqa_problem_register_t#
-
using control_problem_register_t = alpaqa_control_problem_register_t#
-
using problem_functions_t = alpaqa_problem_functions_t#
-
using control_problem_functions_t = alpaqa_control_problem_functions_t#
Enums
-
enum class LBFGSStepSize#
Which method to use to select the L-BFGS step size.
Values:
-
enumerator BasedOnExternalStepSize#
Initial inverse Hessian approximation is set to \( H_0 = \gamma I \), where \( \gamma \) is the forward-backward splitting step size.
-
enumerator BasedOnCurvature#
Initial inverse Hessian approximation is set to \( H_0 = \frac{s^\top y}{y^\top y} I \).
-
enumerator BasedOnGradientStepSize#
-
enumerator BasedOnExternalStepSize#
-
enum class PANOCStopCrit#
Values:
-
enumerator ApproxKKT#
Find an ε-approximate KKT point in the ∞-norm:
\[ \varepsilon = \left\| \gamma_k^{-1} (x^k - \hat x^k) + \nabla \psi(\hat x^k) - \nabla \psi(x^k) \right\|_\infty \]
-
enumerator ApproxKKT2#
Find an ε-approximate KKT point in the 2-norm:
\[ \varepsilon = \left\| \gamma_k^{-1} (x^k - \hat x^k) + \nabla \psi(\hat x^k) - \nabla \psi(x^k) \right\|_2 \]
-
enumerator ProjGradNorm#
∞-norm of the projected gradient with step size γ:
\[ \varepsilon = \left\| x^k - \Pi_C\left(x^k - \gamma_k \nabla \psi(x^k)\right) \right\|_\infty \]
-
enumerator ProjGradNorm2#
2-norm of the projected gradient with step size γ:
This is the same criterion as used by OpEn.\[ \varepsilon = \left\| x^k - \Pi_C\left(x^k - \gamma_k \nabla \psi(x^k)\right) \right\|_2 \]
-
enumerator ProjGradUnitNorm#
∞-norm of the projected gradient with unit step size:
\[ \varepsilon = \left\| x^k - \Pi_C\left(x^k - \nabla \psi(x^k)\right) \right\|_\infty \]
-
enumerator ProjGradUnitNorm2#
2-norm of the projected gradient with unit step size:
\[ \varepsilon = \left\| x^k - \Pi_C\left(x^k - \nabla \psi(x^k)\right) \right\|_2 \]
-
enumerator FPRNorm#
∞-norm of fixed point residual:
\[ \varepsilon = \gamma_k^{-1} \left\| x^k - \Pi_C\left(x^k - \gamma_k \nabla \psi(x^k)\right) \right\|_\infty \]
-
enumerator FPRNorm2#
2-norm of fixed point residual:
\[ \varepsilon = \gamma_k^{-1} \left\| x^k - \Pi_C\left(x^k - \gamma_k \nabla \psi(x^k)\right) \right\|_2 \]
-
enumerator Ipopt#
The stopping criterion used by Ipopt, see https://link.springer.com/article/10.1007/s10107-004-0559-y equation (5).
Given a candidate iterate \( \hat x^k \) and the corresponding candidate Lagrange multipliers \( \hat y^k \) for the general constraints \( g(x)\in D \), the multipliers \( w \) for the box constraints \( x\in C \) (that are otherwise not computed explicitly) are given by
where\[ w^k = v^k - \Pi_C(v^k), \]The quantity that is compared to the (scaled) tolerance is then given by\[\begin{split} \begin{aligned} v^k &\triangleq \hat x^k - \nabla f(\hat x^k) - \nabla g(\hat x^k)\, \hat y^k \\ &= \hat x^k - \nabla \psi(\hat x^k) \end{aligned} \end{split}\]Finally, the quantity is scaled by the factor\[\begin{split} \begin{aligned} \varepsilon' &= \left\| \nabla f(\hat x^k) + \nabla g(\hat x^k)\, \hat y^k + w^k \right\|_\infty \\ &= \left\| \hat x^k - \Pi_C\left(v^k\right) \right\|_\infty \end{aligned} \end{split}\]i.e. \( \varepsilon = \varepsilon' / s_d \).\[ s_d \triangleq \max\left\{ s_\text{max},\;\frac{\|\hat y^k\|_1 + \|w^k\|_1}{2m + 2n} \right\} / s_\text{max}, \]
-
enumerator LBFGSBpp#
The stopping criterion used by LBFGS++, see https://lbfgspp.statr.me/doc/classLBFGSpp_1_1LBFGSBParam.html#afb20e8fd6c6808c1f736218841ba6947.
\[ \varepsilon = \frac{\left\| x^k - \Pi_C\left(x^k - \nabla \psi(x^k)\right) \right\|_\infty} {\max\left\{1, \|x\|_2 \right\}} \]
-
enumerator ApproxKKT#
-
enum class SolverStatus#
Exit status of a numerical solver such as ALM or PANOC.
Values:
-
enumerator Busy#
In progress.
-
enumerator Converged#
Converged and reached given tolerance.
-
enumerator MaxTime#
Maximum allowed execution time exceeded.
-
enumerator MaxIter#
Maximum number of iterations exceeded.
-
enumerator NotFinite#
Intermediate results were infinite or not-a-number.
-
enumerator NoProgress#
No progress was made in the last iteration.
-
enumerator Interrupted#
Solver was interrupted by the user.
-
enumerator Exception#
An unexpected exception was thrown.
-
enumerator Busy#
Functions
-
template<Config Conf = DefaultConfig>
inline void minimize_update_anderson(LimitedMemoryQR<Conf> &qr, rmat<Conf> G_tilde, crvec<Conf> rₖ, crvec<Conf> rₗₐₛₜ, crvec<Conf> gₖ, real_t<Conf> min_div_fac, rvec<Conf> γ_LS, rvec<Conf> xₖ_aa)# Solve one step of Anderson acceleration to find a fixed point of a function g(x):
\( g(x^\star) - x^\star = 0 \)
Updates the QR factorization of \( \mathcal{R}_k = QR \), solves the least squares problem to find \( \gamma_\text{LS} \), computes the next iterate \( x_{k+1} \), and stores the current function value \( g_k \) in the matrix \( G \), which is used as a circular buffer.
\[\begin{split} \begin{aligned} \def\gammaLS{\gamma_\text{LS}} m_k &= \min \{k, m\} \\ g_i &= g(x_i) \\ r_i &= r(x_i) g_i - x_i \\ \Delta r_i &= r_i - r_{i-1} \\ \mathcal{R}_k &= \begin{pmatrix} \Delta r_{k-m_k+1} & \dots & \Delta r_k \end{pmatrix} \in \R^{n\times m_k} \\ \gammaLS &= \argmin_{\gamma \in \R^{m_k}}\; \norm{\mathcal{R}_k \gamma - r_k}_2 \\ \alpha_i &= \begin{cases} \gammaLS[0] & i = 0 \\ \gammaLS[i] - \gammaLS[i-1] & 0 \lt i \lt m_k \\ 1 - \gammaLS[m_k - 1] & i = m_k \end{cases} \\ \tilde G_k &= \begin{pmatrix} g_{k - m_k} & \dots & g_{k-1} \end{pmatrix} \\ G_k &= \begin{pmatrix} g_{k - m_k} & \dots & g_{k} \end{pmatrix} \\ &= \begin{pmatrix} \tilde G_k & g_{k} \end{pmatrix} \\ x_{k+1} &= \sum_{i=0}^{m_k} \alpha_i\,g_{k - m_k + i} \\ &= G_k \alpha \\ \end{aligned} \end{split}\]- Parameters:
qr – [inout] QR factorization of \( \mathcal{R}_k \)
G_tilde – [inout] Matrix of previous function values \( \tilde G_k \) (stored as ring buffer with the same indices as
qr)rₖ – [in] Current residual \( r_k \)
rₗₐₛₜ – [in] Previous residual \( r_{k-1} \)
gₖ – [in] Current function value \( g_k \)
min_div_fac – [in] Minimum divisor when solving close to singular systems, scaled by the maximum eigenvalue of R
γ_LS – [out] Solution to the least squares system
xₖ_aa – [out] Next Anderson iterate
-
inline constexpr const char *enum_name(LBFGSStepSize s)#
-
template<Config Conf>
InnerStatsAccumulator<FISTAStats<Conf>> &operator+=(InnerStatsAccumulator<FISTAStats<Conf>> &acc, const FISTAStats<Conf> &s)#
-
inline constexpr const char *enum_name(PANOCStopCrit s)#
-
std::ostream &operator<<(std::ostream &os, PANOCStopCrit s)#
-
template<Config Conf>
InnerStatsAccumulator<PANOCOCPStats<Conf>> &operator+=(InnerStatsAccumulator<PANOCOCPStats<Conf>> &acc, const PANOCOCPStats<Conf> &s)#
-
template<Config Conf>
InnerStatsAccumulator<PANOCStats<Conf>> &operator+=(InnerStatsAccumulator<PANOCStats<Conf>> &acc, const PANOCStats<Conf> &s)#
-
template<Config Conf>
InnerStatsAccumulator<PANTRStats<Conf>> &operator+=(InnerStatsAccumulator<PANTRStats<Conf>> &acc, const PANTRStats<Conf> &s)#
-
template<Config Conf>
InnerStatsAccumulator<WolfeStats<Conf>> &operator+=(InnerStatsAccumulator<WolfeStats<Conf>> &acc, const WolfeStats<Conf> &s)#
-
template<Config Conf>
InnerStatsAccumulator<ZeroFPRStats<Conf>> &operator+=(InnerStatsAccumulator<ZeroFPRStats<Conf>> &acc, const ZeroFPRStats<Conf> &s)#
-
template<Config Conf>
KKTError<Conf> compute_kkt_error(const TypeErasedProblem<Conf> &problem, crvec<Conf> x, crvec<Conf> y)#
-
std::ostream &operator<<(std::ostream&, const OCPEvalCounter&)#
-
inline OCPEvalCounter::OCPEvalTimer &operator+=(OCPEvalCounter::OCPEvalTimer &a, const OCPEvalCounter::OCPEvalTimer &b)#
-
inline OCPEvalCounter &operator+=(OCPEvalCounter &a, const OCPEvalCounter &b)#
-
inline OCPEvalCounter operator+(OCPEvalCounter a, const OCPEvalCounter &b)#
-
inline void check_finiteness(const auto &v, std::string_view msg)#
If the given vector
vis not finite, break or throw an exception with the given messagemsg.
-
inline void check_finiteness(const std::floating_point auto &v, std::string_view msg)#
-
std::ostream &operator<<(std::ostream&, const EvalCounter&)#
-
inline EvalCounter::EvalTimer &operator+=(EvalCounter::EvalTimer &a, const EvalCounter::EvalTimer &b)#
-
inline EvalCounter &operator+=(EvalCounter &a, const EvalCounter &b)#
-
inline EvalCounter operator+(EvalCounter a, const EvalCounter &b)#
-
template<std::floating_point F>
std::string float_to_str(F value, int precision = std::numeric_limits<F>::max_digits10)#
-
template<class Derived, class ...Args>
std::ostream &print_csv(std::ostream &os, const Eigen::DenseBase<Derived> &M, Args&&... args)#
-
template<class Derived, class ...Args>
std::ostream &print_matlab(std::ostream &os, const Eigen::DenseBase<Derived> &M, Args&&... args)#
-
template<class Derived, class ...Args>
std::ostream &print_python(std::ostream &os, const Eigen::DenseBase<Derived> &M, Args&&... args)#
-
template<class Solver>
auto attach_cancellation(Solver &solver)# Attach SIGINT and SIGTERM handlers to stop the given solver.
- Parameters:
solver – The solver that should be stopped by the handler.
- Returns:
A RAII object that detaches the handler when destroyed.
-
std::ostream &operator<<(std::ostream &os, SolverStatus s)#
-
template<class Func>
void register_function(function_dict_t *&extra_functions, std::string name, Func &&func)# Make the given function available to alpaqa.
-
template<class Func>
void register_function(problem_register_t &result, std::string name, Func &&func)#
-
template<class Func>
void register_function(control_problem_register_t &result, std::string name, Func &&func)#
-
template<class Result, class T, class Ret, class ...Args>
void register_member_function(Result &result, std::string name, Ret (T::* member)(Args...))#
-
template<auto Member>
static auto member_caller()# Wrap the given member function or variable into a (possibly generic) lambda function that accepts the instance as a type-erased void pointer.
The signature of the resulting function depends on the signature of the member function:
Ret Class::member(args...)→Ret(void *self, args...)Ret Class::member(args...) const→Ret(void *self, args...)Ret Class::member(args...) const→Ret(const void *self, args...)
If the given member is a variable:
Type Class::member→Type &(void *self)Type Class::member→const Type &(const void *self)
-
inline void unregister_functions(function_dict_t *&extra_functions)#
Cleans up the extra functions registered by register_function.
Note
This does not need to be called for the functions returned by the registration function, those functions will be cleaned up by alpaqa.
Note
The alpaqa_problem_register_t and alpaqa_control_problem_register_t structs are part of the C API and do not automatically clean up their resources when destroyed, you have to do it manually by calling this function.
-
inline InnerStatsAccumulator<lbfgsb::LBFGSBStats> &operator+=(InnerStatsAccumulator<lbfgsb::LBFGSBStats> &acc, const lbfgsb::LBFGSBStats &s)#
-
template<Config Conf>
InnerStatsAccumulator<lbfgspp::LBFGSBStats<Conf>> &operator+=(InnerStatsAccumulator<lbfgspp::LBFGSBStats<Conf>> &acc, const lbfgspp::LBFGSBStats<Conf> &s)#
-
OwningQPALMData build_qpalm_problem(const TypeErasedProblem<EigenConfigd> &problem)#
Variables
-
template<class T>
constexpr bool is_eigen_config_v = is_eigen_config<T>::value#
-
template<Config Conf>
const rvec<Conf> null_vec = mvec<Conf>{nullptr, 0}# Global empty vector for convenience.
-
template<Config Conf>
const rindexvec<Conf> null_indexvec = mindexvec<Conf>{nullptr, 0}# Global empty index vector for convenience.
-
template<class T>
constexpr bool is_complex_float_v = is_complex_float<T>::value#
-
constexpr tag_invoke_fn_ns::tag_invoke_fn alpaqa_tag_invoke = {}#
-
template<Config Conf = DefaultConfig>
struct ALMParams# - #include <alpaqa/outer/alm.hpp>
Parameters for the Augmented Lagrangian solver.
Public Members
-
real_t initial_penalty = 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 initial_penalty_factor.
-
real_t initial_penalty_factor = 20#
Initial penalty parameter factor.
Active if initial_penalty is set to zero.
-
unsigned int max_iter = 100#
Maximum number of outer ALM iterations.
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
Maximum duration.
-
unsigned print_interval = 0#
When to print progress.
If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
-
int print_precision = std::numeric_limits<real_t>::max_digits10 / 2#
The precision of the floating point values printed by the solver.
-
bool single_penalty_factor = false#
Use one penalty factor for all m constraints.
-
real_t initial_penalty = 1#
-
template<class InnerSolverT>
class ALMSolver# - #include <alpaqa/outer/alm.hpp>
Augmented Lagrangian Method solver.
Public Functions
-
inline ALMSolver(Params params, InnerSolver &&inner_solver)#
-
inline ALMSolver(Params params, const InnerSolver &inner_solver)#
-
template<class P>
inline Stats operator()(const P &problem, rvec x, rvec y, std::optional<rvec> Σ = std::nullopt)#
-
inline std::string get_name() const#
-
inline void stop()#
Abort the computation and return the result so far.
Can be called from other threads or signal handlers.
-
struct Stats#
- #include <alpaqa/outer/alm.hpp>
Public Members
-
unsigned outer_iterations = 0#
Total number of outer ALM iterations (i.e.
the number of times that the inner solver was invoked).
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time.
-
unsigned inner_convergence_failures = 0#
The total number of times that the inner solver failed to converge.
-
real_t ε = inf<config_t>#
Final primal tolerance that was reached, depends on the stopping criterion used by the inner solver, see for example PANOCStopCrit.
-
real_t δ = inf<config_t>#
Final dual tolerance or constraint violation that was reached:
\[ \delta = \| \Pi_D\left(g(x^k) + \Sigma^{-1}y\right) \|_\infty \]
-
SolverStatus status = SolverStatus::Busy#
Whether the solver converged or not.
See also
-
InnerStatsAccumulator<typename InnerSolver::Stats> inner = {}#
The statistics of the inner solver invocations, accumulated over all ALM iterations.
-
unsigned outer_iterations = 0#
-
inline ALMSolver(Params params, InnerSolver &&inner_solver)#
-
template<Config Conf = DefaultConfig>
class AndersonAccel# - #include <alpaqa/accelerators/anderson.hpp>
Anderson Acceleration.
Algorithm for accelerating fixed-point iterations for finding fixed points of a function \( g \), i.e. \( g(x^\star) = x^\star \), or equivalently, roots of the residual \( r(x) \triangleq g(x) - x \).
Public Types
-
using Params = AndersonAccelParams<config_t>#
Public Functions
-
AndersonAccel() = default#
-
inline AndersonAccel(Params params, length_t n)#
- Parameters:
params – Parameters.
n – Problem dimension (size of the vectors).
-
inline void resize(length_t n)#
Change the problem dimension.
Flushes the history.
- Parameters:
n – Problem dimension (size of the vectors).
-
inline void initialize(crvec g_0, crvec r_0)#
Call this function on the first iteration to initialize the accelerator.
-
inline void compute(crvec gₖ, crvec rₖ, rvec xₖ_aa)#
Compute the accelerated iterate \( x^k_\text{AA} \), given the function value at the current iterate \( g^k = g(x^k) \) and the corresponding residual \( r^k = g^k - x^k \).
-
inline void compute(crvec gₖ, vec &&rₖ, rvec xₖ_aa)#
Compute the accelerated iterate \( x^k_\text{AA} \), given the function value at the current iterate \( g^k = g(x^k) \) and the corresponding residual \( r^k = g^k - x^k \).
-
inline void reset()#
Reset the accelerator (but keep the last function value and residual, so calling initialize is not necessary).
-
inline std::string get_name() const#
-
inline const LimitedMemoryQR<config_t> &get_QR() const#
For testing purposes.
-
using Params = AndersonAccelParams<config_t>#
-
template<Config Conf = DefaultConfig>
struct AndersonAccelParams# - #include <alpaqa/accelerators/anderson.hpp>
Parameters for the AndersonAccel class.
-
template<Config Conf>
struct AndersonDirection# - #include <alpaqa/inner/directions/panoc/anderson.hpp>
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using AndersonAccel = alpaqa::AndersonAccel<config_t>#
-
using AcceleratorParams = typename AndersonAccel::Params#
-
using DirectionParams = AndersonDirectionParams<config_t>#
Public Functions
-
AndersonDirection() = default#
-
inline AndersonDirection(const typename AndersonAccel::Params ¶ms, const DirectionParams &directionparams = {})#
-
inline AndersonDirection(const AndersonAccel &anderson, const DirectionParams &directionparams = {})#
-
inline AndersonDirection(AndersonAccel &&anderson, const DirectionParams &directionparams = {})#
-
inline void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0)#
See also
-
inline bool has_initial_direction() const#
-
inline bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ)#
See also
-
inline bool apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, rvec qₖ) const#
See also
-
inline void reset()#
See also
-
inline std::string get_name() const#
See also
-
inline auto get_params() const#
-
struct Params#
- #include <alpaqa/inner/directions/panoc/anderson.hpp>
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf>
struct AndersonDirectionParams# - #include <alpaqa/inner/directions/panoc/anderson.hpp>
Parameters for the AndersonDirection class.
Public Members
-
bool rescale_on_step_size_changes = false#
Instead of flushing the buffer when the step size changes, rescale the buffer by a factor \( \gamma_k / \gamma_{k-1} \).
-
bool rescale_on_step_size_changes = false#
-
class AtomicStopSignal#
- #include <alpaqa/util/atomic-stop-signal.hpp>
Public Functions
-
AtomicStopSignal() = default#
-
inline AtomicStopSignal(const AtomicStopSignal&)#
-
AtomicStopSignal &operator=(const AtomicStopSignal&) = delete#
-
inline AtomicStopSignal(AtomicStopSignal&&) noexcept#
-
inline AtomicStopSignal &operator=(AtomicStopSignal&&) noexcept#
-
inline void stop()#
-
inline bool stop_requested() const#
-
AtomicStopSignal() = default#
-
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.
Subclassed by CasADiProblem< Conf >, FunctionalProblem< Conf >
Public Functions
-
inline BoxConstrProblem(length_t n, length_t m)#
Create a problem with inactive boxes \( (-\infty, +\infty) \), with no \( \ell_1 \)-regularization, and all general constraints handled using ALM.
- Parameters:
n – Number of decision variables
m – 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 void resize(length_t n, length_t m)#
Change the dimensions of the problem (number of decision variables and number of constaints).
Destructive: resizes and/or resets the members C, D, l1_reg and penalty_alm_split.
- Parameters:
n – Number of decision variables
m – Number of constraints
-
BoxConstrProblem(const BoxConstrProblem&) = default#
-
BoxConstrProblem &operator=(const BoxConstrProblem&) = default#
-
BoxConstrProblem(BoxConstrProblem&&) noexcept = default#
-
BoxConstrProblem &operator=(BoxConstrProblem&&) noexcept = default#
-
inline bool provides_get_box_C() const#
Only supported if the ℓ₁-regularization term is zero.
-
inline void check() const#
See also
-
inline std::string get_name() const#
See also
Public Members
-
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.
\[\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_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.
\[\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}\]
-
inline BoxConstrProblem(length_t n, length_t m)#
-
template<Config Conf>
class CasADiControlProblem# - #include <alpaqa/casadi/CasADiControlProblem.hpp>
Public Functions
-
~CasADiControlProblem()#
-
CasADiControlProblem(const CasADiControlProblem&)#
-
CasADiControlProblem &operator=(const CasADiControlProblem&)#
-
CasADiControlProblem(CasADiControlProblem&&) noexcept#
-
CasADiControlProblem &operator=(CasADiControlProblem&&) noexcept#
-
void load_numerical_data(const std::filesystem::path &filepath, char sep = ',')#
Load the numerical problem data (bounds and parameters) from a CSV file.
The file should contain 8 rows, with the following contents:
U lower bound [nu]
U upper bound [nu]
D lower bound [nc]
D upper bound [nc]
D_N lower bound [nc_N]
D_N upper bound [nc_N]
x_init [nx]
param [p]
Line endings are encoded using a single line feed (
\n), and the column separator can be specified using thesepargument.
-
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#
-
inline void check() const#
Public Members
-
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.
-
index_t penalty_alm_split_N = 0#
Same as penalty_alm_split, but for the terminal constraint.
-
~CasADiControlProblem()#
-
struct CasADiFunctions#
- #include <alpaqa/casadi/CasADiProblem.hpp>
Public Functions
-
~CasADiFunctions()#
Public Members
-
std::map<std::string, casadi::Function> functions#
-
~CasADiFunctions()#
-
template<Config Conf = EigenConfigd>
class CasADiProblem : public alpaqa::BoxConstrProblem<EigenConfigd># - #include <alpaqa/casadi/CasADiProblem.hpp>
Problem definition for a CasADi problem, loaded from a DLL.
Public Functions
-
CasADiProblem(const std::string &filename)#
Load a problem generated by CasADi (with parameters).
The file should contain functions with the names
f,grad_f,gandgrad_g. These functions evaluate the objective function, its gradient, the constraints, and the constraint gradient times a vector respectively. For second order solvers, additional functionshess_L,hess_ψ,hess_L_prodandhess_ψ_prodcan be provided to evaluate the Hessian of the (augmented) Lagrangian and Hessian-vector products.- Parameters:
filename – Filename of the shared library to load the functions from.
- Throws:
std::invalid_argument – The dimensions of the loaded functions do not match.
-
CasADiProblem(const SerializedCasADiFunctions &functions)#
Create a problem from a collection of serialized CasADi functions.
-
CasADiProblem(const CasADiFunctions &functions)#
Create a problem from a collection of CasADi functions.
-
~CasADiProblem()#
-
CasADiProblem(const CasADiProblem&)#
-
CasADiProblem &operator=(const CasADiProblem&)#
-
CasADiProblem(CasADiProblem&&) noexcept#
-
CasADiProblem &operator=(CasADiProblem&&) noexcept#
-
void load_numerical_data(const std::filesystem::path &filepath, char sep = ',')#
Load the numerical problem data (bounds and parameters) from a CSV file.
The file should contain 7 rows, with the following contents:
C lower bound [n]
C upper bound [n]
D lower bound [m]
D upper bound [m]
param [p]
l1_reg [0, 1 or n]
Line endings are encoded using a single line feed (
\n), and the column separator can be specified using thesepargument.
-
bool provides_eval_grad_L() const#
-
bool provides_eval_ψ() const#
See also
-
bool provides_eval_grad_ψ() const#
-
bool provides_eval_ψ_grad_ψ() const#
-
bool provides_eval_grad_gi() const#
-
bool provides_eval_jac_g() const#
-
bool provides_eval_hess_L_prod() const#
-
bool provides_eval_hess_L() const#
-
bool provides_eval_hess_ψ_prod() const#
-
bool provides_eval_hess_ψ() const#
-
std::string get_name() const#
See also
-
CasADiProblem(const std::string &filename)#
-
template<Config Conf = DefaultConfig>
struct CBFGSParams# - #include <alpaqa/accelerators/lbfgs.hpp>
Cautious BFGS update.
See also
Public Functions
-
inline explicit operator bool() const#
-
inline explicit operator bool() const#
-
template<class IndexT = size_t>
struct CircularIndexIterator# - #include <alpaqa/util/ringbuffer.hpp>
Public Types
-
using Indices = CircularIndices<Index>#
-
using reference = value_type#
-
using difference_type = std::ptrdiff_t#
-
using pointer = void#
-
using iterator_category = std::input_iterator_tag#
Public Functions
-
inline CircularIndexIterator()#
-
inline CircularIndexIterator &operator++()#
-
inline CircularIndexIterator &operator--()#
-
inline CircularIndexIterator operator++(int)#
-
inline CircularIndexIterator operator--(int)#
-
template<class IndexT>
bool operator==(CircularIndexIterator<IndexT> a, CircularIndexIterator<IndexT> b)# Note
Only valid for two indices in the same range.
-
template<class IndexT>
bool operator!=(CircularIndexIterator<IndexT> a, CircularIndexIterator<IndexT> b)# Note
Only valid for two indices in the same range.
-
using Indices = CircularIndices<Index>#
-
template<class IndexT = size_t>
struct CircularIndices# - #include <alpaqa/util/ringbuffer.hpp>
-
template<class IndexT>
bool operator==(CircularIndices<IndexT> a, CircularIndices<IndexT> b)# Note
Only valid for two indices in the same range.
-
template<class IndexT>
bool operator!=(CircularIndices<IndexT> a, CircularIndices<IndexT> b)# Note
Only valid for two indices in the same range.
-
template<class IndexT>
-
template<class IndexT>
class CircularRange# - #include <alpaqa/util/ringbuffer.hpp>
Public Types
-
using Indices = CircularIndices<Index>#
-
using const_iterator = CircularIndexIterator<Index>#
-
using iterator = const_iterator#
-
using const_reverse_iterator = ReverseCircularIndexIterator<Index>#
-
using reverse_iterator = const_reverse_iterator#
Public Functions
-
inline const_iterator cbegin() const#
-
inline const_iterator cend() const#
-
inline reverse_iterator rbegin() const#
-
inline reverse_iterator rend() const#
-
inline const_reverse_iterator crbegin() const#
-
inline const_reverse_iterator crend() const#
-
using Indices = CircularIndices<Index>#
-
template<Config Conf>
struct ControlProblemVTable : public BasicVTable# - #include <alpaqa/problem/ocproblem.hpp>
Public Types
-
template<class F>
using optional_function_t = util::BasicVTable::optional_function_t<F, ControlProblemVTable>#
Public Functions
-
ControlProblemVTable() = default#
Public Members
-
optional_function_t<void(Box &D) const> get_D = nullptr#
-
optional_function_t<void(Box &D) const> get_D_N = &default_get_D_N#
-
required_function_t<void(index_t timestep, crvec x, crvec u, crvec p, rvec grad_fxu_p) const> eval_grad_f_prod#
-
optional_function_t<void(crvec x, rvec h) const> eval_h_N = nullptr#
-
optional_function_t<void(crvec x, crvec h, rmat Q) const> eval_add_Q_N = &default_eval_add_Q_N#
-
required_function_t<void(index_t timestep, crvec xu, crvec h, crindexvec mask, rmat R, rvec work) const> eval_add_R_masked#
-
required_function_t<void(index_t timestep, crvec xu, crvec h, crindexvec mask, rmat S, rvec work) const> eval_add_S_masked#
-
optional_function_t<void(index_t timestep, crvec xu, crvec h, crindexvec mask_J, crindexvec mask_K, crvec v, rvec out, rvec work) const> eval_add_R_prod_masked = &default_eval_add_R_prod_masked#
-
optional_function_t<void(index_t timestep, crvec xu, crvec h, crindexvec mask_K, crvec v, rvec out, rvec work) const> eval_add_S_prod_masked = &default_eval_add_S_prod_masked#
-
optional_function_t<length_t() const> get_R_work_size = &default_get_R_work_size#
-
optional_function_t<length_t() const> get_S_work_size = &default_get_S_work_size#
-
optional_function_t<void(index_t timestep, crvec x, rvec c) const> eval_constr = nullptr#
-
optional_function_t<void(crvec x, rvec c) const> eval_constr_N = &default_eval_constr_N#
-
optional_function_t<void(index_t timestep, crvec x, crvec p, rvec grad_cx_p) const> eval_grad_constr_prod = nullptr#
-
optional_function_t<void(crvec x, crvec p, rvec grad_cx_p) const> eval_grad_constr_prod_N = &default_eval_grad_constr_prod_N#
-
optional_function_t<void(index_t timestep, crvec x, crvec M, rmat out) const> eval_add_gn_hess_constr = nullptr#
-
optional_function_t<void(crvec x, crvec M, rmat out) const> eval_add_gn_hess_constr_N = &default_eval_add_gn_hess_constr_N#
-
required_function_t<void() const> check#
Public Static Functions
-
static void default_get_D_N(const void *self, Box &D, const ControlProblemVTable &vtable)#
-
static void default_eval_add_Q_N(const void *self, crvec x, crvec h, rmat Q, const ControlProblemVTable &vtable)#
-
static void default_eval_add_R_prod_masked(const void*, index_t, crvec, crvec, crindexvec, crindexvec, crvec, rvec, rvec, const ControlProblemVTable&)#
-
static void default_eval_add_S_prod_masked(const void*, index_t, crvec, crvec, crindexvec, crvec, rvec, rvec, const ControlProblemVTable&)#
-
static length_t default_get_R_work_size(const void*, const ControlProblemVTable&)#
-
static length_t default_get_S_work_size(const void*, const ControlProblemVTable&)#
-
static void default_eval_constr_N(const void *self, crvec x, rvec c, const ControlProblemVTable &vtable)#
-
static void default_eval_grad_constr_prod_N(const void *self, crvec x, crvec p, rvec grad_cx_p, const ControlProblemVTable &vtable)#
-
static void default_eval_add_gn_hess_constr_N(const void *self, crvec x, crvec M, rmat out, const ControlProblemVTable &vtable)#
-
template<class F>
-
template<class Problem>
struct ControlProblemWithCounters# - #include <alpaqa/problem/ocproblem.hpp>
Public Types
-
using Box = typename TypeErasedControlProblem<config_t>::Box#
Public Functions
-
inline void eval_add_R_masked(index_t timestep, crvec xu, crvec h, crindexvec mask, rmat R, rvec work) const#
-
inline void eval_add_S_masked(index_t timestep, crvec xu, crvec h, crindexvec mask, rmat S, rvec work) const#
-
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#
-
inline void eval_add_S_prod_masked(index_t timestep, crvec xu, crvec h, crindexvec mask_K, crvec v, rvec out, rvec work) const#
-
inline void check() const#
-
inline bool provides_get_D() const#
-
inline bool provides_get_D_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#
-
ControlProblemWithCounters() = default#
-
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<OCPEvalCounter> evaluations = std::make_shared<OCPEvalCounter>()#
-
using Box = typename TypeErasedControlProblem<config_t>::Box#
-
template<Config Conf = DefaultConfig>
struct ConvexNewtonDirection# - #include <alpaqa/inner/directions/panoc/convex-newton.hpp>
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using DirectionParams = ConvexNewtonDirectionParams<config_t>#
-
using AcceleratorParams = ConvexNewtonRegularizationParams<config_t>#
Public Functions
-
ConvexNewtonDirection() = default#
-
inline ConvexNewtonDirection(const AcceleratorParams ¶ms, const DirectionParams &directionparams = {})#
-
inline void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0)#
See also
-
inline bool has_initial_direction() const#
-
inline bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ)#
See also
-
inline bool apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, rvec qₖ) const#
See also
-
inline void reset()#
See also
-
inline std::string get_name() const#
See also
-
inline const auto &get_params() const#
-
struct Params#
- #include <alpaqa/inner/directions/panoc/convex-newton.hpp>
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf>
struct ConvexNewtonDirectionParams# - #include <alpaqa/inner/directions/panoc/convex-newton.hpp>
Parameters for the ConvexNewtonDirection class.
-
template<Config Conf>
struct ConvexNewtonRegularizationParams# - #include <alpaqa/inner/directions/panoc/convex-newton.hpp>
Parameters for the ConvexNewtonDirection class.
-
class CUTEstLoader#
Public Types
-
using logical_vec = Eigen::VectorX<logical>#
Pointers to loaded problem functions.
Public Functions
-
inline CUTEstLoader(const char *so_fname, const char *outsdif_fname)#
-
inline std::string get_name()#
-
inline void get_report(double *calls, double *time)#
Public Members
-
std::shared_ptr<void> so_handle#
dlopen handle to shared library
-
cleanup_t cleanup_outsdif#
Responsible for closing the OUTSDIF.d file.
-
cleanup_t cutest_terminate#
Responsible for calling CUTEST_xterminate.
-
integer funit = 42#
Fortran Unit Number for OUTSDIF.d file.
-
integer iout = 6#
Fortran Unit Number for standard output.
-
integer io_buffer = 11#
Fortran Unit Number for internal IO.
-
integer nvar#
Number of decision variabls.
-
integer ncon#
Number of constraints.
-
ConstrFuncs funcs#
-
logical_vec equatn#
whether the constraint is an equality
-
logical_vec linear#
whether the constraint is linear
-
struct ConstrFuncs#
Public Members
-
using logical_vec = Eigen::VectorX<logical>#
-
class CUTEstProblem : public BoxConstrProblem<alpaqa::EigenConfigd>#
- #include <alpaqa/cutest/cutest-loader.hpp>
Wrapper for CUTEst problems loaded from an external shared library.
Public Functions
-
CUTEstProblem(const char *so_fname, const char *outsdif_fname = nullptr, bool sparse = false)#
Load a CUTEst problem from the given shared library and OUTSDIF.d file.
If
so_fnamepoints to a directory,"PROBLEM.so"is appended automatically. Ifoutsdif_fnameisnullptr, the same directory asso_fnameis used.
-
CUTEstProblem(const CUTEstProblem&)#
-
CUTEstProblem &operator=(const CUTEstProblem&)#
-
CUTEstProblem(CUTEstProblem&&) noexcept#
-
CUTEstProblem &operator=(CUTEstProblem&&) noexcept#
-
~CUTEstProblem()#
-
inline std::ostream &format_report(std::ostream &os) const#
-
inline std::string get_name() const#
Public Members
-
std::string name = "<UNKNOWN>"#
Problem name.
-
struct Report#
- #include <alpaqa/cutest/cutest-loader.hpp>
The report generated by CUTEst.
See also
Public Members
-
double time_setup = 0#
CPU time (in seconds) for CUTEST_csetup.
-
double time = 0#
CPU time (in seconds) since the end of CUTEST_csetup.
-
struct Calls#
- #include <alpaqa/cutest/cutest-loader.hpp>
Function call counters.
Note
Note that hessian_times_vector, constraints and constraints_grad may account for codes which allow the evaluation of a selection of constraints only and may thus be much smaller than the number of constraints times the number of iterations.
Public Members
-
unsigned objective = 0#
Number of calls to the objective function.
-
unsigned objective_grad = 0#
Number of calls to the objective gradient.
-
unsigned objective_hess = 0#
Number of calls to the objective Hessian.
-
unsigned hessian_times_vector = 0#
Number of Hessian times vector products.
-
unsigned constraints = 0#
Number of calls to the constraint functions.
-
unsigned constraints_grad = 0#
Number of calls to the constraint gradients.
-
unsigned constraints_hess = 0#
Number of calls to the constraint Hessians.
-
unsigned objective = 0#
-
double time_setup = 0#
-
CUTEstProblem(const char *so_fname, const char *outsdif_fname = nullptr, bool sparse = false)#
-
template<Config Conf>
struct Dim# - #include <alpaqa/inner/directions/panoc-ocp/lqr.hpp>
-
template<class RealT>
struct EigenConfig# - #include <alpaqa/config/config.hpp>
-
struct EigenConfigd : public EigenConfig<double>#
- #include <alpaqa/config/config.hpp>
Double-precision
doubleconfiguration.Public Static Functions
-
static inline constexpr const char *get_name()#
-
static inline constexpr const char *get_name()#
-
struct EigenConfigf : public EigenConfig<float>#
- #include <alpaqa/config/config.hpp>
Single-precision
floatconfiguration.Public Static Functions
-
static inline constexpr const char *get_name()#
-
static inline constexpr const char *get_name()#
-
struct EigenConfigl : public EigenConfig<long double>#
- #include <alpaqa/config/config.hpp>
long doubleconfiguration.(Quad precision on ARM64, 80-bit x87 floats on Intel/AMD x86)
Public Static Functions
-
static inline constexpr const char *get_name()#
-
static inline constexpr const char *get_name()#
-
struct EvalCounter#
- #include <alpaqa/problem/problem-counters.hpp>
Public Functions
-
inline void reset()#
Public Members
-
unsigned proj_diff_g = {}#
-
unsigned proj_multipliers = {}#
-
unsigned prox_grad_step = {}#
-
unsigned inactive_indices_res_lna = {}#
-
unsigned f = {}#
-
unsigned grad_f = {}#
-
unsigned f_grad_f = {}#
-
unsigned f_g = {}#
-
unsigned grad_f_grad_g_prod = {}#
-
unsigned g = {}#
-
unsigned grad_g_prod = {}#
-
unsigned grad_gi = {}#
-
unsigned jac_g = {}#
-
unsigned grad_L = {}#
-
unsigned hess_L_prod = {}#
-
unsigned hess_L = {}#
-
unsigned hess_ψ_prod = {}#
-
unsigned hess_ψ = {}#
-
unsigned ψ = {}#
-
unsigned grad_ψ = {}#
-
unsigned ψ_grad_ψ = {}#
-
struct alpaqa::EvalCounter::EvalTimer time#
-
struct EvalTimer#
- #include <alpaqa/problem/problem-counters.hpp>
Public Members
-
std::chrono::nanoseconds proj_diff_g = {}#
-
std::chrono::nanoseconds proj_multipliers = {}#
-
std::chrono::nanoseconds prox_grad_step = {}#
-
std::chrono::nanoseconds inactive_indices_res_lna = {}#
-
std::chrono::nanoseconds f = {}#
-
std::chrono::nanoseconds grad_f = {}#
-
std::chrono::nanoseconds f_grad_f = {}#
-
std::chrono::nanoseconds f_g = {}#
-
std::chrono::nanoseconds grad_f_grad_g_prod = {}#
-
std::chrono::nanoseconds g = {}#
-
std::chrono::nanoseconds grad_g_prod = {}#
-
std::chrono::nanoseconds grad_gi = {}#
-
std::chrono::nanoseconds jac_g = {}#
-
std::chrono::nanoseconds grad_L = {}#
-
std::chrono::nanoseconds hess_L_prod = {}#
-
std::chrono::nanoseconds hess_L = {}#
-
std::chrono::nanoseconds hess_ψ_prod = {}#
-
std::chrono::nanoseconds hess_ψ = {}#
-
std::chrono::nanoseconds ψ = {}#
-
std::chrono::nanoseconds grad_ψ = {}#
-
std::chrono::nanoseconds ψ_grad_ψ = {}#
-
std::chrono::nanoseconds proj_diff_g = {}#
-
inline void reset()#
-
template<Config Conf = DefaultConfig>
struct FISTAParams# - #include <alpaqa/inner/fista.hpp>
Tuning parameters for the FISTA algorithm.
Public Members
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
Parameters related to the Lipschitz constant estimate and step size.
-
unsigned max_iter = 1000#
Maximum number of inner FISTA iterations.
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
Maximum duration.
-
PANOCStopCrit stop_crit = PANOCStopCrit::ApproxKKT#
What stopping criterion to use.
-
unsigned max_no_progress = 10#
Maximum number of iterations without any progress before giving up.
-
unsigned print_interval = 0#
When to print progress.
If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
-
int print_precision = std::numeric_limits<real_t>::max_digits10 / 2#
The precision of the floating point values printed by the solver.
-
real_t quadratic_upperbound_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the quadratic upper bound condition that determines the step size.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that the step size γ becomes very small, you may want to increase this factor.
-
bool disable_acceleration = false#
Don’t compute accelerated steps, fall back to forward-backward splitting.
For testing purposes.
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
-
template<Config Conf = DefaultConfig>
struct FISTAProgressInfo# - #include <alpaqa/inner/fista.hpp>
Public Members
-
unsigned k#
-
SolverStatus status#
-
unsigned outer_iter#
-
const TypeErasedProblem<config_t> *problem#
-
const FISTAParams<config_t> *params#
-
unsigned k#
-
template<Config Conf>
class FISTASolver# - #include <alpaqa/inner/fista.hpp>
FISTA solver for ALM.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Params = FISTAParams<config_t>#
-
using Stats = FISTAStats<config_t>#
-
using ProgressInfo = FISTAProgressInfo<config_t>#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec err_z)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec e)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x)#
-
inline FISTASolver &set_progress_callback(std::function<void(const ProgressInfo&)> cb)#
Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.
See also
-
std::string get_name() const#
-
inline void stop()#
Public Members
-
std::ostream *os = &std::cout#
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct FISTAStats# - #include <alpaqa/inner/fista.hpp>
-
template<Config Conf = DefaultConfig>
class FunctionalProblem : public alpaqa::BoxConstrProblem<DefaultConfig># - #include <alpaqa/problem/functional-problem.hpp>
Problem class that allows specifying the basic functions as C++
std::functions.Public Functions
-
inline bool provides_eval_grad_gi() const#
-
inline bool provides_eval_jac_g() const#
-
inline bool provides_eval_hess_L_prod() const#
-
inline bool provides_eval_hess_L() const#
-
inline bool provides_eval_hess_ψ_prod() const#
-
inline bool provides_eval_hess_ψ() const#
-
inline std::string get_name() const#
See also
-
FunctionalProblem(const FunctionalProblem&) = default#
-
FunctionalProblem &operator=(const FunctionalProblem&) = default#
-
FunctionalProblem(FunctionalProblem&&) noexcept = default#
-
FunctionalProblem &operator=(FunctionalProblem&&) noexcept = default#
Public Members
-
inline bool provides_eval_grad_gi() const#
-
template<Config Conf>
struct InnerSolveOptions# - #include <alpaqa/inner/inner-solve-options.hpp>
Public Members
-
bool always_overwrite_results = true#
Return the final iterate and multipliers, even if the solver did not converge.
-
std::optional<std::chrono::nanoseconds> max_time = std::nullopt#
Maximum run time (in addition to the inner solver’s own timeout).
Zero means no timeout.
-
real_t tolerance = 0#
Desired tolerance (overrides the solver’s own tolerance).
Zero means no tolerance (use solver’s own tolerance).
-
std::ostream *os = nullptr#
Output stream to print to.
-
unsigned outer_iter = 0#
The current iteration of the outer solver.
-
bool check = true#
Call TypeErasedProblem::check() before starting to solve.
-
bool always_overwrite_results = true#
-
template<class InnerSolverStats>
struct InnerStatsAccumulator#
-
template<Config Conf>
struct InnerStatsAccumulator<FISTAStats<Conf>># - #include <alpaqa/inner/fista.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time in the inner solver.
-
std::chrono::nanoseconds time_progress_callback = {}#
Total time spent in the user-provided progress callback.
-
unsigned iterations = 0#
Total number of inner FISTA iterations.
-
unsigned stepsize_backtracks = 0#
Total number of FISTA step size reductions.
-
std::chrono::nanoseconds elapsed_time = {}#
- template<> LBFGSBStats >
- #include <alpaqa/lbfgsb/lbfgsb-adapter.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time in the inner solver.
-
std::chrono::nanoseconds time_progress_callback = {}#
Total time spent in the user-provided progress callback.
-
unsigned iterations = 0#
Total number of inner PANOC iterations.
-
unsigned lbfgs_rejected = 0#
Total number of times that the L-BFGS update was rejected (i.e.
it could have resulted in a non-positive definite Hessian estimate).
-
std::chrono::nanoseconds elapsed_time = {}#
- template<Config Conf> LBFGSBStats< Conf > >
- #include <alpaqa/lbfgsb-adapter.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}
Total elapsed time in the inner solver.
-
unsigned iterations = 0
Total number of inner PANOC iterations.
-
real_t final_ψ = 0
Final value of the smooth cost \( \psi(\hat x) \).
-
std::chrono::nanoseconds elapsed_time = {}
-
template<Config Conf>
struct InnerStatsAccumulator<PANOCOCPStats<Conf>># - #include <alpaqa/inner/panoc-ocp.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time in the inner solver.
-
std::chrono::nanoseconds time_prox = {}#
Total time spent computing proximal mappings.
-
std::chrono::nanoseconds time_forward = {}#
Total time spent doing forward simulations.
-
std::chrono::nanoseconds time_backward = {}#
Total time spent doing backward gradient evaluations.
-
std::chrono::nanoseconds time_jacobians = {}#
Total time spent computing dynamics Jacobians.
-
std::chrono::nanoseconds time_hessians = {}#
Total time spent computing cost Hessians and Hessian-vector products.
-
std::chrono::nanoseconds time_indices = {}#
Total time spent determining active indices.
-
std::chrono::nanoseconds time_lqr_factor = {}#
Total time spent performing LQR factorizations.
-
std::chrono::nanoseconds time_lqr_solve = {}#
Total time spent solving the (factorized) LQR problem.
-
std::chrono::nanoseconds time_lbfgs_indices = {}#
Total time spent determining active indices for L-BFGS applications.
-
std::chrono::nanoseconds time_lbfgs_apply = {}#
Total time spent applying L-BFGS estimates.
-
std::chrono::nanoseconds time_lbfgs_update = {}#
Total time spent updating the L-BFGS estimate.
-
std::chrono::nanoseconds time_progress_callback = {}#
Total time spent in the user-provided progress callback.
-
unsigned iterations = 0#
Total number of inner PANOC iterations.
-
unsigned linesearch_failures = 0#
Total number of PANOC line search failures.
-
unsigned linesearch_backtracks = 0#
Total number of PANOC line search backtracking steps.
-
unsigned stepsize_backtracks = 0#
Total number of PANOC step size reductions.
-
unsigned lbfgs_failures = 0#
Total number of times that the L-BFGS direction was not finite.
-
unsigned lbfgs_rejected = 0#
Total number of times that the L-BFGS update was rejected (i.e.
it could have resulted in a non-positive definite Hessian estimate).
-
unsigned τ_1_accepted = 0#
Total number of times that a line search parameter of \( \tau = 1 \) was accepted (i.e.
no backtracking necessary).
-
unsigned count_τ = 0#
The total number of line searches performed (used for computing the average value of \( \tau \)).
-
std::chrono::nanoseconds elapsed_time = {}#
-
template<Config Conf>
struct InnerStatsAccumulator<PANOCStats<Conf>># - #include <alpaqa/inner/panoc.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time in the inner solver.
-
std::chrono::nanoseconds time_progress_callback = {}#
Total time spent in the user-provided progress callback.
-
unsigned iterations = 0#
Total number of inner PANOC iterations.
-
unsigned linesearch_failures = 0#
Total number of PANOC line search failures.
-
unsigned linesearch_backtracks = 0#
Total number of PANOC line search backtracking steps.
-
unsigned stepsize_backtracks = 0#
Total number of PANOC step size reductions.
-
unsigned lbfgs_failures = 0#
Total number of times that the L-BFGS direction was not finite.
-
unsigned lbfgs_rejected = 0#
Total number of times that the L-BFGS update was rejected (i.e.
it could have resulted in a non-positive definite Hessian estimate).
-
unsigned τ_1_accepted = 0#
Total number of times that a line search parameter of \( \tau = 1 \) was accepted (i.e.
no backtracking necessary).
-
unsigned count_τ = 0#
The total number of line searches performed (used for computing the average value of \( \tau \)).
-
std::chrono::nanoseconds elapsed_time = {}#
-
template<Config Conf>
struct InnerStatsAccumulator<PANTRStats<Conf>># - #include <alpaqa/inner/pantr.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time in the inner solver.
-
std::chrono::nanoseconds time_progress_callback = {}#
Total time spent in the user-provided progress callback.
-
unsigned iterations = 0#
Total number of inner PANTR iterations.
-
unsigned accelerated_step_rejected = 0#
Total number of PANTR rejected accelerated steps.
-
unsigned stepsize_backtracks = 0#
Total number of FB step size reductions.
-
unsigned direction_failures = 0#
Total number of times that the accelerated direction was not finite.
-
unsigned direction_update_rejected = 0#
Total number of times that the direction update was rejected (e.g.
it could have resulted in a non-positive definite Hessian estimate).
-
std::chrono::nanoseconds elapsed_time = {}#
-
template<Config Conf>
struct InnerStatsAccumulator<WolfeStats<Conf>># - #include <alpaqa/inner/wolfe.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time in the inner solver.
-
std::chrono::nanoseconds time_progress_callback = {}#
Total time spent in the user-provided progress callback.
-
unsigned iterations = 0#
Total number of inner Wolfe iterations.
-
unsigned linesearch_failures = 0#
Total number of Wolfe line search failures.
-
unsigned linesearch_backtracks = 0#
Total number of Wolfe line search backtracking steps.
-
unsigned lbfgs_failures = 0#
Total number of times that the L-BFGS direction was not finite.
-
unsigned lbfgs_rejected = 0#
Total number of times that the L-BFGS update was rejected (i.e.
it could have resulted in a non-positive definite Hessian estimate).
-
unsigned τ_1_accepted = 0#
Total number of times that a line search parameter of \( \tau = 1 \) was accepted (i.e.
no backtracking necessary).
-
unsigned count_τ = 0#
The total number of line searches performed (used for computing the average value of \( \tau \)).
-
std::chrono::nanoseconds elapsed_time = {}#
-
template<Config Conf>
struct InnerStatsAccumulator<ZeroFPRStats<Conf>># - #include <alpaqa/inner/zerofpr.hpp>
Public Members
-
std::chrono::nanoseconds elapsed_time = {}#
Total elapsed time in the inner solver.
-
std::chrono::nanoseconds time_progress_callback = {}#
Total time spent in the user-provided progress callback.
-
unsigned iterations = 0#
Total number of inner ZeroFPR iterations.
-
unsigned linesearch_failures = 0#
Total number of ZeroFPR line search failures.
-
unsigned linesearch_backtracks = 0#
Total number of ZeroFPR line search backtracking steps.
-
unsigned stepsize_backtracks = 0#
Total number of ZeroFPR step size reductions.
-
unsigned lbfgs_failures = 0#
Total number of times that the L-BFGS direction was not finite.
-
unsigned lbfgs_rejected = 0#
Total number of times that the L-BFGS update was rejected (i.e.
it could have resulted in a non-positive definite Hessian estimate).
-
unsigned τ_1_accepted = 0#
Total number of times that a line search parameter of \( \tau = 1 \) was accepted (i.e.
no backtracking necessary).
-
unsigned count_τ = 0#
The total number of line searches performed (used for computing the average value of \( \tau \)).
-
std::chrono::nanoseconds elapsed_time = {}#
-
class IpoptAdapter : public TNLP#
- #include <alpaqa/ipopt/ipopt-adapter.hpp>
Based on https://coin-or.github.io/Ipopt/INTERFACES.html.
Functions required by Ipopt
-
bool get_nlp_info(Index &n, Index &m, Index &nnz_jac_g, Index &nnz_h_lag, IndexStyleEnum &index_style) override#
-
bool get_bounds_info(Index n, Number *x_l, Number *x_u, Index m, Number *g_l, Number *g_u) override#
-
bool get_starting_point(Index n, bool init_x, Number *x, bool init_z, Number *z_L, Number *z_U, Index m, bool init_lambda, Number *lambda) override#
-
bool eval_jac_g(Index n, const Number *x, bool new_x, Index m, Index nele_jac, Index *iRow, Index *jCol, Number *values) override#
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Index = Ipopt::Index#
-
using Number = Ipopt::Number#
Public Members
-
struct alpaqa::IpoptAdapter::Results results#
-
struct Results#
- #include <alpaqa/ipopt/ipopt-adapter.hpp>
-
bool get_nlp_info(Index &n, Index &m, Index &nnz_jac_g, Index &nnz_h_lag, IndexStyleEnum &index_style) override#
-
template<typename T>
struct is_complex_float : public false_type# - #include <alpaqa/util/float.hpp>
- template<std::floating_point T> complex< T > > : public true_type
- #include <alpaqa/util/float.hpp>
-
template<class T>
struct is_config : public false_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_config<EigenConfigd> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_config<EigenConfigf> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_config<EigenConfigl> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_config<EigenConfigq> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<class T>
struct is_eigen_config : public false_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_eigen_config<EigenConfigd> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_eigen_config<EigenConfigf> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_eigen_config<EigenConfigl> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<>
struct is_eigen_config<EigenConfigq> : public true_type# - #include <alpaqa/config/config.hpp>
-
template<Config Conf>
struct KKTError# - #include <alpaqa/problem/kkt-error.hpp>
Public Members
-
template<Config Conf = DefaultConfig>
class LBFGS# - #include <alpaqa/accelerators/lbfgs.hpp>
Limited memory Broyden–Fletcher–Goldfarb–Shanno (L-BFGS) algorithm.
Public Types
-
enum class Sign#
The sign of the vectors \( p \) passed to the update method.
Values:
-
enumerator Positive#
\( p \sim \nabla \psi(x) \)
-
enumerator Negative#
\( p \sim -\nabla \psi(x) \)
-
enumerator Positive#
-
using Params = LBFGSParams<config_t>#
Public Functions
-
LBFGS() = default#
-
bool update_sy(crvec s, crvec y, real_t pₙₑₓₜᵀpₙₑₓₜ, bool forced = false)#
Update the inverse Hessian approximation using the new vectors sₖ = xₙₑₓₜ - xₖ and yₖ = pₙₑₓₜ - pₖ.
-
bool update_sy_impl(const auto &s, const auto &y, real_t pₙₑₓₜᵀpₙₑₓₜ, bool forced = false)#
See also
-
bool update(crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, Sign sign = Sign::Positive, bool forced = false)#
Update the inverse Hessian approximation using the new vectors xₙₑₓₜ and pₙₑₓₜ.
-
bool apply(rvec q, real_t γ = -1) const#
Apply the inverse Hessian approximation to the given vector q.
Initial inverse Hessian approximation is set to \( H_0 = \gamma I \). If
γis negative, \( H_0 = \frac{s^\top y}{y^\top y} I \).
-
bool apply_masked(rvec q, real_t γ, crindexvec J) const#
Apply the inverse Hessian approximation to the given vector q, applying only the columns and rows of the Hessian in the index set J.
-
bool apply_masked(rvec q, real_t γ, const std::vector<index_t> &J) const#
Apply the inverse Hessian approximation to the given vector q, applying only the columns and rows of the Hessian in the index set J.
-
bool apply_masked_impl(rvec q, real_t γ, const auto &J) const#
Apply the inverse Hessian approximation to the given vector q, applying only the columns and rows of the Hessian in the index set J.
-
void reset()#
Throw away the approximation and all previous vectors s and y.
-
inline std::string get_name() const#
Get a string identifier for this accelerator.
-
inline index_t succ(index_t i) const#
Get the next index in the circular buffer of previous s and y vectors.
-
inline index_t pred(index_t i) const#
Get the previous index in the circular buffer of s and y vectors.
-
inline length_t current_history() const#
Get the number of previous s and y vectors currently stored in the buffer.
-
enum class Sign#
-
template<Config Conf>
struct LBFGSDirection# - #include <alpaqa/inner/directions/panoc/lbfgs.hpp>
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using DirectionParams = LBFGSDirectionParams<config_t>#
Public Functions
-
LBFGSDirection() = default#
-
inline LBFGSDirection(const typename LBFGS::Params ¶ms, const DirectionParams &directionparams = {})#
-
inline LBFGSDirection(const LBFGS &lbfgs, const DirectionParams &directionparams = {})#
-
inline LBFGSDirection(LBFGS &&lbfgs, const DirectionParams &directionparams = {})#
-
inline void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0)#
See also
-
inline bool has_initial_direction() const#
-
inline bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ)#
See also
-
inline bool apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, rvec qₖ) const#
See also
-
inline void reset()#
See also
-
inline std::string get_name() const#
See also
-
inline auto get_params() const#
-
struct Params#
- #include <alpaqa/inner/directions/panoc/lbfgs.hpp>
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf>
struct LBFGSDirectionParams# - #include <alpaqa/inner/directions/panoc/lbfgs.hpp>
Parameters for the LBFGSDirection class.
Public Members
-
bool rescale_on_step_size_changes = false#
Instead of flushing the buffer when the step size changes, rescale the buffer by a factor \( \gamma_k / \gamma_{k-1} \).
-
bool rescale_on_step_size_changes = false#
-
template<Config Conf = DefaultConfig>
struct LBFGSParams# - #include <alpaqa/accelerators/lbfgs.hpp>
Parameters for the LBFGS class.
Public Members
-
real_t min_div_fac = std::numeric_limits<real_t>::epsilon()#
Reject update if \( y^\top s \le \text{min_div_fac} \cdot s^\top s \).
Keeps the inverse Hessian approximation positive definite.
-
real_t min_abs_s = std::pow(std::numeric_limits<real_t>::epsilon(), real_t(2))#
Reject update if \( s^\top s \le \text{min_abs_s} \).
Keeps the Hessian approximation nonsingular.
-
CBFGSParams<config_t> cbfgs = {}#
Parameters in the cautious BFGS update condition.
Disabled by default.\[ \frac{y^\top s}{s^\top s} \ge \epsilon \| g \|^\alpha. \]
-
bool force_pos_def = true#
If set to true, the inverse Hessian estimate should remain definite, i.e.
a check is performed that rejects the update if \( y^\top s \le \text{min_div_fac} \cdot s^\top s \). If set to false, just try to prevent a singular Hessian by rejecting the update if \( \left| y^\top s \right| \le \text{min_div_fac} \cdot s^\top s \).
-
LBFGSStepSize stepsize = LBFGSStepSize::BasedOnCurvature#
Scale of the initial inverse Hessian approximation that the rank-one L-BFGS updates are applied to, \( H_0 \).
You probably want to keep this as the default.
See also
-
real_t min_div_fac = std::numeric_limits<real_t>::epsilon()#
-
template<Config Conf = DefaultConfig>
struct LBFGSStorage# - #include <alpaqa/accelerators/lbfgs.hpp>
Layout:
┌───── 2 m ─────┐ ┌ ┌───┬───┬───┬───┐ │ │ │ │ │ │ │ │ s │ y │ s │ y │ n+1 │ │ │ │ │ │ │ ├───┼───┼───┼───┤ │ │ ρ │ α │ ρ │ α │ └ └───┴───┴───┴───┘Public Functions
-
template<Config Conf = DefaultConfig>
class LimitedMemoryQR# - #include <alpaqa/accelerators/internal/limited-memory-qr.hpp>
Incremental QR factorization using modified Gram-Schmidt with reorthogonalization.
Computes A = QR while allowing efficient removal of the first column of A or adding new columns at the end of A.
Public Types
Public Functions
-
LimitedMemoryQR() = default#
-
inline LimitedMemoryQR(length_t n, length_t m)#
The maximum dimensions of Q are n×m and the maximum dimensions of R are m×m.
- Parameters:
n – The size of the vectors, the number of rows of A.
m – The maximum number of columns of A.
-
inline void remove_column()#
Remove the leftmost column.
-
template<class VecB, class VecX>
inline void solve_col(const VecB &b, VecX &x, real_t tol = 0) const# Solve the least squares problem Ax = b.
Do not divide by elements that are smaller in absolute value than
tol.
-
template<class MatB, class MatX>
inline void solve(const MatB &B, MatX &X, real_t tol = 0) const# Solve the least squares problem AX = B.
Do not divide by elements that are smaller in absolute value than
tol.
-
template<class Derived>
inline solve_ret_t<Derived> solve(const Eigen::DenseBase<Derived> &B)# Solve the least squares problem AX = B.
-
inline const mat &get_raw_R() const#
Get the full, raw storage for the upper triangular matrix R.
The columns of this matrix are permuted because it’s stored as a circular buffer for efficiently appending columns to the end and popping columns from the front.
-
inline mat get_full_R() const#
Get the full storage for the upper triangular matrix R but with the columns in the correct order.
Note
Meant for tests only, creates a permuted copy.
-
inline mat get_R() const#
Get the matrix R such that Q times R is the original matrix.
Note
Meant for tests only, creates a permuted copy.
-
inline mat get_Q() const#
Get the matrix Q such that Q times R is the original matrix.
Note
Meant for tests only, creates a copy.
-
inline unsigned long get_reorth_count() const#
Get the number of MGS reorthogonalizations.
-
inline void clear_reorth_count()#
Reset the number of MGS reorthogonalizations.
-
inline void reset()#
Reset all indices, clearing the Q and R matrices.
-
inline void resize(length_t n, length_t m)#
Re-allocate storage for a problem with a different size.
Causes a reset.
-
inline index_t ring_head() const#
Get the head index of the circular buffer (points to the oldest element).
-
inline index_t ring_tail() const#
Get the tail index of the circular buffer (points to one past the most recent element).
-
inline CircularRange<index_t> ring_iter() const#
Get iterators in the circular buffer.
-
inline ReverseCircularRange<index_t> ring_reverse_iter() const#
Get reverse iterators in the circular buffer.
-
LimitedMemoryQR() = default#
-
template<Config Conf = DefaultConfig>
struct LipschitzEstimateParams# - #include <alpaqa/inner/internal/lipschitz.hpp>
Parameters for the estimation of the Lipschitz constant of the gradient of the smooth term of the cost.
This is needed to select a suitable step size for the forward-backward iterations used by solvers like PANOC and PANTR.
-
template<class T>
class MaxHistory# - #include <alpaqa/util/max-history.hpp>
Keep track of the maximum value over a specified horizon length.
-
template<Config Conf>
struct NewtonTRDirection# - #include <alpaqa/inner/directions/pantr/newton-tr.hpp>
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using AcceleratorParams = SteihaugCGParams<config_t>#
-
using DirectionParams = NewtonTRDirectionParams<config_t>#
Public Functions
-
NewtonTRDirection() = default#
-
inline NewtonTRDirection(const AcceleratorParams ¶ms, const DirectionParams &directionparams = {})#
-
inline void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0)#
See also
-
inline bool has_initial_direction() const#
-
inline bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ)#
See also
-
inline real_t apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, real_t radius, rvec qₖ) const#
See also
-
inline void reset()#
See also
-
inline std::string get_name() const#
See also
-
inline auto get_params() const#
-
struct Params#
- #include <alpaqa/inner/directions/pantr/newton-tr.hpp>
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf>
struct NewtonTRDirectionParams# - #include <alpaqa/inner/directions/pantr/newton-tr.hpp>
Parameters for the NewtonTRDirection class.
Public Members
-
real_t hessian_vec_factor = real_t(1)#
The factor in front of the term \( \langle H_{\mathcal{JK}} d_{\mathcal {K}}, d_{\mathcal{J}} \rangle \) in equation (9) in [1].
Set it to zero to leave out that term (this usually only slightly increases the number of iterations, and eliminates one Hessian-vector product per iteration, improving the overall runtime).
-
bool finite_diff = false#
Use finite differences to compute Hessian-vector products.
-
real_t hessian_vec_factor = real_t(1)#
-
template<Config Conf>
struct NoopDirection# - #include <alpaqa/inner/directions/panoc/noop.hpp>
Direction provider that provides no directions (apply always returns false).
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using AcceleratorParams = std::monostate#
-
using DirectionParams = std::monostate#
Public Functions
-
NoopDirection() = default#
-
inline NoopDirection(AcceleratorParams, DirectionParams)#
-
inline void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0)#
See also
-
inline bool has_initial_direction() const#
-
inline bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ)#
See also
-
inline bool apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, rvec qₖ) const#
See also
-
inline void reset()#
See also
-
inline std::string get_name() const#
See also
-
inline void get_params() const#
-
struct Params#
- #include <alpaqa/inner/directions/panoc/noop.hpp>
-
using Problem = TypeErasedProblem<config_t>#
-
struct not_implemented_error : public logic_error#
- #include <alpaqa/util/not-implemented.hpp>
-
template<Config Conf>
struct OCPDim# - #include <alpaqa/problem/ocproblem.hpp>
-
struct OCPEvalCounter#
- #include <alpaqa/problem/ocproblem-counters.hpp>
Public Functions
-
inline void reset()#
Public Members
-
unsigned f = {}#
-
unsigned jac_f = {}#
-
unsigned grad_f_prod = {}#
-
unsigned h = {}#
-
unsigned h_N = {}#
-
unsigned l = {}#
-
unsigned l_N = {}#
-
unsigned qr = {}#
-
unsigned q_N = {}#
-
unsigned add_Q = {}#
-
unsigned add_Q_N = {}#
-
unsigned add_R_masked = {}#
-
unsigned add_S_masked = {}#
-
unsigned add_R_prod_masked = {}#
-
unsigned add_S_prod_masked = {}#
-
unsigned constr = {}#
-
unsigned constr_N = {}#
-
unsigned grad_constr_prod = {}#
-
unsigned grad_constr_prod_N = {}#
-
unsigned add_gn_hess_constr = {}#
-
unsigned add_gn_hess_constr_N = {}#
-
struct alpaqa::OCPEvalCounter::OCPEvalTimer time#
-
struct OCPEvalTimer#
- #include <alpaqa/problem/ocproblem-counters.hpp>
Public Members
-
std::chrono::nanoseconds f = {}#
-
std::chrono::nanoseconds jac_f = {}#
-
std::chrono::nanoseconds grad_f_prod = {}#
-
std::chrono::nanoseconds h = {}#
-
std::chrono::nanoseconds h_N = {}#
-
std::chrono::nanoseconds l = {}#
-
std::chrono::nanoseconds l_N = {}#
-
std::chrono::nanoseconds qr = {}#
-
std::chrono::nanoseconds q_N = {}#
-
std::chrono::nanoseconds add_Q = {}#
-
std::chrono::nanoseconds add_Q_N = {}#
-
std::chrono::nanoseconds add_R_masked = {}#
-
std::chrono::nanoseconds add_S_masked = {}#
-
std::chrono::nanoseconds add_R_prod_masked = {}#
-
std::chrono::nanoseconds add_S_prod_masked = {}#
-
std::chrono::nanoseconds constr = {}#
-
std::chrono::nanoseconds constr_N = {}#
-
std::chrono::nanoseconds grad_constr_prod = {}#
-
std::chrono::nanoseconds grad_constr_prod_N = {}#
-
std::chrono::nanoseconds add_gn_hess_constr = {}#
-
std::chrono::nanoseconds add_gn_hess_constr_N = {}#
-
std::chrono::nanoseconds f = {}#
-
inline void reset()#
-
template<Config Conf>
struct OCPEvaluator# - #include <alpaqa/inner/directions/panoc-ocp/ocp-vars.hpp>
Public Types
-
using OCPVars = OCPVariables<config_t>#
-
using Problem = TypeErasedControlProblem<config_t>#
Public Functions
-
inline real_t forward(rvec storage, const Box &D, const Box &D_N, crvec μ, crvec y) const#
- Pre:
x0 and u initialized
- Post:
x, h and c updated
- Returns:
\( V(u) = \sum_{k=0}^{N-1} \ell(h_k(x_k, u_k)) + V_f(h_N(x_N)) \)
-
inline void backward(rvec storage, rvec g, const auto &qr, const auto &q_N, const Box &D, const Box &D_N, crvec μ, crvec y) const#
- Pre:
x, u, h and c initialized (i.e. forward was called)
-
inline void Qk(crvec storage, crvec y, crvec μ, const Box &D, const Box &D_N, index_t k, rmat out) const#
-
inline void Rk(crvec storage, index_t k, crindexvec mask, rmat out)#
- Post:
initialize work_R
-
inline void Sk(crvec storage, index_t k, crindexvec mask, rmat out)#
- Post:
initialize work_S
-
inline void Rk_prod(crvec storage, index_t k, crindexvec mask_J, crindexvec mask_K, crvec v, rvec out) const#
- Pre:
initialized work_R
Public Members
-
using OCPVars = OCPVariables<config_t>#
-
template<Config Conf>
struct OCPVariables# - #include <alpaqa/inner/directions/panoc-ocp/ocp-vars.hpp>
Public Types
-
struct OwningQPALMData : public QPALMData#
- #include <alpaqa/qpalm/qpalm-adapter.hpp>
-
struct Storage#
- #include <alpaqa/qpalm/qpalm-adapter.hpp>
-
struct Storage#
-
template<Config Conf>
struct PANOCDirection# - #include <alpaqa/inner/directions/panoc-direction-update.hpp>
This class outlines the interface for direction providers used by PANOC-like algorithms.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
Public Functions
-
void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0) = delete#
Initialize the direction provider.
The references
problem,yandΣare guaranteed to remain valid for subsequent calls to update, apply, changed_γ and reset.- Parameters:
problem – [in] Problem description.
y – [in] Lagrange multipliers.
Σ – [in] Penalty factors.
γ_0 – [in] Initial step size.
x_0 – [in] Initial iterate.
x̂_0 – [in] Result of proximal gradient step in
x_0.p_0 – [in] Proximal gradient step in
x_0.grad_ψx_0 – [in] Gradient of the objective in
x_0.
-
bool has_initial_direction() const = delete#
Return whether a direction is available on the very first iteration, before the first call to update.
-
bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ) = delete#
Update the direction provider when accepting the next iterate.
- Parameters:
γₖ – [in] Current step size.
γₙₑₓₜ – [in] Step size for the next iterate.
xₖ – [in] Current iterate.
xₙₑₓₜ – [in] Next iterate.
pₖ – [in] Proximal gradient step in the current iterate.
pₙₑₓₜ – [in] Proximal gradient step in the next iterate.
grad_ψxₖ – [in] Gradient of the objective in the current iterate.
grad_ψxₙₑₓₜ – [in] Gradient of the objective in the next iterate.
-
bool apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, rvec qₖ) const = delete#
Apply the direction estimation in the current point.
- Parameters:
γₖ – [in] Current step size.
xₖ – [in] Current iterate.
x̂ₖ – [in] Result of proximal gradient step in
xₖ.pₖ – [in] Proximal gradient step in
xₖ.grad_ψxₖ – [in] Gradient of the objective at
xₖ.qₖ – [out] Resulting step.
-
void reset() = delete#
Called when using the direction failed.
A possible behavior could be to flush the buffers, hopefully yielding a better direction on the next iteration.
-
std::string get_name() const = delete#
Get a human-readable name for this direction provider.
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct PANOCOCPParams# - #include <alpaqa/inner/panoc-ocp.hpp>
Tuning parameters for the PANOC algorithm.
Public Members
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
Parameters related to the Lipschitz constant estimate and step size.
-
unsigned max_iter = 100#
Maximum number of inner PANOC iterations.
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
Maximum duration.
-
real_t min_linesearch_coefficient = real_t(1. / 256)#
Minimum weight factor between Newton step and projected gradient step, line search parameter.
-
real_t linesearch_strictness_factor = real_t(0.95)#
Parameter β used in the line search (see Algorithm 2 in [2]).
\( 0 < \beta < 1 \)
-
unsigned L_max_inc = 16#
Maximum number of times to double the Lipschitz constant estimate per iteration.
-
PANOCStopCrit stop_crit = PANOCStopCrit::ApproxKKT#
What stopping criterion to use.
-
unsigned max_no_progress = 10#
Maximum number of iterations without any progress before giving up.
-
unsigned gn_interval = 1#
How often to use a Gauss-Newton step. Zero to disable GN entirely.
-
bool gn_sticky = true#
Keep trying to apply a Gauss-Newton step as long as they keep getting accepted with step size one.
-
bool reset_lbfgs_on_gn_step = false#
Flush the L-BFGS buffer when a Gauss-Newton step is accepted.
-
bool lqr_factor_cholesky = true#
Use a Cholesky factorization for the Riccati recursion.
Use LU if set to false.
-
LBFGSParams<config_t> lbfgs_params#
L-BFGS parameters (e.g. memory).
-
unsigned print_interval = 0#
When to print progress.
If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
-
int print_precision = std::numeric_limits<real_t>::max_digits10 / 2#
The precision of the floating point values printed by the solver.
-
real_t quadratic_upperbound_tolerance_factor = real_t(1e2) * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the quadratic upper bound condition that determines the step size.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that the step size γ becomes very small, you may want to increase this factor.
-
real_t linesearch_tolerance_factor = real_t(1e2) * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the line search.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that accelerated steps are rejected (τ = 0) when getting closer to the solution, you may want to increase this factor.
-
bool disable_acceleration = false#
Don’t compute accelerated steps, fall back to forward-backward splitting.
For testing purposes.
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
-
template<Config Conf = DefaultConfig>
struct PANOCOCPProgressInfo# - #include <alpaqa/inner/panoc-ocp.hpp>
Public Members
-
unsigned k#
-
SolverStatus status#
-
bool gn#
-
unsigned outer_iter#
-
const TypeErasedControlProblem<config_t> *problem#
-
const PANOCOCPParams<config_t> *params#
-
unsigned k#
-
template<Config Conf>
class PANOCOCPSolver# - #include <alpaqa/inner/panoc-ocp.hpp>
Public Types
-
using Problem = alpaqa::TypeErasedControlProblem<config_t>#
-
using Params = PANOCOCPParams<config_t>#
-
using Stats = PANOCOCPStats<config_t>#
-
using ProgressInfo = PANOCOCPProgressInfo<config_t>#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec u, rvec y, crvec μ, rvec err_z)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec u, rvec y, crvec μ, rvec e)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec u)#
-
inline PANOCOCPSolver &set_progress_callback(std::function<void(const ProgressInfo&)> cb)#
Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.
See also
-
std::string get_name() const#
-
inline void stop()#
Public Members
-
std::ostream *os = &std::cout#
-
using Problem = alpaqa::TypeErasedControlProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct PANOCOCPStats# - #include <alpaqa/inner/panoc-ocp.hpp>
Public Members
-
SolverStatus status = SolverStatus::Busy#
-
std::chrono::nanoseconds elapsed_time = {}#
-
std::chrono::nanoseconds time_prox = {}#
-
std::chrono::nanoseconds time_forward = {}#
-
std::chrono::nanoseconds time_backward = {}#
-
std::chrono::nanoseconds time_jacobians = {}#
-
std::chrono::nanoseconds time_hessians = {}#
-
std::chrono::nanoseconds time_indices = {}#
-
std::chrono::nanoseconds time_lqr_factor = {}#
-
std::chrono::nanoseconds time_lqr_solve = {}#
-
std::chrono::nanoseconds time_lbfgs_indices = {}#
-
std::chrono::nanoseconds time_lbfgs_apply = {}#
-
std::chrono::nanoseconds time_lbfgs_update = {}#
-
std::chrono::nanoseconds time_progress_callback = {}#
-
unsigned iterations = 0#
-
unsigned linesearch_failures = 0#
-
unsigned linesearch_backtracks = 0#
-
unsigned stepsize_backtracks = 0#
-
unsigned lbfgs_failures = 0#
-
unsigned lbfgs_rejected = 0#
-
unsigned τ_1_accepted = 0#
-
unsigned count_τ = 0#
-
SolverStatus status = SolverStatus::Busy#
-
template<Config Conf = DefaultConfig>
struct PANOCParams# - #include <alpaqa/inner/panoc.hpp>
Tuning parameters for the PANOC algorithm.
Public Members
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
Parameters related to the Lipschitz constant estimate and step size.
-
unsigned max_iter = 100#
Maximum number of inner PANOC iterations.
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
Maximum duration.
-
real_t min_linesearch_coefficient = real_t(1. / 256)#
Minimum weight factor between Newton step and projected gradient step.
-
real_t linesearch_coefficient_update_factor = real_t(0.5)#
Factor to decrease the line search factor by after a line search failure.
-
bool force_linesearch = false#
Ignore the line search condition and always accept the accelerated step.
(For testing purposes only).
-
real_t linesearch_strictness_factor = real_t(0.95)#
Parameter β used in the line search (see Algorithm 2 in [2]).
\( 0 < \beta < 1 \)
-
PANOCStopCrit stop_crit = PANOCStopCrit::ApproxKKT#
What stopping criterion to use.
-
unsigned max_no_progress = 10#
Maximum number of iterations without any progress before giving up.
-
unsigned print_interval = 0#
When to print progress.
If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
-
int print_precision = std::numeric_limits<real_t>::max_digits10 / 2#
The precision of the floating point values printed by the solver.
-
real_t quadratic_upperbound_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the quadratic upper bound condition that determines the step size.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that the step size γ becomes very small, you may want to increase this factor.
-
real_t linesearch_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the line search.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that accelerated steps are rejected (τ = 0) when getting closer to the solution, you may want to increase this factor.
-
bool update_direction_in_candidate = false#
Use the candidate point rather than the accepted point to update the quasi-Newton direction.
-
bool recompute_last_prox_step_after_stepsize_change = false#
If the step size changes, the direction buffer is flushed.
The current step will still be used to update the direction, but may still use the old step size. If set to true, the current step will be recomputed with the new step size as well, to match the step in the candidate iterate.
-
bool eager_gradient_eval = false#
When evaluating ψ(x̂) in a candidate point, always evaluate ∇ψ(x̂) as well.
Can be beneficial if computing ∇ψ(x̂) is not much more expensive than computing just ψ(x), and if ∇ψ(x̂) is required in the next iteration (e.g. for the stopping criterion, or when using the NoopDirection).
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
-
template<Config Conf = DefaultConfig>
struct PANOCProgressInfo# - #include <alpaqa/inner/panoc.hpp>
Public Members
-
unsigned k#
-
SolverStatus status#
-
unsigned outer_iter#
-
const TypeErasedProblem<config_t> *problem#
-
const PANOCParams<config_t> *params#
-
unsigned k#
-
template<class DirectionT>
class PANOCSolver# - #include <alpaqa/inner/panoc.hpp>
PANOC solver for ALM.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Params = PANOCParams<config_t>#
-
using Direction = DirectionT#
-
using Stats = PANOCStats<config_t>#
-
using ProgressInfo = PANOCProgressInfo<config_t>#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec err_z)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec e)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x)#
-
inline PANOCSolver &set_progress_callback(std::function<void(const ProgressInfo&)> cb)#
Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.
See also
-
std::string get_name() const#
-
inline void stop()#
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct PANOCStats# - #include <alpaqa/inner/panoc.hpp>
Public Members
-
SolverStatus status = SolverStatus::Busy#
-
std::chrono::nanoseconds elapsed_time = {}#
-
std::chrono::nanoseconds time_progress_callback = {}#
-
unsigned iterations = 0#
-
unsigned linesearch_failures = 0#
-
unsigned linesearch_backtracks = 0#
-
unsigned stepsize_backtracks = 0#
-
unsigned lbfgs_failures = 0#
-
unsigned lbfgs_rejected = 0#
-
unsigned τ_1_accepted = 0#
-
unsigned count_τ = 0#
-
SolverStatus status = SolverStatus::Busy#
-
template<Config Conf>
struct PANTRDirection# - #include <alpaqa/inner/directions/pantr/pantr-direction.hpp>
This class outlines the interface for direction providers used by PANTR-like algorithms.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
Public Functions
-
void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0) = delete#
Initialize the direction provider.
The references
problem,yandΣare guaranteed to remain valid for subsequent calls to update, apply, changed_γ and reset.- Parameters:
problem – [in] Problem description.
y – [in] Lagrange multipliers.
Σ – [in] Penalty factors.
γ_0 – [in] Initial step size.
x_0 – [in] Initial iterate.
x̂_0 – [in] Result of proximal gradient step in
x_0.p_0 – [in] Proximal gradient step in
x_0.grad_ψx_0 – [in] Gradient of the objective in
x_0.
-
inline bool has_initial_direction() const#
Return whether a direction is available on the very first iteration, before the first call to update.
-
bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ) = delete#
Update the direction provider when accepting the next iterate.
- Parameters:
γₖ – [in] Current step size.
γₙₑₓₜ – [in] Step size for the next iterate.
xₖ – [in] Current iterate.
xₙₑₓₜ – [in] Next iterate.
pₖ – [in] Proximal gradient step in the current iterate.
pₙₑₓₜ – [in] Proximal gradient step in the next iterate.
grad_ψxₖ – [in] Gradient of the objective in the current iterate.
grad_ψxₙₑₓₜ – [in] Gradient of the objective in the next iterate.
-
real_t apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, real_t radius, rvec qₖ) const = delete#
Compute the direction in the given point.
- Parameters:
γₖ – [in] Current step size.
xₖ – [in] Current iterate.
x̂ₖ – [in] Result of proximal gradient step in
xₖ.pₖ – [in] Proximal gradient step in
xₖ.grad_ψxₖ – [in] Gradient of the objective at
xₖ.radius – [in] Trust radius Δ.
qₖ – [out] Resulting step.
- Returns:
Model decrease.
-
void reset() = delete#
Called when using the direction failed.
A possible behavior could be to flush the buffers, hopefully yielding a better direction on the next iteration.
-
std::string get_name() const = delete#
Get a human-readable name for this direction provider.
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct PANTRParams# - #include <alpaqa/inner/pantr.hpp>
Tuning parameters for the PANTR algorithm.
Public Members
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
Parameters related to the Lipschitz constant estimate and step size.
-
unsigned max_iter = 100#
Maximum number of inner PANTR iterations.
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
Maximum duration.
-
PANOCStopCrit stop_crit = PANOCStopCrit::ApproxKKT#
What stopping criterion to use.
-
unsigned max_no_progress = 10#
Maximum number of iterations without any progress before giving up.
-
unsigned print_interval = 0#
When to print progress.
If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
-
int print_precision = std::numeric_limits<real_t>::max_digits10 / 2#
The precision of the floating point values printed by the solver.
-
real_t quadratic_upperbound_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the quadratic upper bound condition that determines the step size.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that the step size γ becomes very small, you may want to increase this factor.
-
bool compute_ratio_using_new_stepsize = false#
Check the quadratic upperbound and update γ before computing the reduction of the TR step.
-
bool update_direction_on_prox_step = true#
-
bool recompute_last_prox_step_after_direction_reset = false#
-
bool disable_acceleration = false#
Don’t compute accelerated steps, fall back to forward-backward splitting.
For testing purposes.
-
bool ratio_approx_fbe_quadratic_model = true#
Compute the trust-region ratio using an approximation of the quadratic model of the FBE, rather than the quadratic model of the subproblem.
Specifically, when set to false, the quadratic model used is
When set to true, the quadratic model used is\[ q(d) = \tfrac12 \inprod{\mathcal R_\gamma(\hat x) d}{d} + \inprod{R_\gamma(\hat x)}{d}. \]where \( \alpha = \) LipschitzEstimateParams::Lγ_factor. This is an approximation of the quadratic model of the FBE,\[ q_\mathrm{approx}(d) = \inv{(1-\alpha)} q(d), \]with \( \mathcal Q_\gamma(x) = \Id - \gamma \nabla^2 \psi(x) \).\[ q_{\varphi_\gamma}(d) = \tfrac12 \inprod{\mathcal Q_\gamma(\hat x) \mathcal R_\gamma(\hat x) d}{d} + \inprod{\mathcal Q_\gamma(\hat x) R_\gamma(\hat x)}{d}, \]
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
-
template<Config Conf = DefaultConfig>
struct PANTRProgressInfo# - #include <alpaqa/inner/pantr.hpp>
Public Members
-
unsigned k#
-
SolverStatus status#
-
unsigned outer_iter#
-
const TypeErasedProblem<config_t> *problem#
-
const PANTRParams<config_t> *params#
-
unsigned k#
-
template<class DirectionT>
class PANTRSolver# - #include <alpaqa/inner/pantr.hpp>
PANTR solver for ALM.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Params = PANTRParams<config_t>#
-
using Direction = DirectionT#
-
using Stats = PANTRStats<config_t>#
-
using ProgressInfo = PANTRProgressInfo<config_t>#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec err_z)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec e)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x)#
-
inline PANTRSolver &set_progress_callback(std::function<void(const ProgressInfo&)> cb)#
Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.
See also
-
std::string get_name() const#
-
inline void stop()#
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct PANTRStats# - #include <alpaqa/inner/pantr.hpp>
Public Members
-
SolverStatus status = SolverStatus::Busy#
-
std::chrono::nanoseconds elapsed_time = {}#
-
std::chrono::nanoseconds time_progress_callback = {}#
-
unsigned iterations = 0#
-
unsigned accelerated_step_rejected = 0#
-
unsigned stepsize_backtracks = 0#
-
unsigned direction_failures = 0#
-
unsigned direction_update_rejected = 0#
-
SolverStatus status = SolverStatus::Busy#
-
template<Config Conf>
struct ProblemVTable : public BasicVTable# - #include <alpaqa/problem/type-erased-problem.hpp>
Struct containing function pointers to all problem functions (like the objective and constraint functions, with their derivatives, and more).
Some default implementations are available. Internal struct, it is used by TypeErasedProblem.
Public Types
-
template<class F>
using optional_function_t = util::BasicVTable::optional_function_t<F, ProblemVTable>#
Public Functions
-
ProblemVTable() = default#
Public Members
-
required_function_t<real_t(real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p) const> eval_prox_grad_step#
-
optional_function_t<index_t(real_t γ, crvec x, crvec grad_ψ, rindexvec J) const> eval_inactive_indices_res_lna = default_eval_inactive_indices_res_lna#
-
optional_function_t<void(crvec x, rvec J_values) const> eval_jac_g = default_eval_jac_g#
-
optional_function_t<Sparsity() const> get_jac_g_sparsity = default_get_jac_g_sparsity#
-
optional_function_t<void(crvec x, index_t i, rvec grad_gi) const> eval_grad_gi = default_eval_grad_gi#
-
optional_function_t<void(crvec x, crvec y, real_t scale, crvec v, rvec Hv) const> eval_hess_L_prod = default_eval_hess_L_prod#
-
optional_function_t<void(crvec x, crvec y, real_t scale, rvec H_values) const> eval_hess_L = default_eval_hess_L#
-
optional_function_t<Sparsity() const> get_hess_L_sparsity = default_get_hess_L_sparsity#
-
optional_function_t<void(crvec x, crvec y, crvec Σ, real_t scale, crvec v, rvec Hv) const> eval_hess_ψ_prod = default_eval_hess_ψ_prod#
-
optional_function_t<void(crvec x, crvec y, crvec Σ, real_t scale, rvec H_values) const> eval_hess_ψ = default_eval_hess_ψ#
-
optional_function_t<Sparsity() const> get_hess_ψ_sparsity = default_get_hess_ψ_sparsity#
-
optional_function_t<real_t(crvec x, rvec grad_fx) const> eval_f_grad_f = default_eval_f_grad_f#
-
optional_function_t<real_t(crvec x, rvec g) const> eval_f_g = default_eval_f_g#
-
optional_function_t<void(crvec x, crvec y, rvec grad_f, rvec grad_gxy) const> eval_grad_f_grad_g_prod = default_eval_grad_f_grad_g_prod#
-
optional_function_t<void(crvec x, crvec y, rvec grad_L, rvec work_n) const> eval_grad_L = default_eval_grad_L#
-
optional_function_t<real_t(crvec x, crvec y, crvec Σ, rvec ŷ) const> eval_ψ = default_eval_ψ#
-
optional_function_t<void(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const> eval_grad_ψ = default_eval_grad_ψ#
-
optional_function_t<real_t(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const> eval_ψ_grad_ψ = default_eval_ψ_grad_ψ#
-
optional_function_t<const Box&() const> get_box_C = default_get_box_C#
-
optional_function_t<const Box&() const> get_box_D = default_get_box_D#
-
optional_function_t<void() const> check = default_check#
-
optional_function_t<std::string() const> get_name = default_get_name#
Public Static Functions
-
static real_t calc_ŷ_dᵀŷ(const void *self, rvec g_ŷ, crvec y, crvec Σ, const ProblemVTable &vtable)#
-
static index_t default_eval_inactive_indices_res_lna(const void*, real_t, crvec, crvec, rindexvec, const ProblemVTable&)#
-
static void default_eval_jac_g(const void*, crvec, rvec, const ProblemVTable&)#
-
static Sparsity default_get_jac_g_sparsity(const void*, const ProblemVTable&)#
-
static void default_eval_grad_gi(const void*, crvec, index_t, rvec, const ProblemVTable&)#
-
static void default_eval_hess_L_prod(const void*, crvec, crvec, real_t, crvec, rvec, const ProblemVTable&)#
-
static Sparsity default_get_hess_L_sparsity(const void*, const ProblemVTable&)#
-
static void default_eval_hess_ψ_prod(const void *self, crvec x, crvec y, crvec, real_t scale, crvec v, rvec Hv, const ProblemVTable &vtable)#
-
static void default_eval_hess_ψ(const void *self, crvec x, crvec y, crvec, real_t scale, rvec H_values, const ProblemVTable &vtable)#
-
static Sparsity default_get_hess_ψ_sparsity(const void*, const ProblemVTable&)#
-
static real_t default_eval_f_grad_f(const void *self, crvec x, rvec grad_fx, const ProblemVTable &vtable)#
-
static real_t default_eval_f_g(const void *self, crvec x, rvec g, const ProblemVTable &vtable)#
-
static void default_eval_grad_f_grad_g_prod(const void *self, crvec x, crvec y, rvec grad_f, rvec grad_gxy, const ProblemVTable &vtable)#
-
static void default_eval_grad_L(const void *self, crvec x, crvec y, rvec grad_L, rvec work_n, const ProblemVTable &vtable)#
-
static real_t default_eval_ψ(const void *self, crvec x, crvec y, crvec Σ, rvec ŷ, const ProblemVTable &vtable)#
-
static void default_eval_grad_ψ(const void *self, crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m, const ProblemVTable &vtable)#
-
static real_t default_eval_ψ_grad_ψ(const void *self, crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m, const ProblemVTable &vtable)#
-
static const Box &default_get_box_C(const void*, const ProblemVTable&)#
-
static const Box &default_get_box_D(const void*, const ProblemVTable&)#
-
static void default_check(const void*, const ProblemVTable&)#
-
static std::string default_get_name(const void*, const ProblemVTable&)#
-
template<class F>
-
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 real_t eval_ψ_grad_ψ(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) 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_jac_g() const#
-
inline bool provides_get_jac_g_sparsity() const#
-
inline bool provides_eval_hess_L_prod() const#
-
inline bool provides_eval_hess_L() const#
-
inline bool provides_get_hess_L_sparsity() const#
-
inline bool provides_eval_hess_ψ_prod() const#
-
inline bool provides_eval_hess_ψ() const#
-
inline bool provides_get_hess_ψ_sparsity() const#
-
inline bool provides_eval_f_grad_f() const#
-
inline bool provides_eval_f_g() const#
-
inline bool provides_eval_grad_f_grad_g_prod() const#
-
inline bool provides_eval_grad_L() const#
-
inline bool provides_eval_ψ() const#
-
inline bool provides_eval_grad_ψ() const#
-
inline bool provides_eval_ψ_grad_ψ() const#
-
inline bool provides_get_box_C() const#
-
inline bool provides_get_box_D() const#
-
inline bool provides_check() const#
-
inline bool provides_get_name() const#
-
ProblemWithCounters() = default#
-
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>()#
-
using Box = typename TypeErasedProblem<config_t>::Box#
-
struct prox_fn#
- #include <alpaqa/functions/prox.hpp>
Proximal mapping customization point.
See also
Public Functions
-
template<class T>
inline auto operator()(T &func, typename T::config_t::crmat in, typename T::config_t::rmat out, typename T::config_t::real_t γ = 1) const noexcept(alpaqa::is_nothrow_tag_invocable_v<prox_fn, T&, typename T::config_t::crmat, typename T::config_t::rmat, typename T::config_t::real_t>) -> typename T::config_t::real_t#
-
template<class T>
-
struct prox_step_fn#
- #include <alpaqa/functions/prox.hpp>
Proximal mapping customization point for forward-backward steps.
See also
Public Functions
-
template<class T>
inline auto operator()(T &func, typename T::config_t::crmat in, typename T::config_t::crmat fwd_step, typename T::config_t::rmat out, typename T::config_t::rmat fb_step, typename T::config_t::real_t γ = 1, typename T::config_t::real_t γ_fwd = -1) const noexcept(alpaqa::is_nothrow_tag_invocable_v<prox_step_fn, T&, typename T::config_t::crmat, typename T::config_t::crmat, typename T::config_t::rmat, typename T::config_t::rmat, typename T::config_t::real_t, typename T::config_t::real_t>) -> typename T::config_t::real_t#
-
template<class T>
inline auto operator()(T &func, typename T::config_t::crmat in, typename T::config_t::crmat fwd_step, typename T::config_t::rmat out, typename T::config_t::rmat fb_step, typename T::config_t::real_t γ = 1, typename T::config_t::real_t γ_fwd = -1) const noexcept(std::is_nothrow_invocable_v<prox_fn, T&, typename T::config_t::crmat, typename T::config_t::rmat, typename T::config_t::real_t>) -> typename T::config_t::real_t Default implementation for prox_step if only prox is provided.
-
template<class T>
-
template<class IndexT = size_t>
struct ReverseCircularIndexIterator# - #include <alpaqa/util/ringbuffer.hpp>
Public Types
-
using ForwardIterator = CircularIndexIterator<IndexT>#
-
using Index = typename ForwardIterator::Index#
-
using Indices = typename ForwardIterator::Indices#
-
using reference = value_type#
-
using difference_type = std::ptrdiff_t#
-
using pointer = void#
-
using iterator_category = std::input_iterator_tag#
Public Functions
-
inline ReverseCircularIndexIterator()#
-
inline ReverseCircularIndexIterator(ForwardIterator forwardit)#
-
inline ReverseCircularIndexIterator &operator++()#
-
inline ReverseCircularIndexIterator &operator--()#
-
inline ReverseCircularIndexIterator operator++(int)#
-
inline ReverseCircularIndexIterator operator--(int)#
Public Members
-
ForwardIterator forwardit#
-
template<class IndexT>
bool operator==(ReverseCircularIndexIterator<IndexT> a, ReverseCircularIndexIterator<IndexT> b)# Note
Only valid for two indices in the same range.
-
template<class IndexT>
bool operator!=(ReverseCircularIndexIterator<IndexT> a, ReverseCircularIndexIterator<IndexT> b)# Note
Only valid for two indices in the same range.
-
using ForwardIterator = CircularIndexIterator<IndexT>#
-
template<class IndexT>
class ReverseCircularRange# - #include <alpaqa/util/ringbuffer.hpp>
Public Types
-
using ForwardRange = CircularRange<IndexT>#
-
using Index = typename ForwardRange::Index#
-
using Indices = typename ForwardRange::Indices#
-
using const_iterator = typename ForwardRange::const_reverse_iterator#
-
using iterator = typename ForwardRange::reverse_iterator#
-
using const_reverse_iterator = typename ForwardRange::const_iterator#
-
using reverse_iterator = typename ForwardRange::iterator#
Public Functions
-
inline ReverseCircularRange(const ForwardRange &forwardrange)#
-
inline const_iterator cbegin() const#
-
inline const_iterator cend() const#
-
inline reverse_iterator rbegin() const#
-
inline reverse_iterator rend() const#
-
inline const_reverse_iterator crbegin() const#
-
inline const_reverse_iterator crend() const#
-
using ForwardRange = CircularRange<IndexT>#
-
struct ScopedMallocAllower : public ScopedMallocChecker<true>#
- #include <alpaqa/util/alloc-check.hpp>
-
struct ScopedMallocBlocker : public ScopedMallocChecker<false>#
- #include <alpaqa/util/alloc-check.hpp>
-
template<bool>
struct ScopedMallocChecker# - #include <alpaqa/util/alloc-check.hpp>
Public Functions
-
inline ScopedMallocChecker() noexcept#
-
inline ScopedMallocChecker() noexcept#
-
struct SerializedCasADiFunctions#
- #include <alpaqa/casadi/CasADiProblem.hpp>
Public Members
-
std::map<std::string, std::string> functions#
-
std::map<std::string, std::string> functions#
-
template<Config Conf>
struct StatefulLQRFactor# - #include <alpaqa/inner/directions/panoc-ocp/lqr.hpp>
Public Functions
-
inline void factor_masked(auto &&AB, auto &&Q, auto &&R, auto &&S, auto &&R_prod, auto &&S_prod, auto &&q, auto &&r, auto &&u, auto &&J, auto &&K, bool use_cholesky)#
- Parameters:
AB – System matrix A & input matrix B
Q – State cost matrix Q
R – Input cost matrix R
S – Cross cost matrix S
R_prod – Product with input cost matrix R
S_prod – Product with cross cost matrix S
q – Linear state factor q
r – Linear input factor r
u – Fixed inputs u
J – Index set of inactive constraints
K – Index set of active constraints
use_cholesky – Use Cholesky instead of LU solver
Public Members
-
inline void factor_masked(auto &&AB, auto &&Q, auto &&R, auto &&S, auto &&R_prod, auto &&S_prod, auto &&q, auto &&r, auto &&u, auto &&J, auto &&K, bool use_cholesky)#
-
template<Config Conf>
struct SteihaugCG# - #include <alpaqa/accelerators/steihaugcg.hpp>
Steihaug conjugate gradients procedure based on https://github.com/scipy/scipy/blob/583e70a50573169fc352b5dc6d94588a97c7389a/scipy/optimize/_trustregion_ncg.py#L44.
Public Types
-
using Params = SteihaugCGParams<config_t>#
Public Functions
-
SteihaugCG() = default#
-
using Params = SteihaugCGParams<config_t>#
-
template<Config Conf>
struct SteihaugCGParams# - #include <alpaqa/accelerators/steihaugcg.hpp>
Parameters for SteihaugCG.
Public Members
-
real_t tol_scale = 1#
Determines the tolerance for termination of the algorithm.
It terminates if the norm of the residual \( r = -g - Hq \) is smaller than the tolerance
\[ \mathrm{tolerance} = \min\left( \mathrm{tol\_max},\; \mathrm{tol\_scale}\cdot \|g\|\cdot \min\left(\mathrm{tol\_scale\_root},\; \sqrt{\|g\|}\right) \right) \]
-
real_t tol_scale_root = real_t(0.5)#
Determines the tolerance for termination of the algorithm.
See tol_scale.
-
real_t tol_scale = 1#
-
template<Config Conf = DefaultConfig>
struct StructuredLBFGSDirection# - #include <alpaqa/inner/directions/panoc/structured-lbfgs.hpp>
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using DirectionParams = StructuredLBFGSDirectionParams<config_t>#
Public Functions
-
StructuredLBFGSDirection() = default#
-
inline StructuredLBFGSDirection(const typename LBFGS::Params ¶ms, const DirectionParams &directionparams = {})#
-
inline StructuredLBFGSDirection(const LBFGS &lbfgs, const DirectionParams &directionparams = {})#
-
inline StructuredLBFGSDirection(LBFGS &&lbfgs, const DirectionParams &directionparams = {})#
-
void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0)#
See also
-
inline bool has_initial_direction() const#
-
inline bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ)#
See also
-
inline void reset()#
See also
-
inline std::string get_name() const#
See also
-
inline auto get_params() const#
Public Members
-
DirectionParams direction_params#
-
struct Params#
- #include <alpaqa/inner/directions/panoc/structured-lbfgs.hpp>
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf>
struct StructuredLBFGSDirectionParams# - #include <alpaqa/inner/directions/panoc/structured-lbfgs.hpp>
Parameters for the StructuredLBFGSDirection class.
Public Types
-
enum FailurePolicy#
Values:
-
enumerator FallbackToProjectedGradient#
If L-BFGS fails, propagate the failure and tell PANOC that no accelerated step is available, causing it to accept the projected gradient step instead.
-
enumerator UseScaledLBFGSInput#
If L-BFGS fails, return \( q_\mathcal{J} = -\gamma\nabla_{x_\mathcal{J}}\psi(x^k) -\gamma\nabla^2_{x_\mathcal{J}x_\mathcal{K}}\psi(x) q_\mathcal{K} \) as the accelerated step (effectively approximating \( \nabla_{x_\mathcal{J}x_\mathcal{J}} \approx \gamma I \)).
-
enumerator FallbackToProjectedGradient#
Public Members
-
real_t hessian_vec_factor = 0#
Set this option to a nonzero value to include the Hessian-vector product \( \nabla^2_{x_\mathcal{J}x_\mathcal{K}}\psi(x) q_\mathcal{K} \) from equation 12b in [4], scaled by this parameter.
Set it to zero to leave out that term (this usually only slightly increases the number of iterations, and eliminates one Hessian-vector product per iteration, improving the overall runtime).
-
bool hessian_vec_finite_differences = true#
If hessian_vec_factor is nonzero, set this option to true to approximate that term using finite differences instead of using AD.
-
bool full_augmented_hessian = true#
If hessian_vec_factor is nonzero and hessian_vec_finite_differences is true, set this option to true to compute the exact Hessian of the augmented Lagrangian, false to approximate it using the Hessian of the Lagrangian.
-
enum alpaqa::StructuredLBFGSDirectionParams::FailurePolicy failure_policy = FallbackToProjectedGradient#
What to do when L-BFGS failed (e.g.
if there were no pairs (s, y) with positive curvature).
-
enum FailurePolicy#
-
template<Config Conf = DefaultConfig>
struct StructuredNewtonDirection# - #include <alpaqa/inner/directions/panoc/structured-newton.hpp>
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using DirectionParams = StructuredNewtonDirectionParams<config_t>#
-
using AcceleratorParams = StructuredNewtonRegularizationParams<config_t>#
Public Functions
-
StructuredNewtonDirection() = default#
-
inline StructuredNewtonDirection(const AcceleratorParams ¶ms, const DirectionParams &directionparams = {})#
-
inline void initialize(const Problem &problem, crvec y, crvec Σ, real_t γ_0, crvec x_0, crvec x̂_0, crvec p_0, crvec grad_ψx_0)#
See also
-
inline bool has_initial_direction() const#
-
inline bool update(real_t γₖ, real_t γₙₑₓₜ, crvec xₖ, crvec xₙₑₓₜ, crvec pₖ, crvec pₙₑₓₜ, crvec grad_ψxₖ, crvec grad_ψxₙₑₓₜ)#
See also
-
inline bool apply(real_t γₖ, crvec xₖ, crvec x̂ₖ, crvec pₖ, crvec grad_ψxₖ, rvec qₖ) const#
See also
-
inline void reset()#
See also
-
inline std::string get_name() const#
See also
-
inline const auto &get_params() const#
-
struct Params#
- #include <alpaqa/inner/directions/panoc/structured-newton.hpp>
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf>
struct StructuredNewtonDirectionParams# - #include <alpaqa/inner/directions/panoc/structured-newton.hpp>
Parameters for the StructuredNewtonDirection class.
-
template<Config Conf>
struct StructuredNewtonRegularizationParams# - #include <alpaqa/inner/directions/panoc/structured-newton.hpp>
Parameters for the StructuredNewtonDirection class.
-
template<Config Conf = DefaultConfig, class Allocator = std::allocator<std::byte>>
class TypeErasedControlProblem : public alpaqa::util::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:
See [3] for more details.\[\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}\]Problem dimensions
Projections onto constraint sets
-
inline void eval_proj_diff_g(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
zandecan 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_proj_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 ALMParams::max_multiplier.
Constraint sets
Dynamics and initial state
-
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) \).
Output mapping
Stage and terminal cost
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 ofworkshould 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 ofworkshould 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_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 \).
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 TypeErased = util::TypeErased<VTable, allocator_type>#
Public Functions
-
TypeErased() noexcept(noexcept(allocator_type()) && noexcept(VTable())) = default
Default constructor.
-
template<class Alloc>
inline TypeErased(std::allocator_arg_t, const Alloc &alloc)# Default constructor (allocator aware).
-
inline TypeErased(const TypeErased &other)
Copy constructor.
-
inline TypeErased(const TypeErased &other, const allocator_type &alloc)
Copy constructor (allocator aware).
-
inline TypeErased(std::allocator_arg_t, const allocator_type &alloc, const TypeErased &other)
Copy constructor (allocator aware).
-
inline TypeErased(TypeErased &&other) noexcept
Move constructor.
-
inline TypeErased(TypeErased &&other, const allocator_type &alloc) noexcept
Move constructor (allocator aware).
-
inline TypeErased(std::allocator_arg_t, const allocator_type &alloc, TypeErased &&other) noexcept
Move constructor (allocator aware).
-
template<class T, class Alloc>
inline explicit TypeErased(std::allocator_arg_t, const Alloc &alloc, T &&d)# Main constructor that type-erases the given argument.
-
template<class T, class Alloc, class ...Args>
inline explicit TypeErased(std::allocator_arg_t, const Alloc &alloc, std::in_place_type_t<T>, Args&&... args)# Main constructor that type-erases the object constructed from the given argument.
Public Static Functions
-
template<class T, class ...Args>
static inline TypeErasedControlProblem make(Args&&... args)#
-
inline void eval_proj_diff_g(crvec z, rvec e) const#
-
template<Config Conf = DefaultConfig, class Allocator = std::allocator<std::byte>>
class TypeErasedProblem : public alpaqa::util::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
Required cost and constraint functions
-
real_t eval_f(crvec x) const#
[Required] Function that evaluates the cost, \( f(x) \)
- Parameters:
x – [in] Decision variable \( x \in \R^n \)
-
void eval_grad_f(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_g(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_grad_g_prod(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_proj_diff_g(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
zandecan 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_proj_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 ALMParams::max_multiplier.
-
real_t eval_prox_grad_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
Functions for second-order solvers
-
void eval_jac_g(crvec x, rvec J_values) const#
[Optional] Function that evaluates the nonzero values of the Jacobian matrix of the constraints, \( \jac_g(x) \)
Required for second-order solvers only.
- Parameters:
x – [in] Decision variable \( x \in \R^n \)
J_values – [out] Nonzero values of the Jacobian \( \jac_g(x) \in \R^{m\times n} \)
-
Sparsity get_jac_g_sparsity() const#
[Optional] Function that returns (a view of) the sparsity pattern of the Jacobian of the constraints.
Required for second-order solvers only.
-
void eval_grad_gi(crvec x, index_t i, rvec grad_gi) const#
[Optional] Function that evaluates the gradient of one specific constraint, \( \nabla g_i(x) \)
Required for second-order solvers only.
- Parameters:
x – [in] Decision variable \( x \in \R^n \)
i – [in] Which constraint \( 0 \le i \lt m \)
grad_gi – [out] Gradient of the constraint \( \nabla g_i(x) \in \R^n \)
-
void eval_hess_L_prod(crvec x, crvec y, real_t scale, crvec v, rvec Hv) const#
[Optional] Function that evaluates the Hessian of the Lagrangian multiplied by a vector, \( \nabla_{xx}^2L(x, y)\,v \)
Required for second-order solvers only.
- Parameters:
x – [in] Decision variable \( x \in \R^n \)
y – [in] Lagrange multipliers \( y \in \R^m \)
scale – [in] Scale factor for the cost function.
v – [in] Vector to multiply by \( v \in \R^n \)
Hv – [out] Hessian-vector product \( \nabla_{xx}^2 L(x, y)\,v \in \R^{n} \)
-
void eval_hess_L(crvec x, crvec y, real_t scale, rvec H_values) const#
[Optional] Function that evaluates the nonzero values of the Hessian of the Lagrangian, \( \nabla_{xx}^2L(x, y) \)
Required for second-order solvers only.
- Parameters:
x – [in] Decision variable \( x \in \R^n \)
y – [in] Lagrange multipliers \( y \in \R^m \)
scale – [in] Scale factor for the cost function.
H_values – [out] Nonzero values of the Hessian \( \nabla_{xx}^2 L(x, y) \in \R^{n\times n} \).
-
Sparsity get_hess_L_sparsity() const#
[Optional] Function that returns (a view of) the sparsity pattern of the Hessian of the Lagrangian.
Required for second-order solvers only.
-
void eval_hess_ψ_prod(crvec x, crvec y, crvec Σ, real_t scale, crvec v, rvec Hv) const#
[Optional] Function that evaluates the Hessian of the augmented Lagrangian multiplied by a vector, \( \nabla_{xx}^2L_\Sigma(x, y)\,v \)
Required for second-order solvers only.
- Parameters:
x – [in] Decision variable \( x \in \R^n \)
y – [in] Lagrange multipliers \( y \in \R^m \)
Σ – [in] Penalty weights \( \Sigma \)
scale – [in] Scale factor for the cost function.
v – [in] Vector to multiply by \( v \in \R^n \)
Hv – [out] Hessian-vector product \( \nabla_{xx}^2 L_\Sigma(x, y)\,v \in \R^{n} \)
-
void eval_hess_ψ(crvec x, crvec y, crvec Σ, real_t scale, rvec H_values) const#
[Optional] Function that evaluates the nonzero values of the Hessian of the augmented Lagrangian, \( \nabla_{xx}^2L_\Sigma(x, y) \)
Required for second-order solvers only.
- Parameters:
x – [in] Decision variable \( x \in \R^n \)
y – [in] Lagrange multipliers \( y \in \R^m \)
Σ – [in] Penalty weights \( \Sigma \)
scale – [in] Scale factor for the cost function.
H_values – [out] Nonzero values of the Hessian \( \nabla_{xx}^2 L_\Sigma(x, y) \in \R^{n\times n} \)
Combined evaluations
-
real_t eval_f_grad_f(crvec x, rvec grad_fx) const#
[Optional] Evaluate both \( f(x) \) and its gradient, \( \nabla f(x) \).
- Default implementation:
-
real_t eval_f_g(crvec x, rvec g) const#
[Optional] Evaluate both \( f(x) \) and \( g(x) \).
- Default implementation:
Augmented Lagrangian
-
real_t eval_ψ(crvec x, crvec y, crvec Σ, rvec ŷ) const#
[Optional] Calculate both ψ(x) and the vector ŷ that can later be used to compute ∇ψ.
\[ \psi(x) = f(x) + \tfrac{1}{2} \text{dist}_\Sigma^2\left(g(x) + \Sigma^{-1}y,\;D\right) \]\[ \hat y = \Sigma\, \left(g(x) + \Sigma^{-1}y - \Pi_D\left(g(x) + \Sigma^{-1}y\right)\right) \]- Default implementation:
- Parameters:
x – [in] Decision variable \( x \)
y – [in] Lagrange multipliers \( y \)
Σ – [in] Penalty weights \( \Sigma \)
ŷ – [out] \( \hat y \)
-
void eval_grad_ψ(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const#
[Optional] Calculate the gradient ∇ψ(x).
\[ \nabla \psi(x) = \nabla f(x) + \nabla g(x)\,\hat y(x) \]- Default implementation:
- Parameters:
x – [in] Decision variable \( x \)
y – [in] Lagrange multipliers \( y \)
Σ – [in] Penalty weights \( \Sigma \)
grad_ψ – [out] \( \nabla \psi(x) \)
work_n – Dimension \( n \)
work_m – Dimension \( m \)
-
real_t eval_ψ_grad_ψ(crvec x, crvec y, crvec Σ, rvec grad_ψ, rvec work_n, rvec work_m) const#
[Optional] Calculate both ψ(x) and its gradient ∇ψ(x).
\[ \psi(x) = f(x) + \tfrac{1}{2} \text{dist}_\Sigma^2\left(g(x) + \Sigma^{-1}y,\;D\right) \]\[ \nabla \psi(x) = \nabla f(x) + \nabla g(x)\,\hat y(x) \]- Default implementation:
- Parameters:
x – [in] Decision variable \( x \)
y – [in] Lagrange multipliers \( y \)
Σ – [in] Penalty weights \( \Sigma \)
grad_ψ – [out] \( \nabla \psi(x) \)
work_n – Dimension \( n \)
work_m – Dimension \( m \)
Checks
-
void check() const#
[Optional] Check that the problem formulation is well-defined, the dimensions match, etc.
Throws an exception if this is not the case.
Metadata
-
std::string get_name() const#
[Optional] Get a descriptive name for the problem.
Querying specialized implementations
-
inline bool provides_eval_inactive_indices_res_lna() const#
Returns true if the problem provides an implementation of eval_inactive_indices_res_lna.
-
inline bool provides_eval_jac_g() const#
Returns true if the problem provides an implementation of eval_jac_g.
-
inline bool provides_get_jac_g_sparsity() const#
Returns true if the problem provides an implementation of get_jac_g_sparsity.
-
inline bool provides_eval_grad_gi() const#
Returns true if the problem provides an implementation of eval_grad_gi.
-
inline bool provides_eval_hess_L_prod() const#
Returns true if the problem provides an implementation of eval_hess_L_prod.
-
inline bool provides_eval_hess_L() const#
Returns true if the problem provides an implementation of eval_hess_L.
-
inline bool provides_get_hess_L_sparsity() const#
Returns true if the problem provides an implementation of get_hess_L_sparsity.
-
inline bool provides_eval_hess_ψ_prod() const#
Returns true if the problem provides an implementation of eval_hess_ψ_prod.
-
inline bool provides_eval_hess_ψ() const#
Returns true if the problem provides an implementation of eval_hess_ψ.
-
inline bool provides_get_hess_ψ_sparsity() const#
Returns true if the problem provides an implementation of get_hess_ψ_sparsity.
-
inline bool provides_eval_f_grad_f() const#
Returns true if the problem provides a specialized implementation of eval_f_grad_f, false if it uses the default implementation.
-
inline bool provides_eval_f_g() const#
Returns true if the problem provides a specialized implementation of eval_f_g, false if it uses the default implementation.
-
inline bool provides_eval_grad_f_grad_g_prod() const#
Returns true if the problem provides a specialized implementation of eval_grad_f_grad_g_prod, false if it uses the default implementation.
-
inline bool provides_eval_grad_L() const#
Returns true if the problem provides a specialized implementation of eval_grad_L, false if it uses the default implementation.
-
inline bool provides_eval_ψ() const#
Returns true if the problem provides a specialized implementation of eval_ψ, false if it uses the default implementation.
-
inline bool provides_eval_grad_ψ() const#
Returns true if the problem provides a specialized implementation of eval_grad_ψ, false if it uses the default implementation.
-
inline bool provides_eval_ψ_grad_ψ() const#
Returns true if the problem provides a specialized implementation of eval_ψ_grad_ψ, false if it uses the default implementation.
-
inline bool provides_get_box_C() const#
Returns true if the problem provides an implementation of get_box_C.
-
inline bool provides_get_box_D() const#
Returns true if the problem provides an implementation of get_box_D.
Querying available functions
-
inline bool supports_eval_hess_ψ_prod() const#
Returns true if eval_hess_ψ_prod can be called.
-
inline bool supports_eval_hess_ψ() const#
Returns true if eval_hess_ψ can be called.
Helpers
-
real_t calc_ŷ_dᵀŷ(rvec g_ŷ, crvec y, crvec Σ) const#
Given g(x), compute the intermediate results ŷ and dᵀŷ that can later be used to compute ψ(x) and ∇ψ(x).
Computes the result using the following algorithm:
\[\begin{split} \begin{aligned} \zeta &= g(x) + \Sigma^{-1} y \\[] d &= \zeta - \Pi_D(\zeta) = \operatorname{eval\_proj\_diff\_g}(\zeta, \zeta) \\[] \hat y &= \Sigma d \\[] \end{aligned} \end{split}\]See also
- Parameters:
g_ŷ – [inout] Input \( g(x) \), outputs \( \hat y \)
y – [in] Lagrange multipliers \( y \)
Σ – [in] Penalty weights \( \Sigma \)
- Returns:
The inner product \( d^\top \hat y \)
Public Types
-
using VTable = ProblemVTable<config_t>#
-
using TypeErased = util::TypeErased<VTable, allocator_type>#
Public Functions
-
TypeErased() noexcept(noexcept(allocator_type()) && noexcept(VTable())) = default
Default constructor.
-
template<class Alloc>
inline TypeErased(std::allocator_arg_t, const Alloc &alloc)# Default constructor (allocator aware).
-
inline TypeErased(const TypeErased &other)
Copy constructor.
-
inline TypeErased(const TypeErased &other, const allocator_type &alloc)
Copy constructor (allocator aware).
-
inline TypeErased(std::allocator_arg_t, const allocator_type &alloc, const TypeErased &other)
Copy constructor (allocator aware).
-
inline TypeErased(TypeErased &&other) noexcept
Move constructor.
-
inline TypeErased(TypeErased &&other, const allocator_type &alloc) noexcept
Move constructor (allocator aware).
-
inline TypeErased(std::allocator_arg_t, const allocator_type &alloc, TypeErased &&other) noexcept
Move constructor (allocator aware).
-
template<class T, class Alloc>
inline explicit TypeErased(std::allocator_arg_t, const Alloc &alloc, T &&d)# Main constructor that type-erases the given argument.
-
template<class T, class Alloc, class ...Args>
inline explicit TypeErased(std::allocator_arg_t, const Alloc &alloc, std::in_place_type_t<T>, Args&&... args)# Main constructor that type-erases the object constructed from the given argument.
Public Static Functions
-
template<class T, class ...Args>
static inline TypeErasedProblem make(Args&&... args)#
-
real_t eval_f(crvec x) const#
-
template<Config Conf>
class UnconstrProblem# - #include <alpaqa/problem/unconstr-problem.hpp>
Implements common problem functions for minimization problems without constraints.
Meant to be used as a base class for custom problem implementations.
Public Functions
-
UnconstrProblem(const UnconstrProblem&) = default#
-
UnconstrProblem &operator=(const UnconstrProblem&) = default#
-
UnconstrProblem(UnconstrProblem&&) noexcept = default#
-
UnconstrProblem &operator=(UnconstrProblem&&) noexcept = default#
-
inline void eval_grad_g_prod(crvec, crvec, rvec grad) const#
Constraint gradient is always zero.
See also
-
inline void eval_grad_gi(crvec, index_t, rvec grad_gi) const#
Constraint gradient is always zero.
See also
-
inline real_t eval_prox_grad_step(real_t γ, crvec x, crvec grad_ψ, rvec x_hat, rvec p) const#
No proximal mapping, just a forward (gradient) step.
-
inline std::string get_name() const#
See also
-
UnconstrProblem(const UnconstrProblem&) = default#
-
template<Config Conf = DefaultConfig>
struct WolfeParams# - #include <alpaqa/inner/wolfe.hpp>
Tuning parameters for the unconstrained solver with Wolfe line search.
Public Members
-
unsigned max_iter = 100#
Maximum number of inner iterations.
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
Maximum duration.
-
real_t min_linesearch_coefficient = real_t(1. / 256)#
Minimum weight factor between Newton step and projected gradient step.
-
bool force_linesearch = false#
Ignore the line search condition and always accept the accelerated step.
(For testing purposes only).
-
PANOCStopCrit stop_crit = PANOCStopCrit::ApproxKKT#
What stopping criterion to use.
-
unsigned max_no_progress = 10#
Maximum number of iterations without any progress before giving up.
-
unsigned print_interval = 0#
When to print progress.
If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
-
int print_precision = std::numeric_limits<real_t>::max_digits10 / 2#
The precision of the floating point values printed by the solver.
-
real_t linesearch_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the line search.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that accelerated steps are rejected (τ = 0) when getting closer to the solution, you may want to increase this factor.
-
unsigned max_iter = 100#
-
template<Config Conf = DefaultConfig>
struct WolfeProgressInfo# - #include <alpaqa/inner/wolfe.hpp>
Iterate information for the unconstrained solver with Wolfe line search.
-
template<class DirectionT>
class WolfeSolver# - #include <alpaqa/inner/wolfe.hpp>
Unconstrained solver with Wolfe line search.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Params = WolfeParams<config_t>#
-
using Direction = DirectionT#
-
using Stats = WolfeStats<config_t>#
-
using ProgressInfo = WolfeProgressInfo<config_t>#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec err_z)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec e)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x)#
-
inline WolfeSolver &set_progress_callback(std::function<void(const ProgressInfo&)> cb)#
Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.
See also
-
std::string get_name() const#
-
inline void stop()#
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct WolfeStats# - #include <alpaqa/inner/wolfe.hpp>
Statistics for the unconstrained solver with Wolfe line search.
Public Members
-
SolverStatus status = SolverStatus::Busy#
-
std::chrono::nanoseconds elapsed_time = {}#
-
std::chrono::nanoseconds time_progress_callback = {}#
-
unsigned iterations = 0#
-
unsigned linesearch_failures = 0#
-
unsigned linesearch_backtracks = 0#
-
unsigned lbfgs_failures = 0#
-
unsigned lbfgs_rejected = 0#
-
unsigned τ_1_accepted = 0#
-
unsigned count_τ = 0#
-
SolverStatus status = SolverStatus::Busy#
-
template<Config Conf = DefaultConfig>
struct ZeroFPRParams# - #include <alpaqa/inner/zerofpr.hpp>
Tuning parameters for the ZeroFPR algorithm.
Public Members
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
Parameters related to the Lipschitz constant estimate and step size.
-
unsigned max_iter = 100#
Maximum number of inner ZeroFPR iterations.
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
Maximum duration.
-
real_t min_linesearch_coefficient = real_t(1. / 256)#
Minimum weight factor between Newton step and projected gradient step.
-
bool force_linesearch = false#
Ignore the line search condition and always accept the accelerated step.
(For testing purposes only).
-
real_t linesearch_strictness_factor = real_t(0.95)#
Parameter β used in the line search (see Algorithm 2 in [2]).
\( 0 < \beta < 1 \)
-
PANOCStopCrit stop_crit = PANOCStopCrit::ApproxKKT#
What stopping criterion to use.
-
unsigned max_no_progress = 10#
Maximum number of iterations without any progress before giving up.
-
unsigned print_interval = 0#
When to print progress.
If set to zero, nothing will be printed. If set to N != 0, progress is printed every N iterations.
-
int print_precision = std::numeric_limits<real_t>::max_digits10 / 2#
The precision of the floating point values printed by the solver.
-
real_t quadratic_upperbound_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the quadratic upper bound condition that determines the step size.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that the step size γ becomes very small, you may want to increase this factor.
-
real_t linesearch_tolerance_factor = 10 * std::numeric_limits<real_t>::epsilon()#
Tolerance factor used in the line search.
Its goal is to account for numerical errors in the function and gradient evaluations. If you notice that accelerated steps are rejected (τ = 0) when getting closer to the solution, you may want to increase this factor.
-
bool update_direction_in_candidate = false#
Use the candidate point rather than the accepted point to update the quasi-Newton direction.
-
bool recompute_last_prox_step_after_stepsize_change = false#
If the step size changes, the direction buffer is flushed.
The current step will still be used to update the direction, but may still use the old step size. If set to true, the current step will be recomputed with the new step size as well, to match the step in the candidate iterate.
-
bool update_direction_from_prox_step = false#
Update the direction between current forward-backward point and the candidate iterate instead of between the current iterate and the candidate iterate.
-
LipschitzEstimateParams<config_t> Lipschitz = {}#
-
template<Config Conf = DefaultConfig>
struct ZeroFPRProgressInfo# - #include <alpaqa/inner/zerofpr.hpp>
Public Members
-
unsigned k#
-
SolverStatus status#
-
unsigned outer_iter#
-
const TypeErasedProblem<config_t> *problem#
-
const ZeroFPRParams<config_t> *params#
-
unsigned k#
-
template<class DirectionT>
class ZeroFPRSolver# - #include <alpaqa/inner/zerofpr.hpp>
ZeroFPR solver for ALM.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Params = ZeroFPRParams<config_t>#
-
using Direction = DirectionT#
-
using Stats = ZeroFPRStats<config_t>#
-
using ProgressInfo = ZeroFPRProgressInfo<config_t>#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec err_z)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec e)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec x)#
-
inline ZeroFPRSolver &set_progress_callback(std::function<void(const ProgressInfo&)> cb)#
Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.
See also
-
std::string get_name() const#
-
inline void stop()#
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct ZeroFPRStats# - #include <alpaqa/inner/zerofpr.hpp>
Public Members
-
SolverStatus status = SolverStatus::Busy#
-
std::chrono::nanoseconds elapsed_time = {}#
-
std::chrono::nanoseconds time_progress_callback = {}#
-
unsigned iterations = 0#
-
unsigned linesearch_failures = 0#
-
unsigned linesearch_backtracks = 0#
-
unsigned stepsize_backtracks = 0#
-
unsigned lbfgs_failures = 0#
-
unsigned lbfgs_rejected = 0#
-
unsigned τ_1_accepted = 0#
-
unsigned count_τ = 0#
-
SolverStatus status = SolverStatus::Busy#
-
namespace casadi_loader#
Typedefs
-
using dim = std::pair<casadi_int, casadi_int>#
Functions
-
CasADiFunctions deserialize_problem(const SerializedCasADiFunctions &functions)#
Convert the map of strings to a map of CasADi functions.
-
void complete_problem(CasADiFunctions &functions)#
Complete the given problem that contains only functions f and g, adding the necessary functions and gradients so that it can be used with CasADiProblem.
-
template<class T, class Loader, class ...Args>
auto wrapped_load(Loader &&loader, const char *name, Args&&... args)#
-
template<class T, class Loader, class ...Args>
std::optional<T> try_load(Loader &&loader, const char *name, Args&&... args)#
-
inline constexpr auto dims(auto... a)#
-
template<Config>
struct CasADiControlFunctionsWithParam#
-
template<Config Conf, size_t N_in, size_t N_out>
class CasADiFunctionEvaluator# - #include <alpaqa/casadi/CasADiFunctionWrapper.hpp>
Class for evaluating CasADi functions, allocating the necessary workspace storage in advance for allocation-free evaluations.
Public Types
-
using casadi_dim = std::pair<casadi_int, casadi_int>#
Public Functions
-
inline CasADiFunctionEvaluator(casadi::Function &&f)#
- Throws:
-
inline CasADiFunctionEvaluator(casadi::Function &&f, const std::array<casadi_dim, N_in> &dim_in, const std::array<casadi_dim, N_out> &dim_out)#
- Throws:
-
inline void validate_dimensions(const std::array<casadi_dim, N_in> &dim_in = {}, const std::array<casadi_dim, N_out> &dim_out = {})#
- Throws:
Public Members
-
casadi::Function fun#
Public Static Functions
-
static inline void validate_num_args(const casadi::Function &fun)#
- Throws:
-
static inline void validate_dimensions(const casadi::Function &fun, const std::array<casadi_dim, N_in> &dim_in = {}, const std::array<casadi_dim, N_out> &dim_out = {})#
- Throws:
-
using casadi_dim = std::pair<casadi_int, casadi_int>#
-
template<Config>
struct CasADiFunctionsWithParam#
-
struct invalid_argument_dimensions : public invalid_argument#
- #include <alpaqa/casadi/CasADiFunctionWrapper.hpp>
-
using dim = std::pair<casadi_int, casadi_int>#
-
namespace csv#
Functions
-
template<class F>
void read_row_impl(std::istream &is, Eigen::Ref<Eigen::VectorX<F>> v, char sep = ',')#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<Eigen::Index>> v, char sep)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<Eigen::Index>> v)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<float>> v, char sep)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<float>> v)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<double>> v, char sep)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<double>> v)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<long double>> v, char sep)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<long double>> v)#
-
inline void read_row(std::istream &is, Eigen::Ref<Eigen::VectorX<type>> v, char sep = ',')#
Read one line of comma-separated values from
isand write it to the vectorv.Lines that start with a
#are skipped.
- template void read_row_impl (std::istream &, Eigen::Ref< Eigen::VectorX< Eigen::Index > >, char)
- template void read_row_impl (std::istream &, Eigen::Ref< Eigen::VectorX< float > >, char)
- template void read_row_impl (std::istream &, Eigen::Ref< Eigen::VectorX< double > >, char)
- template void read_row_impl (std::istream &, Eigen::Ref< Eigen::VectorX< long double > >, char)
- template std::vector< Eigen::Index > read_row_std_vector (std::istream &, char)
-
struct read_error : public runtime_error#
- #include <alpaqa/util/io/csv.hpp>
-
template<class F>
-
namespace cutest#
Typedefs
-
using csetup = Function<"cutest_cint_csetup_", void(integer *status, const integer *funit, const integer *iout, const integer *io_buffer, integer *n, integer *m, doublereal *x, doublereal *bl, doublereal *bu, doublereal *v, doublereal *cl, doublereal *cu, logical *equatn, logical *linear, const integer *e_order, const integer *l_order, const integer *v_order)>#
-
using cdimen = Function<"cutest_cdimen_", void(integer *status, const integer *funit, integer *n, integer *m)>#
-
typedef Function<"cutest_creport_", void(integer *status, doublereal *calls, doublereal *time)> creport#
-
using ureport = Function<"cutest_ureport_", void(integer *status, doublereal *calls, doublereal *time)>#
-
using cfn = Function<"cutest_cfn_", void(integer *status, const integer *n, const integer *m, const doublereal *x, doublereal *f, doublereal *c)>#
-
using cofg = Function<"cutest_cint_cofg_", void(integer *status, const integer *n, const doublereal *x, doublereal *f, doublereal *g, const logical *grad)>#
-
using ccfg = Function<"cutest_cint_ccfg_", void(integer *status, const integer *n, const integer *m, const doublereal *x, doublereal *c, const logical *jtrans, const integer *lcjac1, const integer *lcjac2, doublereal *cjac, const logical *grad)>#
-
using clfg = Function<"cutest_cint_clfg_", void(integer *status, const integer *n, const integer *m, const doublereal *x, const doublereal *y, doublereal *f, doublereal *g, const logical *grad)>#
-
using ccfsg = Function<"cutest_cint_ccfsg_", void(integer *status, const integer *n, const integer *m, const doublereal *x, doublereal *c, integer *nnzj, const integer *lcjac, doublereal *cjac, integer *indvar, integer *indfun, const logical *grad)>#
-
using ccifg = Function<"cutest_cint_ccifg_", void(integer *status, const integer *n, const integer *icon, const doublereal *x, doublereal *ci, doublereal *gci, const logical *grad)>#
-
using cdh = Function<"cutest_cdh_", void(integer *status, const integer *n, const integer *m, const doublereal *x, const doublereal *y, const integer *lh1, doublereal *h)>#
-
using cshp = Function<"cutest_cshp_", void(integer *status, const integer *n, integer *nnzh, const integer *lh, integer *irnh, integer *icnh)>#
-
using csh = Function<"cutest_csh_", void(integer *status, const integer *n, const integer *m, const doublereal *x, const doublereal *y, integer *nnzh, const integer *lh, doublereal *h, integer *irnh, integer *icnh)>#
-
using cigr = Function<"cutest_cigr_", void(integer *status, const integer *n, const integer *iprob, const doublereal *x, doublereal *g)>#
-
using chprod = Function<"cutest_chprod_", void(integer *status, const integer *n, const integer *m, const logical *goth, const doublereal *x, const doublereal *y, doublereal *p, doublereal *q)>#
-
using cjprod = Function<"cutest_cjprod_", void(integer *status, const integer *n, const integer *m, const logical *gotj, const logical *jtrans, const doublereal *x, const doublereal *p, const integer *lp, doublereal *r, const integer *lr)>#
-
using csjp = Function<"cutest_csjp_", void(integer *status, integer *nnzj, const integer *lj, integer *J_var, integer *J_con)>#
-
using fortran_open = Function<"fortran_open_", void(const integer *funit, const char *fname, integer *ierr)>#
-
using integer = int#
-
using doublereal = double#
-
using logical = int#
Enums
-
template<Name Nm, class Sgn>
struct Function# - #include </__w/alpaqa/alpaqa/src/interop/cutest/src/cutest-types.hpp>
Reference to CUTEst function.
Public Static Functions
-
static signature_t *load(void *handle)#
-
static signature_t *load(void *handle)#
-
struct function_call_error : public runtime_error#
- #include <alpaqa/cutest/cutest-errors.hpp>
-
struct function_load_error : public runtime_error#
- #include <alpaqa/cutest/cutest-errors.hpp>
-
template<size_t N>
struct Name# - #include </__w/alpaqa/alpaqa/src/interop/cutest/src/cutest-types.hpp>
Compile-time string for CUTEst function names.
-
using csetup = Function<"cutest_cint_csetup_", void(integer *status, const integer *funit, const integer *iout, const integer *io_buffer, integer *n, integer *m, doublereal *x, doublereal *bl, doublereal *bu, doublereal *v, doublereal *cl, doublereal *cu, logical *equatn, logical *linear, const integer *e_order, const integer *l_order, const integer *v_order)>#
-
namespace detail#
Functions
-
template<Config Conf>
void assign_interleave_xu(const OCPVariables<Conf> &dim, crvec<Conf> u, rvec<Conf> storage)#
-
template<Config Conf>
void assign_interleave_xu(const OCPVariables<Conf> &dim, crvec<Conf> x, crvec<Conf> u, rvec<Conf> storage)#
-
template<Config Conf>
void assign_extract_u(const OCPVariables<Conf> &dim, crvec<Conf> storage, rvec<Conf> u)#
-
template<Config Conf>
void assign_extract_x(const OCPVariables<Conf> &dim, crvec<Conf> storage, rvec<Conf> x)#
-
template<Config Conf>
vec<Conf> extract_u(const TypeErasedControlProblem<Conf> &problem, crvec<Conf> xu)#
-
template<Config Conf>
vec<Conf> extract_x(const TypeErasedControlProblem<Conf> &problem, crvec<Conf> xu)#
-
template<class T>
std::ostream &print_csv_impl(std::ostream &os, const T &M, std::string_view sep = ",", std::string_view begin = "", std::string_view end = "\n")#
-
template<class T>
std::ostream &print_matlab_impl(std::ostream &os, const T &M, std::string_view end = ";\n")#
-
template<class T>
std::ostream &print_python_impl(std::ostream &os, const T &M, std::string_view end = "\n")#
-
template<class ...Args>
std::ostream &print_csv_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<int>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_matlab_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<int>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_python_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<int>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_csv_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_matlab_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_python_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_csv_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long long>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_matlab_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long long>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_python_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long long>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_csv_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<double>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_matlab_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<double>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_python_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<double>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_csv_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long double>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_matlab_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long double>> &M, Args&&... args)#
-
template<class ...Args>
std::ostream &print_python_helper(std::ostream &os, const Eigen::Ref<const Eigen::MatrixX<long double>> &M, Args&&... args)#
-
template<class Signature>
function_wrapper_t(std::function<Signature>) -> function_wrapper_t<Signature>#
-
template<auto Member, class Class, class Ret, class ...Args>
static auto member_caller(Ret (Class::*)(Args...))# Overload for non-const-qualified member functions.
Overload for const-qualified member functions.
See also
Variables
-
std::atomic<void*> solver_to_stop#
-
template<Config Conf>
struct ALMHelpers#
-
template<class Signature>
struct function_wrapper_t - #include <alpaqa/dl/dl-problem.h>
Custom type for which we can export the RTTI to support std::any across shared library boundaries when using libc++.
-
template<Config Conf>
struct IndexSet# - #include <alpaqa/util/index-set.hpp>
Public Functions
-
inline auto sizes()#
-
inline auto sizes() const#
-
inline auto indices()#
-
inline auto indices() const#
-
inline crindexvec indices(index_t i) const#
-
inline crindexvec compl_indices(index_t i) const#
-
inline auto sizes()#
-
template<Config Conf>
struct PANOCHelpers#
-
template<Config Conf>
-
namespace dl#
-
class DLControlProblem#
- #include <alpaqa/dl/dl-problem.hpp>
Class that loads an optimal control problem using
dlopen.The shared library should export a C function with the name
function_namethat accepts a void pointer with user data, and returns a struct of type alpaqa_control_problem_register_t that contains all data to represent the problem, as well as function pointers for all required operations.See also
Note
Copies are shallow, they all share the same problem instance, take that into account when using multiple threads.
Public Functions
-
DLControlProblem(const std::filesystem::path &so_filename, const std::string &function_name = "register_alpaqa_control_problem", alpaqa_register_arg_t user_param = {})#
Load a problem from a shared library.
- Parameters:
so_filename – Filename of the shared library to load.
function_name – Name of the problem registration function. Should have signature
alpaqa_control_problem_register_t(alpaqa_register_arg_t user_param).user_param – Pointer to custom user data to pass to the registration function.
-
inline void check() 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#
-
bool provides_get_D() const#
-
bool provides_get_D_N() const#
-
bool provides_eval_add_Q_N() const#
-
bool provides_eval_add_R_prod_masked() const#
-
bool provides_eval_add_S_prod_masked() const#
-
bool provides_get_R_work_size() const#
-
bool provides_get_S_work_size() const#
-
bool provides_eval_constr() const#
-
bool provides_eval_constr_N() const#
-
bool provides_eval_grad_constr_prod() const#
-
bool provides_eval_grad_constr_prod_N() const#
-
bool provides_eval_add_gn_hess_constr() const#
-
bool provides_eval_add_gn_hess_constr_N() const#
-
DLControlProblem(const std::filesystem::path &so_filename, const std::string &function_name = "register_alpaqa_control_problem", alpaqa_register_arg_t user_param = {})#
-
class DLProblem : public BoxConstrProblem<DefaultConfig>#
- #include <alpaqa/dl/dl-problem.hpp>
Class that loads a problem using
dlopen.The shared library should export a C function with the name
function_namethat accepts a void pointer with user data, and returns a struct of type alpaqa_problem_register_t that contains all data to represent the problem, as well as function pointers for all required operations. See C++/DLProblem/main.cpp and problems/sparse-logistic-regression.cpp for examples.See also
See also
alpaqa_problem_functions_t
See also
alpaqa_problem_register_t
Note
Copies are shallow, they all share the same problem instance, take that into account when using multiple threads.
Public Types
-
using instance_t = ExtraFuncs::instance_t#
Public Functions
-
DLProblem(const std::filesystem::path &so_filename, const std::string &function_name = "register_alpaqa_problem", alpaqa_register_arg_t user_param = {})#
Load a problem from a shared library.
- Parameters:
so_filename – Filename of the shared library to load.
function_name – Name of the problem registration function. Should have signature
alpaqa_problem_register_t(alpaqa_register_arg_t user_param).user_param – Pointer to custom user data to pass to the registration function.
-
DLProblem(const std::filesystem::path &so_filename, const std::string &function_name, std::any &user_param)#
Load a problem from a shared library.
- Parameters:
so_filename – Filename of the shared library to load.
function_name – Name of the problem registration function. Should have signature
alpaqa_problem_register_t(alpaqa_register_arg_t user_param).user_param – Custom user data to pass to the registration function.
-
DLProblem(const std::filesystem::path &so_filename, const std::string &function_name, std::span<std::string_view> user_param)#
Load a problem from a shared library.
- Parameters:
so_filename – Filename of the shared library to load.
function_name – Name of the problem registration function. Should have signature
alpaqa_problem_register_t(alpaqa_register_arg_t user_param).user_param – Custom string arguments to pass to the registration function.
-
std::string get_name() const#
-
bool provides_eval_f() const#
-
bool provides_eval_grad_f() const#
-
bool provides_eval_g() const#
-
bool provides_eval_grad_g_prod() const#
-
bool provides_eval_jac_g() const#
-
bool provides_get_jac_g_sparsity() const#
-
bool provides_eval_grad_gi() const#
-
bool provides_eval_hess_L_prod() const#
-
bool provides_eval_hess_L() const#
-
bool provides_get_hess_L_sparsity() const#
-
bool provides_eval_hess_ψ_prod() const#
-
bool provides_eval_hess_ψ() const#
-
bool provides_get_hess_ψ_sparsity() const#
-
bool provides_eval_f_grad_f() const#
-
bool provides_eval_f_g() const#
-
bool provides_eval_grad_f_grad_g_prod() const#
-
bool provides_eval_grad_L() const#
-
bool provides_eval_ψ() const#
-
bool provides_eval_grad_ψ() const#
-
bool provides_eval_ψ_grad_ψ() const#
-
bool provides_get_box_C() const#
-
bool provides_get_box_D() const#
-
bool provides_eval_inactive_indices_res_lna() const#
-
using instance_t = ExtraFuncs::instance_t#
-
class ExtraFuncs#
- #include <alpaqa/dl/dl-problem.hpp>
Public Functions
-
ExtraFuncs() = default#
-
template<class Signature>
inline const std::function<Signature> &extra_func(const std::string &name) const#
-
template<class Ret, class ...FArgs, class ...Args>
inline decltype(auto) call_extra_func_helper(const void *instance, FuncTag<Ret(const instance_t*, FArgs...)>, const std::string &name, Args&&... args) const#
Public Members
-
std::shared_ptr<function_dict_t> extra_functions#
An associative array of additional functions exposed by the problem.
-
template<class Func>
struct FuncTag# - #include <alpaqa/dl/dl-problem.hpp>
-
ExtraFuncs() = default#
-
struct function_load_error : public runtime_error#
- #include <alpaqa/dl/dl-problem.hpp>
-
struct invalid_abi_error : public runtime_error#
- #include <alpaqa/dl/dl-problem.hpp>
-
class DLControlProblem#
-
namespace functions#
-
-
template<Config Conf, class Weight = typename Conf::real_t>
struct L1Norm# - #include <alpaqa/functions/l1-norm.hpp>
ℓ₁-norm.
- Template Parameters:
Weight – Type of weighting factors. Either scalar or vector.
-
template<Config Conf, class Weight = typename Conf::real_t>
struct L1NormComplex# - #include <alpaqa/functions/l1-norm.hpp>
ℓ₁-norm of complex numbers.
- Template Parameters:
Weight – Type of weighting factors. Either scalar or vector.
-
template<Config Conf, class SVD = DefaultSVD<Conf>>
struct NuclearNorm# - #include <alpaqa/functions/nuclear-norm.hpp>
Nuclear norm (ℓ₁-norm of singular values).
Public Functions
-
template<Config Conf, class Weight = typename Conf::real_t>
-
namespace lbfgsb#
-
struct LBFGSBParams#
- #include <alpaqa/lbfgsb/lbfgsb-adapter.hpp>
Tuning parameters for the L-BFGS-B solver LBFGSBSolver.
Public Members
-
unsigned memory = 10#
-
unsigned max_iter = 1000#
-
std::chrono::nanoseconds max_time = std::chrono::minutes(5)#
-
PANOCStopCrit stop_crit = PANOCStopCrit::ProjGradUnitNorm#
-
int print = -1#
-
unsigned print_interval = 0#
-
unsigned memory = 10#
-
struct LBFGSBProgressInfo#
- #include <alpaqa/lbfgsb/lbfgsb-adapter.hpp>
-
class LBFGSBSolver#
- #include <alpaqa/lbfgsb/lbfgsb-adapter.hpp>
L-BFGS-B solver for ALM.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Params = LBFGSBParams#
-
using Stats = LBFGSBStats#
-
using ProgressInfo = LBFGSBProgressInfo#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec err_z)#
- Parameters:
problem – [in] Problem description
opts – [in] Solve options
x – [inout] Decision variable \( x \)
y – [inout] Lagrange multipliers \( y \)
Σ – [in] Constraint weights \( \Sigma \)
err_z – [out] Slack variable error \( g(x) - \Pi_D(g(x) + \Sigma^{-1} y) \)
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec u, rvec y, crvec Σ, rvec e)#
-
inline LBFGSBSolver &set_progress_callback(std::function<void(const ProgressInfo&)> cb)#
Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.
See also
-
std::string get_name() const#
-
inline void stop()#
Public Members
-
std::ostream *os = &std::cout#
-
using Problem = TypeErasedProblem<config_t>#
-
struct LBFGSBStats#
- #include <alpaqa/lbfgsb/lbfgsb-adapter.hpp>
-
struct LBFGSBParams#
-
namespace lbfgspp#
-
template<Config Conf>
class LBFGSBSolver# - #include <alpaqa/lbfgsb-adapter.hpp>
L-BFGS-B solver for ALM.
Public Types
-
using Problem = TypeErasedProblem<config_t>#
-
using Stats = LBFGSBStats<config_t>#
-
using SolveOptions = InnerSolveOptions<config_t>#
Public Functions
-
Stats operator()(const Problem &problem, const SolveOptions &opts, rvec x, rvec y, crvec Σ, rvec err_z)#
-
template<class P>
inline Stats operator()(const P &problem, const SolveOptions &opts, rvec u, rvec y, crvec Σ, rvec e)#
-
std::string get_name() const#
-
inline void stop()#
Public Members
-
std::ostream *os = &std::cout#
-
using Problem = TypeErasedProblem<config_t>#
-
template<Config Conf = DefaultConfig>
struct LBFGSBStats# - #include <alpaqa/lbfgsb-adapter.hpp>
-
template<Config Conf>
-
namespace params#
Typedefs
-
template<class S>
using attribute_table_t = std::map<std::string_view, attribute_accessor<S>># Dictionary that maps struct attribute names to type-erased functions that set those attributes.
-
template<class S>
using attribute_alias_table_t = std::map<std::string_view, std::string_view># Dictionary that maps struct attribute names to type-erased functions that set those attributes.
-
template<class T, class S>
using enum_table_t = std::map<std::string_view, enum_accessor<T, S>># Dictionary that maps enumerator names to their values and documentation.
Functions
-
template<class T>
void set_param(T&, const json &j)# Update/overwrite the first argument based on the JSON object
j.
-
inline auto split_key(std::string_view full, char tok = '.')#
Split the string
fullon the first occurrence oftok.Returns (s, “”) if tok was not found.
-
template<class T>
void set_param(T&, ParamString)# Update/overwrite the first argument based on the option in
s.
-
template<class T>
void set_params(T &t, std::string_view prefix, std::span<const std::string_view> options, std::optional<std::span<unsigned>> used = std::nullopt)# Overwrites
tbased on theoptionsthat start withprefix.If
usedis notnullopt, sets corresponding flag of the options that were used.
-
template<class T>
bool is_leaf()#
-
template<class T>
Result get_members(const MemberGetter &s)# Catch-all.
-
template<class T>
Result get_members(const MemberGetter &s) Struct types.
-
template<class T>
Result get_members(const MemberGetter &s) Enum types.
-
template<>
Result get_members<bool>(const MemberGetter &s)# True/false.
-
template<>
void set_param(vec_from_file<config_t> &v, const json &j)#
-
template<>
void set_param(std::monostate&, const nlohmann::json&)#
-
template<>
void set_param(bool &t, const nlohmann::json &j)#
-
template<>
void set_param(std::string &t, const nlohmann::json &j)#
- template void get_param (const util::possible_alias_t< std::string > &, json &)
- template void get_param (const util::possible_alias_t< bool > &, json &)
- template void set_param (util::possible_alias_t< float > &, const json &)
- template void get_param (const util::possible_alias_t< float > &, json &)
- template void set_param (util::possible_alias_t< double, float > &, const json &)
- template void get_param (const util::possible_alias_t< double, float > &, json &)
- template void set_param (util::possible_alias_t< long double, double, float > &, const json &)
- template void get_param (const util::possible_alias_t< long double, double, float > &, json &)
- template void set_param (util::possible_alias_t< int8_t > &, const json &)
- template void get_param (const util::possible_alias_t< int8_t > &, json &)
- template void set_param (util::possible_alias_t< uint8_t > &, const json &)
- template void get_param (const util::possible_alias_t< uint8_t > &, json &)
- template void set_param (util::possible_alias_t< int16_t > &, const json &)
- template void get_param (const util::possible_alias_t< int16_t > &, json &)
- template void set_param (util::possible_alias_t< uint16_t > &, const json &)
- template void get_param (const util::possible_alias_t< uint16_t > &, json &)
- template void set_param (util::possible_alias_t< int32_t > &, const json &)
- template void get_param (const util::possible_alias_t< int32_t > &, json &)
- template void set_param (util::possible_alias_t< int64_t > &, const json &)
- template void get_param (const util::possible_alias_t< int64_t > &, json &)
- template void set_param (util::possible_alias_t< uint32_t > &, const json &)
- template void get_param (const util::possible_alias_t< uint32_t > &, json &)
- template void set_param (util::possible_alias_t< uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< uint64_t > &, json &)
- template void set_param (util::possible_alias_t< short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< long long, long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< long long, long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< ptrdiff_t, long long, long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< ptrdiff_t, long long, long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< unsigned long long, unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< unsigned long long, unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< size_t, unsigned long long, unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, const json &)
- template void get_param (const util::possible_alias_t< size_t, unsigned long long, unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, json &)
- template void set_param (util::possible_alias_t< std::chrono::nanoseconds > &, const json &)
- template void get_param (const util::possible_alias_t< std::chrono::nanoseconds > &, json &)
- template void set_param (util::possible_alias_t< std::chrono::microseconds > &, const json &)
- template void get_param (const util::possible_alias_t< std::chrono::microseconds > &, json &)
- template void set_param (util::possible_alias_t< std::chrono::milliseconds > &, const json &)
- template void get_param (const util::possible_alias_t< std::chrono::milliseconds > &, json &)
- template void set_param (util::possible_alias_t< std::chrono::seconds > &, const json &)
- template void get_param (const util::possible_alias_t< std::chrono::seconds > &, json &)
- template void set_param (util::possible_alias_t< std::chrono::minutes > &, const json &)
- template void get_param (const util::possible_alias_t< std::chrono::minutes > &, json &)
- template void set_param (util::possible_alias_t< std::chrono::hours > &, const json &)
- template void get_param (const util::possible_alias_t< std::chrono::hours > &, json &)
- template void set_param (util::possible_alias_t< PANOCStopCrit > &, const json &)
- template void get_param (const util::possible_alias_t< PANOCStopCrit > &, json &)
- template void set_param (util::possible_alias_t< LBFGSStepSize > &, const json &)
- template void get_param (const util::possible_alias_t< LBFGSStepSize > &, json &)
- template void set_param (util::possible_alias_t< CBFGSParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< CBFGSParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< LipschitzEstimateParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< LipschitzEstimateParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< PANOCParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< PANOCParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< FISTAParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< FISTAParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< ZeroFPRParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< ZeroFPRParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< PANTRParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< PANTRParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< LBFGSParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< LBFGSParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< AndersonAccelParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< AndersonAccelParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< LBFGSDirectionParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< LBFGSDirectionParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< AndersonDirectionParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< AndersonDirectionParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< StructuredLBFGSDirectionParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< StructuredLBFGSDirectionParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< NewtonTRDirectionParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< NewtonTRDirectionParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< SteihaugCGParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< SteihaugCGParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< StructuredNewtonRegularizationParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< StructuredNewtonRegularizationParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< StructuredNewtonDirectionParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< StructuredNewtonDirectionParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< ConvexNewtonRegularizationParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< ConvexNewtonRegularizationParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< ConvexNewtonDirectionParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< ConvexNewtonDirectionParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< ALMParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< ALMParams< config_t > > &, json &)
- template void set_param (util::possible_alias_t< PANOCOCPParams< config_t > > &, const json &)
- template void get_param (const util::possible_alias_t< PANOCOCPParams< config_t > > &, json &)
-
template<>
void set_param(std::monostate&, ParamString)#
-
template<>
void set_param(bool &b, ParamString s)#
-
template<>
void set_param(std::string_view &v, ParamString s)#
-
template<>
void set_param(std::string &v, ParamString s)#
-
template<class T>
void set_param_default(T &f, ParamString s)#
-
template<>
void set_param(alpaqa::vec<config_t> &v, ParamString s)#
-
template<>
void set_param(vec_from_file<config_t> &v, ParamString s)#
-
template<class Duration>
void set_param_default(Duration &t, ParamString s)#
- template void set_param (util::possible_alias_t< float > &, ParamString)
- template void set_param (util::possible_alias_t< double, float > &, ParamString)
- template void set_param (util::possible_alias_t< long double, double, float > &, ParamString)
- template void set_param (util::possible_alias_t< int8_t > &, ParamString)
- template void set_param (util::possible_alias_t< uint8_t > &, ParamString)
- template void set_param (util::possible_alias_t< int16_t > &, ParamString)
- template void set_param (util::possible_alias_t< uint16_t > &, ParamString)
- template void set_param (util::possible_alias_t< int32_t > &, ParamString)
- template void set_param (util::possible_alias_t< int64_t > &, ParamString)
- template void set_param (util::possible_alias_t< uint32_t > &, ParamString)
- template void set_param (util::possible_alias_t< uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< long long, long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< ptrdiff_t, long long, long, int, short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< unsigned long long, unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< size_t, unsigned long long, unsigned long, unsigned int, unsigned short, int8_t, uint8_t, int16_t, uint16_t, int32_t, int64_t, uint32_t, uint64_t > &, ParamString)
- template void set_param (util::possible_alias_t< std::chrono::nanoseconds > &, ParamString)
- template void set_param (util::possible_alias_t< std::chrono::microseconds > &, ParamString)
- template void set_param (util::possible_alias_t< std::chrono::milliseconds > &, ParamString)
- template void set_param (util::possible_alias_t< std::chrono::seconds > &, ParamString)
- template void set_param (util::possible_alias_t< std::chrono::minutes > &, ParamString)
- template void set_param (util::possible_alias_t< std::chrono::hours > &, ParamString)
- template void set_param (util::possible_alias_t< PANOCStopCrit > &, ParamString)
- template void set_param (util::possible_alias_t< LBFGSStepSize > &, ParamString)
- template void set_param (util::possible_alias_t< PANOCParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< FISTAParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< ZeroFPRParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< PANTRParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< LBFGSParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< AndersonAccelParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< LBFGSDirectionParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< AndersonDirectionParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< StructuredLBFGSDirectionParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< NewtonTRDirectionParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< SteihaugCGParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< StructuredNewtonRegularizationParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< StructuredNewtonDirectionParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< ConvexNewtonRegularizationParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< ConvexNewtonDirectionParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< ALMParams< config_t > > &, ParamString)
- template void set_param (util::possible_alias_t< PANOCOCPParams< config_t > > &, ParamString)
-
template<>
void set_param(Ipopt::IpoptApplication&, const json &j)#
-
template<>
void get_param(const Ipopt::IpoptApplication&, json &j)#
-
template<>
void set_param(Ipopt::IpoptApplication &app, ParamString s)#
-
template<>
void set_param(lbfgsb::LBFGSBSolver::Params &t, const json &j)#
-
template<>
void get_param(const lbfgsb::LBFGSBSolver::Params &t, json &j)#
-
template<>
void set_param(lbfgsb::LBFGSBSolver::Params &t, ParamString s)#
-
template<>
void set_param(qpalm::Settings &t, const json &j)#
-
template<>
void get_param(const qpalm::Settings &t, json &j)#
-
template<>
void set_param(qpalm::Settings &t, ParamString s)#
Variables
-
template<class T>
constexpr bool is_duration = false#
-
class any_ptr#
- #include <alpaqa/params/structs.hpp>
Like std::any, but storing just the pointer, without any dynamic allocation.
-
template<class S>
struct attribute_accessor# Function wrapper to set attributes of a struct, type-erasing the type of the attribute.
-
template<>
struct attribute_accessor<MemberGetter># - #include </__w/alpaqa/alpaqa/src/alpaqa/src/driver/param-complete.hpp>
Public Types
-
using get_members_func_t = Result(const MemberGetter&)#
-
using get_members_func_t = Result(const MemberGetter&)#
-
template<class T, class S>
struct attribute_alias_table# Specialize this type to define the alternative attribute name to attribute setters dictionaries for a struct type
T.
-
template<class T, class S>
struct attribute_table# Specialize this type to define the attribute name to attribute setters dictionaries for a struct type
T.
-
template<class S>
struct attribute_table<RootOpts, S># -
Public Static Attributes
-
static const attribute_table_t<S> table = {{"method", attribute_accessor<S>::template make<type>(&type::method, "Solver to use")}, {"out", attribute_accessor<S>::template make<type>(&type::out, "File to write output to")}, {"sol", attribute_accessor<S>::template make<type>(&type::sol, "Folder to write the solutions and statistics to")}, {"x0", attribute_accessor<S>::template make<type>(&type::x0, "Initial guess for the solution")}, {"mul_g0", attribute_accessor<S>::template make<type>(&type::mul_g0, "Initial guess for the general constraint multipliers")}, {"mul_x0", attribute_accessor<S>::template make<type>(&type::mul_x0, "Initial guess for the bound constraint multipliers")}, {"num_exp", attribute_accessor<S>::template make<type>(&type::num_exp, "Number of times to repeat the experiment")}, {"extra_stats", attribute_accessor<S>::template make<type>(&type::extra_stats, "Log more per-iteration solver statistics")}, {"problem", attribute_accessor<S>::template make<type>(&type::problem, "Options to pass to the problem")},}#
-
static const attribute_table_t<S> table = {{"method", attribute_accessor<S>::template make<type>(&type::method, "Solver to use")}, {"out", attribute_accessor<S>::template make<type>(&type::out, "File to write output to")}, {"sol", attribute_accessor<S>::template make<type>(&type::sol, "Folder to write the solutions and statistics to")}, {"x0", attribute_accessor<S>::template make<type>(&type::x0, "Initial guess for the solution")}, {"mul_g0", attribute_accessor<S>::template make<type>(&type::mul_g0, "Initial guess for the general constraint multipliers")}, {"mul_x0", attribute_accessor<S>::template make<type>(&type::mul_x0, "Initial guess for the bound constraint multipliers")}, {"num_exp", attribute_accessor<S>::template make<type>(&type::num_exp, "Number of times to repeat the experiment")}, {"extra_stats", attribute_accessor<S>::template make<type>(&type::extra_stats, "Log more per-iteration solver statistics")}, {"problem", attribute_accessor<S>::template make<type>(&type::problem, "Options to pass to the problem")},}#
-
template<class S>
struct attribute_table<Struct, S># -
Public Static Attributes
-
static const attribute_table_t<S> table = {}#
-
static const attribute_table_t<S> table = {}#
-
template<class T, class S>
struct enum_accessor# Function wrapper access the enumerators of an enum, type-erasing the type of the enum.
-
template<class T>
struct enum_accessor<T, MemberGetter># - #include </__w/alpaqa/alpaqa/src/alpaqa/src/driver/param-complete.hpp>
Public Members
-
std::string_view doc#
-
std::string_view doc#
-
template<class T, class S>
struct enum_table# Specialize this type to define the enumerator name to value dictionaries for an enum type
T.
-
struct invalid_json_param : public invalid_argument#
- #include <alpaqa/params/json.hpp>
Custom parameter parsing exception.
Public Members
-
std::vector<std::string> backtrace#
-
std::vector<std::string> backtrace#
-
struct invalid_param : public invalid_argument#
- #include <alpaqa/params/params.hpp>
Custom parameter parsing exception.
-
struct MemberGetter#
- #include </__w/alpaqa/alpaqa/src/alpaqa/src/driver/param-complete.hpp>
-
struct ParamString#
- #include <alpaqa/params/params.hpp>
Represents a parameter value encoded as a string in the format
abc.def.key=value.
-
struct Result#
- #include </__w/alpaqa/alpaqa/src/alpaqa/src/driver/param-complete.hpp>
-
struct Member#
- #include </__w/alpaqa/alpaqa/src/alpaqa/src/driver/param-complete.hpp>
-
struct Member#
-
struct RootOpts#
-
struct Struct#
-
struct Value#
-
template<Config Conf>
struct vec_from_file# - #include <alpaqa/params/vec-from-file.hpp>
-
template<class S>
-
namespace sets#
Functions
-
template<Config Conf>
Conf::real_t alpaqa_tag_invoke(tag_t<alpaqa::prox>, Box<Conf> &self, typename Conf::crmat in, typename Conf::rmat out, typename Conf::real_t γ)#
-
template<Config Conf>
Conf::real_t alpaqa_tag_invoke(tag_t<alpaqa::prox_step>, Box<Conf> &self, typename Conf::crmat in, typename Conf::crmat fwd_step, typename Conf::rmat out, typename Conf::rmat fb_step, typename Conf::real_t γ, typename Conf::real_t γ_fwd)#
-
template<Config Conf>
inline auto project(const auto &v, const Box<Conf> &box)# Project a vector onto a box.
\[ \Pi_C(v) \]- Parameters:
v – [in] The vector to project
box – [in] The box to project onto
-
template<Config Conf>
inline auto projecting_difference(const auto &v, const Box<Conf> &box)# Get the difference between the given vector and its projection.
\[ v - \Pi_C(v) \]Warning
Beware catastrophic cancellation!
- Parameters:
v – [in] The vector to project
box – [in] The box to project onto
-
template<Config Conf>
inline auto dist_squared(const auto &v, const Box<Conf> &box)# Get the distance squared between the given vector and its projection.
\[ \left\| v - \Pi_C(v) \right\|_2^2 \]Warning
Beware catastrophic cancellation!
- Parameters:
v – [in] The vector to project
box – [in] The box to project onto
-
template<Config Conf>
inline auto dist_squared(const auto &v, const Box<Conf> &box, const auto &Σ) -> real_t<Conf># Get the distance squared between the given vector and its projection in the Σ norm.
\[ \left\| v - \Pi_C(v) \right\|_\Sigma^2 = \left(v - \Pi_C(v)\right)^\top \Sigma \left(v - \Pi_C(v)\right) \]Warning
Beware catastrophic cancellation!
- Parameters:
v – [in] The vector to project
box – [in] The box to project onto
Σ – [in] Diagonal matrix defining norm
-
template<Config Conf = DefaultConfig>
struct Box# - #include <alpaqa/problem/box.hpp>
-
template<Config Conf>
-
namespace sparsity#
Typedefs
-
template<class To>
using ConverterVariant = detail::ConverterVariantHelper<To, SparsityVariant<typename To::config_t>>::type#
Enums
Functions
-
template<Config Conf>
bool is_dense(const Sparsity<Conf> &sp)# Returns true if the sparsity pattern represents a dense matrix.
-
template<Config Conf>
struct Dense# - #include <alpaqa/problem/sparsity.hpp>
Dense matrix structure.
Stores all elements in column-major storage. Symmetric dense matrices always store all elements.
-
template<Config Conf, class StorageIndex>
struct SparseCOO# - #include <alpaqa/problem/sparsity.hpp>
Sparse coordinate list structure (COO).
Public Types
-
enum Order#
Values:
-
enumerator Unsorted#
The indices are not sorted.
-
enumerator SortedByColsAndRows#
The indices are sorted by column first, and within each column, the rows are sorted as well.
-
enumerator SortedByColsOnly#
The indices are sorted by column, but the rows within each column are not sorted.
-
enumerator SortedByRowsAndCols#
The indices are sorted by row first, and within each row, the columns are sorted as well.
-
enumerator SortedByRowsOnly#
The indices are sorted by row, but the columns within each row are not sorted.
-
enumerator Unsorted#
-
using storage_index_t = StorageIndex#
-
using index_vector_t = Eigen::VectorX<storage_index_t>#
-
using index_vector_view_t = Eigen::Ref<const index_vector_t>#
-
using index_vector_map_t = Eigen::Map<const index_vector_t>#
Public Members
-
Symmetry symmetry = Symmetry::Unsymmetric#
-
index_vector_view_t row_indices = index_vector_map_t{nullptr, 0}#
-
index_vector_view_t col_indices = index_vector_map_t{nullptr, 0}#
-
storage_index_t first_index = 0#
Zero for C/C++, one for Fortran.
-
enum Order#
-
template<Config Conf, class StorageIndex>
struct SparseCSC# - #include <alpaqa/problem/sparsity.hpp>
Sparse compressed-column structure (CCS or CSC).
Public Types
-
enum Order#
Values:
-
enumerator Unsorted#
The row indices are not sorted.
-
enumerator SortedRows#
Within each column, all row indices are sorted in ascending order.
-
enumerator Unsorted#
-
using storage_index_t = StorageIndex#
-
using index_vector_t = Eigen::VectorX<storage_index_t>#
-
using index_vector_view_t = Eigen::Ref<const index_vector_t>#
-
using index_vector_map_t = Eigen::Map<const index_vector_t>#
Public Members
-
Symmetry symmetry = Symmetry::Unsymmetric#
-
index_vector_view_t inner_idx = index_vector_map_t{nullptr, 0}#
-
index_vector_view_t outer_ptr = index_vector_map_t{nullptr, 0}#
-
enum Order#
-
template<Config Conf>
struct Sparsity# - #include <alpaqa/problem/sparsity.hpp>
Stores any of the supported sparsity patterns.
See also
Public Functions
-
inline Sparsity(std::convertible_to<SparsityVariant<Conf>> auto value)#
Public Members
-
SparsityVariant<Conf> value#
-
inline Sparsity(std::convertible_to<SparsityVariant<Conf>> auto value)#
-
template<class To>
struct SparsityConversionRequest# Additional options for the conversion performed by SparsityConverter.
-
template<Config Conf>
struct SparsityConversionRequest<Dense<Conf>># - #include <alpaqa/problem/sparsity-conversions.hpp>
-
template<Config Conf, class StorageIndex>
struct SparsityConversionRequest<SparseCOO<Conf, StorageIndex>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Members
-
std::optional<StorageIndex> first_index = std::nullopt#
Convert the index offset (zero for C/C++, one for Fortran).
-
std::optional<StorageIndex> first_index = std::nullopt#
-
template<Config Conf, class StorageIndex>
struct SparsityConversionRequest<SparseCSC<Conf, StorageIndex>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Members
-
std::optional<typename SparseCSC<Conf, StorageIndex>::Order> order = std::nullopt#
Sort the indices.
-
std::optional<typename SparseCSC<Conf, StorageIndex>::Order> order = std::nullopt#
-
template<class From, class To>
struct SparsityConverter# Converts one matrix storage format to another.
- Template Parameters:
From – The input sparsity pattern type.
To – The output sparsity pattern type.
-
template<Config Conf>
struct SparsityConverter<Dense<Conf>, Dense<Conf>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline SparsityConverter(from_sparsity_t from, Request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
Public Members
-
to_sparsity_t sparsity#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
-
template<Config Conf, class StorageIndex>
struct SparsityConverter<Dense<Conf>, SparseCOO<Conf, StorageIndex>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using to_sparsity_t = SparseCOO<Conf, StorageIndex>#
-
using storage_index_t = typename to_sparsity_t::storage_index_t#
-
using index_vector_t = typename to_sparsity_t::index_vector_t#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using to_sparsity_t = SparseCOO<Conf, StorageIndex>#
-
template<Config Conf, class StorageIndex>
struct SparsityConverter<Dense<Conf>, SparseCSC<Conf, StorageIndex>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using to_sparsity_t = SparseCSC<Conf, StorageIndex>#
-
using storage_index_t = typename to_sparsity_t::storage_index_t#
-
using index_vector_t = typename to_sparsity_t::index_vector_t#
-
using index_vector_view_t = typename to_sparsity_t::index_vector_view_t#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using to_sparsity_t = SparseCSC<Conf, StorageIndex>#
-
template<Config Conf, class StorageIndex>
struct SparsityConverter<SparseCOO<Conf, StorageIndex>, Dense<Conf>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using from_sparsity_t = SparseCOO<Conf, StorageIndex>#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using from_sparsity_t = SparseCOO<Conf, StorageIndex>#
-
template<Config Conf, class StorageIndexFrom, class StorageIndexTo>
struct SparsityConverter<SparseCOO<Conf, StorageIndexFrom>, SparseCOO<Conf, StorageIndexTo>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using from_sparsity_t = SparseCOO<Conf, StorageIndexFrom>#
-
using to_sparsity_t = SparseCOO<Conf, StorageIndexTo>#
-
using storage_index_t = typename to_sparsity_t::storage_index_t#
-
using index_vector_t = typename to_sparsity_t::index_vector_t#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using from_sparsity_t = SparseCOO<Conf, StorageIndexFrom>#
-
template<Config Conf, class StorageIndexFrom, class StorageIndexFromTo>
struct SparsityConverter<SparseCOO<Conf, StorageIndexFrom>, SparseCSC<Conf, StorageIndexFromTo>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using to_sparsity_t = SparseCSC<Conf, StorageIndexFromTo>#
-
using from_sparsity_t = SparseCOO<Conf, StorageIndexFrom>#
-
using storage_index_t = typename to_sparsity_t::storage_index_t#
-
using index_vector_t = typename to_sparsity_t::index_vector_t#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using to_sparsity_t = SparseCSC<Conf, StorageIndexFromTo>#
-
template<Config Conf, class StorageIndex>
struct SparsityConverter<SparseCSC<Conf, StorageIndex>, Dense<Conf>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using from_sparsity_t = SparseCSC<Conf, StorageIndex>#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using from_sparsity_t = SparseCSC<Conf, StorageIndex>#
-
template<Config Conf, class StorageIndexFrom, class StorageIndexTo>
struct SparsityConverter<SparseCSC<Conf, StorageIndexFrom>, SparseCOO<Conf, StorageIndexTo>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using from_sparsity_t = SparseCSC<Conf, StorageIndexFrom>#
-
using to_sparsity_t = SparseCOO<Conf, StorageIndexTo>#
-
using storage_index_t = typename to_sparsity_t::storage_index_t#
-
using index_vector_t = typename to_sparsity_t::index_vector_t#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using from_sparsity_t = SparseCSC<Conf, StorageIndexFrom>#
-
template<Config Conf, class StorageIndexFrom, class StorageIndexTo>
struct SparsityConverter<SparseCSC<Conf, StorageIndexFrom>, SparseCSC<Conf, StorageIndexTo>># - #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using to_sparsity_t = SparseCSC<Conf, StorageIndexTo>#
-
using from_sparsity_t = SparseCSC<Conf, StorageIndexFrom>#
-
using storage_index_t = typename to_sparsity_t::storage_index_t#
-
using index_vector_t = typename to_sparsity_t::index_vector_t#
-
using index_vector_view_t = typename to_sparsity_t::index_vector_view_t#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline to_sparsity_t convert_sparsity(from_sparsity_t from, Request request)#
-
inline SparsityConverter(from_sparsity_t from, Request request = {})#
-
inline operator const to_sparsity_t&() const &#
-
inline const to_sparsity_t &get_sparsity() const#
-
using to_sparsity_t = SparseCSC<Conf, StorageIndexTo>#
-
template<class Conf, class To>
struct SparsityConverter<Sparsity<Conf>, To># - #include <alpaqa/problem/sparsity-conversions.hpp>
Converts any supported matrix storage format to the given format.
See also
Public Types
-
using Request = SparsityConversionRequest<to_sparsity_t>#
Public Functions
-
inline operator const to_sparsity_t&() const#
-
inline const to_sparsity_t &get_sparsity() const#
Public Members
-
ConverterVariant<To> converter#
-
using Request = SparsityConversionRequest<to_sparsity_t>#
-
namespace detail#
Functions
-
template<class ...Ts>
overloaded(Ts...) -> overloaded<Ts...>#
-
template<class To, class>
struct ConverterVariantHelper#
- template<class To, class... Froms> variant< Froms... > >
- #include <alpaqa/problem/sparsity-conversions.hpp>
Public Types
-
using type = std::variant<SparsityConverter<Froms, To>...>#
-
using type = std::variant<SparsityConverter<Froms, To>...>#
-
template<class ...Ts>
struct overloaded : public Ts - #include <alpaqa/problem/sparsity.hpp>
-
template<class ...Ts>
-
template<class To>
-
namespace tag_invoke_ns#
Variables
-
constexpr tag_invoke_fn_ns::tag_invoke_fn alpaqa_tag_invoke = {}#
-
constexpr tag_invoke_fn_ns::tag_invoke_fn alpaqa_tag_invoke = {}#
-
namespace util#
Typedefs
-
template<class NewAlias, class ...PossibleAliases>
using possible_alias_t = std::conditional_t<detail::any_is_same<NewAlias, PossibleAliases...>(), detail::dummy<NewAlias, PossibleAliases...>, NewAlias># If
NewAliasis not the same type as any ofPossibleAliases, the result isNewAlias.If
NewAliasis not distinct fromPossibleAliases, the result is a dummy type, uniquely determined byNewAliasandPossibleAliases.
-
template<class M>
using class_from_member_ptr_impl_t = typename class_from_member_ptr_impl<M>::type#
-
template<auto M>
using class_from_member_ptr_t = class_from_member_ptr_impl_t<decltype(M)>#
-
template<class ...Pack>
using first_type_or_void_t = typename first_type_or_void<Pack...>::type#
Functions
-
template<class Rep, class Period>
std::string_view parse_single_duration(std::chrono::duration<Rep, Period> &t, std::string_view s)# Adds the first duration in the string
sto the durationt.
-
template<class Rep, class Period>
void parse_duration(std::chrono::duration<Rep, Period> &t, std::string_view s)# Adds the sum of the durations in the string
sto the durationt.
-
template<class T>
std::from_chars_result from_chars(const char *first, const char *last, T &value, std::chars_format fmt = std::chars_format::general)#
-
template<class T>
std::from_chars_result from_chars(const char *first, const char *last, T &value, int base = 10)#
-
template<class T, class ...Args>
std::from_chars_result from_chars(const char *first, const char *last, T &value, std::chars_format fmt = std::chars_format::general)#
-
template<class T, class ...Args>
std::from_chars_result from_chars(const char *first, const char *last, T &value, int base = 10)#
-
template<std::ranges::viewable_range R1, std::ranges::viewable_range R2, class Comp = std::ranges::less, class Proj1 = std::identity, class Proj2 = std::identity>
set_intersection_iterable<std::ranges::views::all_t<R1>, std::ranges::views::all_t<R2>, Comp, Proj1, Proj2> iter_set_intersection(R1 &&r1, R2 &&r2, Comp comp = {}, Proj1 proj1 = {}, Proj2 proj2 = {})#
-
template<class SpMat, class Mat, class MaskVec>
void sparse_add_masked(const SpMat &R_full, Mat &&R, const MaskVec &mask)# R += R_full(mask,mask)
-
template<class SpMat, class Mat, class MaskVec>
void sparse_add_masked_rows(const SpMat &S_full, Mat &&S, const MaskVec &mask)# S += S_full(mask,:)
-
template<class SpMat, class CVec, class Vec, class MaskVec>
void sparse_matvec_add_masked_rows_cols(const SpMat &R, const CVec &v, Vec &&out, const MaskVec &mask_J, const MaskVec &mask_K)# out += R(mask_J,mask_K) * v(mask_K);
-
template<class SpMat, class CVec, class Vec, class MaskVec>
void sparse_matvec_add_transpose_masked_rows(const SpMat &S, const CVec &v, Vec &&out, const MaskVec &mask)# out += S(mask,:)ᵀ * v(mask);
-
inline auto split(std::string_view full, std::string_view tok)#
Split the string
fullon the first occurrence oftok.Returns
(s, "")if tok was not found.
-
inline auto split_second(std::string_view full, std::string_view tok)#
Split the string
son the first occurrence oftok.Returns
("", s)if tok was not found.
-
std::string join(std::ranges::input_range auto strings, join_opt opt = {})#
Join the list of strings into a single string, using the separator given by
opt.See also
-
std::string join_quote(std::ranges::input_range auto strings, join_quote_opt opt = {})#
Join the list of strings into a single string, using the separator given by
opt.Each original string is quoted using the quote strings specified by
optSee also
-
void sort_case_insensitive(auto &range)#
Sort the given range of strings in-place in a case-insensitive manner.
-
template<class Class, auto Method, class ...ExtraArgs>
constexpr auto type_erased_wrapped()# Returns a function that accepts a void pointer, casts it to the class type of the member function
Method, launders it, and then invokesMethodwith it, passing on the arguments toMethod.The function can also accept additional arguments at the end, of type
ExtraArgs.
-
template<class VTable, class Allocator>
inline constexpr size_t default_te_buffer_size()#
-
template<class ...Types>
inline constexpr size_t required_te_buffer_size_for()#
-
class bad_type_erased_constness : public logic_error#
- #include <alpaqa/util/type-erasure.hpp>
Public Functions
-
inline bad_type_erased_constness()#
-
inline bad_type_erased_constness()#
-
class bad_type_erased_type : public logic_error#
- #include <alpaqa/util/type-erasure.hpp>
-
struct BasicVTable#
- #include <alpaqa/util/type-erasure.hpp>
Struct that stores the size of a polymorphic object, as well as pointers to functions to copy, move or destroy the object.
Inherit from this struct to add useful functions.
Subclassed by ControlProblemVTable< DefaultConfig >, ProblemVTable< DefaultConfig >, ControlProblemVTable< Conf >, ProblemVTable< Conf >
Public Types
-
template<class F>
using required_function_t = typename required_function<F>::type# A required function includes a void pointer to self, in addition to the arguments of
F.
-
template<class F, class VTable = BasicVTable>
using optional_function_t = typename optional_function<F, VTable>::type# An optional function includes a void pointer to self, the arguments of
F, and an additional reference to the VTable, so that it can be implemented in terms of other functions.
Public Functions
-
BasicVTable() = default#
Public Members
-
required_function_t<void(void *storage) const> copy = nullptr#
Copy-construct a new instance into storage.
-
required_function_t<void(void *storage)> move = nullptr#
Move-construct a new instance into storage.
-
required_function_t<void()> destroy = nullptr#
Destruct the given instance.
-
const std::type_info *type = &typeid(void)#
The original type of the stored object.
-
template<class, class VTable = BasicVTable>
struct optional_function#
-
template<class R, class ...Args, class VTable>
struct optional_function<R(Args...) const, VTable># - #include <alpaqa/util/type-erasure.hpp>
-
template<class R, class ...Args, class VTable>
struct optional_function<R(Args...), VTable># - #include <alpaqa/util/type-erasure.hpp>
-
template<class>
struct required_function#
-
template<class F>
-
template<class M>
struct class_from_member_ptr_impl# - #include <alpaqa/util/type-traits.hpp>
- template<class C, class Ret, class... Args> *)(Args...) const >
- #include <alpaqa/util/type-traits.hpp>
Public Types
-
using type = std::add_const_t<C>#
-
using type = std::add_const_t<C>#
- template<class C, class Ret, class... Args> *)(Args...)>
- #include <alpaqa/util/type-traits.hpp>
Public Types
-
using type = C
-
using type = C
-
template<class T>
struct copyable_unique_ptr# - #include <alpaqa/util/copyable_unique_ptr.hpp>
Public Functions
-
copyable_unique_ptr() = default#
-
inline copyable_unique_ptr(const copyable_unique_ptr &o)#
-
inline copyable_unique_ptr &operator=(const copyable_unique_ptr &o)#
-
copyable_unique_ptr(copyable_unique_ptr&&) noexcept = default#
-
copyable_unique_ptr &operator=(copyable_unique_ptr&&) noexcept = default#
-
inline auto &operator*()#
-
inline auto &operator*() const#
-
copyable_unique_ptr() = default#
-
template<class Rng>
struct enumerate_t : public std::ranges::view_interface<enumerate_t<Rng>># - #include <alpaqa/util/enumerate.hpp>
Public Types
Public Functions
-
enumerate_t() = default#
-
inline auto begin() const -> std::input_or_output_iterator auto#
-
inline auto end() const#
-
struct iter_t#
- #include <alpaqa/util/enumerate.hpp>
Public Types
-
using difference_type = std::ptrdiff_t#
Public Functions
-
iter_t() = default#
-
inline bool operator!=(sentinel_t s) const#
-
inline bool operator==(sentinel_t s) const#
-
inline value_type operator*() const#
Friends
-
inline friend bool operator!=(sentinel_t s, const iter_t &i)#
-
inline friend bool operator==(sentinel_t s, const iter_t &i)#
-
using difference_type = std::ptrdiff_t#
-
struct sentinel_t#
- #include <alpaqa/util/enumerate.hpp>
-
enumerate_t() = default#
-
template<class ...Pack>
struct first_type_or_void#
-
template<class First, class ...Pack>
struct first_type_or_void<First, Pack...># - #include <alpaqa/util/type-traits.hpp>
-
template<>
struct first_type_or_void<># - #include <alpaqa/util/type-traits.hpp>
Public Types
-
using type = void#
-
using type = void#
-
struct invalid_duration_units : public invalid_argument#
- #include <alpaqa/util/duration-parse.hpp>
Public Functions
-
inline explicit invalid_duration_units(const std::string &arg, std::string_view units)#
Public Members
-
std::string_view units#
Points into original argument, beware lifetime issues.
-
inline explicit invalid_duration_units(const std::string &arg, std::string_view units)#
-
struct invalid_duration_value : public invalid_argument#
- #include <alpaqa/util/duration-parse.hpp>
Public Functions
-
inline explicit invalid_duration_value(const std::string &arg, std::from_chars_result result)#
Public Members
-
std::from_chars_result result#
-
inline explicit invalid_duration_value(const std::string &arg, std::from_chars_result result)#
-
template<class It>
struct iter_range_adapter# - #include <alpaqa/util/iter-adapter.hpp>
Public Functions
-
iter_range_adapter() = default#
-
inline auto begin() const & -> std::input_or_output_iterator auto#
-
inline auto begin() && -> std::input_or_output_iterator auto#
-
inline auto end() const#
-
struct iter_t : public std::remove_cvref_t<It>#
- #include <alpaqa/util/iter-adapter.hpp>
Public Types
-
using difference_type = std::ptrdiff_t#
Public Functions
-
iter_t() = default#
-
inline bool operator!=(sentinel_t) const#
-
inline bool operator==(sentinel_t) const#
Friends
-
inline friend bool operator!=(sentinel_t s, const iter_t &i)#
-
inline friend bool operator==(sentinel_t s, const iter_t &i)#
-
using difference_type = std::ptrdiff_t#
-
struct sentinel_t#
- #include <alpaqa/util/iter-adapter.hpp>
-
iter_range_adapter() = default#
-
struct join_quote_opt#
- #include <alpaqa/util/string-util.hpp>
See also
-
template<class First, class ...Pack>
struct last_type# - #include <alpaqa/util/type-traits.hpp>
-
template<class Only>
struct last_type<Only># - #include <alpaqa/util/type-traits.hpp>
Public Types
-
using type = Only
-
using type = Only
-
template<class T>
struct noop_delete# - #include <alpaqa/util/noop-delete.hpp>
Deleter for
std::unique_ptrthat just destructs the object, without deallocating.
-
template<std::ranges::input_range R1, std::ranges::input_range R2, class Comp = std::ranges::less, class Proj1 = std::identity, class Proj2 = std::identity>
struct set_intersection_iterable : public std::ranges::view_interface<set_intersection_iterable<R1, R2, std::ranges::less, std::identity, std::identity>># - #include <alpaqa/util/set-intersection.hpp>
Public Functions
-
set_intersection_iterable() = default#
-
inline set_intersection_iterable(R1 &&range1, R2 &&range2, Comp &&comp, Proj1 &&proj1, Proj2 &&proj2)#
-
inline auto begin() const -> std::input_or_output_iterator auto#
-
inline auto end() const#
-
template<std::input_iterator I1, std::sentinel_for<I1> S1, std::input_iterator I2, std::sentinel_for<I2> S2>
struct iter_t# - #include <alpaqa/util/set-intersection.hpp>
Public Types
-
using difference_type = std::ptrdiff_t#
Public Functions
-
iter_t() = default#
-
inline bool operator!=(sentinel_t) const#
-
inline bool operator==(sentinel_t s) const#
-
inline value_type operator*() const#
-
inline void advance()#
Friends
-
inline friend bool operator!=(sentinel_t s, const iter_t &i)#
-
inline friend bool operator==(sentinel_t s, const iter_t &i)#
-
using difference_type = std::ptrdiff_t#
-
struct sentinel_t#
- #include <alpaqa/util/set-intersection.hpp>
-
set_intersection_iterable() = default#
-
template<class VTable = BasicVTable, class Allocator = std::allocator<std::byte>, size_t SmallBufferSize = default_te_buffer_size<VTable, Allocator>()>
class TypeErased# - #include <alpaqa/util/type-erasure.hpp>
Class for polymorphism through type erasure.
Saves the entire vtable, and uses small buffer optimization.
Subclassed by TypeErasedControlProblem< config_t >, TypeErasedProblem< config_t >, TypeErasedControlProblem< Conf, Allocator >, TypeErasedProblem< Conf, Allocator >
Public Functions
-
TypeErased() noexcept(noexcept(allocator_type()) && noexcept(VTable())) = default#
Default constructor.
-
template<class Alloc>
inline TypeErased(std::allocator_arg_t, const Alloc &alloc)# Default constructor (allocator aware).
-
inline TypeErased(const TypeErased &other)#
Copy constructor.
-
inline TypeErased(const TypeErased &other, const allocator_type &alloc)#
Copy constructor (allocator aware).
-
inline TypeErased(std::allocator_arg_t, const allocator_type &alloc, const TypeErased &other)#
Copy constructor (allocator aware).
-
inline TypeErased &operator=(const TypeErased &other)#
Copy assignment.
-
inline TypeErased(TypeErased &&other) noexcept#
Move constructor.
-
inline TypeErased(TypeErased &&other, const allocator_type &alloc) noexcept#
Move constructor (allocator aware).
-
inline TypeErased(std::allocator_arg_t, const allocator_type &alloc, TypeErased &&other) noexcept#
Move constructor (allocator aware).
-
inline TypeErased &operator=(TypeErased &&other) noexcept#
Move assignment.
-
inline ~TypeErased()#
Destructor.
-
template<class T, class Alloc>
inline explicit TypeErased(std::allocator_arg_t, const Alloc &alloc, T &&d)# Main constructor that type-erases the given argument.
-
template<class T, class Alloc, class ...Args>
inline explicit TypeErased(std::allocator_arg_t, const Alloc &alloc, std::in_place_type_t<T>, Args&&... args)# Main constructor that type-erases the object constructed from the given argument.
-
template<class T>
inline explicit TypeErased(T &&d)# Main constructor that type-erases the given argument.
Requirement prevents this constructor from taking precedence over the copy and move constructors.
-
template<class T, class ...Args>
inline explicit TypeErased(std::in_place_type_t<T>, Args&&... args)# Main constructor that type-erases the object constructed from the given argument.
-
inline explicit operator bool() const noexcept#
Check if this wrapper wraps an object.
False for default-constructed objects.
-
inline bool owns_referenced_object() const noexcept#
Check if this wrapper owns the storage of the wrapped object, or whether it simply stores a reference to an object that was allocated elsewhere.
-
inline bool referenced_object_is_const() const noexcept#
Check if the wrapped object is const.
-
inline allocator_type get_allocator() const noexcept#
Get a copy of the allocator.
-
inline const std::type_info &type() const noexcept#
Query the contained type.
-
template<class T>
inline T &as() &# Convert the type-erased object to the given type.
- Throws:
alpaqa::util::bad_type_erased_type – If T does not match the stored type.
-
template<class T>
inline T &as() const &# Convert the type-erased object to the given type.
- Throws:
alpaqa::util::bad_type_erased_type – If T does not match the stored type.
-
template<class T>
inline T &&as() &&# Convert the type-erased object to the given type.
- Throws:
alpaqa::util::bad_type_erased_type – If T does not match the stored type.
-
inline void *get_pointer() const#
Get a type-erased pointer to the wrapped object.
See also
- Throws:
alpaqa::util::bad_type_erased_constness – If the wrapped object is const.
-
inline const void *get_const_pointer() const#
Get a type-erased pointer to the wrapped object.
Public Static Functions
Public Static Attributes
-
static constexpr size_t small_buffer_size = SmallBufferSize#
Friends
-
template<std::derived_from<TypeErased> Child>
inline friend void derived_from_TypeErased_helper(const Child&) noexcept# See also
derived_from_TypeErased
-
TypeErased() noexcept(noexcept(allocator_type()) && noexcept(VTable())) = default#
-
namespace detail#
Functions
-
template<class A, class ...Bs>
constexpr bool any_is_same()# Check if
Ais equal to any ofBs.
-
template<class SpMat, class MaskVec>
auto select_rows_in_col(const SpMat &sp_mat, MaskVec &mask, auto column)# Returns a range over the row indices in the given column of
sp_matthat are also inmask.The range consists of the full Eigen InnerIterators (row, column, value).
-
template<class SpMat, class MaskVec>
auto select_rows_in_col_iota(const SpMat &sp_mat, MaskVec &mask, auto column)# Like select_rows_in_col, but returns a range of tuples containing the Eigen InnerIterator and a linear index into the mask.
-
template<class...>
struct dummy# Unused unique type tag for template specializations that were rejected because some types were not distinct.
-
template<class Class, class ...ExtraArgs>
struct Launderer# - #include <alpaqa/util/type-erasure.hpp>
Public Static Functions
-
template<auto Method>
static inline constexpr auto invoker()# Returns a function that accepts a void pointer, casts it to the class type of the member function
Method, launders it, and then invokesMethodwith it, passing on the arguments toMethod.The function can also accept additional arguments at the end, of type
ExtraArgs.
-
template<auto Method>
-
template<class A, class ...Bs>
-
template<class NewAlias, class ...PossibleAliases>
-
namespace vec_util#
-
using DefaultConfig = EigenConfigd#