Python API Reference

Python API Reference#

Parallel quadratic programming solver for optimal control.

class cyqlone.CyQPALMBackendSettings(*args, **kwargs)#

Attributes:

changing_constr_factor: (self) -> float
detailed_timings: (self) -> bool
max_update_count: (self) -> int
print_precision: (self) -> int
print_residuals: (self) -> bool
processors: (self) -> int
spin_count: (self) -> int
strategy: (self) -> cyqlone._common.WarmStartingStrategy
tricyqle_params: (self) -> cyqlone._common.TricyqleParams

__init__#

property changing_constr_factor#: (self) -> float

property detailed_timings#: (self) -> bool

property max_update_count#: (self) -> int

property print_precision#: (self) -> int

property print_residuals#: (self) -> bool

property processors#: (self) -> int

property spin_count#: (self) -> int

property strategy#: (self) -> cyqlone._common.WarmStartingStrategy

property tricyqle_params#: (self) -> cyqlone._common.TricyqleParams

class cyqlone.CyqloneOCP(*args, **kwargs)#

Attributes:

N_horiz: (self) -> int
data_F: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_G: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_G0N: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_H: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_c: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_lb: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_lb0N: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_rq: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_ub: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
data_ub0N: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]
indices_G0: (self) -> numpy.ndarray[dtype=int32, shape=(*), order=’A’, device=’cpu’]
nu: (self) -> int
nx: (self) -> int
ny: (self) -> int
ny_0: (self) -> int
ny_N: (self) -> int

Methods

`compute_kkt_error`
`reconstruct_ineq_multipliers`
`reconstruct_solution`
`update`

property N_horiz#: (self) -> int

__init__#

compute_kkt_error#

property data_F#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_G#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_G0N#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_H#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_c#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_lb#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_lb0N#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_rq#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_ub#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property data_ub0N#: (self) -> numpy.ndarray[dtype=float64, shape=(*, *, *), device=’cpu’]

property indices_G0#: (self) -> numpy.ndarray[dtype=int32, shape=(*), order=’A’, device=’cpu’]

property nu#: (self) -> int

property nx#: (self) -> int

property ny#: (self) -> int

property ny_0#: (self) -> int

property ny_N#: (self) -> int

reconstruct_ineq_multipliers#

reconstruct_solution#

update#

class cyqlone.CyqloneParams(*args, **kwargs)#

__init__#

class cyqlone.DefaultTimings(*args, **kwargs)#

Attributes:

num_invocations: (self) -> int
wall_time: (self) -> datetime.timedelta

__init__#

property num_invocations#: (self) -> int

property wall_time#: (self) -> datetime.timedelta

class cyqlone.DetailedStats#

Attributes:

entries: (self) -> list[cyqlone._common.DetailedStats.Entry]

Methods

Entry
ExitReason

class Entry#

Attributes:

eq_constr_viol: (self) -> float
exit_reason: (self) -> cyqlone._common.DetailedStats.ExitReason
ineq_constr_viol: (self) -> float
inner_iter: (self) -> int
linesearch_breakpoint_index: (self) -> int
linesearch_step_size: (self) -> float
num_active_constr: (self) -> int
num_changing_constr: (self) -> int
outer_iter: (self) -> int
stationarity: (self) -> float

__init__(*args, **kwargs)#

property eq_constr_viol#: (self) -> float

property exit_reason#: (self) -> cyqlone._common.DetailedStats.ExitReason

property ineq_constr_viol#: (self) -> float

property inner_iter#: (self) -> int

property linesearch_breakpoint_index#: (self) -> int

property linesearch_step_size#: (self) -> float

property num_active_constr#: (self) -> int

property num_changing_constr#: (self) -> int

property outer_iter#: (self) -> int

property stationarity#: (self) -> float

class ExitReason(*values)#

Busy = 0#

Converged = 1#

NoActiveSetChange = 2#

Fail = 3#

__init__(*args, **kwargs)#

property entries#: (self) -> list[cyqlone._common.DetailedStats.Entry]

class cyqlone.KKTError#

Attributes:

complementarity: (self) -> float
equality_residual: (self) -> float
inequality_residual: (self) -> float
stationarity: (self) -> float

__init__(*args, **kwargs)#

property complementarity#: (self) -> float

property equality_residual#: (self) -> float

property inequality_residual#: (self) -> float

property stationarity#: (self) -> float

class cyqlone.LinearOCPSparseQP(*args, **kwargs)#

Attributes:

A: Constraint Jacobian matrix in sparse CSC format
Q: Cost Hessian matrix in sparse CSC format (lower triangular part only)

Methods

build_kkt_matrix

property A#: Constraint Jacobian matrix in sparse CSC format

