Python API Reference#

Index#

Augmented Lagrangian and PANOC solvers for nonconvex numerical optimization.

class alpaqa.ALMParams#

C++ documentation: alpaqa::ALMParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.ALMParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.ALMParams, **kwargs) -> None

property dual_tolerance#

property initial_penalty#

property initial_penalty_factor#

property initial_tolerance#

property max_iter#

property max_multiplier#

property max_penalty#

property max_time#

property min_penalty#

property penalty_update_factor#

property print_interval#

property print_precision#

property rel_penalty_increase_threshold#

property single_penalty_factor#

to_dict(self: alpaqa._alpaqa.float64.ALMParams) → dict#

property tolerance#

property tolerance_update_factor#

class alpaqa.ALMSolver#

Main augmented Lagrangian solver.

C++ documentation: alpaqa::ALMSolver

__call__(self: alpaqa._alpaqa.float64.ALMSolver, problem: alpaqa._alpaqa.float64.Problem | alpaqa._alpaqa.float64.ControlProblem, x: numpy.ndarray[numpy.float64[m, 1]] | None = None, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, *, asynchronous: bool = True, suppress_interrupt: bool = False) → tuple#

Solve.

Parameters:

problem – Problem to solve.
x – Initial guess for decision variables \(x\)
y – Initial guess for Lagrange multipliers \(y\)
asynchronous – Release the GIL and run the solver on a separate thread
suppress_interrupt – If the solver is interrupted by a KeyboardInterrupt, don’t propagate this exception back to the Python interpreter, but stop the solver early, and return a solution with the status set to alpaqa.SolverStatus.Interrupted.

Returns:

Solution \(x\)
Lagrange multipliers \(y\) at the solution
Statistics

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.ALMSolver, other: alpaqa._alpaqa.float64.ALMSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.ALMSolver) -> None

Build an ALM solver using Structured PANOC as inner solver.

__init__(self: alpaqa._alpaqa.float64.ALMSolver, inner_solver: alpaqa._alpaqa.float64.InnerSolver) -> None

Build an ALM solver using the given inner solver.

__init__(self: alpaqa._alpaqa.float64.ALMSolver, inner_solver: alpaqa._alpaqa.float64.InnerOCPSolver) -> None

Build an ALM solver using the given inner solver.

__init__(self: alpaqa._alpaqa.float64.ALMSolver, alm_params: Union[alpaqa._alpaqa.float64.ALMParams, dict], inner_solver: alpaqa._alpaqa.float64.InnerSolver) -> None

Build an ALM solver using the given inner solver.

__init__(self: alpaqa._alpaqa.float64.ALMSolver, alm_params: Union[alpaqa._alpaqa.float64.ALMParams, dict], inner_solver: alpaqa._alpaqa.float64.InnerOCPSolver) -> None

Build an ALM solver using the given inner solver.

property inner_solver#

property name#

property params#

stop(self: alpaqa._alpaqa.float64.ALMSolver) → None#

class alpaqa.AndersonAccel#

C++ documentation alpaqa::AndersonAccel

class Params#

C++ documentation alpaqa::AndersonAccelParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.AndersonAccel.Params, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.AndersonAccel.Params, **kwargs) -> None

property memory#

property min_div_fac#

to_dict(self: alpaqa._alpaqa.float64.AndersonAccel.Params) → dict#

property Q#

property R#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.AndersonAccel, params: Union[alpaqa._alpaqa.float64.AndersonAccel.Params, dict]) -> None
__init__(self: alpaqa._alpaqa.float64.AndersonAccel, params: Union[alpaqa._alpaqa.float64.AndersonAccel.Params, dict], n: int) -> None

compute(*args, **kwargs)#

Overloaded function.

compute(self: alpaqa._alpaqa.float64.AndersonAccel, g_k: numpy.ndarray[numpy.float64[m, 1]], r_k: numpy.ndarray[numpy.float64[m, 1]], x_k_aa: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
compute(self: alpaqa._alpaqa.float64.AndersonAccel, g_k: numpy.ndarray[numpy.float64[m, 1]], r_k: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

property current_history#

property history#

initialize(self: alpaqa._alpaqa.float64.AndersonAccel, g_0: numpy.ndarray[numpy.float64[m, 1]], r_0: numpy.ndarray[numpy.float64[m, 1]]) → None#

property n#

property params#

reset(self: alpaqa._alpaqa.float64.AndersonAccel) → None#

resize(self: alpaqa._alpaqa.float64.AndersonAccel, n: int) → None#

class alpaqa.AndersonDirection#

C++ documentation: alpaqa::AndersonDirection

class DirectionParams#

C++ documentation: alpaqa::AndersonDirection::DirectionParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.AndersonDirection.DirectionParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.AndersonDirection.DirectionParams, **kwargs) -> None

property rescale_on_step_size_changes#

to_dict(self: alpaqa._alpaqa.float64.AndersonDirection.DirectionParams) → dict#

__init__(self: alpaqa._alpaqa.float64.AndersonDirection, anderson_params: alpaqa._alpaqa.float64.AndersonAccel.Params | dict = {}, direction_params: alpaqa._alpaqa.float64.AndersonDirection.DirectionParams | dict = {}) → None#

property params#

class alpaqa.Box#

C++ documentation: alpaqa::Box

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.Box, other: alpaqa._alpaqa.float64.Box) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.Box, n: int) -> None

Create an \(n\)-dimensional box at with bounds at \(\pm\infty\) (no constraints).

__init__(self: alpaqa._alpaqa.float64.Box, *, lower: numpy.ndarray[numpy.float64[m, 1]], upper: numpy.ndarray[numpy.float64[m, 1]]) -> None

Create a box with the given bounds.

property lowerbound#

property upperbound#

class alpaqa.BoxConstrProblem#

C++ documentation: alpaqa::BoxConstrProblem

property C#: Box constraints on \(x\)

property D#: Box constraints on \(g(x)\)

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.BoxConstrProblem, other: alpaqa._alpaqa.float64.BoxConstrProblem) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.BoxConstrProblem, n: int, m: int) -> None

Parameters:

n – Number of unknowns
m – Number of constraints

eval_inactive_indices_res_lna(*args, **kwargs)#

Overloaded function.

eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.BoxConstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], J: numpy.ndarray[numpy.int64[m, 1], flags.writeable]) -> int
eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.BoxConstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.int64[m, 1]]

eval_proj_diff_g(*args, **kwargs)#

Overloaded function.

