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, 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, alm_params: Union[alpaqa._alpaqa.float64.ALMParams, dict], inner_solver: alpaqa._alpaqa.float64.InnerSolver) -> 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 lower¶

property upper¶

class alpaqa.BoxConstrProblem¶

C++ documentation: alpaqa::BoxConstrProblem

__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, num_variables: int, num_constraints: int) -> None

Parameters:

num_variables – Number of decision variables
num_constraints – 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_projecting_difference_constraints(*args, **kwargs)¶

Overloaded function.

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

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

eval_proximal_gradient_step(*args, **kwargs)¶

Overloaded function.

eval_proximal_gradient_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_proximal_gradient_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]

property general_bounds¶: General constraint bounds, \(g(x) \in D\)

get_general_bounds(self: alpaqa._alpaqa.float64.BoxConstrProblem) → alpaqa._alpaqa.float64.Box¶

get_variable_bounds(self: alpaqa._alpaqa.float64.BoxConstrProblem) → alpaqa._alpaqa.float64.Box¶

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

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

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

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

resize(self: alpaqa._alpaqa.float64.BoxConstrProblem, num_variables: int, num_constraints: int) → None¶

property variable_bounds¶: Box constraints on the decision variables, \(x\in C\)

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, dl_flags: alpaqa._alpaqa.DynamicLoadFlags = …) -> 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_augmented_lagrangian_hessian_product(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_constraints(*args, **kwargs)¶

Overloaded function.

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

eval_constraints_gradient_product(*args, **kwargs)¶

Overloaded function.

eval_constraints_gradient_product(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_constraints_gradient_product(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_constraints_jacobian(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_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_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_lagrangian_gradient(*args, **kwargs)¶

Overloaded function.

eval_lagrangian_gradient(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_lagrangian_gradient(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_lagrangian_hessian(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_lagrangian_hessian_product(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_objective(self: alpaqa._alpaqa.float64.CUTEstProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → float¶

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

eval_objective_and_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_objective_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_projecting_difference_constraints(*args, **kwargs)¶

Overloaded function.

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

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

eval_proximal_gradient_step(*args, **kwargs)¶

Overloaded function.

eval_proximal_gradient_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_proximal_gradient_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_general_bounds(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.

get_variable_bounds(self: alpaqa._alpaqa.float64.CUTEstProblem) → alpaqa._alpaqa.float64.Box¶

property name¶: CUTEst problem name.

property num_constraints¶: Number of general constraints, dimension of \(g(x)\)

property num_variables¶: Number of decision variables, dimension of \(x\)

provides_get_variable_bounds(self: alpaqa._alpaqa.float64.CUTEstProblem) → bool¶

property x0¶: Initial guess for decision variables.

property y0¶: Initial guess for multipliers.

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_augmented_lagrangian(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian(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_augmented_lagrangian(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_augmented_lagrangian_and_gradient(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian_and_gradient(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_augmented_lagrangian_and_gradient(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_augmented_lagrangian_gradient(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian_gradient(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_augmented_lagrangian_gradient(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_augmented_lagrangian_hessian(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_augmented_lagrangian_hessian_product(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_constraints(*args, **kwargs)¶

Overloaded function.

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

eval_constraints_gradient_product(*args, **kwargs)¶

Overloaded function.

eval_constraints_gradient_product(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_constraints_gradient_product(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_constraints_jacobian(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_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_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_lagrangian_gradient(*args, **kwargs)¶

Overloaded function.

eval_lagrangian_gradient(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_lagrangian_gradient(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_lagrangian_hessian(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_lagrangian_hessian_product(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_objective(self: alpaqa._alpaqa.float64.CasADiProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → float¶

eval_objective_and_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_objective_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_projecting_difference_constraints(*args, **kwargs)¶

Overloaded function.

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

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

eval_proximal_gradient_step(*args, **kwargs)¶

Overloaded function.

eval_proximal_gradient_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_proximal_gradient_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]

get_general_bounds(self: alpaqa._alpaqa.float64.CasADiProblem) → alpaqa._alpaqa.float64.Box¶

get_variable_bounds(self: alpaqa._alpaqa.float64.CasADiProblem) → alpaqa._alpaqa.float64.Box¶

property num_constraints¶: Number of general constraints, dimension of \(g(x)\)

property num_variables¶: Number of decision variables, dimension of \(x\)

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

provides_eval_augmented_lagrangian(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_eval_augmented_lagrangian_and_gradient(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_eval_augmented_lagrangian_gradient(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_eval_augmented_lagrangian_hessian(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_eval_augmented_lagrangian_hessian_product(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_eval_constraints_jacobian(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

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

provides_eval_lagrangian_gradient(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_eval_lagrangian_hessian(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_eval_lagrangian_hessian_product(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

provides_get_variable_bounds(self: alpaqa._alpaqa.float64.CasADiProblem) → bool¶

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_augmented_lagrangian(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian(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_augmented_lagrangian(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_augmented_lagrangian_and_gradient(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian_and_gradient(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_augmented_lagrangian_and_gradient(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_augmented_lagrangian_gradient(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian_gradient(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_augmented_lagrangian_gradient(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_augmented_lagrangian_hessian(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_augmented_lagrangian_hessian_product(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_constraints(*args, **kwargs)¶

Overloaded function.

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

eval_constraints_gradient_product(*args, **kwargs)¶

Overloaded function.

eval_constraints_gradient_product(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_constraints_gradient_product(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_constraints_jacobian(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_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_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_lagrangian_gradient(*args, **kwargs)¶

Overloaded function.

eval_lagrangian_gradient(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_lagrangian_gradient(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_lagrangian_hessian(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_lagrangian_hessian_product(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_objective(self: alpaqa._alpaqa.float64.DLProblem, x: numpy.ndarray[numpy.float64[m, 1]]) → float¶

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

eval_objective_and_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_objective_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_objective_gradient_and_constraints_gradient_product(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_projecting_difference_constraints(*args, **kwargs)¶

Overloaded function.

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

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

eval_proximal_gradient_step(*args, **kwargs)¶

Overloaded function.

eval_proximal_gradient_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_proximal_gradient_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]

get_general_bounds(self: alpaqa._alpaqa.float64.DLProblem) → alpaqa._alpaqa.float64.Box¶

get_variable_bounds(self: alpaqa._alpaqa.float64.DLProblem) → alpaqa._alpaqa.float64.Box¶

property num_constraints¶: Number of general constraints, dimension of \(g(x)\)

property num_variables¶: Number of decision variables, dimension of \(x\)

provides_eval_augmented_lagrangian(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_augmented_lagrangian_and_gradient(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_augmented_lagrangian_gradient(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_augmented_lagrangian_hessian(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_augmented_lagrangian_hessian_product(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_constraints_jacobian(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

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

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

provides_eval_lagrangian_gradient(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_lagrangian_hessian(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_lagrangian_hessian_product(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_objective_and_constraints(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_objective_and_gradient(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_eval_objective_gradient_and_constraints_gradient_product(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_get_augmented_lagrangian_hessian_sparsity(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_get_constraints_jacobian_sparsity(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_get_general_bounds(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_get_lagrangian_hessian_sparsity(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

provides_get_variable_bounds(self: alpaqa._alpaqa.float64.DLProblem) → bool¶

class alpaqa.DynamicLoadFlags¶

C++ documentation: guanaqo::DynamicLoadFlags

__init__(*args, **kwargs)¶

Overloaded function.

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

property deepbind¶

property global_¶

property lazy¶

property nodelete¶

to_dict(self: alpaqa._alpaqa.DynamicLoadFlags) → dict¶

class alpaqa.EvalCounter¶

C++ documentation: alpaqa::EvalCounter

class EvalTimer¶

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

__init__(*args, **kwargs)¶

property augmented_lagrangian¶

property augmented_lagrangian_and_gradient¶

property augmented_lagrangian_gradient¶

property augmented_lagrangian_hessian¶

property augmented_lagrangian_hessian_product¶

property constraints¶

property constraints_gradient_product¶

property constraints_jacobian¶

property grad_gi¶

property inactive_indices_res_lna¶

property lagrangian_gradient¶

property lagrangian_hessian¶

property lagrangian_hessian_product¶

property objective¶

property objective_and_constraints¶

property objective_and_gradient¶

property objective_gradient¶

property objective_gradient_and_constraints_gradient_product¶

property projecting_difference_constraints¶

property projection_multipliers¶

property proximal_gradient_step¶

__init__(*args, **kwargs)¶

property augmented_lagrangian¶

property augmented_lagrangian_and_gradient¶

property augmented_lagrangian_gradient¶

property augmented_lagrangian_hessian¶

property augmented_lagrangian_hessian_product¶

property constraints¶

property constraints_gradient_product¶

property constraints_jacobian¶

property grad_gi¶

property inactive_indices_res_lna¶

property lagrangian_gradient¶

property lagrangian_hessian¶

property lagrangian_hessian_product¶

property objective¶

property objective_and_constraints¶

property objective_and_gradient¶

property objective_gradient¶

property objective_gradient_and_constraints_gradient_product¶

property projecting_difference_constraints¶

property projection_multipliers¶

property proximal_gradient_step¶

property time¶

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 disable_acceleration¶

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.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.LBFGSBSolver) -> 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.

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

property name¶

property params¶

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

class alpaqa.IpoptApplicationReturnStatus¶

Ipopt::ApplicationReturnStatus enum

Members:

Solve_Succeeded

Solved_To_Acceptable_Level

Infeasible_Problem_Detected

Search_Direction_Becomes_Too_Small

Diverging_Iterates

User_Requested_Stop

Feasible_Point_Found

Maximum_Iterations_Exceeded

Restoration_Failed

Error_In_Step_Computation

Maximum_CpuTime_Exceeded

Maximum_WallTime_Exceeded

Not_Enough_Degrees_Of_Freedom

Invalid_Problem_Definition

Invalid_Option

Invalid_Number_Detected

Unrecoverable_Exception

NonIpopt_Exception_Thrown

Insufficient_Memory

Internal_Error

Diverging_Iterates = <IpoptApplicationReturnStatus.Diverging_Iterates: 4>¶

Error_In_Step_Computation = <IpoptApplicationReturnStatus.Error_In_Step_Computation: -3>¶

Feasible_Point_Found = <IpoptApplicationReturnStatus.Feasible_Point_Found: 6>¶

Infeasible_Problem_Detected = <IpoptApplicationReturnStatus.Infeasible_Problem_Detected: 2>¶

Insufficient_Memory = <IpoptApplicationReturnStatus.Insufficient_Memory: -102>¶

Internal_Error = <IpoptApplicationReturnStatus.Internal_Error: -199>¶

Invalid_Number_Detected = <IpoptApplicationReturnStatus.Invalid_Number_Detected: -13>¶

Invalid_Option = <IpoptApplicationReturnStatus.Invalid_Option: -12>¶

Invalid_Problem_Definition = <IpoptApplicationReturnStatus.Invalid_Problem_Definition: -11>¶

Maximum_CpuTime_Exceeded = <IpoptApplicationReturnStatus.Maximum_CpuTime_Exceeded: -4>¶

Maximum_Iterations_Exceeded = <IpoptApplicationReturnStatus.Maximum_Iterations_Exceeded: -1>¶

Maximum_WallTime_Exceeded = <IpoptApplicationReturnStatus.Maximum_WallTime_Exceeded: -5>¶

NonIpopt_Exception_Thrown = <IpoptApplicationReturnStatus.NonIpopt_Exception_Thrown: -101>¶

Not_Enough_Degrees_Of_Freedom = <IpoptApplicationReturnStatus.Not_Enough_Degrees_Of_Freedom: -10>¶

Restoration_Failed = <IpoptApplicationReturnStatus.Restoration_Failed: -2>¶

Search_Direction_Becomes_Too_Small = <IpoptApplicationReturnStatus.Search_Direction_Becomes_Too_Small: 3>¶

Solve_Succeeded = <IpoptApplicationReturnStatus.Solve_Succeeded: 0>¶

Solved_To_Acceptable_Level = <IpoptApplicationReturnStatus.Solved_To_Acceptable_Level: 1>¶

Unrecoverable_Exception = <IpoptApplicationReturnStatus.Unrecoverable_Exception: -100>¶

User_Requested_Stop = <IpoptApplicationReturnStatus.User_Requested_Stop: 5>¶

__init__(self: alpaqa._alpaqa.float64.IpoptApplicationReturnStatus, value: int) → None¶

property name¶

property value¶

class alpaqa.IpoptSolver¶

Ipopt binding for testing purposes

__call__(self: alpaqa._alpaqa.float64.IpoptSolver, problem: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]] | None = None, y: numpy.ndarray[numpy.float64[m, 1]] | None = None, w: numpy.ndarray[numpy.float64[m, 1]] | None = None) → tuple¶

__init__(self: alpaqa._alpaqa.float64.IpoptSolver, options: dict = {}) → None¶

class alpaqa.IpoptSolverReturn¶

Ipopt::SolverReturn enum

Members:

SUCCESS

MAXITER_EXCEEDED

CPUTIME_EXCEEDED

WALLTIME_EXCEEDED

STOP_AT_TINY_STEP

STOP_AT_ACCEPTABLE_POINT

LOCAL_INFEASIBILITY

USER_REQUESTED_STOP

FEASIBLE_POINT_FOUND

DIVERGING_ITERATES

RESTORATION_FAILURE

ERROR_IN_STEP_COMPUTATION

INVALID_NUMBER_DETECTED

TOO_FEW_DEGREES_OF_FREEDOM

INVALID_OPTION

OUT_OF_MEMORY

INTERNAL_ERROR

UNASSIGNED

CPUTIME_EXCEEDED = <IpoptSolverReturn.CPUTIME_EXCEEDED: 2>¶

DIVERGING_ITERATES = <IpoptSolverReturn.DIVERGING_ITERATES: 9>¶

ERROR_IN_STEP_COMPUTATION = <IpoptSolverReturn.ERROR_IN_STEP_COMPUTATION: 11>¶

FEASIBLE_POINT_FOUND = <IpoptSolverReturn.FEASIBLE_POINT_FOUND: 8>¶

INTERNAL_ERROR = <IpoptSolverReturn.INTERNAL_ERROR: 16>¶

INVALID_NUMBER_DETECTED = <IpoptSolverReturn.INVALID_NUMBER_DETECTED: 12>¶

INVALID_OPTION = <IpoptSolverReturn.INVALID_OPTION: 14>¶

LOCAL_INFEASIBILITY = <IpoptSolverReturn.LOCAL_INFEASIBILITY: 6>¶

MAXITER_EXCEEDED = <IpoptSolverReturn.MAXITER_EXCEEDED: 1>¶

OUT_OF_MEMORY = <IpoptSolverReturn.OUT_OF_MEMORY: 15>¶

RESTORATION_FAILURE = <IpoptSolverReturn.RESTORATION_FAILURE: 10>¶

STOP_AT_ACCEPTABLE_POINT = <IpoptSolverReturn.STOP_AT_ACCEPTABLE_POINT: 5>¶

STOP_AT_TINY_STEP = <IpoptSolverReturn.STOP_AT_TINY_STEP: 4>¶

SUCCESS = <IpoptSolverReturn.SUCCESS: 0>¶

TOO_FEW_DEGREES_OF_FREEDOM = <IpoptSolverReturn.TOO_FEW_DEGREES_OF_FREEDOM: 13>¶

UNASSIGNED = <IpoptSolverReturn.UNASSIGNED: 17>¶

USER_REQUESTED_STOP = <IpoptSolverReturn.USER_REQUESTED_STOP: 7>¶

WALLTIME_EXCEEDED = <IpoptSolverReturn.WALLTIME_EXCEEDED: 3>¶

__init__(self: alpaqa._alpaqa.float64.IpoptSolverReturn, value: int) → None¶

property name¶

property value¶

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.LBFGSBParams¶

C++ documentation: alpaqa::LBFGSBParams

__init__(*args, **kwargs)¶

Overloaded function.

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

property max_iter¶

property max_time¶

property memory¶

property print¶

property print_interval¶

property print_precision¶

property stop_crit¶

to_dict(self: alpaqa._alpaqa.float64.LBFGSBParams) → dict¶

class alpaqa.LBFGSBProgressInfo¶

Data passed to the LBFGSB progress callback.

C++ documentation: alpaqa::LBFGSBProgressInfo

__init__(*args, **kwargs)¶

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

property k¶: Iteration

property params¶: Solver parameters

property problem¶: Problem being solved

property status¶: Current solver status

property x¶: Decision variable \(x\)

property y¶: Lagrange multipliers \(y\)

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

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

property τ¶: Line search parameter \(\tau\) (or \(\tau_\mathrm{rel}\))

property τ_max¶: Maximum line search parameter \(\tau_\mathrm{max}\)

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

class alpaqa.LBFGSBSolver¶

C++ documentation: alpaqa::LBFGSBSolver

Params¶: alias of LBFGSBParams

__call__(self: alpaqa._alpaqa.float64.LBFGSBSolver, 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.LBFGSBSolver, other: alpaqa._alpaqa.float64.LBFGSBSolver) -> None

Create a copy

__init__(self: alpaqa._alpaqa.float64.LBFGSBSolver, lbfgsb_params: Union[alpaqa._alpaqa.float64.LBFGSBParams, dict] = {}) -> None

Create a LBFGSB solver using structured L-BFGS directions.

property name¶

property params¶

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

stop(self: alpaqa._alpaqa.float64.LBFGSBSolver) → None¶

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.

__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¶

bounds: tuple[ndarray, ndarray] | None = None¶

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.

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.

constraints_bounds: tuple[ndarray, ndarray] | None = None¶

constraints_expr: SX | MX | None = None¶

name: str = 'alpaqa_casadi_problem'¶

parameter: SX | MX | None = None¶

parameter_value: ndarray | None = None¶

penalty_constraints_bounds: tuple[ndarray, ndarray] | None = None¶

penalty_constraints_expr: SX | MX | None = None¶

regularizer: float | ndarray | None = None¶

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_box(C: tuple[ndarray, ndarray]) → MinimizationProblemDescription[source]¶: Add box constraints \(x \in C\) on the problem variables.

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_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.

with_param(p: SX | MX, value: ndarray | None = 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().

objective_expr: SX | MX¶

variable: SX | MX¶

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.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.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_augmented_lagrangian(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian(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_augmented_lagrangian(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_augmented_lagrangian_and_gradient(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian_and_gradient(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_augmented_lagrangian_and_gradient(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_augmented_lagrangian_gradient(*args, **kwargs)¶

Overloaded function.

eval_augmented_lagrangian_gradient(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_augmented_lagrangian_gradient(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_augmented_lagrangian_hessian(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_augmented_lagrangian_hessian_product(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_constraints(*args, **kwargs)¶

Overloaded function.

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

eval_constraints_gradient_product(*args, **kwargs)¶

Overloaded function.

eval_constraints_gradient_product(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_constraints_gradient_product(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_constraints_jacobian(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_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_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_lagrangian_gradient(*args, **kwargs)¶

Overloaded function.

eval_lagrangian_gradient(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_lagrangian_gradient(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_lagrangian_hessian(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_lagrangian_hessian_product(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_objective(self: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]]) → float¶

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

eval_objective_and_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_objective_gradient(*args, **kwargs)¶

Overloaded function.

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

eval_objective_gradient_and_constraints_gradient_product(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_projecting_difference_constraints(*args, **kwargs)¶

Overloaded function.

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

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

eval_proximal_gradient_step(*args, **kwargs)¶

Overloaded function.

eval_proximal_gradient_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_proximal_gradient_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]

get_general_bounds(self: alpaqa._alpaqa.float64.Problem) → alpaqa._alpaqa.float64.Box¶

get_variable_bounds(self: alpaqa._alpaqa.float64.Problem) → alpaqa._alpaqa.float64.Box¶

property num_constraints¶: Number of general constraints, dimension of \(g(x)\)

property num_variables¶: Number of decision variables, dimension of \(x\)

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

provides_eval_augmented_lagrangian(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_augmented_lagrangian_and_gradient(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_augmented_lagrangian_gradient(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_augmented_lagrangian_hessian(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_augmented_lagrangian_hessian_product(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_constraints_jacobian(self: alpaqa._alpaqa.float64.Problem) → bool¶

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

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

provides_eval_lagrangian_gradient(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_lagrangian_hessian(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_lagrangian_hessian_product(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_objective_and_constraints(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_objective_and_gradient(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_eval_objective_gradient_and_constraints_gradient_product(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_get_augmented_lagrangian_hessian_sparsity(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_get_constraints_jacobian_sparsity(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_get_general_bounds(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_get_lagrangian_hessian_sparsity(self: alpaqa._alpaqa.float64.Problem) → bool¶

provides_get_variable_bounds(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, num_variables: int) -> None

Parameters:: num_variables – Number of decision variables

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

eval_constraints_gradient_product(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_constraints_jacobian(self: alpaqa._alpaqa.float64.UnconstrProblem, x: numpy.ndarray[numpy.float64[m, 1]], J_values: 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_projecting_difference_constraints(*args, **kwargs)¶

Overloaded function.

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

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

eval_proximal_gradient_step(*args, **kwargs)¶

Overloaded function.

eval_proximal_gradient_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_proximal_gradient_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 num_constraints¶: Number of general constraints, dimension of \(g(x)\)

property num_variables¶: Number of decision variables, dimension of \(x\)

resize(self: alpaqa._alpaqa.float64.UnconstrProblem, num_variables: 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_accel¶

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.deserialize_casadi_problem(functions: dict[str, str]) → alpaqa._alpaqa.float64.CasADiProblem¶: Deserialize a CasADi problem from the given serialized functions.

alpaqa.kkt_error(problem: alpaqa._alpaqa.float64.Problem, x: numpy.ndarray[numpy.float64[m, 1]], y: numpy.ndarray[numpy.float64[m, 1]]) → alpaqa._alpaqa.float64.KKTError¶

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: Function, g: Function | None, second_order: Literal['no', 'full', 'prod', 'L', 'L_prod', 'psi', 'psi_prod']='no', name: str = 'alpaqa_problem', sym: 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 = None, h_N: Function | None = None, c: Function | None = None, c_N: Function | None = 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.