property Q#: Cost Hessian matrix in sparse CSC format (lower triangular part only)

__init__#

build_kkt_matrix#

class cyqlone.OCP(*args, **kwargs)#

Attributes:

N_horiz: (self) -> int
dim: (self) -> tuple[int, int, int, int, int]
nu: (self) -> int
nx: (self) -> int
ny: (self) -> int
ny_N: (self) -> int
qr: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]
rhs_eq: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]
rhs_lb: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]
rhs_ub: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]
x0: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

Methods

`A`
`AB`
`B`
`C`
`CD`
`D`
`H`
`Q`
`R`
`S`
`b`
`dump_mat`
`load_mat`
`q`
`r`

A#

AB#

B#

C#

CD#

D#

H#

property N_horiz#: (self) -> int

Q#

R#

S#

__init__#

b#

property dim#: (self) -> tuple[int, int, int, int, int]

dump_mat#

load_mat#

property nu#: (self) -> int

property nx#: (self) -> int

property ny#: (self) -> int

property ny_N#: (self) -> int

q#

property qr#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

r#

property rhs_eq#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

property rhs_lb#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

property rhs_ub#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

property x0#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

class cyqlone.PlatooningParams(*args, **kwargs)#

Attributes:

F_max: (self) -> float
N_horiz: (self) -> int
T_horiz: (self) -> float
dist_init: (self) -> float
dist_min: (self) -> float
friction: (self) -> float
masses: (self) -> list[float]
p_target: (self) -> float
scale_cost: (self) -> float
v_max: (self) -> float

property F_max#: (self) -> float

property N_horiz#: (self) -> int

property T_horiz#: (self) -> float

__init__#

property dist_init#: (self) -> float

property dist_min#: (self) -> float

property friction#: (self) -> float

property masses#: (self) -> list[float]

property p_target#: (self) -> float

property scale_cost#: (self) -> float

property v_max#: (self) -> float

class cyqlone.Settings(*args, **kwargs)#

Attributes:

boost_penalty_x: (self) -> float
detailed_stats: (self) -> bool
dual_tolerance: (self) -> float
eq_constr_tolerance: (self) -> float
force_linesearch_if_dir_deriv_pos: (self) -> bool
force_linesearch_if_no_set_change: (self) -> bool
initial_inner_tolerance: (self) -> float
initial_penalty_x: (self) -> float
initial_penalty_y: (self) -> float
linesearch_include_multipliers: (self) -> bool
max_inner_iter: (self) -> int
max_no_changes_active_set: (self) -> int
max_outer_iter: (self) -> int
max_penalty_x: (self) -> float
max_penalty_y: (self) -> float
max_time: (self) -> datetime.timedelta
max_total_inner_iter: (self) -> int
print_directional_deriv: (self) -> bool
print_linesearch_inputs: (self) -> bool
proximal: (self) -> bool
recompute: (self) -> bool
recompute_eq_res: (self) -> bool
recompute_inner: (self) -> bool
scale_newton_step: (self) -> bool
tolerance: (self) -> float
verbose: (self) -> bool
Δx: (self) -> float
Δy: (self) -> float
Δy_always: (self) -> float
θ: (self) -> float
ρ: (self) -> float

__init__#

property boost_penalty_x#: (self) -> float

property detailed_stats#: (self) -> bool

property dual_tolerance#: (self) -> float

property eq_constr_tolerance#: (self) -> float

property force_linesearch_if_dir_deriv_pos#: (self) -> bool

property force_linesearch_if_no_set_change#: (self) -> bool

property initial_inner_tolerance#: (self) -> float

property initial_penalty_x#: (self) -> float

property initial_penalty_y#: (self) -> float

property linesearch_include_multipliers#: (self) -> bool

property max_inner_iter#: (self) -> int

property max_no_changes_active_set#: (self) -> int

property max_outer_iter#: (self) -> int

property max_penalty_x#: (self) -> float

property max_penalty_y#: (self) -> float

property max_time#: (self) -> datetime.timedelta

property max_total_inner_iter#: (self) -> int

property print_directional_deriv#: (self) -> bool

property print_linesearch_inputs#: (self) -> bool

property proximal#: (self) -> bool

property recompute#: (self) -> bool

property recompute_eq_res#: (self) -> bool

property recompute_inner#: (self) -> bool

property scale_newton_step#: (self) -> bool

property tolerance#: (self) -> float

property verbose#: (self) -> bool

property Δx#: (self) -> float

property Δy#: (self) -> float

property Δy_always#: (self) -> float

property θ#: (self) -> float

property ρ#: (self) -> float

class cyqlone.Solution#

Attributes:

equality_multipliers: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]
inequality_multipliers: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]
solution: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

__init__(*args, **kwargs)#

property equality_multipliers#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

property inequality_multipliers#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

property solution#: (self) -> numpy.ndarray[dtype=float64, shape=(*), order=’A’, device=’cpu’]

class cyqlone.SolveMethod(*values)#

StairPCG = 0#

JacobiPCG = 1#

PCR = 2#

class cyqlone.SolverStats(*args, **kwargs)#

Attributes:

detail: (self) -> cyqlone._common.DetailedStats | None
inner_iter: (self) -> int
max_penalty: (self) -> float
outer_iter: (self) -> int
primal_residual_norm: (self) -> float
stationarity: (self) -> float
timings: (self) -> cyqlone._common.SolverTimings

__init__#

property detail#: (self) -> cyqlone._common.DetailedStats | None

property inner_iter#: (self) -> int

property max_penalty#: (self) -> float

property outer_iter#: (self) -> int

property primal_residual_norm#: (self) -> float

property stationarity#: (self) -> float

property timings#: (self) -> cyqlone._common.SolverTimings

class cyqlone.SolverStatus(*values)#

Busy = 0#

Converged = 1#

MaxTime = 2#

MaxIter = 3#

NotFinite = 4#

NoProgress = 5#

Interrupted = 6#

Exception = 7#

class cyqlone.SolverTimings(*args, **kwargs)#

Attributes:

active_set_change: (self) -> cyqlone._common.DefaultTimings
backend: (self) -> dict[str, cyqlone._common.DefaultTimings]
boost_regularization: (self) -> cyqlone._common.DefaultTimings
line_search: (self) -> cyqlone._common.DefaultTimings
mat_vec_A: (self) -> cyqlone._common.DefaultTimings
mat_vec_AT: (self) -> cyqlone._common.DefaultTimings
mat_vec_M: (self) -> cyqlone._common.DefaultTimings
mat_vec_MT: (self) -> cyqlone._common.DefaultTimings
mat_vec_Q: (self) -> cyqlone._common.DefaultTimings
recompute_inner: (self) -> cyqlone._common.DefaultTimings
recompute_outer: (self) -> cyqlone._common.DefaultTimings
scaling: (self) -> cyqlone._common.DefaultTimings
solve: (self) -> cyqlone._common.DefaultTimings
total: (self) -> cyqlone._common.DefaultTimings
update_penalty: (self) -> cyqlone._common.DefaultTimings
update_regularization: (self) -> cyqlone._common.DefaultTimings

__init__#

property active_set_change#: (self) -> cyqlone._common.DefaultTimings

property backend#: (self) -> dict[str, cyqlone._common.DefaultTimings]

property boost_regularization#: (self) -> cyqlone._common.DefaultTimings

property line_search#: (self) -> cyqlone._common.DefaultTimings

property mat_vec_A#: (self) -> cyqlone._common.DefaultTimings

property mat_vec_AT#: (self) -> cyqlone._common.DefaultTimings

property mat_vec_M#: (self) -> cyqlone._common.DefaultTimings

property mat_vec_MT#: (self) -> cyqlone._common.DefaultTimings

property mat_vec_Q#: (self) -> cyqlone._common.DefaultTimings

property recompute_inner#: (self) -> cyqlone._common.DefaultTimings

property recompute_outer#: (self) -> cyqlone._common.DefaultTimings

property scaling#: (self) -> cyqlone._common.DefaultTimings

property solve#: (self) -> cyqlone._common.DefaultTimings

property total#: (self) -> cyqlone._common.DefaultTimings

property update_penalty#: (self) -> cyqlone._common.DefaultTimings

property update_regularization#: (self) -> cyqlone._common.DefaultTimings

class cyqlone.SpringMassParams(*args, **kwargs)#

Attributes:

F_max: (self) -> float
N_horiz: (self) -> int
T_horiz: (self) -> float
actuator_placement: (self) -> cyqlone._common.SpringMassParams.ActuatorPlacement
friction: (self) -> float
k_spring: (self) -> float
masses: (self) -> list[float]
n_actuators: (self) -> int
p_max: (self) -> float
p_max_f: (self) -> float
p_min: (self) -> float
p_min_f: (self) -> float
q_pos: (self) -> float
q_pos_f: (self) -> float
q_vel: (self) -> float
q_vel_f: (self) -> float
r_act: (self) -> float
seed: (self) -> int
v_max: (self) -> float
v_max_f: (self) -> float
width: (self) -> float

Methods

`domahidi_2012`
`wang_boyd_2008`

ActuatorPlacement

class ActuatorPlacement(*values)#

IndividualActuators = 0#

RandomActuators = 1#