eval_proj_diff_g(self: alpaqa._alpaqa.float64.BoxConstrProblem, z: numpy.ndarray[numpy.float64[m, 1]], e: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_proj_diff_g(self: alpaqa._alpaqa.float64.BoxConstrProblem, z: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_proj_multipliers(self: alpaqa._alpaqa.float64.BoxConstrProblem, y: numpy.ndarray[numpy.float64[m, 1], flags.writeable], M: float) → None#

eval_prox_grad_step(*args, **kwargs)#

Overloaded function.

eval_prox_grad_step(self: alpaqa._alpaqa.float64.BoxConstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], x_hat: numpy.ndarray[numpy.float64[m, 1], flags.writeable], p: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_prox_grad_step(self: alpaqa._alpaqa.float64.BoxConstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], float]

get_box_C(self: alpaqa._alpaqa.float64.BoxConstrProblem) → alpaqa._alpaqa.float64.Box#

get_box_D(self: alpaqa._alpaqa.float64.BoxConstrProblem) → alpaqa._alpaqa.float64.Box#

property l1_reg#: \(\ell_1\) regularization on \(x\)

property m#: Number of general constraints, dimension of \(g(x)\)

property n#: Number of decision variables, dimension of \(x\)

property penalty_alm_split#: Index between quadratic penalty and augmented Lagrangian constraints

resize(self: alpaqa._alpaqa.float64.BoxConstrProblem, n: int, m: int) → None#

class alpaqa.CUTEstProblem#

C++ documentation: alpaqa::CUTEstProblem

See alpaqa.Problem for the full documentation.

class Report#

class Calls#

__init__(*args, **kwargs)#

property constraints#

property constraints_grad#

property constraints_hess#

property hessian_times_vector#

property objective#

property objective_grad#

property objective_hess#

__init__(*args, **kwargs)#

property calls#

property time#

property time_setup#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.CUTEstProblem, so_filename: str, outsdiff_filename: str = None, sparse: bool = False) -> None

Load a CUTEst problem from the given shared library and OUTSDIF.d file

__init__(self: alpaqa._alpaqa.float64.CUTEstProblem, other: alpaqa._alpaqa.float64.CUTEstProblem) -> None

Create a copy

check(self: alpaqa._alpaqa.float64.CUTEstProblem) → None#

eval_f(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → float#

eval_f_g(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], g: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → float#

eval_f_grad_f(*args, **kwargs)#

Overloaded function.

eval_f_grad_f(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_f_grad_f(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> tuple

eval_g(*args, **kwargs)#

Overloaded function.

eval_g(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], gx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_g(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_L(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_L: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_f(*args, **kwargs)#

Overloaded function.

eval_grad_f(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_f(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_g_prod(*args, **kwargs)#

Overloaded function.

eval_grad_g_prod(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_gxy: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_g_prod(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_gi(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], i: int, grad_gi: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_hess_L(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float = 1.0) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Hessian of the Lagrangian and its symmetry.

eval_hess_L_prod(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_hess_ψ_prod(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_inactive_indices_res_lna(*args, **kwargs)#

Overloaded function.

eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.CUTEstProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], J: numpy.ndarray[numpy.int64[m, 1], flags.writeable]) -> int
eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.CUTEstProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.int64[m, 1]]

eval_jac_g(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Jacobian of the constraints and its symmetry.

eval_proj_diff_g(*args, **kwargs)#

Overloaded function.

eval_proj_diff_g(self: alpaqa._alpaqa.float64.CUTEstProblem, z: numpy.ndarray[numpy.float64[m, 1]], e: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_proj_diff_g(self: alpaqa._alpaqa.float64.CUTEstProblem, z: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_proj_multipliers(self: alpaqa._alpaqa.float64.CUTEstProblem, y: numpy.ndarray[numpy.float64[m, 1], flags.writeable], M: float) → None#

eval_prox_grad_step(*args, **kwargs)#

Overloaded function.

eval_prox_grad_step(self: alpaqa._alpaqa.float64.CUTEstProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], x_hat: numpy.ndarray[numpy.float64[m, 1], flags.writeable], p: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_prox_grad_step(self: alpaqa._alpaqa.float64.CUTEstProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], float]

format_report(self: alpaqa._alpaqa.float64.CUTEstProblem, report: alpaqa._alpaqa.float64.CUTEstProblem.Report | None = None) → str#: Convert the given report to a string.

get_box_C(self: alpaqa._alpaqa.float64.CUTEstProblem) → alpaqa._alpaqa.float64.Box#

get_box_D(self: alpaqa._alpaqa.float64.CUTEstProblem) → alpaqa._alpaqa.float64.Box#

get_report(self: alpaqa._alpaqa.float64.CUTEstProblem) → alpaqa._alpaqa.float64.CUTEstProblem.Report#: Get the report generated by cutest_creport.

property m#: Number of general constraints, dimension of \(g(x)\)

property n#: Number of decision variables, dimension of \(x\)

property name#: CUTEst problem name.

provides_get_box_C(self: alpaqa._alpaqa.float64.CUTEstProblem) → bool#

property x0#: Initial guess for decision variables.

property y0#: Initial guess for multipliers.

class alpaqa.CasADiControlProblem#

C++ documentation: alpaqa::CasADiControlProblem

See alpaqa.ControlProblem for the full documentation.

property D#

property D_N#

property N#

property U#

__init__(self: alpaqa._alpaqa.float64.CasADiControlProblem, other: alpaqa._alpaqa.float64.CasADiControlProblem) → None#: Create a copy

property nc#

property nc_N#

property nh#

property nh_N#

property nu#

property nx#

property param#: Parameter vector \(p\) of the problem

property x_init#: Initial state vector \(x^0\) of the problem

class alpaqa.CasADiProblem#

C++ documentation: alpaqa::CasADiProblem

See alpaqa.Problem for the full documentation.

__init__(self: alpaqa._alpaqa.float64.CasADiProblem, other: alpaqa._alpaqa.float64.CasADiProblem) → None#: Create a copy

check(self: alpaqa._alpaqa.float64.CasADiProblem) → None#

eval_f(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → float#

eval_f_grad_f(*args, **kwargs)#

Overloaded function.

eval_f_grad_f(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_f_grad_f(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> tuple

eval_g(*args, **kwargs)#

Overloaded function.

eval_g(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], gx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_g(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_L(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_L: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_f(*args, **kwargs)#

Overloaded function.

eval_grad_f(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_f(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_g_prod(*args, **kwargs)#

Overloaded function.

eval_grad_g_prod(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_gxy: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_g_prod(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_gi(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], i: int, grad_gi: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_ψ(*args, **kwargs)#

Overloaded function.

eval_grad_ψ(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_m: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_ψ(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_hess_L(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float = 1.0) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Hessian of the Lagrangian and its symmetry.

eval_hess_L_prod(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_hess_ψ(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], scale: float = 1.0) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Hessian of the augmented Lagrangian and its symmetry.

eval_hess_ψ_prod(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_inactive_indices_res_lna(*args, **kwargs)#

Overloaded function.

eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.CasADiProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], J: numpy.ndarray[numpy.int64[m, 1], flags.writeable]) -> int
eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.CasADiProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.int64[m, 1]]

eval_jac_g(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Jacobian of the constraints and its symmetry.

eval_proj_diff_g(*args, **kwargs)#

Overloaded function.

eval_proj_diff_g(self: alpaqa._alpaqa.float64.CasADiProblem, z: numpy.ndarray[numpy.float64[m, 1]], e: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_proj_diff_g(self: alpaqa._alpaqa.float64.CasADiProblem, z: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_proj_multipliers(self: alpaqa._alpaqa.float64.CasADiProblem, y: numpy.ndarray[numpy.float64[m, 1], flags.writeable], M: float) → None#

eval_prox_grad_step(*args, **kwargs)#

Overloaded function.

eval_prox_grad_step(self: alpaqa._alpaqa.float64.CasADiProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], x_hat: numpy.ndarray[numpy.float64[m, 1], flags.writeable], p: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_prox_grad_step(self: alpaqa._alpaqa.float64.CasADiProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], float]

eval_ψ(*args, **kwargs)#

Overloaded function.

eval_ψ(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], ŷ: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_ψ(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]]]

eval_ψ_grad_ψ(*args, **kwargs)#

Overloaded function.

eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_m: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]]]

get_box_C(self: alpaqa._alpaqa.float64.CasADiProblem) → alpaqa._alpaqa.float64.Box#

get_box_D(self: alpaqa._alpaqa.float64.CasADiProblem) → alpaqa._alpaqa.float64.Box#

property m#: Number of general constraints, dimension of \(g(x)\)

property n#: Number of decision variables, dimension of \(x\)

property param#: Parameter vector \(p\) of the problem

provides_eval_grad_L(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_grad_gi(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_grad_ψ(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_hess_L(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_hess_L_prod(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_hess_ψ(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_hess_ψ_prod(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_jac_g(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_ψ(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

provides_get_box_C(self: alpaqa._alpaqa.float64.CasADiProblem) → bool#

class alpaqa.ControlProblem#

C++ documentation: alpaqa::TypeErasedControlProblem

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.ControlProblem, other: alpaqa._alpaqa.float64.ControlProblem) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.ControlProblem, problem: alpaqa._alpaqa.float64.CasADiControlProblem) -> None

Explicit conversion

class alpaqa.ControlProblemWithCounters#

__init__(*args, **kwargs)#

property evaluations#

property problem#

class alpaqa.ConvexNewtonDirection#

C++ documentation: alpaqa::ConvexNewtonDirection

class AcceleratorParams#

C++ documentation: alpaqa::ConvexNewtonDirection::AcceleratorParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.ConvexNewtonDirection.AcceleratorParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.ConvexNewtonDirection.AcceleratorParams, **kwargs) -> None

property ldlt#

to_dict(self: alpaqa._alpaqa.float64.ConvexNewtonDirection.AcceleratorParams) → dict#

property ζ#

property ν#

class DirectionParams#

C++ documentation: alpaqa::ConvexNewtonDirection::DirectionParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.ConvexNewtonDirection.DirectionParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.ConvexNewtonDirection.DirectionParams, **kwargs) -> None

property hessian_vec_factor#

property quadratic#

to_dict(self: alpaqa._alpaqa.float64.ConvexNewtonDirection.DirectionParams) → dict#

__init__(self: alpaqa._alpaqa.float64.ConvexNewtonDirection, newton_params: alpaqa._alpaqa.float64.ConvexNewtonDirection.AcceleratorParams | dict = {}, direction_params: alpaqa._alpaqa.float64.ConvexNewtonDirection.DirectionParams | dict = {}) → None#

property params#

class alpaqa.DLProblem#

C++ documentation: alpaqa::dl::DLProblem

See alpaqa.Problem for the full documentation.

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.DLProblem, so_filename: str, *args, function_name: str = ‘register_alpaqa_problem’, user_param_str: bool = False, **kwargs) -> None

Load a problem from the given shared library file. By default, extra arguments are passed to the problem as a void pointer to a std::tuple<pybind11::args, pybind11::kwargs>. If the keyword argument user_param_str=True is used, the args is converted to a list of strings, and passed as a void pointer to a std::span<std::string_view>.

__init__(self: alpaqa._alpaqa.float64.DLProblem, other: alpaqa._alpaqa.float64.DLProblem) -> None

Create a copy

call_extra_func(self: alpaqa._alpaqa.float64.DLProblem, name: str, *args, **kwargs) → object#: Call the given extra member function registered by the problem, with the signature pybind11::object(pybind11::args, pybind11::kwargs).

check(self: alpaqa._alpaqa.float64.DLProblem) → None#

eval_f(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → float#

eval_f_g(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], g: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → float#

eval_f_grad_f(*args, **kwargs)#

Overloaded function.

eval_f_grad_f(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_f_grad_f(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> tuple

eval_g(*args, **kwargs)#

Overloaded function.

eval_g(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], gx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_g(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_L(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_L: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_f(*args, **kwargs)#

Overloaded function.

eval_grad_f(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_f(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_f_grad_g_prod(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_f: numpy.ndarray[numpy.float64[m, 1], flags.writeable], grad_gxy: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_g_prod(*args, **kwargs)#

Overloaded function.

eval_grad_g_prod(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_gxy: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_g_prod(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_gi(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], i: int, grad_gi: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_ψ(*args, **kwargs)#

Overloaded function.

eval_grad_ψ(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_m: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_ψ(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_hess_L(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float = 1.0) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Hessian of the Lagrangian and its symmetry.

eval_hess_L_prod(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_hess_ψ(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], scale: float = 1.0) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Hessian of the augmented Lagrangian and its symmetry.

eval_hess_ψ_prod(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_inactive_indices_res_lna(*args, **kwargs)#

Overloaded function.

eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.DLProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], J: numpy.ndarray[numpy.int64[m, 1], flags.writeable]) -> int
eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.DLProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.int64[m, 1]]

eval_jac_g(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Jacobian of the constraints and its symmetry.

eval_proj_diff_g(*args, **kwargs)#

Overloaded function.

eval_proj_diff_g(self: alpaqa._alpaqa.float64.DLProblem, z: numpy.ndarray[numpy.float64[m, 1]], e: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_proj_diff_g(self: alpaqa._alpaqa.float64.DLProblem, z: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_proj_multipliers(self: alpaqa._alpaqa.float64.DLProblem, y: numpy.ndarray[numpy.float64[m, 1], flags.writeable], M: float) → None#

eval_prox_grad_step(*args, **kwargs)#

Overloaded function.

eval_prox_grad_step(self: alpaqa._alpaqa.float64.DLProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], x_hat: numpy.ndarray[numpy.float64[m, 1], flags.writeable], p: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_prox_grad_step(self: alpaqa._alpaqa.float64.DLProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], float]

eval_ψ(*args, **kwargs)#

Overloaded function.

eval_ψ(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], ŷ: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_ψ(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]]]

eval_ψ_grad_ψ(*args, **kwargs)#

Overloaded function.

eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_m: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]]]

get_box_C(self: alpaqa._alpaqa.float64.DLProblem) → alpaqa._alpaqa.float64.Box#

get_box_D(self: alpaqa._alpaqa.float64.DLProblem) → alpaqa._alpaqa.float64.Box#

property m#: Number of general constraints, dimension of \(g(x)\)

property n#: Number of decision variables, dimension of \(x\)

provides_eval_f_g(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_f_grad_f(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_grad_L(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_grad_f_grad_g_prod(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_grad_gi(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_grad_ψ(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_hess_L(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_hess_L_prod(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_hess_ψ(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_hess_ψ_prod(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_jac_g(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_ψ(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_get_box_C(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_get_box_D(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_get_hess_L_sparsity(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_get_hess_ψ_sparsity(self: alpaqa._alpaqa.float64.DLProblem) → bool#

provides_get_jac_g_sparsity(self: alpaqa._alpaqa.float64.DLProblem) → bool#

class alpaqa.EvalCounter#

C++ documentation: alpaqa::EvalCounter

class EvalTimer#

C++ documentation: alpaqa::EvalCounter::EvalTimer

__init__(*args, **kwargs)#

property f#

property f_g#

property f_grad_f#

property g#

property grad_L#

property grad_f#

property grad_f_grad_g_prod#

property grad_g_prod#

property grad_gi#

property grad_ψ#

property hess_L#

property hess_L_prod#

property hess_ψ#

property hess_ψ_prod#

property inactive_indices_res_lna#

property jac_g#

property proj_diff_g#

property proj_multipliers#

property prox_grad_step#

property ψ#

property ψ_grad_ψ#

__init__(*args, **kwargs)#

property f#

property f_g#

property f_grad_f#

property g#

property grad_L#

property grad_f#

property grad_f_grad_g_prod#

property grad_g_prod#

property grad_gi#

property grad_ψ#

property hess_L#

property hess_L_prod#

property hess_ψ#

property hess_ψ_prod#

property inactive_indices_res_lna#

property jac_g#

property proj_diff_g#

property proj_multipliers#

property prox_grad_step#

property time#

property ψ#

property ψ_grad_ψ#

class alpaqa.FISTAParams#

C++ documentation: alpaqa::FISTAParams

property L_max#

property L_min#

property Lipschitz#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.FISTAParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.FISTAParams, **kwargs) -> None

property max_iter#

property max_no_progress#

property max_time#

property print_interval#

property print_precision#

property quadratic_upperbound_tolerance_factor#

property stop_crit#

to_dict(self: alpaqa._alpaqa.float64.FISTAParams) → dict#

class alpaqa.FISTAProgressInfo#

Data passed to the FISTA progress callback.

C++ documentation: alpaqa::FISTAProgressInfo

property L#: Estimate of Lipschitz constant of objective \(L\)

__init__(*args, **kwargs)#

property fpr#: Fixed-point residual \(\left\|p\right\| / \gamma\)

property grad_ψ#: Gradient of objective \(\nabla\psi(x)\)

property grad_ψ_hat#: Gradient of objective at x̂ \(\nabla\psi(\hat x)\)

property k#: Iteration

property norm_sq_p#: \(\left\|p\right\|^2\)

property p#: Projected gradient step \(p\)

property params#: Solver parameters

property problem#: Problem being solved

property status#: Current solver status

property t#: Acceleration parameter \(t\)

property x#: Decision variable \(x\)

property x_hat#: Decision variable after projected gradient step \(\hat x\)

property y#: Lagrange multipliers \(y\)

property y_hat#: Candidate updated multipliers at x̂ \(\hat y(\hat x)\)

property Σ#: Penalty factor \(\Sigma\)

property γ#: Step size \(\gamma\)

property ε#: Tolerance reached \(\varepsilon_k\)

property φγ#: Forward-backward envelope \(\varphi_\gamma(x)\)

property ψ#: Objective value \(\psi(x)\)

property ψ_hat#: Objective at x̂ \(\psi(\hat x)\)

class alpaqa.FISTASolver#

C++ documentation: alpaqa::FISTASolver

Params#: alias of FISTAParams

__call__(self: alpaqa._alpaqa.float64.FISTASolver, problem: alpaqa._alpaqa.float64.Problem, opts: alpaqa._alpaqa.float64.InnerSolveOptions = {}, x: numpy.ndarray[numpy.float64[m, 1]] | None = None, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, Σ: numpy.ndarray[numpy.float64[m, 1]] | None = None, *, asynchronous: bool = True, suppress_interrupt: bool = False) → tuple#

Solve the given problem.

Parameters:

problem – Problem to solve
opts – Options (such as desired tolerance)
x – Optional initial guess for the decision variables
y – Lagrange multipliers (when used as ALM inner solver)
Σ – Penalty factors (when used as ALM inner solver)
asynchronous – Release the GIL and run the solver on a separate thread
suppress_interrupt – If the solver is interrupted by a KeyboardInterrupt, don’t propagate this exception back to the Python interpreter, but stop the solver early, and return a solution with the status set to alpaqa.SolverStatus.Interrupted.

Returns:

Solution \(x\)
Updated Lagrange multipliers (only if parameter y was not None)
Constraint violation (only if parameter y was not None)
Statistics

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.FISTASolver, other: alpaqa._alpaqa.float64.FISTASolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.FISTASolver, fista_params: Union[alpaqa._alpaqa.float64.FISTAParams, dict] = {}) -> None

Create a FISTA solver using structured L-BFGS directions.

property name#

property params#

set_progress_callback(self: alpaqa._alpaqa.float64.FISTASolver, callback: Callable[[alpaqa._alpaqa.float64.FISTAProgressInfo], None]) → alpaqa._alpaqa.float64.FISTASolver#: Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.

stop(self: alpaqa._alpaqa.float64.FISTASolver) → None#

class alpaqa.InnerOCPSolver#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.InnerOCPSolver, other: alpaqa._alpaqa.float64.InnerOCPSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.InnerOCPSolver, inner_solver: alpaqa._alpaqa.float64.PANOCOCPSolver) -> None

Explicit conversion.

property name#

stop(self: alpaqa._alpaqa.float64.InnerOCPSolver) → None#

class alpaqa.InnerSolveOptions#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.InnerSolveOptions, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.InnerSolveOptions, **kwargs) -> None

property always_overwrite_results#

property max_time#

to_dict(self: alpaqa._alpaqa.float64.InnerSolveOptions) → dict#

property tolerance#

class alpaqa.InnerSolver#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.InnerSolver, other: alpaqa._alpaqa.float64.InnerSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.InnerSolver, inner_solver: alpaqa._alpaqa.float64.PANOCSolver) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.InnerSolver, inner_solver: alpaqa._alpaqa.float64.FISTASolver) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.InnerSolver, inner_solver: alpaqa._alpaqa.float64.ZeroFPRSolver) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.InnerSolver, inner_solver: alpaqa._alpaqa.float64.PANTRSolver) -> None

Explicit conversion.

property name#

property params#

stop(self: alpaqa._alpaqa.float64.InnerSolver) → None#

class alpaqa.KKTError#

C++ documentation: alpaqa::KKTError

__init__(*args, **kwargs)#

property bounds_violation#

property complementarity#

property constr_violation#

property stationarity#

class alpaqa.LBFGS#

C++ documentation alpaqa::LBFGS

Negative = <Sign.Negative: 1>#

class Params#

C++ documentation alpaqa::LBFGSParams

class CBFGS#

C++ documentation alpaqa::CBFGSParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.LBFGS.Params.CBFGS, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.LBFGS.Params.CBFGS, **kwargs) -> None

to_dict(self: alpaqa._alpaqa.float64.LBFGS.Params.CBFGS) → dict#

property α#

property ϵ#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.LBFGS.Params, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.LBFGS.Params, **kwargs) -> None

property cbfgs#

property force_pos_def#

property memory#

property min_abs_s#

property min_div_fac#

property stepsize#

to_dict(self: alpaqa._alpaqa.float64.LBFGS.Params) → dict#

Positive = <Sign.Positive: 0>#

class Sign#

C++ documentation alpaqa::LBFGS::Sign

Members:

Positive

Negative

Negative = <Sign.Negative: 1>#

Positive = <Sign.Positive: 0>#

__init__(self: alpaqa._alpaqa.float64.LBFGS.Sign, value: int) → None#

property name#

property value#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.LBFGS, params: Union[alpaqa._alpaqa.float64.LBFGS.Params, dict]) -> None
__init__(self: alpaqa._alpaqa.float64.LBFGS, params: Union[alpaqa._alpaqa.float64.LBFGS.Params, dict], n: int) -> None

apply(self: alpaqa._alpaqa.float64.LBFGS, q: numpy.ndarray[numpy.float64[m, 1], flags.writeable], γ: float) → bool#

apply_masked(self: alpaqa._alpaqa.float64.LBFGS, q: numpy.ndarray[numpy.float64[m, 1], flags.writeable], γ: float, J: List[int]) → bool#

current_history(self: alpaqa._alpaqa.float64.LBFGS) → int#

property n#

property params#

reset(self: alpaqa._alpaqa.float64.LBFGS) → None#

resize(self: alpaqa._alpaqa.float64.LBFGS, n: int) → None#

s(self: alpaqa._alpaqa.float64.LBFGS, i: int) → numpy.ndarray[numpy.float64[m, 1], flags.writeable]#

scale_y(self: alpaqa._alpaqa.float64.LBFGS, factor: float) → None#

update(self: alpaqa._alpaqa.float64.LBFGS, xk: numpy.ndarray[numpy.float64[m, 1]], xkp1: numpy.ndarray[numpy.float64[m, 1]], pk: numpy.ndarray[numpy.float64[m, 1]], pkp1: numpy.ndarray[numpy.float64[m, 1]], sign: alpaqa._alpaqa.float64.LBFGS.Sign = <Sign.Positive: 0>, forced: bool = False) → bool#

update_sy(self: alpaqa._alpaqa.float64.LBFGS, sk: numpy.ndarray[numpy.float64[m, 1]], yk: numpy.ndarray[numpy.float64[m, 1]], pkp1Tpkp1: float, forced: bool = False) → bool#

static update_valid(params: alpaqa._alpaqa.float64.LBFGS.Params, yTs: float, sTs: float, pTp: float) → bool#

y(self: alpaqa._alpaqa.float64.LBFGS, i: int) → numpy.ndarray[numpy.float64[m, 1], flags.writeable]#

α(self: alpaqa._alpaqa.float64.LBFGS, i: int) → float#

ρ(self: alpaqa._alpaqa.float64.LBFGS, i: int) → float#

class alpaqa.LBFGSDirection#

C++ documentation: alpaqa::LBFGSDirection

class DirectionParams#

C++ documentation: alpaqa::LBFGSDirection::DirectionParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.LBFGSDirection.DirectionParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.LBFGSDirection.DirectionParams, **kwargs) -> None

property rescale_on_step_size_changes#

to_dict(self: alpaqa._alpaqa.float64.LBFGSDirection.DirectionParams) → dict#

__init__(self: alpaqa._alpaqa.float64.LBFGSDirection, lbfgs_params: alpaqa._alpaqa.float64.LBFGS.Params | dict = {}, direction_params: alpaqa._alpaqa.float64.LBFGSDirection.DirectionParams | dict = {}) → None#

property params#

class alpaqa.LBFGSStepsize#

C++ documentation: alpaqa::LBFGSStepSize

Members:

BasedOnExternalStepSize

BasedOnCurvature

BasedOnCurvature = <LBFGSStepsize.BasedOnCurvature: 1>#

BasedOnExternalStepSize = <LBFGSStepsize.BasedOnExternalStepSize: 0>#

__init__(self: alpaqa._alpaqa.LBFGSStepsize, value: int) → None#

property name#

property value#

class alpaqa.LipschitzEstimateParams#

C++ documentation: alpaqa::LipschitzEstimateParams

property L_0#

property Lγ_factor#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.LipschitzEstimateParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.LipschitzEstimateParams, **kwargs) -> None

to_dict(self: alpaqa._alpaqa.float64.LipschitzEstimateParams) → dict#

property δ#

property ε#

High-level description of a minimization problem.

objective_expr: SX | MX#

variable: SX | MX#

constraints_expr: SX | MX | None = None#

penalty_constraints_expr: SX | MX | None = None#

parameter: SX | MX | None = None#

parameter_value: ndarray | None = None#

regularizer: float | ndarray | None = None#

bounds: Tuple[ndarray, ndarray] | None = None#

constraints_bounds: Tuple[ndarray, ndarray] | None = None#

penalty_constraints_bounds: Tuple[ndarray, ndarray] | None = None#

name: str = 'alpaqa_casadi_problem'#

subject_to_box(C: Tuple[ndarray, ndarray]) → MinimizationProblemDescription[source]#: Add box constraints \(x \in C\) on the problem variables.

subject_to(g: SX | MX, D: ndarray | Tuple[ndarray, ndarray] | None = None) → MinimizationProblemDescription[source]#: Add general constraints \(g(x) \in D\), handled using an augmented Lagrangian method.

subject_to_penalty(g: SX | MX, D: ndarray | Tuple[ndarray, ndarray] | None = None) → MinimizationProblemDescription[source]#: Add general constraints \(g(x) \in D\), handled using a quadratic penalty method.

with_l1_regularizer(λ: float | ndarray) → MinimizationProblemDescription[source]#: Add an \(\ell_1\)-regularization term \(\|\lambda x\|_1\) to the objective.

with_param(p: SX | MX, value: ndarray = None) → MinimizationProblemDescription[source]#: Make the problem depend on a symbolic parameter, with an optional default value. The value can be changed after the problem has been loaded, as wel as in between solves.

with_param_value(value: ndarray) → MinimizationProblemDescription[source]#: Explicitly change the parameter value for the parameter added by with_param().

with_name(name: str) → MinimizationProblemDescription[source]#: Set the name of the problem. Must be a valid file name, and for compiled problems, it should also be a valid C identifier, therefore it is recommended to stick to letters, numbers and underscores.

compile(**kwargs) → CasADiProblem[source]#

Generate, compile and load the problem.

A C compiler is required (e.g. GCC or Clang on Linux, Xcode on macOS, or Visual Studio on Windows). If no compiler is available, you could use the alpaqa.MinimizationProblemDescription.build() method instead.

Parameters:

**kwargs – Arguments passed to alpaqa.casadi_loader.generate_and_compile_casadi_problem().

Keyword Arguments:

second_order: str – Whether to generate functions for evaluating second-order derivatives:
- 'no': only first-order derivatives (default).
- 'full': Hessians and Hessian-vector products of the Lagrangian and the augmented Lagrangian.
- 'prod': Hessian-vector products of the Lagrangian and the augmented Lagrangian.
- 'L': Hessian of the Lagrangian.
- 'L_prod': Hessian-vector product of the Lagrangian.
- 'psi': Hessian of the augmented Lagrangian.
- 'psi_prod': Hessian-vector product of the augmented Lagrangian.
name: str – Optional string description of the problem (used for filenames).
sym: Callable – Symbolic variable constructor, usually either cs.SX.sym (default) or cs.MX.sym. SX expands the expressions and generally results in better run-time performance, while MX usually has faster compile times.

build(**kwargs) → CasADiProblem[source]#

Finalize the problem formulation and return a problem type that can be used by the solvers.

This method is usually not recommended: the alpaqa.MinimizationProblemDescription.compile() method is preferred because it pre-compiles the problem for better performance.

Keyword Arguments:

second_order: str – Whether to generate functions for evaluating second-order derivatives:
- 'no': only first-order derivatives (default).
- 'full': Hessians and Hessian-vector products of the Lagrangian and the augmented Lagrangian.
- 'prod': Hessian-vector products of the Lagrangian and the augmented Lagrangian.
- 'L': Hessian of the Lagrangian.
- 'L_prod': Hessian-vector product of the Lagrangian.
- 'psi': Hessian of the augmented Lagrangian.
- 'psi_prod': Hessian-vector product of the augmented Lagrangian.
sym: Callable – Symbolic variable constructor, usually either cs.SX.sym (default) or cs.MX.sym. SX expands the expressions and generally results in better run-time performance.

__init__(objective_expr: SX | MX, variable: SX | MX, constraints_expr: SX | MX | None = None, penalty_constraints_expr: SX | MX | None = None, parameter: SX | MX | None = None, parameter_value: ndarray | None = None, regularizer: float | ndarray | None = None, bounds: Tuple[ndarray, ndarray] | None = None, constraints_bounds: Tuple[ndarray, ndarray] | None = None, penalty_constraints_bounds: Tuple[ndarray, ndarray] | None = None, name: str = 'alpaqa_casadi_problem') → None#

class alpaqa.NewtonTRDirection#

C++ documentation: alpaqa::NewtonTRDirection

__init__(self: alpaqa._alpaqa.float64.NewtonTRDirection, accelerator_params: alpaqa._alpaqa.float64.SteihaugCGParams | dict = {}, direction_params: alpaqa._alpaqa.float64.NewtonTRDirectionParams | dict = {}) → None#

property params#

class alpaqa.NewtonTRDirectionParams#

C++ documentation: alpaqa::NewtonTRDirectionParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.NewtonTRDirectionParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.NewtonTRDirectionParams, **kwargs) -> None

property finite_diff#

property finite_diff_stepsize#

property hessian_vec_factor#

to_dict(self: alpaqa._alpaqa.float64.NewtonTRDirectionParams) → dict#

class alpaqa.NoopDirection#

C++ documentation: alpaqa::NoopDirection

AcceleratorParams = None#

DirectionParams = None#

__init__(self: alpaqa._alpaqa.float64.NoopDirection) → None#

params = None#

class alpaqa.OCPEvalCounter#

C++ documentation: alpaqa::OCPEvalCounter

class OCPEvalTimer#

C++ documentation: alpaqa::OCPEvalCounter::OCPEvalTimer

__init__(*args, **kwargs)#

property add_Q#

property add_Q_N#

property add_R_masked#

property add_R_prod_masked#

property add_S_masked#

property add_S_prod_masked#

property add_gn_hess_constr#

property add_gn_hess_constr_N#

property constr#

property constr_N#

property f#

property grad_constr_prod#

property grad_constr_prod_N#

property grad_f_prod#

property h#

property h_N#

property jac_f#

property l#

property l_N#

property q_N#

property qr#

__init__(*args, **kwargs)#

property add_Q#

property add_Q_N#

property add_R_masked#

property add_R_prod_masked#

property add_S_masked#

property add_S_prod_masked#

property add_gn_hess_constr#

property add_gn_hess_constr_N#

property constr#

property constr_N#

property f#

property grad_constr_prod#

property grad_constr_prod_N#

property grad_f_prod#

property h#

property h_N#

property jac_f#

property l#

property l_N#

property q_N#

property qr#

property time#

class alpaqa.OCPEvaluator#

Qk(self: alpaqa._alpaqa.float64.OCPEvaluator, k: int, u: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]] | None = None, μ: numpy.ndarray[numpy.float64[m, 1]] | None = None) → numpy.ndarray[numpy.float64[m, n]]#

Rk(self: alpaqa._alpaqa.float64.OCPEvaluator, k: int, u: numpy.ndarray[numpy.float64[m, 1]], mask: numpy.ndarray[numpy.int64[m, 1]]) → numpy.ndarray[numpy.float64[m, n]]#

Sk(self: alpaqa._alpaqa.float64.OCPEvaluator, k: int, u: numpy.ndarray[numpy.float64[m, 1]], mask: numpy.ndarray[numpy.int64[m, 1]]) → numpy.ndarray[numpy.float64[m, n]]#

__init__(self: alpaqa._alpaqa.float64.OCPEvaluator, problem: alpaqa._alpaqa.float64.ControlProblem) → None#

forward_backward(self: alpaqa._alpaqa.float64.OCPEvaluator, u: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]] | None = None, μ: numpy.ndarray[numpy.float64[m, 1]] | None = None) → Tuple[float, numpy.ndarray[numpy.float64[m, 1]]]#

Returns:

Cost
Gradient

lqr_factor_solve(self: alpaqa._alpaqa.float64.OCPEvaluator, u: numpy.ndarray[numpy.float64[m, 1]], γ: float, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, μ: numpy.ndarray[numpy.float64[m, 1]] | None = None) → numpy.ndarray[numpy.float64[m, 1]]#

lqr_factor_solve_QRS(self: alpaqa._alpaqa.float64.OCPEvaluator, u: numpy.ndarray[numpy.float64[m, 1]], γ: float, Q: list, R: list, S: list, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, μ: numpy.ndarray[numpy.float64[m, 1]] | None = None, masked: bool = True) → numpy.ndarray[numpy.float64[m, 1]]#

class alpaqa.PANOCDirection#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANOCDirection, direction: alpaqa._alpaqa.float64.NoopDirection) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.PANOCDirection, direction: alpaqa._alpaqa.float64.LBFGSDirection) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.PANOCDirection, direction: alpaqa._alpaqa.float64.StructuredLBFGSDirection) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.PANOCDirection, direction: alpaqa._alpaqa.float64.StructuredNewtonDirection) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.PANOCDirection, direction: alpaqa._alpaqa.float64.ConvexNewtonDirection) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.PANOCDirection, direction: alpaqa._alpaqa.float64.AndersonDirection) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.PANOCDirection, direction: object) -> None

Explicit conversion from a custom Python class.

property params#

class alpaqa.PANOCOCPParams#

C++ documentation: alpaqa::PANOCOCPParams

property L_max#

property L_max_inc#

property L_min#

property Lipschitz#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANOCOCPParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.PANOCOCPParams, **kwargs) -> None

property disable_acceleration#

property gn_interval#

property gn_sticky#

property lbfgs_params#

property linesearch_strictness_factor#

property linesearch_tolerance_factor#

property lqr_factor_cholesky#

property max_iter#

property max_no_progress#

property max_time#

property min_linesearch_coefficient#

property print_interval#

property print_precision#

property quadratic_upperbound_tolerance_factor#

property reset_lbfgs_on_gn_step#

property stop_crit#

to_dict(self: alpaqa._alpaqa.float64.PANOCOCPParams) → dict#

class alpaqa.PANOCOCPProgressInfo#

Data passed to the PANOC progress callback.

C++ documentation: alpaqa::PANOCOCPProgressInfo

property L#: Estimate of Lipschitz constant of objective \(L\)

__init__(*args, **kwargs)#

property fpr#: Fixed-point residual \(\left\|p\right\| / \gamma\)

property gn#: Was \(q\) a Gauss-Newton or L-BFGS step?

property grad_ψ#: Gradient of objective \(\nabla\psi(u)\)

property k#: Iteration

property lqr_min_rcond#: Minimum reciprocal condition number encountered in LQR factorization

property nJ#: Number of inactive constraints \(\#\mathcal J\)

property norm_sq_p#: \(\left\|p\right\|^2\)

property p#: Projected gradient step \(p\)

property params#: Solver parameters

property problem#: Problem being solved

property q#: Previous accelerated step \(q\)

property status#: Current solver status

property u#: Inputs

property u_hat#: Inputs after projected gradient step

property x#: States

property x_hat#: States after projected gradient step

property xu#: States \(x\) and inputs \(u\)

property xu_hat#: Variables after projected gradient step \(\hat u\)

property γ#: Step size \(\gamma\)

property ε#: Tolerance reached \(\varepsilon_k\)

property τ#: Line search parameter \(\tau\)

property φγ#: Forward-backward envelope \(\varphi_\gamma(u)\)

property ψ#: Objective value \(\psi(u)\)

property ψ_hat#: Objective at x̂ \(\psi(\hat u)\)

class alpaqa.PANOCOCPSolver#

C++ documentation: alpaqa::PANOCOCPSolver

Params#: alias of PANOCOCPParams

__call__(self: alpaqa._alpaqa.float64.PANOCOCPSolver, problem: alpaqa._alpaqa.float64.ControlProblem, opts: alpaqa._alpaqa.float64.InnerSolveOptions = {}, x: numpy.ndarray[numpy.float64[m, 1]] | None = None, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, Σ: numpy.ndarray[numpy.float64[m, 1]] | None = None, *, asynchronous: bool = True, suppress_interrupt: bool = False) → tuple#

Solve the given problem.

Parameters:

problem – Problem to solve
opts – Options (such as desired tolerance)
x – Optional initial guess for the decision variables
y – Lagrange multipliers (when used as ALM inner solver)
Σ – Penalty factors (when used as ALM inner solver)
asynchronous – Release the GIL and run the solver on a separate thread
suppress_interrupt – If the solver is interrupted by a KeyboardInterrupt, don’t propagate this exception back to the Python interpreter, but stop the solver early, and return a solution with the status set to alpaqa.SolverStatus.Interrupted.

Returns:

Solution \(x\)
Updated Lagrange multipliers (only if parameter y was not None)
Constraint violation (only if parameter y was not None)
Statistics

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANOCOCPSolver, other: alpaqa._alpaqa.float64.PANOCOCPSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.PANOCOCPSolver, panoc_params: Union[alpaqa._alpaqa.float64.PANOCOCPParams, dict]) -> None

Create a PANOC solver.

property name#

property params#

set_progress_callback(self: alpaqa._alpaqa.float64.PANOCOCPSolver, callback: Callable[[alpaqa._alpaqa.float64.PANOCOCPProgressInfo], None]) → alpaqa._alpaqa.float64.PANOCOCPSolver#: Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.

stop(self: alpaqa._alpaqa.float64.PANOCOCPSolver) → None#

class alpaqa.PANOCParams#

C++ documentation: alpaqa::PANOCParams

property L_max#

property L_min#

property Lipschitz#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANOCParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.PANOCParams, **kwargs) -> None

property eager_gradient_eval#

property force_linesearch#

property linesearch_coefficient_update_factor#

property linesearch_strictness_factor#

property linesearch_tolerance_factor#

property max_iter#

property max_no_progress#

property max_time#

property min_linesearch_coefficient#

property print_interval#

property print_precision#

property quadratic_upperbound_tolerance_factor#

property recompute_last_prox_step_after_stepsize_change#

property stop_crit#

to_dict(self: alpaqa._alpaqa.float64.PANOCParams) → dict#

property update_direction_in_candidate#

class alpaqa.PANOCProgressInfo#

Data passed to the PANOC progress callback.

C++ documentation: alpaqa::PANOCProgressInfo

property L#: Estimate of Lipschitz constant of objective \(L\)

__init__(*args, **kwargs)#

property fpr#: Fixed-point residual \(\left\|p\right\| / \gamma\)

property grad_ψ#: Gradient of objective \(\nabla\psi(x)\)

property grad_ψ_hat#: Gradient of objective at x̂ \(\nabla\psi(\hat x)\)

property k#: Iteration

property norm_sq_p#: \(\left\|p\right\|^2\)

property p#: Projected gradient step \(p\)

property params#: Solver parameters

property problem#: Problem being solved

property q#: Previous quasi-Newton step \(\nabla\psi(\hat x)\)

property status#: Current solver status

property x#: Decision variable \(x\)

property x_hat#: Decision variable after projected gradient step \(\hat x\)

property y#: Lagrange multipliers \(y\)

property y_hat#: Candidate updated multipliers at x̂ \(\hat y(\hat x)\)

property Σ#: Penalty factor \(\Sigma\)

property γ#: Step size \(\gamma\)

property ε#: Tolerance reached \(\varepsilon_k\)

property τ#: Previous line search parameter \(\tau\)

property φγ#: Forward-backward envelope \(\varphi_\gamma(x)\)

property ψ#: Objective value \(\psi(x)\)

property ψ_hat#: Objective at x̂ \(\psi(\hat x)\)

class alpaqa.PANOCSolver#

C++ documentation: alpaqa::PANOCSolver

Params#: alias of PANOCParams

__call__(self: alpaqa._alpaqa.float64.PANOCSolver, problem: alpaqa._alpaqa.float64.Problem, opts: alpaqa._alpaqa.float64.InnerSolveOptions = {}, x: numpy.ndarray[numpy.float64[m, 1]] | None = None, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, Σ: numpy.ndarray[numpy.float64[m, 1]] | None = None, *, asynchronous: bool = True, suppress_interrupt: bool = False) → tuple#

Solve the given problem.

Parameters:

problem – Problem to solve
opts – Options (such as desired tolerance)
x – Optional initial guess for the decision variables
y – Lagrange multipliers (when used as ALM inner solver)
Σ – Penalty factors (when used as ALM inner solver)
asynchronous – Release the GIL and run the solver on a separate thread
suppress_interrupt – If the solver is interrupted by a KeyboardInterrupt, don’t propagate this exception back to the Python interpreter, but stop the solver early, and return a solution with the status set to alpaqa.SolverStatus.Interrupted.

Returns:

Solution \(x\)
Updated Lagrange multipliers (only if parameter y was not None)
Constraint violation (only if parameter y was not None)
Statistics

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANOCSolver, other: alpaqa._alpaqa.float64.PANOCSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.PANOCSolver, panoc_params: Union[alpaqa._alpaqa.float64.PANOCParams, dict] = {}, lbfgs_params: Union[alpaqa._alpaqa.float64.LBFGS.Params, dict] = {}, direction_params: Union[alpaqa._alpaqa.float64.StructuredLBFGSDirection.DirectionParams, dict] = {}) -> None

Create a PANOC solver using structured L-BFGS directions.

__init__(self: alpaqa._alpaqa.float64.PANOCSolver, panoc_params: Union[alpaqa._alpaqa.float64.PANOCParams, dict], direction: alpaqa._alpaqa.float64.PANOCDirection) -> None

Create a PANOC solver using a custom direction.

property direction#

property name#

property params#

set_progress_callback(self: alpaqa._alpaqa.float64.PANOCSolver, callback: Callable[[alpaqa._alpaqa.float64.PANOCProgressInfo], None]) → alpaqa._alpaqa.float64.PANOCSolver#: Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.

stop(self: alpaqa._alpaqa.float64.PANOCSolver) → None#

class alpaqa.PANOCStopCrit#

C++ documentation: alpaqa::PANOCStopCrit

Members:

ApproxKKT

ApproxKKT2

ProjGradNorm

ProjGradNorm2

ProjGradUnitNorm

ProjGradUnitNorm2

FPRNorm

FPRNorm2

Ipopt

LBFGSBpp

ApproxKKT = <PANOCStopCrit.ApproxKKT: 0>#

ApproxKKT2 = <PANOCStopCrit.ApproxKKT2: 1>#

FPRNorm = <PANOCStopCrit.FPRNorm: 6>#

FPRNorm2 = <PANOCStopCrit.FPRNorm2: 7>#

Ipopt = <PANOCStopCrit.Ipopt: 8>#

LBFGSBpp = <PANOCStopCrit.LBFGSBpp: 9>#

ProjGradNorm = <PANOCStopCrit.ProjGradNorm: 2>#

ProjGradNorm2 = <PANOCStopCrit.ProjGradNorm2: 3>#

ProjGradUnitNorm = <PANOCStopCrit.ProjGradUnitNorm: 4>#

ProjGradUnitNorm2 = <PANOCStopCrit.ProjGradUnitNorm2: 5>#

__init__(self: alpaqa._alpaqa.PANOCStopCrit, value: int) → None#

property name#

property value#

class alpaqa.PANTRDirection#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANTRDirection, direction: alpaqa._alpaqa.float64.NewtonTRDirection) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.PANTRDirection, direction: object) -> None

Explicit conversion from a custom Python class.

property params#

class alpaqa.PANTRParams#

C++ documentation: alpaqa::PANTRParams

property L_max#

property L_min#

property Lipschitz#

property TR_tolerance_factor#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANTRParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.PANTRParams, **kwargs) -> None

property compute_ratio_using_new_stepsize#

property disable_acceleration#

property initial_radius#

property max_iter#

property max_no_progress#

property max_time#

property min_radius#

property print_interval#

property print_precision#

property quadratic_upperbound_tolerance_factor#

property radius_factor_acceptable#

property radius_factor_good#

property radius_factor_rejected#

property ratio_approx_fbe_quadratic_model#

property ratio_threshold_acceptable#

property ratio_threshold_good#

property recompute_last_prox_step_after_direction_reset#

property stop_crit#

to_dict(self: alpaqa._alpaqa.float64.PANTRParams) → dict#

property update_direction_on_prox_step#

class alpaqa.PANTRProgressInfo#

Data passed to the PANTR progress callback.

C++ documentation: alpaqa::PANTRProgressInfo

property L#: Estimate of Lipschitz constant of objective \(L\)

__init__(*args, **kwargs)#

property fpr#: Fixed-point residual \(\left\|p\right\| / \gamma\)

property grad_ψ#: Gradient of objective \(\nabla\psi(x)\)

property grad_ψ_hat#: Gradient of objective at x̂ \(\nabla\psi(\hat x)\)

property k#: Iteration

property norm_sq_p#: \(\left\|p\right\|^2\)

property p#: Projected gradient step \(p\)

property params#: Solver parameters

property problem#: Problem being solved

property q#: Previous quasi-Newton step \(\nabla\psi(\hat x)\)

property status#: Current solver status

property x#: Decision variable \(x\)

property x_hat#: Decision variable after projected gradient step \(\hat x\)

property y#: Lagrange multipliers \(y\)

property y_hat#: Candidate updated multipliers at x̂ \(\hat y(\hat x)\)

property Δ#: Previous trust radius \(\Delta\)

property Σ#: Penalty factor \(\Sigma\)

property γ#: Step size \(\gamma\)

property ε#: Tolerance reached \(\varepsilon_k\)

property ρ#: Previous decrease ratio \(\rho\)

property τ#: Acceptance (1) or rejection (0) of previous accelerated step \(\tau\)

property φγ#: Forward-backward envelope \(\varphi_\gamma(x)\)

property ψ#: Objective value \(\psi(x)\)

property ψ_hat#: Objective at x̂ \(\psi(\hat x)\)

class alpaqa.PANTRSolver#

C++ documentation: alpaqa::PANTRSolver

Params#: alias of PANTRParams

__call__(self: alpaqa._alpaqa.float64.PANTRSolver, problem: alpaqa._alpaqa.float64.Problem, opts: alpaqa._alpaqa.float64.InnerSolveOptions = {}, x: numpy.ndarray[numpy.float64[m, 1]] | None = None, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, Σ: numpy.ndarray[numpy.float64[m, 1]] | None = None, *, asynchronous: bool = True, suppress_interrupt: bool = False) → tuple#

Solve the given problem.

Parameters:

problem – Problem to solve
opts – Options (such as desired tolerance)
x – Optional initial guess for the decision variables
y – Lagrange multipliers (when used as ALM inner solver)
Σ – Penalty factors (when used as ALM inner solver)
asynchronous – Release the GIL and run the solver on a separate thread
suppress_interrupt – If the solver is interrupted by a KeyboardInterrupt, don’t propagate this exception back to the Python interpreter, but stop the solver early, and return a solution with the status set to alpaqa.SolverStatus.Interrupted.

Returns:

Solution \(x\)
Updated Lagrange multipliers (only if parameter y was not None)
Constraint violation (only if parameter y was not None)
Statistics

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.PANTRSolver, other: alpaqa._alpaqa.float64.PANTRSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.PANTRSolver, pantr_params: Union[alpaqa._alpaqa.float64.PANTRParams, dict] = {}, steihaug_params: Union[alpaqa._alpaqa.float64.SteihaugCGParams, dict] = {}, direction_params: Union[alpaqa._alpaqa.float64.NewtonTRDirectionParams, dict] = {}) -> None

Create a PANTR solver using a structured Newton CG subproblem solver.

__init__(self: alpaqa._alpaqa.float64.PANTRSolver, pantr_params: Union[alpaqa._alpaqa.float64.PANTRParams, dict], direction: alpaqa._alpaqa.float64.PANTRDirection) -> None

Create a PANTR solver using a custom direction.

property direction#

property name#

property params#

set_progress_callback(self: alpaqa._alpaqa.float64.PANTRSolver, callback: Callable[[alpaqa._alpaqa.float64.PANTRProgressInfo], None]) → alpaqa._alpaqa.float64.PANTRSolver#: Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.

stop(self: alpaqa._alpaqa.float64.PANTRSolver) → None#

class alpaqa.Problem#

C++ documentation: alpaqa::TypeErasedProblem

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.Problem, other: alpaqa._alpaqa.float64.Problem) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.Problem, problem: alpaqa._alpaqa.float64.CasADiProblem) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.Problem, problem: alpaqa._alpaqa.float64.CUTEstProblem) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.Problem, problem: alpaqa._alpaqa.float64.DLProblem) -> None

Explicit conversion.

__init__(self: alpaqa._alpaqa.float64.Problem, problem: object) -> None

Explicit conversion from a custom Python class.

check(self: alpaqa._alpaqa.float64.Problem) → None#

eval_f(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]]) → float#

eval_f_g(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], g: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → float#

eval_f_grad_f(*args, **kwargs)#

Overloaded function.

eval_f_grad_f(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_f_grad_f(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]]) -> tuple

eval_g(*args, **kwargs)#

Overloaded function.

eval_g(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], gx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_g(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_L(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_L: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_f(*args, **kwargs)#

Overloaded function.

eval_grad_f(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], grad_fx: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_f(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_f_grad_g_prod(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_f: numpy.ndarray[numpy.float64[m, 1], flags.writeable], grad_gxy: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_g_prod(*args, **kwargs)#

Overloaded function.

eval_grad_g_prod(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_gxy: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_g_prod(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_grad_gi(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], i: int, grad_gi: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_ψ(*args, **kwargs)#

Overloaded function.

eval_grad_ψ(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_m: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_grad_ψ(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_hess_L(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float = 1.0) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Hessian of the Lagrangian and its symmetry.

eval_hess_L_prod(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_hess_ψ(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], scale: float = 1.0) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Hessian of the augmented Lagrangian and its symmetry.

eval_hess_ψ_prod(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], scale: float, v: numpy.ndarray[numpy.float64[m, 1]], Hv: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_inactive_indices_res_lna(*args, **kwargs)#

Overloaded function.

eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.Problem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], J: numpy.ndarray[numpy.int64[m, 1], flags.writeable]) -> int
eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.Problem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.int64[m, 1]]

eval_jac_g(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]]) → Tuple[object, alpaqa._alpaqa.Symmetry]#: Returns the Jacobian of the constraints and its symmetry.

eval_proj_diff_g(*args, **kwargs)#

Overloaded function.

eval_proj_diff_g(self: alpaqa._alpaqa.float64.Problem, z: numpy.ndarray[numpy.float64[m, 1]], e: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_proj_diff_g(self: alpaqa._alpaqa.float64.Problem, z: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_proj_multipliers(self: alpaqa._alpaqa.float64.Problem, y: numpy.ndarray[numpy.float64[m, 1], flags.writeable], M: float) → None#

eval_prox_grad_step(*args, **kwargs)#

Overloaded function.

eval_prox_grad_step(self: alpaqa._alpaqa.float64.Problem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], x_hat: numpy.ndarray[numpy.float64[m, 1], flags.writeable], p: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_prox_grad_step(self: alpaqa._alpaqa.float64.Problem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], float]

eval_ψ(*args, **kwargs)#

Overloaded function.

eval_ψ(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], ŷ: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_ψ(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]]]

eval_ψ_grad_ψ(*args, **kwargs)#

Overloaded function.

eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_n: numpy.ndarray[numpy.float64[m, 1], flags.writeable], work_m: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], Σ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[float, numpy.ndarray[numpy.float64[m, 1]]]

get_box_C(self: alpaqa._alpaqa.float64.Problem) → alpaqa._alpaqa.float64.Box#

get_box_D(self: alpaqa._alpaqa.float64.Problem) → alpaqa._alpaqa.float64.Box#

property m#: Number of general constraints, dimension of \(g(x)\)

property n#: Number of decision variables, dimension of \(x\)

provides_check(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_f_g(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_f_grad_f(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_grad_L(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_grad_f_grad_g_prod(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_grad_gi(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_grad_ψ(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_hess_L(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_hess_L_prod(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_hess_ψ(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_hess_ψ_prod(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_jac_g(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_ψ(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_eval_ψ_grad_ψ(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_get_box_C(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_get_box_D(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_get_hess_L_sparsity(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_get_hess_ψ_sparsity(self: alpaqa._alpaqa.float64.Problem) → bool#

provides_get_jac_g_sparsity(self: alpaqa._alpaqa.float64.Problem) → bool#

class alpaqa.ProblemWithCounters#

__init__(*args, **kwargs)#

property evaluations#

property problem#

class alpaqa.SolverStatus#

C++ documentation: alpaqa::SolverStatus

Members:

Busy : In progress.

Converged : Converged and reached given tolerance

MaxTime : Maximum allowed execution time exceeded

MaxIter : Maximum number of iterations exceeded

NotFinite : Intermediate results were infinite or NaN

NoProgress : No progress was made in the last iteration

Interrupted : Solver was interrupted by the user

Busy = <SolverStatus.Busy: 0>#

Converged = <SolverStatus.Converged: 1>#

Interrupted = <SolverStatus.Interrupted: 6>#

MaxIter = <SolverStatus.MaxIter: 3>#

MaxTime = <SolverStatus.MaxTime: 2>#

NoProgress = <SolverStatus.NoProgress: 5>#

NotFinite = <SolverStatus.NotFinite: 4>#

__init__(self: alpaqa._alpaqa.SolverStatus, value: int) → None#

property name#

property value#

class alpaqa.SteihaugCGParams#

C++ documentation: alpaqa::SteihaugCGParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.SteihaugCGParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.SteihaugCGParams, **kwargs) -> None

property max_iter_factor#

to_dict(self: alpaqa._alpaqa.float64.SteihaugCGParams) → dict#

property tol_max#

property tol_scale#

property tol_scale_root#

class alpaqa.StructuredLBFGSDirection#

C++ documentation: alpaqa::StructuredLBFGSDirection

class DirectionParams#

C++ documentation: alpaqa::StructuredLBFGSDirection::DirectionParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.StructuredLBFGSDirection.DirectionParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.StructuredLBFGSDirection.DirectionParams, **kwargs) -> None

property full_augmented_hessian#

property hessian_vec_factor#

property hessian_vec_finite_differences#

to_dict(self: alpaqa._alpaqa.float64.StructuredLBFGSDirection.DirectionParams) → dict#

__init__(self: alpaqa._alpaqa.float64.StructuredLBFGSDirection, lbfgs_params: alpaqa._alpaqa.float64.LBFGS.Params | dict = {}, direction_params: alpaqa._alpaqa.float64.StructuredLBFGSDirection.DirectionParams | dict = {}) → None#

property params#

class alpaqa.StructuredNewtonDirection#

C++ documentation: alpaqa::StructuredNewtonDirection

class DirectionParams#

C++ documentation: alpaqa::StructuredNewtonDirection::DirectionParams

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.StructuredNewtonDirection.DirectionParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.StructuredNewtonDirection.DirectionParams, **kwargs) -> None

property hessian_vec_factor#

to_dict(self: alpaqa._alpaqa.float64.StructuredNewtonDirection.DirectionParams) → dict#

__init__(self: alpaqa._alpaqa.float64.StructuredNewtonDirection, direction_params: alpaqa._alpaqa.float64.StructuredNewtonDirection.DirectionParams | dict = {}) → None#

property params#

class alpaqa.Symmetry#

C++ documentation: alpaqa::sparsity::Symmetry

Members:

Unsymmetric

Upper

Lower

Lower = <Symmetry.Lower: 2>#

Unsymmetric = <Symmetry.Unsymmetric: 0>#

Upper = <Symmetry.Upper: 1>#

__init__(self: alpaqa._alpaqa.Symmetry, value: int) → None#

property name#

property value#

class alpaqa.UnconstrProblem#

C++ documentation: alpaqa::UnconstrProblem

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.UnconstrProblem, other: alpaqa._alpaqa.float64.UnconstrProblem) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.UnconstrProblem, n: int) -> None

Parameters:: n – Number of unknowns

eval_g(self: alpaqa._alpaqa.float64.UnconstrProblem, x: numpy.ndarray[numpy.float64[m, 1]], g: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_g_prod(self: alpaqa._alpaqa.float64.UnconstrProblem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]], grad_gxy: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_grad_gi(self: alpaqa._alpaqa.float64.UnconstrProblem, x: numpy.ndarray[numpy.float64[m, 1]], i: int, grad_gi: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_inactive_indices_res_lna(*args, **kwargs)#

Overloaded function.

eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.UnconstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], J: numpy.ndarray[numpy.int64[m, 1], flags.writeable]) -> int
eval_inactive_indices_res_lna(self: alpaqa._alpaqa.float64.UnconstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.int64[m, 1]]

eval_jac_g(self: alpaqa._alpaqa.float64.UnconstrProblem, x: numpy.ndarray[numpy.float64[m, 1]], J_values: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) → None#

eval_proj_diff_g(*args, **kwargs)#

Overloaded function.

eval_proj_diff_g(self: alpaqa._alpaqa.float64.UnconstrProblem, z: numpy.ndarray[numpy.float64[m, 1]], e: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> None
eval_proj_diff_g(self: alpaqa._alpaqa.float64.UnconstrProblem, z: numpy.ndarray[numpy.float64[m, 1]]) -> numpy.ndarray[numpy.float64[m, 1]]

eval_proj_multipliers(self: alpaqa._alpaqa.float64.UnconstrProblem, y: numpy.ndarray[numpy.float64[m, 1], flags.writeable], M: float) → None#

eval_prox_grad_step(*args, **kwargs)#

Overloaded function.

eval_prox_grad_step(self: alpaqa._alpaqa.float64.UnconstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]], x_hat: numpy.ndarray[numpy.float64[m, 1], flags.writeable], p: numpy.ndarray[numpy.float64[m, 1], flags.writeable]) -> float
eval_prox_grad_step(self: alpaqa._alpaqa.float64.UnconstrProblem, γ: float, x: numpy.ndarray[numpy.float64[m, 1]], grad_ψ: numpy.ndarray[numpy.float64[m, 1]]) -> Tuple[numpy.ndarray[numpy.float64[m, 1]], numpy.ndarray[numpy.float64[m, 1]], float]

property m#: Number of general constraints, dimension of \(g(x)\)

property n#: Number of decision variables, dimension of \(x\)

resize(self: alpaqa._alpaqa.float64.UnconstrProblem, n: int) → None#

class alpaqa.ZeroFPRParams#

C++ documentation: alpaqa::ZeroFPRParams

property L_max#

property L_min#

property Lipschitz#

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.ZeroFPRParams, params: dict) -> None
__init__(self: alpaqa._alpaqa.float64.ZeroFPRParams, **kwargs) -> None

property force_linesearch#

property linesearch_strictness_factor#

property linesearch_tolerance_factor#

property max_iter#

property max_no_progress#

property max_time#

property min_linesearch_coefficient#

property print_interval#

property print_precision#

property quadratic_upperbound_tolerance_factor#

property recompute_last_prox_step_after_stepsize_change#

property stop_crit#

to_dict(self: alpaqa._alpaqa.float64.ZeroFPRParams) → dict#

property update_direction_from_prox_step#

property update_direction_in_candidate#

class alpaqa.ZeroFPRProgressInfo#

Data passed to the ZeroFPR progress callback.

C++ documentation: alpaqa::ZeroFPRProgressInfo

property L#: Estimate of Lipschitz constant of objective \(L\)

__init__(*args, **kwargs)#

property fpr#: Fixed-point residual \(\left\|p\right\| / \gamma\)

property grad_ψ#: Gradient of objective \(\nabla\psi(x)\)

property grad_ψ_hat#: Gradient of objective at x̂ \(\nabla\psi(\hat x)\)

property k#: Iteration

property norm_sq_p#: \(\left\|p\right\|^2\)

property p#: Projected gradient step \(p\)

property params#: Solver parameters

property problem#: Problem being solved

property q#: Previous quasi-Newton step \(\nabla\psi(\hat x)\)

property status#: Current solver status

property x#: Decision variable \(x\)

property x_hat#: Decision variable after projected gradient step \(\hat x\)

property y#: Lagrange multipliers \(y\)

property y_hat#: Candidate updated multipliers at x̂ \(\hat y(\hat x)\)

property Σ#: Penalty factor \(\Sigma\)

property γ#: Step size \(\gamma\)

property ε#: Tolerance reached \(\varepsilon_k\)

property τ#: Previous line search parameter \(\tau\)

property φγ#: Forward-backward envelope \(\varphi_\gamma(x)\)

property ψ#: Objective value \(\psi(x)\)

property ψ_hat#: Objective at x̂ \(\psi(\hat x)\)

class alpaqa.ZeroFPRSolver#

C++ documentation: alpaqa::ZeroFPRSolver

Params#: alias of ZeroFPRParams

__call__(self: alpaqa._alpaqa.float64.ZeroFPRSolver, problem: alpaqa._alpaqa.float64.Problem, opts: alpaqa._alpaqa.float64.InnerSolveOptions = {}, x: numpy.ndarray[numpy.float64[m, 1]] | None = None, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, Σ: numpy.ndarray[numpy.float64[m, 1]] | None = None, *, asynchronous: bool = True, suppress_interrupt: bool = False) → tuple#

Solve the given problem.

Parameters:

problem – Problem to solve
opts – Options (such as desired tolerance)
x – Optional initial guess for the decision variables
y – Lagrange multipliers (when used as ALM inner solver)
Σ – Penalty factors (when used as ALM inner solver)
asynchronous – Release the GIL and run the solver on a separate thread
suppress_interrupt – If the solver is interrupted by a KeyboardInterrupt, don’t propagate this exception back to the Python interpreter, but stop the solver early, and return a solution with the status set to alpaqa.SolverStatus.Interrupted.

Returns:

Solution \(x\)
Updated Lagrange multipliers (only if parameter y was not None)
Constraint violation (only if parameter y was not None)
Statistics

__init__(*args, **kwargs)#

Overloaded function.

__init__(self: alpaqa._alpaqa.float64.ZeroFPRSolver, other: alpaqa._alpaqa.float64.ZeroFPRSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.ZeroFPRSolver, zerofpr_params: Union[alpaqa._alpaqa.float64.ZeroFPRParams, dict] = {}, lbfgs_params: Union[alpaqa._alpaqa.float64.LBFGS.Params, dict] = {}, direction_params: Union[alpaqa._alpaqa.float64.StructuredLBFGSDirection.DirectionParams, dict] = {}) -> None

Create a ZeroFPR solver using structured L-BFGS directions.

__init__(self: alpaqa._alpaqa.float64.ZeroFPRSolver, zerofpr_params: Union[alpaqa._alpaqa.float64.ZeroFPRParams, dict], direction: alpaqa._alpaqa.float64.PANOCDirection) -> None

Create a ZeroFPR solver using a custom direction.

property direction#

property name#

property params#

set_progress_callback(self: alpaqa._alpaqa.float64.ZeroFPRSolver, callback: Callable[[alpaqa._alpaqa.float64.ZeroFPRProgressInfo], None]) → alpaqa._alpaqa.float64.ZeroFPRSolver#: Specify a callable that is invoked with some intermediate results on each iteration of the algorithm.

stop(self: alpaqa._alpaqa.float64.ZeroFPRSolver) → None#

alpaqa.control_problem_with_counters(problem: alpaqa._alpaqa.float64.CasADiControlProblem) → alpaqa._alpaqa.float64.ControlProblemWithCounters#

Wrap the problem to count all function evaluations.

Parameters:

problem – The original problem to wrap. Copied.

Returns:

Wrapped problem.
Counters for wrapped problem.

alpaqa.deserialize_casadi_problem(functions: Dict[str, str]) → alpaqa._alpaqa.float64.CasADiProblem#: Deserialize a CasADi problem from the given serialized functions.

alpaqa.kkt_error(arg0: alpaqa._alpaqa.float64.Problem, arg1: numpy.ndarray[numpy.float64[m, 1]], arg2: numpy.ndarray[numpy.float64[m, 1]]) → alpaqa._alpaqa.float64.KKTError#

alpaqa.load_casadi_control_problem(so_name: str, N: int) → alpaqa._alpaqa.float64.CasADiControlProblem#: Load a compiled CasADi optimal control problem.

alpaqa.load_casadi_problem(so_name: str) → alpaqa._alpaqa.float64.CasADiProblem#: Load a compiled CasADi problem.

alpaqa.minimize(f: SX | MX, x: SX | MX) → MinimizationProblemDescription[source]#: Formulate a minimization problem with objective function \(f(x)\) and unknown variables \(x\).

exception alpaqa.not_implemented_error#

alpaqa.problem_with_counters(*args, **kwargs)#

Overloaded function.

problem_with_counters(problem: alpaqa._alpaqa.float64.CasADiProblem) -> alpaqa._alpaqa.float64.ProblemWithCounters

Wrap the problem to count all function evaluations.

Parameters:

problem – The original problem to wrap. Copied.

Returns:

Wrapped problem.
Counters for wrapped problem.

problem_with_counters(problem: alpaqa._alpaqa.float64.CUTEstProblem) -> alpaqa._alpaqa.float64.ProblemWithCounters

Wrap the problem to count all function evaluations.

Parameters:

problem – The original problem to wrap. Copied.

Returns:

Wrapped problem.
Counters for wrapped problem.

problem_with_counters(problem: alpaqa._alpaqa.float64.DLProblem) -> alpaqa._alpaqa.float64.ProblemWithCounters

Wrap the problem to count all function evaluations.

Parameters:

problem – The original problem to wrap. Copied.

Returns:

Wrapped problem.
Counters for wrapped problem.

problem_with_counters(problem: object) -> alpaqa._alpaqa.float64.ProblemWithCounters

alpaqa.provided_functions(problem: alpaqa._alpaqa.float64.Problem) → str#: Returns a string representing the functions provided by the problem.

alpaqa.prox(*args, **kwargs)#

Overloaded function.

prox(self: alpaqa._alpaqa.float64.functions.NuclearNorm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1) -> float

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version overwrites the given output arguments.

See also

alpaqa.prox_step()

prox(self: alpaqa._alpaqa.float64.functions.NuclearNorm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version returns the outputs as a tuple.

See also

alpaqa.prox_step()

prox(self: alpaqa._alpaqa.float64.functions.L1Norm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1) -> float

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version overwrites the given output arguments.

See also

alpaqa.prox_step()

prox(self: alpaqa._alpaqa.float64.functions.L1Norm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version returns the outputs as a tuple.

See also

alpaqa.prox_step()

prox(self: alpaqa._alpaqa.float64.functions.L1NormElementwise, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1) -> float

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version overwrites the given output arguments.

See also

alpaqa.prox_step()

prox(self: alpaqa._alpaqa.float64.functions.L1NormElementwise, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version returns the outputs as a tuple.

See also

alpaqa.prox_step()

prox(self: alpaqa._alpaqa.float64.Box, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1) -> float

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version overwrites the given output arguments.

See also

alpaqa.prox_step()

prox(self: alpaqa._alpaqa.float64.Box, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox Compute the proximal mapping of self at in with step size γ. This version returns the outputs as a tuple.

See also

alpaqa.prox_step()

alpaqa.prox_step(*args, **kwargs)#

Overloaded function.

prox_step(self: alpaqa._alpaqa.float64.functions.NuclearNorm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], output_step: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> float

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version overwrites the given output arguments.

See also

alpaqa.prox()

prox_step(self: alpaqa._alpaqa.float64.functions.NuclearNorm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]], numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version returns the outputs as a tuple.

See also

alpaqa.prox()

prox_step(self: alpaqa._alpaqa.float64.functions.L1Norm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], output_step: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> float

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version overwrites the given output arguments.

See also

alpaqa.prox()

prox_step(self: alpaqa._alpaqa.float64.functions.L1Norm, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]], numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version returns the outputs as a tuple.

See also

alpaqa.prox()

prox_step(self: alpaqa._alpaqa.float64.functions.L1NormElementwise, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], output_step: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> float

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version overwrites the given output arguments.

See also

alpaqa.prox()

prox_step(self: alpaqa._alpaqa.float64.functions.L1NormElementwise, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]], numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version returns the outputs as a tuple.

See also

alpaqa.prox()

prox_step(self: alpaqa._alpaqa.float64.Box, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], output: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], output_step: numpy.ndarray[numpy.float64[m, n], flags.writeable, flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> float

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version overwrites the given output arguments.

See also

alpaqa.prox()

prox_step(self: alpaqa._alpaqa.float64.Box, input: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], input_step: numpy.ndarray[numpy.float64[m, n], flags.f_contiguous], γ: float = 1, γ_step: float = -1) -> Tuple[float, numpy.ndarray[numpy.float64[m, n]], numpy.ndarray[numpy.float64[m, n]]]

C++ documentation: alpaqa::prox_step Compute a generalized forward-backward step. This version returns the outputs as a tuple.

See also

alpaqa.prox()

alpaqa.casadi_generator.generate_casadi_problem(f: ~casadi.casadi.Function, g: ~casadi.casadi.Function | None, second_order: ~typing.Literal['no', 'full', 'prod', 'L', 'L_prod', 'psi', 'psi_prod'] = 'no', name: str = 'alpaqa_problem', sym: ~typing.Callable = <function GenSX.sym>) → CodeGenerator[source]#

Convert the objective and constraint functions into a CasADi code generator.

Parameters:

f – Objective function.
g – Constraint function.
second_order – Whether to generate functions for evaluating Hessians.
name – Optional string description of the problem (used for filename).
sym – Symbolic variable constructor, usually either casadi.SX.sym (default) or casadi.MX.sym.

Returns:

Code generator that generates the functions and derivatives used by the solvers.

alpaqa.casadi_generator.generate_casadi_control_problem(f: Function, l: Function, l_N: Function, h: Function = None, h_N: Function = None, c: Function = None, c_N: Function = None, name: str = 'alpaqa_control_problem') → CodeGenerator[source]#

Convert the dynamics and cost functions into a CasADi code generator.

Parameters:

f – Dynamics.
name – Optional string description of the problem (used for filename).

Returns:

Code generator that generates the functions and derivatives used by the solvers.

alpaqa.casadi_generator.write_casadi_problem_data(sofile, C, D, param, l1_reg, penalty_alm_split, name)[source]#: Write the CSV file with constant data for the problem.

alpaqa.casadi_generator.write_casadi_control_problem_data(sofile, U, D, D_N, x_init, param, penalty_alm_split=0, penalty_alm_split_N=None)[source]#: Write the CSV file with constant data for the problem.

alpaqa.casadi_loader.generate_and_compile_casadi_problem_no_load(f: Function, g: Function, *, C=None, D=None, param=None, l1_reg=None, penalty_alm_split=None, second_order: Literal['no', 'full', 'prod', 'L', 'L_prod', 'psi', 'psi_prod'] = 'no', name: str = 'alpaqa_problem', **kwargs) → Path[source]#

Compile the objective and constraint functions into a alpaqa Problem.

Parameters:

f – Objective function f(x).
g – Constraint function g(x).
C – Bound constraints on x.
D – Bound constraints on g(x).
param – Problem parameter values.
l1_reg – L1-regularization on x.
penalty_alm_split – This many components at the beginning of g(x) are handled using a quadratic penalty method rather than an augmented Lagrangian method.
second_order – Whether to generate functions for evaluating Hessians.
name – Optional string description of the problem (used for filename).
kwargs – Parameters passed to casadi_generator.generate_casadi_problem().

Returns:

Path to the shared object file with CasADi functions that can be loaded by the solvers.

Note

If you copy the shared object file, don’t forget to also copy the accompanying CSV file with problem data.

alpaqa.casadi_loader.generate_and_compile_casadi_problem(*args, **kwargs) → CasADiProblem[source]#

Calls generate_and_compile_casadi_problem_no_load() and loads the resulting problem file.

Returns:: Problem specification that can be passed to the solvers.