alpaqa 1.0.0a12
Nonconvex constrained optimization
Loading...
Searching...
No Matches
params.cpp
Go to the documentation of this file.
1#include <alpaqa/inner/directions/panoc/anderson.hpp>
2#include <alpaqa/inner/directions/panoc/lbfgs.hpp>
3#include <alpaqa/inner/directions/panoc/structured-lbfgs.hpp>
4#include <alpaqa/inner/directions/panoc/structured-newton.hpp>
5#include <alpaqa/inner/directions/pantr/newton-tr.hpp>
6#include <alpaqa/inner/internal/lipschitz.hpp>
7#include <alpaqa/inner/internal/panoc-stop-crit.hpp>
8#include <alpaqa/inner/panoc.hpp>
9#include <alpaqa/inner/pantr.hpp>
10#include <alpaqa/inner/zerofpr.hpp>
11#include <alpaqa/outer/alm.hpp>
12#include <alpaqa/util/io/csv.hpp>
13#if ALPAQA_WITH_OCP
14#include <alpaqa/inner/panoc-ocp.hpp>
15#endif
16
17#include <alpaqa/implementation/params/params.tpp>
18
19#include <fstream>
20
21#include "from_chars-compat.ipp"
22
23namespace alpaqa::params {
24
25template <>
26void ALPAQA_EXPORT set_param(bool &b, ParamString s) {
27 assert_key_empty<bool>(s);
28 if (s.value == "0" || s.value == "false")
29 b = false;
30 else if (s.value == "1" || s.value == "true")
31 b = true;
32 else
33 throw std::invalid_argument(
34 "Invalid value '" + std::string(s.value) +
35 "' for type 'bool' in '" + std::string(s.full_key) +
36 "',\n "
37 "possible values are: '0', '1', 'true', 'false'");
38}
39
40template <>
41void ALPAQA_EXPORT set_param(std::string_view &v, ParamString s) {
42 assert_key_empty<bool>(s);
43 v = s.value;
44}
45
46template <>
47void ALPAQA_EXPORT set_param(std::string &v, ParamString s) {
48 assert_key_empty<bool>(s);
49 v = s.value;
50}
51
52template <class T>
53 requires((std::floating_point<T> || std::integral<T>) && !std::is_enum_v<T>)
54void set_param(T &f, ParamString s) {
55 assert_key_empty<T>(s);
56 const auto *val_end = s.value.data() + s.value.size();
57 const auto *ptr = set_param_float_int(f, s);
58 if (ptr != val_end)
59 throw std::invalid_argument("Invalid suffix '" +
60 std::string(ptr, val_end) + "' for type '" +
61 demangled_typename(typeid(T)) + "' in '" +
62 std::string(s.full_key) + "'");
63}
64
65#ifdef ALPAQA_WITH_QUAD_PRECISION
66template <>
67void ALPAQA_EXPORT set_param(__float128 &f, ParamString s) {
68 long double ld;
69 set_param(ld, s);
70 f = static_cast<__float128>(ld);
71}
72#endif
73
74template <>
75void ALPAQA_EXPORT set_param(alpaqa::vec<config_t> &v, ParamString s) {
76 v.resize(std::count(s.value.begin(), s.value.end(), ',') + 1);
77 std::string_view value, remainder = s.value;
78 for (auto &e : v) {
79 std::tie(value, remainder) = split_key(remainder, ',');
80 set_param(e, {.full_key = s.full_key, .key = "", .value = value});
81 }
82}
83
84template <>
85void ALPAQA_EXPORT set_param(vec_from_file<config_t> &v, ParamString s) {
86 assert_key_empty<vec_from_file<config_t>>(s);
87 if (s.value.starts_with('@')) {
88 std::string fpath{s.value.substr(1)};
89 std::ifstream f(fpath);
90 if (!f)
91 throw std::invalid_argument("Unable to open file '" + fpath +
92 "' in '" + std::string(s.full_key) +
93 '\'');
94 try {
95 auto r = alpaqa::csv::read_row_std_vector<real_t<config_t>>(f);
96 auto r_size = static_cast<length_t<config_t>>(r.size());
97 if (v.expected_size >= 0 && r_size != v.expected_size)
98 throw std::invalid_argument(
99 "Incorrect size in '" + std::string(s.full_key) +
100 "' (got " + std::to_string(r.size()) + ", expected " +
101 std::to_string(v.expected_size) + ')');
102 v.value.emplace(cmvec<config_t>{r.data(), r_size});
103 } catch (alpaqa::csv::read_error &e) {
104 throw std::invalid_argument(
105 "Unable to read from file '" + fpath + "' in '" +
106 std::string(s.full_key) +
107 "': alpaqa::csv::read_error: " + e.what());
108 }
109 } else {
110 alpaqa::params::set_param(v.value.emplace(), s);
111 if (v.expected_size >= 0 && v.value->size() != v.expected_size)
112 throw std::invalid_argument(
113 "Incorrect size in '" + std::string(s.full_key) + "' (got " +
114 std::to_string(v.value->size()) + ", expected " +
115 std::to_string(v.expected_size) + ')');
116 }
117}
118
119template <class Rep, class Period>
120void set_param(std::chrono::duration<Rep, Period> &t, ParamString s) {
121 using Duration = std::remove_cvref_t<decltype(t)>;
122 assert_key_empty<Duration>(s);
123 const auto *val_end = s.value.data() + s.value.size();
124 double value;
125#if ALPAQA_USE_FROM_CHARS_FLOAT
126 auto [ptr, ec] = std::from_chars(s.value.data(), val_end, value);
127 if (ec != std::errc())
128 throw std::invalid_argument("Invalid value '" +
129 std::string(ptr, val_end) + "' for type '" +
130 demangled_typename(typeid(Duration)) +
131 "' in '" + std::string(s.full_key) +
132 "': " + std::make_error_code(ec).message());
133#else
134#pragma message "Using std::stod as a fallback to replace std::from_chars"
135 size_t end_index;
136 try {
137 value = std::stod(std::string(s.value), &end_index);
138 } catch (std::exception &e) {
139 throw std::invalid_argument(
140 "Invalid value '" + std::string(s.value) + "' for type '" +
141 demangled_typename(typeid(Duration)) + "' in '" +
142 std::string(s.full_key) + "': " + e.what());
143 }
144 const char *ptr = s.value.data() + end_index;
145#endif
146 std::string_view units{ptr, val_end};
147 auto cast = [](auto t) { return std::chrono::duration_cast<Duration>(t); };
148 if (units == "s" || units.empty())
149 t = cast(std::chrono::duration<double, std::ratio<1, 1>>{value});
150 else if (units == "ms")
151 t = cast(std::chrono::duration<double, std::ratio<1, 1000>>{value});
152 else if (units == "us" || units == "µs")
153 t = cast(std::chrono::duration<double, std::ratio<1, 1000000>>{value});
154 else if (units == "ns")
155 t = cast(
156 std::chrono::duration<double, std::ratio<1, 1000000000>>{value});
157 else if (units == "min")
158 t = cast(std::chrono::duration<double, std::ratio<60, 1>>{value});
159 else
160 throw std::invalid_argument("Invalid units '" + std::string(units) +
161 "' in '" + std::string(s.full_key) + "'");
162}
163
164template <>
165void ALPAQA_EXPORT set_param(LBFGSStepSize &t, ParamString s) {
166 if (s.value == "BasedOnExternalStepSize")
167 t = LBFGSStepSize::BasedOnExternalStepSize;
168 else if (s.value == "BasedOnCurvature")
169 t = LBFGSStepSize::BasedOnCurvature;
170 else
171 throw std::invalid_argument("Invalid value '" + std::string(s.value) +
172 "' for type 'LBFGSStepSize' in '" +
173 std::string(s.full_key) + "'");
174}
175
176template <>
177void ALPAQA_EXPORT set_param(PANOCStopCrit &t, ParamString s) {
178 if (s.value == "ApproxKKT")
179 t = PANOCStopCrit::ApproxKKT;
180 else if (s.value == "ApproxKKT2")
181 t = PANOCStopCrit::ApproxKKT2;
182 else if (s.value == "ProjGradNorm")
183 t = PANOCStopCrit::ProjGradNorm;
184 else if (s.value == "ProjGradNorm2")
185 t = PANOCStopCrit::ProjGradNorm2;
186 else if (s.value == "ProjGradUnitNorm")
187 t = PANOCStopCrit::ProjGradUnitNorm;
188 else if (s.value == "ProjGradUnitNorm2")
189 t = PANOCStopCrit::ProjGradUnitNorm2;
190 else if (s.value == "FPRNorm")
191 t = PANOCStopCrit::FPRNorm;
192 else if (s.value == "FPRNorm2")
193 t = PANOCStopCrit::FPRNorm2;
194 else if (s.value == "Ipopt")
195 t = PANOCStopCrit::Ipopt;
196 else if (s.value == "LBFGSBpp")
197 t = PANOCStopCrit::LBFGSBpp;
198 else
199 throw std::invalid_argument("Invalid value '" + std::string(s.value) +
200 "' for type 'PANOCStopCrit' in '" +
201 std::string(s.full_key) + "'");
202}
203
204PARAMS_TABLE(LBFGSParams<config_t>, //
205 PARAMS_MEMBER(memory), //
206 PARAMS_MEMBER(min_div_fac), //
207 PARAMS_MEMBER(min_abs_s), //
208 PARAMS_MEMBER(cbfgs), //
209 PARAMS_MEMBER(force_pos_def), //
210 PARAMS_MEMBER(stepsize), //
211);
212
213PARAMS_TABLE(AndersonAccelParams<config_t>, //
214 PARAMS_MEMBER(memory), //
215 PARAMS_MEMBER(min_div_fac), //
216);
217
218PARAMS_TABLE(CBFGSParams<config_t>, //
219 PARAMS_MEMBER(α), //
220 PARAMS_MEMBER(ϵ), //
221);
222
223PARAMS_TABLE(LipschitzEstimateParams<config_t>, //
224 PARAMS_MEMBER(L_0), //
225 PARAMS_MEMBER(δ), //
226 PARAMS_MEMBER(ε), //
227 PARAMS_MEMBER(Lγ_factor), //
228);
229
230PARAMS_TABLE(PANTRParams<config_t>, //
231 PARAMS_MEMBER(Lipschitz), //
232 PARAMS_MEMBER(max_iter), //
233 PARAMS_MEMBER(max_time), //
234 PARAMS_MEMBER(L_min), //
235 PARAMS_MEMBER(L_max), //
236 PARAMS_MEMBER(stop_crit), //
237 PARAMS_MEMBER(max_no_progress), //
238 PARAMS_MEMBER(print_interval), //
239 PARAMS_MEMBER(print_precision), //
240 PARAMS_MEMBER(quadratic_upperbound_tolerance_factor), //
241 PARAMS_MEMBER(TR_tolerance_factor), //
242 PARAMS_MEMBER(ratio_threshold_acceptable), //
243 PARAMS_MEMBER(ratio_threshold_good), //
244 PARAMS_MEMBER(radius_factor_rejected), //
245 PARAMS_MEMBER(radius_factor_acceptable), //
246 PARAMS_MEMBER(radius_factor_good), //
247 PARAMS_MEMBER(initial_radius), //
248 PARAMS_MEMBER(min_radius), //
249 PARAMS_MEMBER(compute_ratio_using_new_stepsize), //
250 PARAMS_MEMBER(update_direction_on_prox_step), //
251 PARAMS_MEMBER(recompute_last_prox_step_after_direction_reset), //
252 PARAMS_MEMBER(disable_acceleration), //
253 PARAMS_MEMBER(ratio_approx_fbe_quadratic_model), //
254);
255
256PARAMS_TABLE(PANOCParams<config_t>, //
257 PARAMS_MEMBER(Lipschitz), //
258 PARAMS_MEMBER(max_iter), //
259 PARAMS_MEMBER(max_time), //
260 PARAMS_MEMBER(min_linesearch_coefficient), //
261 PARAMS_MEMBER(force_linesearch), //
262 PARAMS_MEMBER(linesearch_strictness_factor), //
263 PARAMS_MEMBER(L_min), //
264 PARAMS_MEMBER(L_max), //
265 PARAMS_MEMBER(stop_crit), //
266 PARAMS_MEMBER(max_no_progress), //
267 PARAMS_MEMBER(print_interval), //
268 PARAMS_MEMBER(print_precision), //
269 PARAMS_MEMBER(quadratic_upperbound_tolerance_factor), //
270 PARAMS_MEMBER(linesearch_tolerance_factor), //
271 PARAMS_MEMBER(update_direction_in_candidate), //
272 PARAMS_MEMBER(recompute_last_prox_step_after_lbfgs_flush), //
273 PARAMS_MEMBER(eager_gradient_eval), //
274);
275
276PARAMS_TABLE(ZeroFPRParams<config_t>, //
277 PARAMS_MEMBER(Lipschitz), //
278 PARAMS_MEMBER(max_iter), //
279 PARAMS_MEMBER(max_time), //
280 PARAMS_MEMBER(min_linesearch_coefficient), //
281 PARAMS_MEMBER(force_linesearch), //
282 PARAMS_MEMBER(linesearch_strictness_factor), //
283 PARAMS_MEMBER(L_min), //
284 PARAMS_MEMBER(L_max), //
285 PARAMS_MEMBER(stop_crit), //
286 PARAMS_MEMBER(max_no_progress), //
287 PARAMS_MEMBER(print_interval), //
288 PARAMS_MEMBER(print_precision), //
289 PARAMS_MEMBER(quadratic_upperbound_tolerance_factor), //
290 PARAMS_MEMBER(linesearch_tolerance_factor), //
291 PARAMS_MEMBER(update_direction_in_candidate), //
292 PARAMS_MEMBER(recompute_last_prox_step_after_lbfgs_flush), //
293 PARAMS_MEMBER(update_direction_from_prox_step), //
294);
295
296PARAMS_TABLE(LBFGSDirectionParams<config_t>, //
297 PARAMS_MEMBER(rescale_on_step_size_changes), //
298);
299
300PARAMS_TABLE(AndersonDirectionParams<config_t>, //
301 PARAMS_MEMBER(rescale_on_step_size_changes), //
302);
303
304PARAMS_TABLE(StructuredLBFGSDirectionParams<config_t>, //
305 PARAMS_MEMBER(hessian_vec_factor), //
306 PARAMS_MEMBER(hessian_vec_finite_differences), //
307 PARAMS_MEMBER(full_augmented_hessian), //
308);
309
310PARAMS_TABLE(NewtonTRDirectionParams<config_t>, //
311 PARAMS_MEMBER(rescale_on_step_size_changes), //
312 PARAMS_MEMBER(hessian_vec_factor), //
313 PARAMS_MEMBER(finite_diff), //
314 PARAMS_MEMBER(finite_diff_stepsize), //
315);
316
317PARAMS_TABLE(SteihaugCGParams<config_t>, //
318 PARAMS_MEMBER(tol_scale), //
319 PARAMS_MEMBER(tol_scale_root), //
320 PARAMS_MEMBER(tol_max), //
321 PARAMS_MEMBER(max_iter_factor), //
322);
323
324PARAMS_TABLE(StructuredNewtonRegularizationParams<config_t>, //
325 PARAMS_MEMBER(min_eig), //
326 PARAMS_MEMBER(print_eig), //
327);
328
329PARAMS_TABLE(StructuredNewtonDirectionParams<config_t>, //
330 PARAMS_MEMBER(hessian_vec_factor), //
331);
332
333PARAMS_TABLE(ALMParams<config_t>, //
334 PARAMS_MEMBER(tolerance), //
335 PARAMS_MEMBER(dual_tolerance), //
336 PARAMS_MEMBER(penalty_update_factor), //
337 PARAMS_MEMBER(penalty_update_factor_lower), //
338 PARAMS_MEMBER(min_penalty_update_factor), //
339 PARAMS_MEMBER(initial_penalty), //
340 PARAMS_MEMBER(initial_penalty_factor), //
341 PARAMS_MEMBER(initial_penalty_lower), //
342 PARAMS_MEMBER(initial_tolerance), //
343 PARAMS_MEMBER(initial_tolerance_increase), //
344 PARAMS_MEMBER(tolerance_update_factor), //
345 PARAMS_MEMBER(ρ_increase), //
346 PARAMS_MEMBER(ρ_max), //
347 PARAMS_MEMBER(rel_penalty_increase_threshold), //
348 PARAMS_MEMBER(max_multiplier), //
349 PARAMS_MEMBER(max_penalty), //
350 PARAMS_MEMBER(min_penalty), //
351 PARAMS_MEMBER(max_iter), //
352 PARAMS_MEMBER(max_time), //
353 PARAMS_MEMBER(max_num_initial_retries), //
354 PARAMS_MEMBER(max_num_retries), //
355 PARAMS_MEMBER(max_total_num_retries), //
356 PARAMS_MEMBER(print_interval), //
357 PARAMS_MEMBER(print_precision), //
358 PARAMS_MEMBER(single_penalty_factor), //
359);
360
361#if ALPAQA_WITH_OCP
362PARAMS_TABLE(PANOCOCPParams<config_t>,
363 PARAMS_MEMBER(Lipschitz), //
364 PARAMS_MEMBER(max_iter), //
365 PARAMS_MEMBER(max_time), //
366 PARAMS_MEMBER(min_linesearch_coefficient), //
367 PARAMS_MEMBER(linesearch_strictness_factor), //
368 PARAMS_MEMBER(L_min), //
369 PARAMS_MEMBER(L_max), //
370 PARAMS_MEMBER(L_max_inc), //
371 PARAMS_MEMBER(stop_crit), //
372 PARAMS_MEMBER(max_no_progress), //
373 PARAMS_MEMBER(gn_interval), //
374 PARAMS_MEMBER(gn_sticky), //
375 PARAMS_MEMBER(reset_lbfgs_on_gn_step), //
376 PARAMS_MEMBER(lqr_factor_cholesky), //
377 PARAMS_MEMBER(lbfgs_params), //
378 PARAMS_MEMBER(print_interval), //
379 PARAMS_MEMBER(print_precision), //
380 PARAMS_MEMBER(quadratic_upperbound_tolerance_factor), //
381 PARAMS_MEMBER(linesearch_tolerance_factor), //
382 PARAMS_MEMBER(disable_acceleration), //
383);
384#endif
385
386namespace detail {
387
388/// Check if @p A is equal to any of @p Bs.
389template <class A, class... Bs>
390constexpr bool any_is_same() {
391 return (std::is_same_v<A, Bs> || ...);
392}
393
394/// Unused unique type tag for template specializations that were rejected
395/// because some types were not distinct.
396template <class...>
397struct _dummy;
398
399/// If @p NewAlias is not the same type as any of @p PossibleAliases, the result
400/// is @p NewAlias. If @p NewAlias is not distinct from @p PossibleAliases, the
401/// result is a dummy type, uniquely determined by @p NewAlias and
402/// @p PossibleAliases.
403template <class NewAlias, class... PossibleAliases>
404using possible_alias_t =
405 std::conditional_t<any_is_same<NewAlias, PossibleAliases...>(),
406 _dummy<NewAlias, PossibleAliases...>, NewAlias>;
407
408} // namespace detail
409
410template <class... Ts>
411void set_param(detail::_dummy<Ts...> &, ParamString) {}
412
413#define ALPAQA_SET_PARAM_INST(...) \
414 template void ALPAQA_EXPORT set_param( \
415 detail::possible_alias_t<__VA_ARGS__> &, ParamString)
416
417ALPAQA_SET_PARAM_INST(float);
418ALPAQA_SET_PARAM_INST(double, float);
419ALPAQA_SET_PARAM_INST(long double, double, float);
420
421ALPAQA_SET_PARAM_INST(int8_t);
422ALPAQA_SET_PARAM_INST(uint8_t);
423ALPAQA_SET_PARAM_INST(int16_t);
424ALPAQA_SET_PARAM_INST(uint16_t);
425ALPAQA_SET_PARAM_INST(int32_t);
426ALPAQA_SET_PARAM_INST(int64_t);
427ALPAQA_SET_PARAM_INST(uint32_t);
428ALPAQA_SET_PARAM_INST(uint64_t);
429
430// Here, we would like to instantiate alpaqa::params::set_param for all standard
431// integer types, but the issue is that they might not be distinct types:
432// For example, on some platforms, int32_t might be a weak alias to int, whereas
433// on other platforms, it could be a distinct type.
434// To resolve this issue, we use some metaprogramming to ensure distinct
435// instantiations with unique dummy types.
436#define ALPAQA_SET_PARAM_INST_INT(...) \
437 ALPAQA_SET_PARAM_INST(__VA_ARGS__, int8_t, uint8_t, int16_t, uint16_t, \
438 int32_t, int64_t, uint32_t, uint64_t)
439
440ALPAQA_SET_PARAM_INST_INT(short);
441ALPAQA_SET_PARAM_INST_INT(int, short);
442ALPAQA_SET_PARAM_INST_INT(long, int, short);
443ALPAQA_SET_PARAM_INST_INT(long long, long, int, short);
444ALPAQA_SET_PARAM_INST_INT(ptrdiff_t, long long, long, int, short);
445ALPAQA_SET_PARAM_INST_INT(unsigned short);
446ALPAQA_SET_PARAM_INST_INT(unsigned int, unsigned short);
447ALPAQA_SET_PARAM_INST_INT(unsigned long, unsigned int, unsigned short);
448ALPAQA_SET_PARAM_INST_INT(unsigned long long, unsigned long, unsigned int,
449 unsigned short);
450ALPAQA_SET_PARAM_INST_INT(size_t, unsigned long long, unsigned long,
451 unsigned int, unsigned short);
452
453ALPAQA_SET_PARAM_INST(std::chrono::nanoseconds);
454ALPAQA_SET_PARAM_INST(std::chrono::microseconds);
455ALPAQA_SET_PARAM_INST(std::chrono::milliseconds);
456ALPAQA_SET_PARAM_INST(std::chrono::seconds);
457ALPAQA_SET_PARAM_INST(std::chrono::minutes);
458ALPAQA_SET_PARAM_INST(std::chrono::hours);
459
460ALPAQA_SET_PARAM_INST(PANOCParams<config_t>);
461ALPAQA_SET_PARAM_INST(ZeroFPRParams<config_t>);
462ALPAQA_SET_PARAM_INST(PANTRParams<config_t>);
463ALPAQA_SET_PARAM_INST(LBFGSParams<config_t>);
464ALPAQA_SET_PARAM_INST(AndersonAccelParams<config_t>);
465ALPAQA_SET_PARAM_INST(LBFGSDirectionParams<config_t>);
466ALPAQA_SET_PARAM_INST(AndersonDirectionParams<config_t>);
467ALPAQA_SET_PARAM_INST(StructuredLBFGSDirectionParams<config_t>);
468ALPAQA_SET_PARAM_INST(NewtonTRDirectionParams<config_t>);
469ALPAQA_SET_PARAM_INST(SteihaugCGParams<config_t>);
470ALPAQA_SET_PARAM_INST(StructuredNewtonRegularizationParams<config_t>);
471ALPAQA_SET_PARAM_INST(StructuredNewtonDirectionParams<config_t>);
472ALPAQA_SET_PARAM_INST(ALMParams<config_t>);
473#if ALPAQA_WITH_OCP
474ALPAQA_SET_PARAM_INST(PANOCOCPParams<config_t>);
475#endif
476
477} // namespace alpaqa::params
demangled_typename
std::string demangled_typename(const std::type_info &t)
Get the pretty name of the given type as a string.
Definition demangled-typename.cpp:7
from_chars-compat.ipp
finite_diff
vec finite_diff(const std::function< real_t(crvec)> &f, crvec x)
Definition gradient-checker.cpp:175
alpaqa::params::detail::possible_alias_t
std::conditional_t< any_is_same< NewAlias, PossibleAliases... >(), _dummy< NewAlias, PossibleAliases... >, NewAlias > possible_alias_t
If NewAlias is not the same type as any of PossibleAliases, the result is NewAlias.
Definition params.cpp:406
alpaqa::params::detail::any_is_same
constexpr bool any_is_same()
Check if A is equal to any of Bs.
Definition params.cpp:390
alpaqa::params::set_param
void set_param(bool &b, ParamString s)
Definition params.cpp:26
alpaqa::params::ParamString::full_key
std::string_view full_key
Full key string, used for diagnostics.
Definition params.hpp:18
alpaqa::params::split_key
auto split_key(std::string_view full, char tok='.')
Split the string full on the first occurrence of tok.
Definition params.hpp:32
alpaqa::params::ParamString::value
std::string_view value
The value of the parameter to store.
Definition params.hpp:22
alpaqa::params::ParamString
Represents a parameter value encoded as a string in the format abc.def.key=value.
Definition params.hpp:16
alpaqa::params::vec_from_file
Definition params.hpp:67
alpaqa::PANOCStopCrit::LBFGSBpp
@ LBFGSBpp
The stopping criterion used by LBFGS++, see https://lbfgspp.statr.me/doc/classLBFGSpp_1_1LBFGSBParam....
alpaqa::PANOCStopCrit::ProjGradUnitNorm
@ ProjGradUnitNorm
∞-norm of the projected gradient with unit step size:
alpaqa::PANOCStopCrit::ProjGradNorm
@ ProjGradNorm
∞-norm of the projected gradient with step size γ:
alpaqa::PANOCStopCrit::Ipopt
@ Ipopt
The stopping criterion used by Ipopt, see https://link.springer.com/article/10.1007/s10107-004-0559-y...
alpaqa::PANOCStopCrit::FPRNorm2
@ FPRNorm2
2-norm of fixed point residual:
alpaqa::PANOCStopCrit::ProjGradNorm2
@ ProjGradNorm2
2-norm of the projected gradient with step size γ:
alpaqa::PANOCStopCrit::ApproxKKT
@ ApproxKKT
Find an ε-approximate KKT point in the ∞-norm:
alpaqa::PANOCStopCrit::FPRNorm
@ FPRNorm
∞-norm of fixed point residual:
alpaqa::PANOCStopCrit::ApproxKKT2
@ ApproxKKT2
Find an ε-approximate KKT point in the 2-norm:
alpaqa::PANOCStopCrit::ProjGradUnitNorm2
@ ProjGradUnitNorm2
2-norm of the projected gradient with unit step size:
alpaqa::length_t
typename Conf::length_t length_t
Definition config.hpp:76
alpaqa::cmvec
typename Conf::cmvec cmvec
Definition config.hpp:68
alpaqa::inf
constexpr const auto inf
Definition config.hpp:85
alpaqa::vec
typename Conf::vec vec
Definition config.hpp:66
alpaqa::LBFGSStepSize
LBFGSStepSize
Which method to use to select the L-BFGS step size.
Definition lbfgs.hpp:25
alpaqa::LBFGSStepSize::BasedOnCurvature
@ BasedOnCurvature
Initial inverse Hessian approximation is set to .
alpaqa::LBFGSStepSize::BasedOnExternalStepSize
@ BasedOnExternalStepSize
Initial inverse Hessian approximation is set to .
alpaqa::ALMParams
Parameters for the Augmented Lagrangian solver.
Definition alm.hpp:20
alpaqa::AndersonAccelParams
Parameters for the AndersonAccel class.
Definition anderson.hpp:14
alpaqa::AndersonDirectionParams
Parameters for the AndersonDirection class.
Definition anderson.hpp:11
alpaqa::LBFGSDirectionParams
Parameters for the LBFGSDirection class.
Definition lbfgs.hpp:11
alpaqa::LBFGSParams
Parameters for the LBFGS class.
Definition lbfgs.hpp:39
alpaqa::NewtonTRDirectionParams
Parameters for the NewtonTRDirection class.
Definition newton-tr.hpp:16
alpaqa::PANOCOCPParams
Tuning parameters for the PANOC algorithm.
Definition panoc-ocp.hpp:16
alpaqa::PANOCParams
Tuning parameters for the PANOC algorithm.
Definition panoc.hpp:24
alpaqa::PANTRParams
Tuning parameters for the PANTR algorithm.
Definition pantr.hpp:22
alpaqa::StructuredNewtonDirectionParams
Parameters for the StructuredNewtonDirection class.
Definition structured-newton.hpp:36
alpaqa::StructuredNewtonRegularizationParams
Parameters for the StructuredNewtonDirection class.
Definition structured-newton.hpp:24
alpaqa::ZeroFPRParams
Tuning parameters for the ZeroFPR algorithm.
Definition zerofpr.hpp:23
ALPAQA_SET_PARAM_INST
#define ALPAQA_SET_PARAM_INST(...)
Definition params.cpp:413
ALPAQA_SET_PARAM_INST_INT
#define ALPAQA_SET_PARAM_INST_INT(...)
Definition params.cpp:436
PARAMS_MEMBER
#define PARAMS_MEMBER(name)
Helper macro to easily initialize a alpaqa::params::dict_to_struct_table_t.
Definition params.tpp:137
PARAMS_TABLE
#define PARAMS_TABLE(type_,...)
Helper macro to easily specialize alpaqa::params::dict_to_struct_table.
Definition params.tpp:128
alpaqa::CBFGSParams
Cautious BFGS update.
Definition lbfgs.hpp:17
alpaqa::StructuredLBFGSDirectionParams
Parameters for the StructuredLBFGSDirection class.
Definition structured-lbfgs.hpp:14
alpaqa::csv::read_error
Definition csv.hpp:11
Generated on Wed Sep 27 2023 for alpaqa by doxygen 1.9.8