RandomPairsOfActuators = 2#

WangBoydActuators = 3#

property F_max#: (self) -> float

IndividualActuators = 0#

property N_horiz#: (self) -> int

RandomActuators = 1#

RandomPairsOfActuators = 2#

property T_horiz#: (self) -> float

WangBoydActuators = 3#

__init__#

property actuator_placement#: (self) -> cyqlone._common.SpringMassParams.ActuatorPlacement

domahidi_2012 = <nanobind.nb_func object>#

property friction#: (self) -> float

property k_spring#: (self) -> float

property masses#: (self) -> list[float]

property n_actuators#: (self) -> int

property p_max#: (self) -> float

property p_max_f#: (self) -> float

property p_min#: (self) -> float

property p_min_f#: (self) -> float

property q_pos#: (self) -> float

property q_pos_f#: (self) -> float

property q_vel#: (self) -> float

property q_vel_f#: (self) -> float

property r_act#: (self) -> float

property seed#: (self) -> int

property v_max#: (self) -> float

property v_max_f#: (self) -> float

wang_boyd_2008 = <nanobind.nb_func object>#

property width#: (self) -> float

class cyqlone.TricyqleParams(*args, **kwargs)#

Attributes:

cr_max_update_fraction_Y0: (self) -> float
enable_prefetching: (self) -> bool
parallel_factor_pcr_threshold: (self) -> int
parallel_solve_cr_threshold: (self) -> int
pcg_max_iter: (self) -> int
pcg_print_resid: (self) -> bool
pcg_tolerance: (self) -> float
pcr_max_update_fraction: (self) -> float
solve_method: (self) -> cyqlone::SolveMethod

__init__#

property cr_max_update_fraction_Y0#: (self) -> float

property enable_prefetching#: (self) -> bool

property parallel_factor_pcr_threshold#: (self) -> int

property parallel_solve_cr_threshold#: (self) -> int

property pcg_max_iter#: (self) -> int

property pcg_print_resid#: (self) -> bool

property pcg_tolerance#: (self) -> float

property pcr_max_update_fraction#: (self) -> float

property solve_method#: (self) -> cyqlone::SolveMethod

class cyqlone.WarmStartingStrategy(*values)#

Zeros = 0#

Copy = 1#

Shift = 2#

ShiftNoInequality = 3#

class cyqlone.simd4.CyqloneSolver(*args, **kwargs)#

Attributes:

num_dynamics_constraints: (self) -> int
num_general_constraints: (self) -> int
num_variables: (self) -> int
params: (self) -> cyqlone._common.TricyqleParams
params_string: (self) -> str

Methods

__init__#

build_rhs#

build_sparse#

build_sparse_diag#

build_sparse_factor#

factor#

factor_solve#

initialize_bounds#

initialize_gradient#

initialize_rhs#

property num_dynamics_constraints#: (self) -> int

property num_general_constraints#: (self) -> int

property num_variables#: (self) -> int

pack_constraints#

pack_dynamics#

pack_variables#

property params#: (self) -> cyqlone._common.TricyqleParams

property params_string#: (self) -> str

residual_dynamics_constr#

set_barrier_spin_count#

solve_forward#

solve_reverse#

transposed_dynamics_constr#

unpack_constraints#

unpack_dynamics#

unpack_variables#

update#

class cyqlone.simd4.QPALM_Cyqlone(*args, **kwargs)#

Attributes:

equality_multipliers: (self) -> list[float]
inequality_multipliers: (self) -> list[float]
solution: (self) -> list[float]
stats: (self) -> cyqlone._common.SolverStats | None

Methods

`__call__`
`get_initial_guess`
`set_b_eq`
`set_b_lb`
`set_b_ub`
`set_initial_guess`
`update_data`
`warm_start_solution`

__call__#

__init__#

property equality_multipliers#: (self) -> list[float]

get_initial_guess#

property inequality_multipliers#: (self) -> list[float]

set_b_eq#

set_b_lb#

set_b_ub#

set_initial_guess#

property solution#: (self) -> list[float]

property stats#: (self) -> cyqlone._common.SolverStats | None

update_data#

warm_start_solution#

`build_rhs`
`build_sparse`
`build_sparse_diag`
`build_sparse_factor`
`factor`
`factor_solve`
`initialize_bounds`
`initialize_gradient`
`initialize_rhs`
`pack_constraints`
`pack_dynamics`
`pack_variables`
`residual_dynamics_constr`
`set_barrier_spin_count`
`solve_forward`
`solve_reverse`
`transposed_dynamics_constr`
`unpack_constraints`
`unpack_dynamics`
`unpack_variables`
`update`

Python API Reference

Contents

Python API Reference#