QPALM

Solver

template<class Backend>
class Solver

Public Types

using BackendStats = typename detail::backend_stats_type<backend_type>::type

Public Functions

inline SolverStatus operator()()

index_t get_num_variables() const

index_t get_num_equality_constraints() const

index_t get_num_inequality_constraints() const

bool has_result() const

void get_solution(std::span<real_t>) const

std::vector<real_t> get_solution() const

void get_equality_multipliers(std::span<real_t>) const

std::vector<real_t> get_equality_multipliers() const

void get_equality_constraints(std::span<real_t>) const

std::vector<real_t> get_equality_constraints() const

void get_inequality_multipliers(std::span<real_t>) const

std::vector<real_t> get_inequality_multipliers() const

void get_inequality_constraints(std::span<real_t>) const

std::vector<real_t> get_inequality_constraints() const

void get_penalty_factors(std::span<real_t>) const

std::vector<real_t> get_penalty_factors() const

void warm_start_solution()

void set_initial_guess (std::span< const real_t > x, std::span< const real_t > y, std::span< const real_t > λ)

bool get_initial_guess (std::span< real_t > x, std::span< real_t > y, std::span< real_t > λ)

void set_b_eq(std::span<const real_t> b_eq)

void set_b_lb(std::span<const real_t> b_lb)

void set_b_ub(std::span<const real_t> b_ub)

inline void stop()

Solver(Backend backend, Settings settings = {})

Solver(const Solver&) = delete

Solver &operator=(const Solver&) = delete

Solver(Solver&&) noexcept

Solver &operator=(Solver&&) noexcept

~Solver()

Public Members

Backend backend

Settings settings

std::unique_ptr<SolverImplementation<backend_type>> impl = {}

std::optional<SolverStats> stats = std::nullopt

std::optional<BackendStats> stats_backend = std::nullopt

guanaqo::AtomicStopSignal stop_signal = {}

Settings

struct Settings

Public Functions

inline bool operator==(const Settings&) const

inline bool operator!=(const Settings &other) const

Public Members

unsigned max_outer_iter = 100

Maximum number of (total) iterations.

unsigned max_inner_iter = 100

unsigned max_total_inner_iter = 10000

std::chrono::microseconds max_time = 5min

real_t tolerance = real_t(1e-8)

Primal tolerance.

real_t dual_tolerance = real_t(1e-8)

real_t eq_constr_tolerance = real_t(1e-10)

real_t initial_inner_tolerance = real_t(1)

real_t ρ   = real_t(1e-1)

real_t θ   = 0.25

real_t Δy   = 100

real_t Δy_always   = 1

real_t max_penalty_y = 1e9

real_t initial_penalty_y = 20

bool scale_initial_penalty_y = false

real_t Δx   = 10

real_t max_penalty_x = 1e7

real_t boost_penalty_x = 1e12

real_t initial_penalty_x = 1e7

bool proximal = true

bool recompute_eq_res = true

bool recompute_inner = false

bool recompute = true

bool verbose = true

int print_precision = 3

unsigned max_no_changes_active_set = 5

bool linesearch_include_multipliers = true

bool force_linesearch_if_no_set_change = true

bool force_linesearch_if_dir_deriv_pos = false

bool detailed_stats = false

bool scale_newton_step = false

bool print_directional_deriv = false

bool print_linesearch_inputs = false

Statistics

struct SolverStats

Public Members

unsigned inner_iter = 0

unsigned outer_iter = 0

real_t stationarity = std::numeric_limits<real_t>::quiet_NaN()

real_t primal_residual_norm = std::numeric_limits<real_t>::quiet_NaN()

real_t max_penalty = std::numeric_limits<real_t>::quiet_NaN()

SolverTimings timings = {}

std::optional<DetailedStats> detail = std::nullopt

struct DetailedStats

Public Types

enum ExitReason

Values:

enumerator Busy

enumerator Converged

enumerator NoActiveSetChange

enumerator Fail

Public Members

std::vector<Entry> entries

struct Entry

Public Members

unsigned outer_iter

unsigned inner_iter

real_t stationarity

real_t ineq_constr_viol

real_t eq_constr_viol

real_t linesearch_step_size

size_t linesearch_breakpoint_index

index_t num_active_constr

index_t num_changing_constr

ExitReason exit_reason

Backends

template<index_t VL, StorageOrder DefaultOrder = StorageOrder::ColMajor>
struct unique_CyQPALMBackend : public std::unique_ptr<CyQPALMBackend<VL, StorageOrder::ColMajor>>

Public Functions

unique_CyQPALMBackend() = default

unique_CyQPALMBackend(unique_CyQPALMBackend&&) noexcept = default

unique_CyQPALMBackend &operator=(unique_CyQPALMBackend&&) noexcept = default

~unique_CyQPALMBackend()

inline unique_CyQPALMBackend(std::unique_ptr<CyQPALMBackend<VL, DefaultOrder>> &&o) noexcept

T *operator->()

STL member.

Public Members

T ptr

STL member.

template<index_t VL, StorageOrder DefaultOrder>
unique_CyQPALMBackend<VL, DefaultOrder> cyqlone::qpalm::make_cyqpalm_backend(const CyqloneStorage<> &ocp, CyqloneData data, const CyQPALMBackendSettings &settings)

Warning

doxygenfunction: Cannot find function “cyqlone::qpalm::update_cyqpalm_backend” in doxygen xml output for project “cyqlone” from directory: /home/runner/work/cyqlone/cyqlone/staging/develop/xml

Warning

doxygenfunction: Cannot find function “cyqlone::qpalm::update_cyqpalm_backend” in doxygen xml output for project “cyqlone” from directory: /home/runner/work/cyqlone/cyqlone/staging/develop/xml