Skip to content

Instantly share code, notes, and snippets.

@jgillis

jgillis/gist:fda83c1f159a0d4bdcacdee9c6df06b3

Created April 21, 2026 13:27
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save jgillis/fda83c1f159a0d4bdcacdee9c6df06b3 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save jgillis/fda83c1f159a0d4bdcacdee9c6df06b3 to your computer and use it in GitHub Desktop.
Download ZIP
casadi.pyi
Raw
gistfile1.txt
```python
# This file was automatically generated by SWIG (https://www.swig.org).
# Do not modify by hand.
from __future__ import annotations
from collections.abc import Iterator, Mapping, Sequence
from typing import Any, Generic, Self, TypeVar, overload
import numpy as np
from numpy.typing import NDArray
from collections.abc import Callable
from typing import Protocol, runtime_checkable
_T = TypeVar("_T", "DM", "SX", "MX")
@runtime_checkable
class _SupportsDM(Protocol):
"""Any object exposing a ``__DM__()`` method -- the conversion hook
used by ``to_ptr<DM>()`` for user-defined numeric types."""
def __DM__(self) -> "DM": ...
@runtime_checkable
class _SupportsSX(Protocol):
def __SX__(self) -> "SX": ...
@runtime_checkable
class _SupportsMX(Protocol):
def __MX__(self) -> "MX": ...
_DM = bool | int | float | DM | Sparsity | _SupportsDM | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]
_SX = SX | _SupportsSX | _DM
_MX = MX | _SupportsMX | _DM
_IM = IM | int | Sequence[int] | Sequence[Sequence[int]] | NDArray[np.int_] | NDArray[np.bool_]
_SXElem = SXElem | float
_Slice = Slice | int | slice
_GenericType = bool | int | float | str | "Function" | Sequence["_GenericType"] | Mapping[str,"_GenericType"]
_MIndex = int | slice | Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_] | Sparsity | DM
CASADI_INT_TYPE_STR: Any = ...
SOLVER_RET_SUCCESS: int = ...
SOLVER_RET_UNKNOWN: int = ...
SOLVER_RET_LIMITED: int = ...
SOLVER_RET_NAN: int = ...
SOLVER_RET_INFEASIBLE: int = ...
SOLVER_RET_EXCEPTION: int = ...
MNAME: Any = ...
class SwigPyIterator:
def value(self) -> Any: ...
def incr(self, n: Any = ...) -> Any: ...
def decr(self, n: Any = ...) -> Any: ...
def distance(self, x: Any) -> int: ...
def equal(self, x: Any) -> bool: ...
def copy(self) -> Any: ...
def next(self) -> Any: ...
def __next__(self) -> Any: ...
def previous(self) -> Any: ...
def advance(self, n: Any) -> Any: ...
def __eq__(self, x: Any) -> bool: ...
def __ne__(self, x: Any) -> bool: ...
def __iadd__(self, n: Any) -> Any: ...
def __isub__(self, n: Any) -> Any: ...
def __add__(self, n: Any) -> Any: ...
@overload
def __sub__(self, x: Any) -> int: ...
@overload
def __sub__(self, n: Any) -> Any: ...
L_INT: Any = ...
L_BOOL: Any = ...
LL: Any = ...
LR: Any = ...
L_DICT: Any = ...
L_DOUBLE: Any = ...
L_STR: Any = ...
LABEL: Any = ...
@overload
def arcsin(x: _DM) -> DM: ...
@overload
def arcsin(x: _SX) -> SX: ...
@overload
def arcsin(x: _MX) -> MX: ...
@overload
def arccos(x: _DM) -> DM: ...
@overload
def arccos(x: _SX) -> SX: ...
@overload
def arccos(x: _MX) -> MX: ...
@overload
def arctan(x: _DM) -> DM: ...
@overload
def arctan(x: _SX) -> SX: ...
@overload
def arctan(x: _MX) -> MX: ...
@overload
def arctanh(x: _DM) -> DM: ...
@overload
def arctanh(x: _SX) -> SX: ...
@overload
def arctanh(x: _MX) -> MX: ...
@overload
def arcsinh(x: _DM) -> DM: ...
@overload
def arcsinh(x: _SX) -> SX: ...
@overload
def arcsinh(x: _MX) -> MX: ...
@overload
def arccosh(x: _DM) -> DM: ...
@overload
def arccosh(x: _SX) -> SX: ...
@overload
def arccosh(x: _MX) -> MX: ...
@overload
def arctan2(y: _DM,x: _DM) -> DM: ...
@overload
def arctan2(y: _SX,x: _SX) -> SX: ...
@overload
def arctan2(y: _MX,x: _MX) -> MX: ...
@overload
def veccat(*args: Sparsity) -> Sparsity: ...
@overload
def veccat(*args: _DM) -> DM: ...
@overload
def veccat(*args: _SX) -> SX: ...
@overload
def veccat(*args: _MX) -> MX: ...
@overload
def vertcat(*args: Sparsity) -> Sparsity: ...
@overload
def vertcat(*args: _DM) -> DM: ...
@overload
def vertcat(*args: _SX) -> SX: ...
@overload
def vertcat(*args: _MX) -> MX: ...
@overload
def horzcat(*args: Sparsity) -> Sparsity: ...
@overload
def horzcat(*args: _DM) -> DM: ...
@overload
def horzcat(*args: _SX) -> SX: ...
@overload
def horzcat(*args: _MX) -> MX: ...
@overload
def diagcat(*args: Sparsity) -> Sparsity: ...
@overload
def diagcat(*args: _DM) -> DM: ...
@overload
def diagcat(*args: _SX) -> SX: ...
@overload
def diagcat(*args: _MX) -> MX: ...
@overload
def vvcat(args: Sequence[Sparsity]) -> Sparsity: ...
@overload
def vvcat(args: Sequence[_DM]) -> DM: ...
@overload
def vvcat(args: Sequence[_SX]) -> SX: ...
@overload
def vvcat(args: Sequence[_MX]) -> MX: ...
@overload
def vcat(args: Sequence[Sparsity]) -> Sparsity: ...
@overload
def vcat(args: Sequence[_DM]) -> DM: ...
@overload
def vcat(args: Sequence[_SX]) -> SX: ...
@overload
def vcat(args: Sequence[_MX]) -> MX: ...
@overload
def hcat(args: Sequence[Sparsity]) -> Sparsity: ...
@overload
def hcat(args: Sequence[_DM]) -> DM: ...
@overload
def hcat(args: Sequence[_SX]) -> SX: ...
@overload
def hcat(args: Sequence[_MX]) -> MX: ...
@overload
def dcat(args: Sequence[Sparsity]) -> Sparsity: ...
@overload
def dcat(args: Sequence[_DM]) -> DM: ...
@overload
def dcat(args: Sequence[_SX]) -> SX: ...
@overload
def dcat(args: Sequence[_MX]) -> MX: ...
class NZproxy(Generic[_T]):
def __init__(self, matrix: _T) -> None: ...
@overload
def __getitem__(self: "NZproxy[MX]", s: _MIndex | MX) -> MX: ...
@overload
def __getitem__(self, s: _MIndex) -> _T: ...
@overload
def __setitem__(self: "NZproxy[MX]", s: _MIndex | MX,val: bool | int | float | MX | Sequence[bool | int | float]) -> None: ...
@overload
def __setitem__(self, s: _MIndex,val: bool | int | float | _T | Sequence[bool | int | float]) -> None: ...
def __len__(self) -> int: ...
def __iter__(self) -> Iterator[_T]: ...
class PrintableCommon:
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class GenSharedObject:
def debug_repr(self) -> str: ...
def is_null(self) -> bool: ...
def __hash__(self) -> int: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class GenWeakRef(GenSharedObject):
def is_null(self) -> bool: ...
def shared(self) -> SharedObject: ...
def alive(self) -> bool: ...
def shared_if_alive(self, shared: Any) -> bool: ...
@overload
def __init__(self, dummy: Any = ...) -> None: ...
@overload
def __init__(self, shared: Any) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class SharedObject(GenSharedObject):
def class_name(self) -> str: ...
def disp(self, more: bool = ...) -> None: ...
def str(self, more: bool = ...) -> str: ...
def print_ptr(self) -> None: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class WeakRef(GenWeakRef):
@overload
def __init__(self, dummy: Any = ...) -> None: ...
@overload
def __init__(self, shared: Any) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
def complement(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], size: int) -> list[int]: ...
@overload
def lookupvector(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[int]: ...
@overload
def lookupvector(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], size: int) -> list[int]: ...
def temporary_file(prefix: str, suffix: str, directory: str = ...) -> str: ...
@overload
def normalized_setup() -> None: ...
@overload
def normalized_setup(stream: Any) -> None: ...
class StreamStateGuard:
@overload
def __init__(self, os: Any) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
def normalized_out(val: float) -> None: ...
def normalized_in(stream: Any, ret: Any) -> int: ...
SWIG_IND1: bool = ...
class GenericType(PrintableCommon):
def serialize(self, s: Any) -> None: ...
@staticmethod
def deserialize(s: Any) -> _GenericType: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: _GenericType) -> None: ...
OP_ASSIGN: int = ...
OP_ADD: int = ...
OP_SUB: int = ...
OP_MUL: int = ...
OP_DIV: int = ...
OP_NEG: int = ...
OP_EXP: int = ...
OP_LOG: int = ...
OP_POW: int = ...
OP_CONSTPOW: int = ...
OP_SQRT: int = ...
OP_SQ: int = ...
OP_TWICE: int = ...
OP_SIN: int = ...
OP_COS: int = ...
OP_TAN: int = ...
OP_ASIN: int = ...
OP_ACOS: int = ...
OP_ATAN: int = ...
OP_LT: int = ...
OP_LE: int = ...
OP_EQ: int = ...
OP_NE: int = ...
OP_NOT: int = ...
OP_AND: int = ...
OP_OR: int = ...
OP_FLOOR: int = ...
OP_CEIL: int = ...
OP_FMOD: int = ...
OP_FABS: int = ...
OP_SIGN: int = ...
OP_COPYSIGN: int = ...
OP_IF_ELSE_ZERO: int = ...
OP_ERF: int = ...
OP_FMIN: int = ...
OP_FMAX: int = ...
OP_INV: int = ...
OP_SINH: int = ...
OP_COSH: int = ...
OP_TANH: int = ...
OP_ASINH: int = ...
OP_ACOSH: int = ...
OP_ATANH: int = ...
OP_ATAN2: int = ...
OP_CONST: int = ...
OP_INPUT: int = ...
OP_OUTPUT: int = ...
OP_PARAMETER: int = ...
OP_CALL: int = ...
OP_FIND: int = ...
OP_LOW: int = ...
OP_MAP: int = ...
OP_MTIMES: int = ...
OP_SOLVE: int = ...
OP_TRANSPOSE: int = ...
OP_DETERMINANT: int = ...
OP_INVERSE: int = ...
OP_DOT: int = ...
OP_BILIN: int = ...
OP_RANK1: int = ...
OP_HORZCAT: int = ...
OP_VERTCAT: int = ...
OP_DIAGCAT: int = ...
OP_HORZSPLIT: int = ...
OP_VERTSPLIT: int = ...
OP_DIAGSPLIT: int = ...
OP_RESHAPE: int = ...
OP_SUBREF: int = ...
OP_SUBASSIGN: int = ...
OP_GETNONZEROS: int = ...
OP_GETNONZEROS_PARAM: int = ...
OP_ADDNONZEROS: int = ...
OP_ADDNONZEROS_PARAM: int = ...
OP_SETNONZEROS: int = ...
OP_SETNONZEROS_PARAM: int = ...
OP_PROJECT: int = ...
OP_ASSERTION: int = ...
OP_MONITOR: int = ...
OP_NORM2: int = ...
OP_NORM1: int = ...
OP_NORMINF: int = ...
OP_NORMF: int = ...
OP_MMIN: int = ...
OP_MMAX: int = ...
OP_HORZREPMAT: int = ...
OP_HORZREPSUM: int = ...
OP_ERFINV: int = ...
OP_PRINTME: int = ...
OP_LIFT: int = ...
OP_EINSTEIN: int = ...
OP_BSPLINE: int = ...
OP_CONVEXIFY: int = ...
OP_SPARSITY_CAST: int = ...
OP_LOG1P: int = ...
OP_EXPM1: int = ...
OP_HYPOT: int = ...
OP_LOGSUMEXP: int = ...
OP_REMAINDER: int = ...
OP_DUMP: int = ...
class SparsityInterfaceCommon:
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class Sparsity(SharedObject, SparsityInterfaceCommon, PrintableCommon):
@staticmethod
def scalar(dense_scalar: bool = ...) -> Sparsity: ...
@overload
@staticmethod
def dense(nrow: int, ncol: int = ...) -> Sparsity: ...
@overload
@staticmethod
def dense(rc: tuple[int, int]) -> Sparsity: ...
@staticmethod
def unit(n: int, el: int) -> Sparsity: ...
@staticmethod
def upper(n: int) -> Sparsity: ...
@staticmethod
def lower(n: int) -> Sparsity: ...
@overload
@staticmethod
def diag(nrow: int) -> Sparsity: ...
@overload
@staticmethod
def diag(rc: tuple[int, int]) -> Sparsity: ...
@overload
@staticmethod
def diag(nrow: int, ncol: int) -> Sparsity: ...
@staticmethod
def band(n: int, p: int) -> Sparsity: ...
@staticmethod
def banded(n: int, p: int) -> Sparsity: ...
@staticmethod
def rowcol(row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], nrow: int, ncol: int) -> Sparsity: ...
@overload
@staticmethod
def triplet(nrow: int, ncol: int, row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> Sparsity: ...
@overload
@staticmethod
def triplet(nrow: int, ncol: int, row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], invert_mapping: bool) -> tuple[Sparsity, list[int]]: ...
@staticmethod
def nonzeros(nrow: int, ncol: int, nz: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> Sparsity: ...
@staticmethod
def compressed(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], order_rows: bool = ...) -> Sparsity: ...
@staticmethod
def permutation(p: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], invert: bool = ...) -> Sparsity: ...
def permutation_vector(self, invert: bool = ...) -> list[int]: ...
def get_diag(self) -> tuple[Sparsity, list[int]]: ...
def compress(self, canonical: bool = ...) -> list[int]: ...
@overload
def is_equal(self, y: Sparsity) -> bool: ...
@overload
def is_equal(self, nrow: int, ncol: int, colind: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> bool: ...
def __eq__(self, y: Sparsity) -> bool: ...
def __ne__(self, y: Sparsity) -> bool: ...
def is_stacked(self, y: Sparsity, n: int) -> bool: ...
def size1(self) -> int: ...
def rows(self) -> int: ...
def size2(self) -> int: ...
def columns(self) -> int: ...
def numel(self) -> int: ...
def density(self) -> float: ...
def is_empty(self, both: bool = ...) -> bool: ...
def nnz(self) -> int: ...
def nnz_upper(self, strictly: bool = ...) -> int: ...
def nnz_lower(self, strictly: bool = ...) -> int: ...
def nnz_diag(self) -> int: ...
def bw_upper(self) -> int: ...
def bw_lower(self) -> int: ...
@overload
def size(self) -> tuple[int, int]: ...
@overload
def size(self, axis: int) -> int: ...
def info(self) -> dict[str, _GenericType]: ...
def to_file(self, filename: str, format_hint: str = ...) -> None: ...
@staticmethod
def from_file(filename: str, format_hint: str = ...) -> Sparsity: ...
@overload
def serialize(self) -> str: ...
@overload
def serialize(self, s: Any) -> None: ...
@overload
@staticmethod
def deserialize(stream: Any) -> Sparsity: ...
@overload
@staticmethod
def deserialize(s: Any) -> Sparsity: ...
@overload
@staticmethod
def deserialize(s: str) -> Sparsity: ...
@overload
def colind(self) -> list[int]: ...
@overload
def colind(self, cc: int) -> int: ...
@overload
def row(self) -> list[int]: ...
@overload
def row(self, el: int) -> int: ...
def get_col(self) -> list[int]: ...
def resize(self, nrow: int, ncol: int) -> None: ...
def add_nz(self, rr: int, cc: int) -> int: ...
def has_nz(self, rr: int, cc: int) -> bool: ...
@overload
def get_nz(self, INOUT: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> [int]: ...
@overload
def get_nz(self, rr: int, cc: int) -> int: ...
@overload
def get_nz(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[int]: ...
def get_lower(self) -> list[int]: ...
def get_upper(self) -> list[int]: ...
def get_ccs(self) -> tuple[list[int], list[int]]: ...
def get_crs(self) -> tuple[list[int], list[int]]: ...
def get_triplet(self) -> tuple[list[int], list[int]]: ...
@overload
def sub(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], sp: Sparsity, ind1: bool = ...) -> tuple[Sparsity, list[int]]: ...
@overload
def sub(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> tuple[Sparsity, list[int]]: ...
def transpose(self, invert_mapping: bool = ...) -> tuple[Sparsity, list[int]]: ...
def is_transpose(self, y: Sparsity) -> bool: ...
def is_reshape(self, y: Sparsity) -> bool: ...
def combine(self, y: Sparsity, f0x_is_zero: bool, function0_is_zero: bool) -> Sparsity: ...
def unite(self, y: Sparsity) -> Sparsity: ...
def __add__(self, b: Sparsity) -> Sparsity: ...
def intersect(self, y: Sparsity) -> Sparsity: ...
def __mul__(self, b: Sparsity) -> Sparsity: ...
def is_subset(self, rhs: Sparsity) -> bool: ...
def sparsity_cast_mod(self, X: Sparsity, Y: Sparsity) -> Sparsity: ...
def pattern_inverse(self) -> Sparsity: ...
def enlarge(self, nrow: int, ncol: int, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def enlargeRows(self, nrow: int, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def enlargeColumns(self, ncol: int, cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def makeDense(self) -> tuple[Sparsity, list[int]]: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> list[int]: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> list[int]: ...
def append(self, sp: Sparsity) -> None: ...
def appendColumns(self, sp: Sparsity) -> None: ...
def is_scalar(self, scalar_and_dense: bool = ...) -> bool: ...
def is_dense(self) -> bool: ...
def is_row(self) -> bool: ...
def is_column(self) -> bool: ...
def is_vector(self) -> bool: ...
def is_diag(self) -> bool: ...
def is_square(self) -> bool: ...
def is_symmetric(self) -> bool: ...
def is_triu(self, strictly: bool = ...) -> bool: ...
def is_tril(self, strictly: bool = ...) -> bool: ...
def is_singular(self) -> bool: ...
def is_permutation(self) -> bool: ...
def is_selection(self, allow_empty: bool = ...) -> bool: ...
def is_orthonormal(self, allow_empty: bool = ...) -> bool: ...
def is_orthonormal_rows(self, allow_empty: bool = ...) -> bool: ...
def is_orthonormal_columns(self, allow_empty: bool = ...) -> bool: ...
def rowsSequential(self, strictly: bool = ...) -> bool: ...
def removeDuplicates(self, INOUT: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> [int]: ...
def etree(self, ata: bool = ...) -> list[int]: ...
def ldl(self, amd: bool = ...) -> tuple[Sparsity, list[int]]: ...
def qr_sparse(self, amd: bool = ...) -> tuple[Sparsity, Sparsity, list[int], list[int]]: ...
def dfs(self, j: int, top: int, INOUT: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], INOUT: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], pinv: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], INOUT: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> tuple[int, [int], [int], [bool]]: ...
def scc(self) -> tuple[int, list[int], list[int]]: ...
def btf(self) -> tuple[int, list[int], list[int], list[int], list[int], list[int], list[int]]: ...
def amd(self) -> list[int]: ...
def find(self, ind1: bool = ...) -> list[int]: ...
def uni_coloring(self, AT: Sparsity = ..., cutoff: int = ...) -> Sparsity: ...
def star_coloring(self, ordering: int = ..., cutoff: int = ...) -> Sparsity: ...
def star_coloring2(self, ordering: int = ..., cutoff: int = ...) -> Sparsity: ...
def largest_first(self) -> list[int]: ...
def pmult(self, p: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], permute_rows: bool = ..., permute_columns: bool = ..., invert_permutation: bool = ...) -> Sparsity: ...
def dim(self, with_nz: bool = ...) -> str: ...
def postfix_dim(self) -> str: ...
def repr_el(self, k: int) -> str: ...
def spy(self) -> None: ...
def spy_matlab(self, mfile: str) -> None: ...
def export_code(self, lang: str, options: Mapping[str, _GenericType] = ...) -> None: ...
@staticmethod
def type_name() -> str: ...
def hash(self) -> Any: ...
@staticmethod
def test_cast(ptr: Any) -> bool: ...
@staticmethod
def kkt(H: Sparsity, J: Sparsity, with_x_diag: bool = ..., with_lam_g_diag: bool = ...) -> Sparsity: ...
T: Sparsity
shape: tuple[int,int]
@overload
def __init__(self, dummy: int = ...) -> None: ...
@overload
def __init__(self, rc: tuple[int, int]) -> None: ...
@overload
def __init__(self, other: Sparsity) -> None: ...
@overload
def __init__(self, nrow: int, ncol: int) -> None: ...
@overload
def __init__(self, nrow: int, ncol: int, colind: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], order_rows: bool = ...) -> None: ...
@overload
def hash_sparsity(nrow: int, ncol: int, colind: Any, row: Any) -> Any: ...
@overload
def hash_sparsity(nrow: int, ncol: int, colind: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> Any: ...
class Slice(PrintableCommon):
start: int
stop: int
step: int
@overload
def all(self) -> list[int]: ...
@overload
def all(self, len: int, ind1: bool = ...) -> list[int]: ...
@overload
def all(self, outer: _Slice, len: int) -> list[int]: ...
def size(self) -> int: ...
def is_empty(self) -> bool: ...
def is_scalar(self, len: int) -> bool: ...
def scalar(self, len: int) -> int: ...
def __eq__(self, other: _Slice) -> bool: ...
def __ne__(self, other: _Slice) -> bool: ...
def apply(self, len: int, ind1: bool = ...) -> Slice: ...
def __sub__(self, i: int) -> Slice: ...
def __mul__(self, i: int) -> Slice: ...
def type_name(self) -> str: ...
def disp(self, more: bool = ...) -> None: ...
def str(self, more: bool = ...) -> str: ...
def info(self) -> dict[str, _GenericType]: ...
def serialize(self, s: Any) -> None: ...
@staticmethod
def deserialize(s: Any) -> Slice: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, i: int, ind1: bool = ...) -> None: ...
@overload
def __init__(self, other: _Slice) -> None: ...
@overload
def __init__(self, start: Any, stop: Any, step: Any = ...) -> None: ...
@overload
def __init__(self, start: Any, stop: int, step: Any = ...) -> None: ...
@overload
def __init__(self, start: int, stop: Any, step: Any = ...) -> None: ...
@overload
def __init__(self, start: int, stop: int, step: int = ...) -> None: ...
def to_slice(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> Slice: ...
def to_slice2(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> Any: ...
def is_slice(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> bool: ...
def is_slice2(v: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> bool: ...
class GenericMatrixCommon:
def __mldivide__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rmldivide__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __mrdivide__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rmrdivide__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __mpower__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rmpower__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
def index_interp1d(x: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], xq: float, equidistant: bool = ...) -> float: ...
class GenDM(GenericMatrixCommon, SparsityInterfaceCommon):
def nnz(self) -> int: ...
def nnz_lower(self) -> int: ...
def nnz_upper(self) -> int: ...
def nnz_diag(self) -> int: ...
def numel(self) -> int: ...
def size1(self) -> int: ...
def rows(self) -> int: ...
def size2(self) -> int: ...
def columns(self) -> int: ...
def dim(self, with_nz: bool = ...) -> str: ...
@overload
def size(self) -> tuple[int, int]: ...
@overload
def size(self, axis: int) -> int: ...
def is_empty(self, both: bool = ...) -> bool: ...
def is_dense(self) -> bool: ...
def is_scalar(self, scalar_and_dense: bool = ...) -> bool: ...
def is_square(self) -> bool: ...
def is_vector(self) -> bool: ...
def is_row(self) -> bool: ...
def is_column(self) -> bool: ...
def is_triu(self) -> bool: ...
def is_tril(self) -> bool: ...
@overload
def row(self) -> list[int]: ...
@overload
def row(self, el: int) -> int: ...
@overload
def colind(self) -> list[int]: ...
@overload
def colind(self, col: int) -> int: ...
def sparsity(self) -> Sparsity: ...
@overload
@staticmethod
def sym(name: str, nrow: int = ..., ncol: int = ...) -> DM: ...
@overload
@staticmethod
def sym(name: str, rc: tuple[int, int]) -> DM: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity) -> DM: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity, p: int) -> list[DM]: ...
@overload
@staticmethod
def sym(name: str, nrow: int, ncol: int, p: int) -> list[DM]: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity, p: int, r: int) -> list[list[DM]]: ...
@overload
@staticmethod
def sym(name: str, nrow: int, ncol: int, p: int, r: int) -> list[list[DM]]: ...
@overload
@staticmethod
def zeros(nrow: int = ..., ncol: int = ...) -> DM: ...
@overload
@staticmethod
def zeros(rc: tuple[int, int]) -> DM: ...
@overload
@staticmethod
def zeros(sp: Sparsity) -> DM: ...
@overload
@staticmethod
def ones(nrow: int = ..., ncol: int = ...) -> DM: ...
@overload
@staticmethod
def ones(rc: tuple[int, int]) -> DM: ...
@overload
@staticmethod
def ones(sp: Sparsity) -> DM: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class GenSX(GenericMatrixCommon, SparsityInterfaceCommon):
def nnz(self) -> int: ...
def nnz_lower(self) -> int: ...
def nnz_upper(self) -> int: ...
def nnz_diag(self) -> int: ...
def numel(self) -> int: ...
def size1(self) -> int: ...
def rows(self) -> int: ...
def size2(self) -> int: ...
def columns(self) -> int: ...
def dim(self, with_nz: bool = ...) -> str: ...
@overload
def size(self) -> tuple[int, int]: ...
@overload
def size(self, axis: int) -> int: ...
def is_empty(self, both: bool = ...) -> bool: ...
def is_dense(self) -> bool: ...
def is_scalar(self, scalar_and_dense: bool = ...) -> bool: ...
def is_square(self) -> bool: ...
def is_vector(self) -> bool: ...
def is_row(self) -> bool: ...
def is_column(self) -> bool: ...
def is_triu(self) -> bool: ...
def is_tril(self) -> bool: ...
@overload
def row(self) -> list[int]: ...
@overload
def row(self, el: int) -> int: ...
@overload
def colind(self) -> list[int]: ...
@overload
def colind(self, col: int) -> int: ...
def sparsity(self) -> Sparsity: ...
@overload
@staticmethod
def sym(name: str, nrow: int = ..., ncol: int = ...) -> SX: ...
@overload
@staticmethod
def sym(name: str, rc: tuple[int, int]) -> SX: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity) -> SX: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity, p: int) -> list[SX]: ...
@overload
@staticmethod
def sym(name: str, nrow: int, ncol: int, p: int) -> list[SX]: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity, p: int, r: int) -> list[list[SX]]: ...
@overload
@staticmethod
def sym(name: str, nrow: int, ncol: int, p: int, r: int) -> list[list[SX]]: ...
@overload
@staticmethod
def zeros(nrow: int = ..., ncol: int = ...) -> SX: ...
@overload
@staticmethod
def zeros(rc: tuple[int, int]) -> SX: ...
@overload
@staticmethod
def zeros(sp: Sparsity) -> SX: ...
@overload
@staticmethod
def ones(nrow: int = ..., ncol: int = ...) -> SX: ...
@overload
@staticmethod
def ones(rc: tuple[int, int]) -> SX: ...
@overload
@staticmethod
def ones(sp: Sparsity) -> SX: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class GenMX(GenericMatrixCommon, SparsityInterfaceCommon):
def nnz(self) -> int: ...
def nnz_lower(self) -> int: ...
def nnz_upper(self) -> int: ...
def nnz_diag(self) -> int: ...
def numel(self) -> int: ...
def size1(self) -> int: ...
def rows(self) -> int: ...
def size2(self) -> int: ...
def columns(self) -> int: ...
def dim(self, with_nz: bool = ...) -> str: ...
@overload
def size(self) -> tuple[int, int]: ...
@overload
def size(self, axis: int) -> int: ...
def is_empty(self, both: bool = ...) -> bool: ...
def is_dense(self) -> bool: ...
def is_scalar(self, scalar_and_dense: bool = ...) -> bool: ...
def is_square(self) -> bool: ...
def is_vector(self) -> bool: ...
def is_row(self) -> bool: ...
def is_column(self) -> bool: ...
def is_triu(self) -> bool: ...
def is_tril(self) -> bool: ...
@overload
def row(self) -> list[int]: ...
@overload
def row(self, el: int) -> int: ...
@overload
def colind(self) -> list[int]: ...
@overload
def colind(self, col: int) -> int: ...
def sparsity(self) -> Sparsity: ...
@overload
@staticmethod
def sym(name: str, nrow: int = ..., ncol: int = ...) -> MX: ...
@overload
@staticmethod
def sym(name: str, rc: tuple[int, int]) -> MX: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity) -> MX: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity, p: int) -> list[MX]: ...
@overload
@staticmethod
def sym(name: str, nrow: int, ncol: int, p: int) -> list[MX]: ...
@overload
@staticmethod
def sym(name: str, sp: Sparsity, p: int, r: int) -> list[list[MX]]: ...
@overload
@staticmethod
def sym(name: str, nrow: int, ncol: int, p: int, r: int) -> list[list[MX]]: ...
@overload
@staticmethod
def zeros(nrow: int = ..., ncol: int = ...) -> MX: ...
@overload
@staticmethod
def zeros(rc: tuple[int, int]) -> MX: ...
@overload
@staticmethod
def zeros(sp: Sparsity) -> MX: ...
@overload
@staticmethod
def ones(nrow: int = ..., ncol: int = ...) -> MX: ...
@overload
@staticmethod
def ones(rc: tuple[int, int]) -> MX: ...
@overload
@staticmethod
def ones(sp: Sparsity) -> MX: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class GenericExpressionCommon:
def __hash__(self) -> int: ...
def __matmul__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rmatmul__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __add__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __radd__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __sub__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rsub__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __mul__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rmul__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __truediv__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rtruediv__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __pow__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __rpow__(self, other: bool | int | float | DM | SX | MX | Self | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> Self: ...
def __neg__(self) -> Self: ...
def __pos__(self) -> Self: ...
def __abs__(self) -> Self: ...
def __lt__(self, other: bool | int | float | DM | SX | MX | Self) -> Self: ...
def __le__(self, other: bool | int | float | DM | SX | MX | Self) -> Self: ...
def __gt__(self, other: bool | int | float | DM | SX | MX | Self) -> Self: ...
def __ge__(self, other: bool | int | float | DM | SX | MX | Self) -> Self: ...
def __eq__(self, other: bool | int | float | DM | SX | MX | Self) -> Self: ...
def __ne__(self, other: bool | int | float | DM | SX | MX | Self) -> Self: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
IS_GLOBAL: int = ...
IS_MEMBER: int = ...
IS_SPARSITY: int = ...
IS_DMATRIX: int = ...
IS_IMATRIX: int = ...
IS_SX: int = ...
IS_MX: int = ...
IS_DOUBLE: int = ...
class MatrixCommon:
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class DM(MatrixCommon, GenericExpressionCommon, GenDM, PrintableCommon):
def has_nz(self, rr: int, cc: int) -> bool: ...
def __bool__(self) -> bool: ...
@overload
def get(self, ind1: bool, sp: Sparsity) -> DM: ...
@overload
def get(self, ind1: bool, rr: _Slice) -> DM: ...
@overload
def get(self, ind1: bool, rr: _IM) -> DM: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: _Slice) -> DM: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: _IM) -> DM: ...
@overload
def get(self, ind1: bool, rr: _IM, cc: _Slice) -> DM: ...
@overload
def get(self, ind1: bool, rr: _IM, cc: _IM) -> DM: ...
@overload
def set(self, m: _DM, ind1: bool, sp: Sparsity) -> None: ...
@overload
def set(self, m: _DM, ind1: bool, rr: _Slice) -> None: ...
@overload
def set(self, m: _DM, ind1: bool, rr: _IM) -> None: ...
@overload
def set(self, m: _DM, ind1: bool, rr: _Slice, cc: _Slice) -> None: ...
@overload
def set(self, m: _DM, ind1: bool, rr: _Slice, cc: _IM) -> None: ...
@overload
def set(self, m: _DM, ind1: bool, rr: _IM, cc: _Slice) -> None: ...
@overload
def set(self, m: _DM, ind1: bool, rr: _IM, cc: _IM) -> None: ...
@overload
def get_nz(self, ind1: bool, k: _Slice) -> DM: ...
@overload
def get_nz(self, ind1: bool, k: _IM) -> DM: ...
@overload
def set_nz(self, m: _DM, ind1: bool, k: _Slice) -> None: ...
@overload
def set_nz(self, m: _DM, ind1: bool, k: _IM) -> None: ...
def __pos__(self) -> DM: ...
def __neg__(self) -> DM: ...
@staticmethod
def binary(op: int, x: _DM, y: _DM) -> DM: ...
@staticmethod
def unary(op: int, x: _DM) -> DM: ...
@staticmethod
def scalar_matrix(op: int, x: _DM, y: _DM) -> DM: ...
@staticmethod
def matrix_scalar(op: int, x: _DM, y: _DM) -> DM: ...
@staticmethod
def matrix_matrix(op: int, x: _DM, y: _DM) -> DM: ...
@overload
@staticmethod
def call(f: Function, x: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> list[float]: ...
@overload
@staticmethod
def call(f: Function, x: Sequence[_DM]) -> list[DM]: ...
def printme(self, y: _DM) -> DM: ...
@staticmethod
def set_max_depth(eq_depth: int = ...) -> None: ...
@staticmethod
def get_max_depth() -> int: ...
@staticmethod
def get_input(f: Function) -> list[DM]: ...
@staticmethod
def get_free(f: Function) -> list[DM]: ...
@staticmethod
def type_name() -> str: ...
def print_split(self) -> tuple[list[str], list[str]]: ...
def disp(self, more: bool = ...) -> None: ...
def str(self, more: bool = ...) -> str: ...
def print_scalar(self) -> None: ...
def print_vector(self, truncate: bool = ...) -> None: ...
def print_dense(self, truncate: bool = ...) -> None: ...
def print_sparse(self, truncate: bool = ...) -> None: ...
def clear(self) -> None: ...
def resize(self, nrow: int, ncol: int) -> None: ...
@overload
def reserve(self, nnz: int) -> None: ...
@overload
def reserve(self, nnz: int, ncol: int) -> None: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def remove(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
def enlarge(self, nrow: int, ncol: int, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def sparsity(self) -> Sparsity: ...
def get_output(self, oind: int) -> DM: ...
@overload
@staticmethod
def triplet(row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], d: _DM) -> DM: ...
@overload
@staticmethod
def triplet(row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], d: _DM, rc: tuple[int, int]) -> DM: ...
@overload
@staticmethod
def triplet(row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], d: _DM, nrow: int, ncol: int) -> DM: ...
@overload
@staticmethod
def inf(nrow: int = ..., ncol: int = ...) -> DM: ...
@overload
@staticmethod
def inf(rc: tuple[int, int]) -> DM: ...
@overload
@staticmethod
def inf(sp: Sparsity) -> DM: ...
@overload
@staticmethod
def nan(nrow: int = ..., ncol: int = ...) -> DM: ...
@overload
@staticmethod
def nan(rc: tuple[int, int]) -> DM: ...
@overload
@staticmethod
def nan(sp: Sparsity) -> DM: ...
@staticmethod
def eye(n: int) -> DM: ...
def element_hash(self) -> int: ...
def is_regular(self) -> bool: ...
def is_smooth(self) -> bool: ...
def is_leaf(self) -> bool: ...
def is_commutative(self) -> bool: ...
def is_symbolic(self) -> bool: ...
def is_valid_input(self) -> bool: ...
def has_duplicates(self) -> bool: ...
def reset_input(self) -> None: ...
def is_constant(self) -> bool: ...
def is_call(self) -> bool: ...
def is_output(self) -> bool: ...
def has_output(self) -> bool: ...
def which_output(self) -> int: ...
def which_function(self) -> Function: ...
def is_integer(self) -> bool: ...
def is_zero(self) -> bool: ...
def is_one(self) -> bool: ...
def is_minus_one(self) -> bool: ...
def is_half(self) -> bool: ...
def is_value(self, val: float) -> bool: ...
def is_inf(self) -> bool: ...
def is_minus_inf(self) -> bool: ...
def is_nonnegative(self) -> bool: ...
def is_eye(self) -> bool: ...
def op(self) -> int: ...
def is_op(self, op: int) -> bool: ...
def has_zeros(self) -> bool: ...
def nonzeros(self) -> list[float]: ...
def elements(self) -> list[float]: ...
def __float__(self) -> float: ...
def __int__(self) -> int: ...
def name(self) -> str: ...
def dep(self, ch: int = ...) -> DM: ...
def n_dep(self) -> int: ...
@staticmethod
def set_precision(precision: int) -> None: ...
@staticmethod
def set_width(width: int) -> None: ...
@staticmethod
def set_scientific(scientific: bool) -> None: ...
@staticmethod
def rng(seed: int) -> None: ...
@overload
@staticmethod
def rand(nrow: int = ..., ncol: int = ...) -> DM: ...
@overload
@staticmethod
def rand(rc: tuple[int, int]) -> DM: ...
@overload
@staticmethod
def rand(sp: Sparsity) -> DM: ...
def export_code(self, lang: str, options: Mapping[str, _GenericType] = ...) -> None: ...
def info(self) -> dict[str, _GenericType]: ...
@overload
def serialize(self) -> str: ...
@overload
def serialize(self, s: Any) -> None: ...
@overload
@staticmethod
def deserialize(stream: Any) -> DM: ...
@overload
@staticmethod
def deserialize(s: Any) -> DM: ...
@overload
@staticmethod
def deserialize(s: str) -> DM: ...
def to_file(self, filename: str, format: str = ...) -> None: ...
@staticmethod
def from_file(filename: str, format_hint: str = ...) -> DM: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, sp: Sparsity) -> None: ...
@overload
def __init__(self, val: float) -> None: ...
@overload
def __init__(self, m: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]]) -> None: ...
@overload
def __init__(self, m: _DM) -> None: ...
@overload
def __init__(self, x: Sequence[_SXElem]) -> None: ...
@overload
def __init__(self, x: _SX) -> None: ...
@overload
def __init__(self, nrow: int, ncol: int) -> None: ...
@overload
def __init__(self, sp: Sparsity, d: _DM) -> None: ...
def assign(self, rhs: _DM) -> None: ...
shape: tuple[int,int]
T: Self
nz: NZproxy[Self]
def reshape(self, arg: tuple[int,int] | int | Sparsity) -> Self: ...
@overload
def __getitem__(self, s: _MIndex | tuple[_MIndex,_MIndex]) -> Self: ...
@overload
def __setitem__(self, s: _MIndex | tuple[_MIndex,_MIndex],val: bool | int | float | DM | SX | MX | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_] | NDArray[Any]) -> None: ...
def __iter__(self) -> Iterator[Self]: ...
def full(self) -> Any: ...
def sparse(self) -> Any: ...
def __array__(self, *args: Any,**kwargs: Any) -> NDArray[np.float64]: ...
class SXElem:
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: _SXElem) -> None: ...
class SX(MatrixCommon, GenericExpressionCommon, GenSX, PrintableCommon):
def has_nz(self, rr: int, cc: int) -> bool: ...
def __bool__(self) -> bool: ...
@overload
def get(self, ind1: bool, sp: Sparsity) -> SX: ...
@overload
def get(self, ind1: bool, rr: _Slice) -> SX: ...
@overload
def get(self, ind1: bool, rr: _IM) -> SX: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: _Slice) -> SX: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: _IM) -> SX: ...
@overload
def get(self, ind1: bool, rr: _IM, cc: _Slice) -> SX: ...
@overload
def get(self, ind1: bool, rr: _IM, cc: _IM) -> SX: ...
@overload
def set(self, m: _SX, ind1: bool, sp: Sparsity) -> None: ...
@overload
def set(self, m: _SX, ind1: bool, rr: _Slice) -> None: ...
@overload
def set(self, m: _SX, ind1: bool, rr: _IM) -> None: ...
@overload
def set(self, m: _SX, ind1: bool, rr: _Slice, cc: _Slice) -> None: ...
@overload
def set(self, m: _SX, ind1: bool, rr: _Slice, cc: _IM) -> None: ...
@overload
def set(self, m: _SX, ind1: bool, rr: _IM, cc: _Slice) -> None: ...
@overload
def set(self, m: _SX, ind1: bool, rr: _IM, cc: _IM) -> None: ...
@overload
def get_nz(self, ind1: bool, k: _Slice) -> SX: ...
@overload
def get_nz(self, ind1: bool, k: _IM) -> SX: ...
@overload
def set_nz(self, m: _SX, ind1: bool, k: _Slice) -> None: ...
@overload
def set_nz(self, m: _SX, ind1: bool, k: _IM) -> None: ...
def __pos__(self) -> SX: ...
def __neg__(self) -> SX: ...
@staticmethod
def binary(op: int, x: _SX, y: _SX) -> SX: ...
@staticmethod
def unary(op: int, x: _SX) -> SX: ...
@staticmethod
def scalar_matrix(op: int, x: _SX, y: _SX) -> SX: ...
@staticmethod
def matrix_scalar(op: int, x: _SX, y: _SX) -> SX: ...
@staticmethod
def matrix_matrix(op: int, x: _SX, y: _SX) -> SX: ...
@overload
@staticmethod
def call(f: Function, x: Sequence[_SX]) -> list[SX]: ...
@overload
@staticmethod
def call(f: Function, x: Sequence[_SXElem]) -> list[SXElem]: ...
def printme(self, y: _SX) -> SX: ...
@staticmethod
def set_max_depth(eq_depth: int = ...) -> None: ...
@staticmethod
def get_max_depth() -> int: ...
@staticmethod
def get_input(f: Function) -> list[SX]: ...
@staticmethod
def get_free(f: Function) -> list[SX]: ...
@staticmethod
def type_name() -> str: ...
def print_split(self) -> tuple[list[str], list[str]]: ...
def disp(self, more: bool = ...) -> None: ...
def str(self, more: bool = ...) -> str: ...
def print_scalar(self) -> None: ...
def print_vector(self, truncate: bool = ...) -> None: ...
def print_dense(self, truncate: bool = ...) -> None: ...
def print_sparse(self, truncate: bool = ...) -> None: ...
def clear(self) -> None: ...
def resize(self, nrow: int, ncol: int) -> None: ...
@overload
def reserve(self, nnz: int) -> None: ...
@overload
def reserve(self, nnz: int, ncol: int) -> None: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def remove(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
def enlarge(self, nrow: int, ncol: int, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def sparsity(self) -> Sparsity: ...
def get_output(self, oind: int) -> SX: ...
@overload
@staticmethod
def triplet(row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], d: _SX) -> SX: ...
@overload
@staticmethod
def triplet(row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], d: _SX, rc: tuple[int, int]) -> SX: ...
@overload
@staticmethod
def triplet(row: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], col: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], d: _SX, nrow: int, ncol: int) -> SX: ...
@overload
@staticmethod
def inf(nrow: int = ..., ncol: int = ...) -> SX: ...
@overload
@staticmethod
def inf(rc: tuple[int, int]) -> SX: ...
@overload
@staticmethod
def inf(sp: Sparsity) -> SX: ...
@overload
@staticmethod
def nan(nrow: int = ..., ncol: int = ...) -> SX: ...
@overload
@staticmethod
def nan(rc: tuple[int, int]) -> SX: ...
@overload
@staticmethod
def nan(sp: Sparsity) -> SX: ...
@staticmethod
def eye(n: int) -> SX: ...
def element_hash(self) -> int: ...
def is_regular(self) -> bool: ...
def is_smooth(self) -> bool: ...
def is_leaf(self) -> bool: ...
def is_commutative(self) -> bool: ...
def is_symbolic(self) -> bool: ...
def is_valid_input(self) -> bool: ...
def has_duplicates(self) -> bool: ...
def reset_input(self) -> None: ...
def is_constant(self) -> bool: ...
def is_call(self) -> bool: ...
def is_output(self) -> bool: ...
def has_output(self) -> bool: ...
def which_output(self) -> int: ...
def which_function(self) -> Function: ...
def is_integer(self) -> bool: ...
def is_zero(self) -> bool: ...
def is_one(self) -> bool: ...
def is_minus_one(self) -> bool: ...
def is_half(self) -> bool: ...
def is_value(self, val: float) -> bool: ...
def is_inf(self) -> bool: ...
def is_minus_inf(self) -> bool: ...
def is_nonnegative(self) -> bool: ...
def is_eye(self) -> bool: ...
def op(self) -> int: ...
def is_op(self, op: int) -> bool: ...
def has_zeros(self) -> bool: ...
def nonzeros(self) -> list[SXElem]: ...
def elements(self) -> list[SXElem]: ...
def __float__(self) -> float: ...
def __int__(self) -> int: ...
def name(self) -> str: ...
def dep(self, ch: int = ...) -> SX: ...
def n_dep(self) -> int: ...
@staticmethod
def set_precision(precision: int) -> None: ...
@staticmethod
def set_width(width: int) -> None: ...
@staticmethod
def set_scientific(scientific: bool) -> None: ...
@staticmethod
def rng(seed: int) -> None: ...
@overload
@staticmethod
def rand(nrow: int = ..., ncol: int = ...) -> SX: ...
@overload
@staticmethod
def rand(rc: tuple[int, int]) -> SX: ...
@overload
@staticmethod
def rand(sp: Sparsity) -> SX: ...
def export_code(self, lang: str, options: Mapping[str, _GenericType] = ...) -> None: ...
def info(self) -> dict[str, _GenericType]: ...
@overload
def serialize(self) -> str: ...
@overload
def serialize(self, s: Any) -> None: ...
@overload
@staticmethod
def deserialize(stream: Any) -> SX: ...
@overload
@staticmethod
def deserialize(s: Any) -> SX: ...
@overload
@staticmethod
def deserialize(s: str) -> SX: ...
def to_file(self, filename: str, format: str = ...) -> None: ...
@staticmethod
def from_file(filename: str, format_hint: str = ...) -> DM: ...
shape: tuple[int,int]
T: Self
nz: NZproxy[Self]
def reshape(self, arg: tuple[int,int] | int | Sparsity) -> Self: ...
@overload
def __getitem__(self, s: _MIndex | tuple[_MIndex,_MIndex]) -> Self: ...
@overload
def __setitem__(self, s: _MIndex | tuple[_MIndex,_MIndex],val: bool | int | float | DM | SX | MX | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_] | NDArray[Any]) -> None: ...
def __iter__(self) -> Iterator[Self]: ...
def __array__(self, *args: Any,**kwargs: Any) -> NDArray[np.float64]: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, sp: Sparsity) -> None: ...
@overload
def __init__(self, val: float) -> None: ...
@overload
def __init__(self, m: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]]) -> None: ...
@overload
def __init__(self, x: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def __init__(self, x: _DM) -> None: ...
@overload
def __init__(self, m: _SX) -> None: ...
@overload
def __init__(self, nrow: int, ncol: int) -> None: ...
@overload
def __init__(self, sp: Sparsity, d: _SX) -> None: ...
class MX(GenericExpressionCommon, PrintableCommon, GenMX, SharedObject):
@staticmethod
def type_name() -> str: ...
def __bool__(self) -> bool: ...
def sparsity(self) -> Sparsity: ...
def nonzeros(self) -> list[MX]: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
@overload
def erase(self, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def enlarge(self, nrow: int, ncol: int, rr: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], cc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], ind1: bool = ...) -> None: ...
def __neg__(self) -> MX: ...
def inv(self) -> MX: ...
def dep(self, ch: int = ...) -> MX: ...
def n_out(self) -> int: ...
def get_output(self, oind: int) -> MX: ...
def n_dep(self) -> int: ...
def name(self) -> str: ...
def __float__(self) -> float: ...
def to_DM(self) -> DM: ...
def is_symbolic(self) -> bool: ...
def is_constant(self) -> bool: ...
def is_integer(self) -> bool: ...
def is_doubled(self) -> bool: ...
def is_call(self) -> bool: ...
def which_function(self) -> Function: ...
def is_output(self) -> bool: ...
def has_output(self) -> bool: ...
def which_output(self) -> int: ...
def is_op(self, op: int) -> bool: ...
def is_multiplication(self) -> bool: ...
def is_commutative(self) -> bool: ...
def is_norm(self) -> bool: ...
def is_valid_input(self) -> bool: ...
def n_primitives(self) -> int: ...
def primitives(self) -> list[MX]: ...
@overload
def split_primitives(self, x: _DM) -> list[DM]: ...
@overload
def split_primitives(self, x: _SX) -> list[SX]: ...
@overload
def split_primitives(self, x: _MX) -> list[MX]: ...
@overload
def join_primitives(self, v: Sequence[_DM]) -> DM: ...
@overload
def join_primitives(self, v: Sequence[_SX]) -> SX: ...
@overload
def join_primitives(self, v: Sequence[_MX]) -> MX: ...
def has_duplicates(self) -> bool: ...
def reset_input(self) -> None: ...
def is_eye(self) -> bool: ...
def is_zero(self) -> bool: ...
def is_one(self) -> bool: ...
def is_minus_one(self) -> bool: ...
def is_half(self) -> bool: ...
def is_value(self, val: float) -> bool: ...
def is_inf(self) -> bool: ...
def is_minus_inf(self) -> bool: ...
def is_transpose(self) -> bool: ...
def is_regular(self) -> bool: ...
def is_binary(self) -> bool: ...
def is_nonnegative(self) -> bool: ...
def is_unary(self) -> bool: ...
def op(self) -> int: ...
def info(self) -> dict[str, _GenericType]: ...
def serialize(self, s: Any) -> None: ...
@staticmethod
def deserialize(s: Any) -> MX: ...
def get_temp(self) -> int: ...
def set_temp(self, t: int) -> None: ...
@staticmethod
def binary(op: int, x: _MX, y: _MX, unique_x: bool = ..., unique_y: bool = ...) -> MX: ...
@staticmethod
def unary(op: int, x: _MX, unique: bool = ...) -> MX: ...
@overload
@staticmethod
def inf(nrow: int = ..., ncol: int = ...) -> MX: ...
@overload
@staticmethod
def inf(rc: tuple[int, int]) -> MX: ...
@overload
@staticmethod
def inf(sp: Sparsity) -> MX: ...
@overload
@staticmethod
def nan(nrow: int = ..., ncol: int = ...) -> MX: ...
@overload
@staticmethod
def nan(rc: tuple[int, int]) -> MX: ...
@overload
@staticmethod
def nan(sp: Sparsity) -> MX: ...
@staticmethod
def eye(n: int) -> MX: ...
def nzref(self, sp: Sparsity, nz: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> MX: ...
@overload
def get(self, ind1: bool, rr: int) -> MX: ...
@overload
def get(self, ind1: bool, sp: Sparsity) -> MX: ...
@overload
def get(self, ind1: bool, rr: _Slice) -> MX: ...
@overload
def get(self, ind1: bool, rr: _IM) -> MX: ...
@overload
def get(self, ind1: bool, rr: _MX) -> MX: ...
@overload
def get(self, ind1: bool, rr: int, cc: int) -> MX: ...
@overload
def get(self, ind1: bool, rr: int, cc: _Slice) -> MX: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: int) -> MX: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: _Slice) -> MX: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: _IM) -> MX: ...
@overload
def get(self, ind1: bool, rr: _Slice, cc: _MX) -> MX: ...
@overload
def get(self, ind1: bool, rr: _IM, cc: _Slice) -> MX: ...
@overload
def get(self, ind1: bool, rr: _IM, cc: _IM) -> MX: ...
@overload
def get(self, ind1: bool, rr: _MX, cc: _Slice) -> MX: ...
@overload
def get(self, ind1: bool, rr: _MX, cc: _MX) -> MX: ...
@overload
def set(self, m: _MX, ind1: bool, sp: Sparsity) -> None: ...
@overload
def set(self, m: _MX, ind1: bool, rr: _Slice) -> None: ...
@overload
def set(self, m: _MX, ind1: bool, rr: _IM) -> None: ...
@overload
def set(self, m: _MX, ind1: bool, rr: _Slice, cc: _Slice) -> None: ...
@overload
def set(self, m: _MX, ind1: bool, rr: _Slice, cc: _IM) -> None: ...
@overload
def set(self, m: _MX, ind1: bool, rr: _IM, cc: _Slice) -> None: ...
@overload
def set(self, m: _MX, ind1: bool, rr: _IM, cc: _IM) -> None: ...
@overload
def get_nz(self, ind1: bool, kk: int) -> MX: ...
@overload
def get_nz(self, ind1: bool, kk: _Slice) -> MX: ...
@overload
def get_nz(self, ind1: bool, kk: _IM) -> MX: ...
@overload
def get_nz(self, ind1: bool, kk: _MX) -> MX: ...
@overload
def get_nz(self, ind1: bool, inner: _Slice, outer: _MX) -> MX: ...
@overload
def get_nz(self, ind1: bool, inner: _MX, outer: _Slice) -> MX: ...
@overload
def get_nz(self, ind1: bool, inner: _MX, outer: _MX) -> MX: ...
@overload
def set_nz(self, m: _MX, ind1: bool, kk: int) -> None: ...
@overload
def set_nz(self, m: _MX, ind1: bool, kk: _Slice) -> None: ...
@overload
def set_nz(self, m: _MX, ind1: bool, kk: _IM) -> None: ...
@overload
def set_nz(self, m: _MX, ind1: bool, kk: _MX) -> None: ...
@overload
@staticmethod
def einstein(A: _MX, B: _MX, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> MX: ...
@overload
@staticmethod
def einstein(A: _MX, B: _MX, C: _MX, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> MX: ...
@staticmethod
def simplify_ref_count(arg: Any, res: Any, opts: Mapping[str, _GenericType] = ...) -> bool: ...
@staticmethod
def simplify_const_folding(arg: Any, res: Any, opts: Mapping[str, _GenericType] = ...) -> bool: ...
@staticmethod
def bspline_dual(x: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], knots: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]], degree: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> DM: ...
@staticmethod
def interpn_linear(x: Sequence[_MX], v: _MX, xq: Sequence[_MX], opts: Mapping[str, _GenericType] = ...) -> MX: ...
def printme(self, b: _MX) -> MX: ...
def attachAssert(self, y: _MX, fail_message: str = ...) -> MX: ...
def monitor(self, comment: str) -> MX: ...
def dump(self, base_filename: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
def reset_dump_count(self) -> None: ...
def mapping(self) -> IM: ...
@staticmethod
def set_max_depth(eq_depth: int = ...) -> None: ...
@staticmethod
def get_max_depth() -> int: ...
@staticmethod
def test_cast(ptr: Any) -> bool: ...
@staticmethod
def get_input(f: Function) -> list[MX]: ...
@staticmethod
def get_free(f: Function) -> list[MX]: ...
def eval_mx(self, arg: Sequence[_MX], unique: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_] = ...) -> list[MX]: ...
shape: tuple[int,int]
T: Self
nz: NZproxy[Self]
def reshape(self, arg: tuple[int,int] | int | Sparsity) -> Self: ...
@overload
def __getitem__(self, s: _MIndex | tuple[_MIndex,_MIndex]) -> Self: ...
@overload
def __setitem__(self, s: _MIndex | tuple[_MIndex,_MIndex],val: bool | int | float | DM | SX | MX | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_] | NDArray[Any]) -> None: ...
def __iter__(self) -> Iterator[Self]: ...
def __array__(self, *args: Any,**kwargs: Any) -> NDArray[np.float64]: ...
@overload
def __getitem__(self, s: MX | tuple[_MIndex | MX,_MIndex | MX]) -> MX: ...
@overload
def __setitem__(self, s: MX | tuple[_MIndex | MX,_MIndex | MX],val: bool | int | float | DM | SX | MX | Sequence[bool | int | float] | Sequence[Sequence[bool | int | float]] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_] | NDArray[Any]) -> None: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, sp: Sparsity) -> None: ...
@overload
def __init__(self, x: float) -> None: ...
@overload
def __init__(self, x: _DM) -> None: ...
@overload
def __init__(self, other: _MX) -> None: ...
@overload
def __init__(self, nrow: int, ncol: int) -> None: ...
@overload
def __init__(self, sp: Sparsity, val: _MX) -> None: ...
@overload
def __init__(self, sp: Sparsity, fname: str) -> None: ...
@overload
def __init__(self, val: _DM, name: str) -> None: ...
class Function(SharedObject, PrintableCommon):
@staticmethod
def type_name() -> str: ...
@overload
@staticmethod
def jit(name: str, body: str, name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
@staticmethod
def jit(name: str, body: str, name_in: Sequence[str], name_out: Sequence[str], sparsity_in: Sequence[Sparsity], sparsity_out: Sequence[Sparsity], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def expand(self) -> Function: ...
@overload
def expand(self, name: str, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def simplify(self, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def simplify(self, name: str, opts: Mapping[str, _GenericType] = ...) -> Function: ...
def n_in(self) -> int: ...
def n_out(self) -> int: ...
@overload
def size1_in(self, ind: int) -> int: ...
@overload
def size1_in(self, iname: str) -> int: ...
@overload
def size2_in(self, ind: int) -> int: ...
@overload
def size2_in(self, iname: str) -> int: ...
@overload
def size_in(self, ind: int) -> tuple[int, int]: ...
@overload
def size_in(self, iname: str) -> tuple[int, int]: ...
@overload
def size1_out(self, ind: int) -> int: ...
@overload
def size1_out(self, oname: str) -> int: ...
@overload
def size2_out(self, ind: int) -> int: ...
@overload
def size2_out(self, oname: str) -> int: ...
@overload
def size_out(self, ind: int) -> tuple[int, int]: ...
@overload
def size_out(self, oname: str) -> tuple[int, int]: ...
@overload
def nnz_in(self) -> int: ...
@overload
def nnz_in(self, ind: int) -> int: ...
@overload
def nnz_in(self, iname: str) -> int: ...
@overload
def nnz_out(self) -> int: ...
@overload
def nnz_out(self, ind: int) -> int: ...
@overload
def nnz_out(self, oname: str) -> int: ...
@overload
def numel_in(self) -> int: ...
@overload
def numel_in(self, ind: int) -> int: ...
@overload
def numel_in(self, iname: str) -> int: ...
@overload
def numel_out(self) -> int: ...
@overload
def numel_out(self, ind: int) -> int: ...
@overload
def numel_out(self, oname: str) -> int: ...
@overload
def name_in(self) -> list[str]: ...
@overload
def name_in(self, ind: int) -> str: ...
@overload
def name_out(self) -> list[str]: ...
@overload
def name_out(self, ind: int) -> str: ...
def index_in(self, name: str) -> int: ...
def index_out(self, name: str) -> int: ...
def has_in(self, name: str) -> bool: ...
def has_out(self, name: str) -> bool: ...
def default_in(self, ind: int) -> float: ...
def max_in(self, ind: int) -> float: ...
def min_in(self, ind: int) -> float: ...
def nominal_in(self, ind: int) -> list[float]: ...
def nominal_out(self, ind: int) -> list[float]: ...
@overload
def sparsity_in(self, ind: int) -> Sparsity: ...
@overload
def sparsity_in(self, iname: str) -> Sparsity: ...
@overload
def sparsity_out(self, ind: int) -> Sparsity: ...
@overload
def sparsity_out(self, iname: str) -> Sparsity: ...
@overload
def is_diff_in(self) -> list[bool]: ...
@overload
def is_diff_in(self, ind: int) -> bool: ...
@overload
def is_diff_out(self) -> list[bool]: ...
@overload
def is_diff_out(self, ind: int) -> bool: ...
def factory(self, name: str, s_in: Sequence[str], s_out: Sequence[str], aux: Mapping[str, Sequence[str]] = ..., opts: Mapping[str, _GenericType] = ...) -> Function: ...
def oracle(self) -> Function: ...
@overload
def wrap(self) -> Function: ...
@overload
def wrap(self, name: str) -> Function: ...
@overload
def wrap_as_needed(self, opts: Mapping[str, _GenericType]) -> Function: ...
@overload
def wrap_as_needed(self, name: str, opts: Mapping[str, _GenericType]) -> Function: ...
def which_depends(self, s_in: str, s_out: Sequence[str], order: int = ..., tr: bool = ...) -> list[bool]: ...
def print_dimensions(self) -> None: ...
def print_options(self) -> None: ...
def print_option(self, name: str) -> None: ...
def has_option(self, option_name: str) -> bool: ...
def change_option(self, option_name: str, option_value: _GenericType) -> None: ...
def reset_dump_count(self) -> None: ...
def uses_output(self) -> bool: ...
def jacobian_old(self, iind: int, oind: int) -> Function: ...
def hessian_old(self, iind: int, oind: int) -> Function: ...
@overload
def sparsity_jac(self, iind: str, oind: int = ..., compact: bool = ..., symmetric: bool = ...) -> Sparsity: ...
@overload
def sparsity_jac(self, iind: int, oind: int, compact: bool = ..., symmetric: bool = ...) -> Sparsity: ...
@overload
def sparsity_jac(self, iind: int, oind: str, compact: bool = ..., symmetric: bool = ...) -> Sparsity: ...
@overload
def sparsity_jac(self, iind: str, oind: str, compact: bool = ..., symmetric: bool = ...) -> Sparsity: ...
def jacobian(self) -> Function: ...
@overload
def call(self, arg: Mapping[str, _DM], always_inline: bool = ..., never_inline: bool = ...) -> dict[str, DM]: ...
@overload
def call(self, arg: Sequence[_DM], always_inline: bool = ..., never_inline: bool = ...) -> list[DM]: ...
@overload
def call(self, arg: Sequence[_SX], always_inline: bool = ..., never_inline: bool = ...) -> list[SX]: ...
@overload
def call(self, arg: Mapping[str, _SX], always_inline: bool = ..., never_inline: bool = ...) -> dict[str, SX]: ...
@overload
def call(self, arg: Mapping[str, _MX], always_inline: bool = ..., never_inline: bool = ...) -> dict[str, MX]: ...
@overload
def call(self, arg: Sequence[_MX], always_inline: bool = ..., never_inline: bool = ...) -> list[MX]: ...
def mapsum(self, x: Sequence[_MX], parallelization: str = ...) -> list[MX]: ...
@overload
def mapaccum(self, N: int, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def mapaccum(self, name: str, N: int, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def mapaccum(self, name: str, N: int, n_accum: int, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def mapaccum(self, name: str, n: int, accum_in: Sequence[str], accum_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def mapaccum(self, name: str, n: int, accum_in: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], accum_out: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
def fold(self, N: int, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def map(self, n: int, parallelization: str = ...) -> Function: ...
@overload
def map(self, n: int, reduce_in: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], reduce_out: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_] = ..., opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def map(self, n: int, parallelization: str, max_num_threads: int) -> Function: ...
@overload
def map(self, name: str, parallelization: str, n: int, reduce_in: Sequence[str], reduce_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def map(self, name: str, parallelization: str, n: int, reduce_in: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], reduce_out: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
def slice(self, name: str, order_in: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], order_out: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
@staticmethod
def conditional(name: str, f: Function, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
@staticmethod
def conditional(name: str, f: Sequence[Function], f_def: Function, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@staticmethod
def bspline(name: str, knots: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]], coeffs: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], degree: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], m: int = ..., opts: Mapping[str, _GenericType] = ...) -> Function: ...
@staticmethod
def if_else(name: str, f_true: Function, f_false: Function, opts: Mapping[str, _GenericType] = ...) -> Function: ...
def forward(self, nfwd: int) -> Function: ...
def reverse(self, nadj: int) -> Function: ...
@overload
def jac_sparsity(self, compact: bool = ...) -> list[Sparsity]: ...
@overload
def jac_sparsity(self, oind: int, iind: int, compact: bool = ...) -> Sparsity: ...
@overload
def generate(self, opts: Mapping[str, _GenericType] = ...) -> str: ...
@overload
def generate(self, fname: str, opts: Mapping[str, _GenericType] = ...) -> str: ...
def generate_dependencies(self, fname: str, opts: Mapping[str, _GenericType] = ...) -> str: ...
@overload
def generate_in(self, fname: str) -> list[DM]: ...
@overload
def generate_in(self, fname: str, arg: Sequence[_DM]) -> None: ...
@overload
def generate_out(self, fname: str) -> list[DM]: ...
@overload
def generate_out(self, fname: str, arg: Sequence[_DM]) -> None: ...
def serialize(self, opts: Mapping[str, _GenericType] = ...) -> str: ...
def save(self, fname: str, opts: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def export_code(self, lang: str, options: Mapping[str, _GenericType] = ...) -> str: ...
@overload
def export_code(self, lang: str, fname: str, options: Mapping[str, _GenericType] = ...) -> None: ...
def stats(self, mem: Any = ...) -> dict[str, _GenericType]: ...
@overload
def sx_in(self) -> list[SX]: ...
@overload
def sx_in(self, iind: int) -> SX: ...
@overload
def sx_in(self, iname: str) -> SX: ...
@overload
def mx_in(self) -> list[MX]: ...
@overload
def mx_in(self, ind: int) -> MX: ...
@overload
def mx_in(self, iname: str) -> MX: ...
@overload
def sx_out(self) -> list[SX]: ...
@overload
def sx_out(self, oind: int) -> SX: ...
@overload
def sx_out(self, oname: str) -> SX: ...
@overload
def mx_out(self) -> list[MX]: ...
@overload
def mx_out(self, ind: int) -> MX: ...
@overload
def mx_out(self, oname: str) -> MX: ...
def nz_from_in(self, arg: Sequence[_DM]) -> list[float]: ...
def nz_from_out(self, arg: Sequence[_DM]) -> list[float]: ...
def nz_to_in(self, arg: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> list[DM]: ...
def nz_to_out(self, arg: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> list[DM]: ...
@overload
def convert_in(self, arg: Mapping[str, _DM]) -> list[DM]: ...
@overload
def convert_in(self, arg: Sequence[_DM]) -> dict[str, DM]: ...
@overload
def convert_in(self, arg: Sequence[_SX]) -> dict[str, SX]: ...
@overload
def convert_in(self, arg: Mapping[str, _SX]) -> list[SX]: ...
@overload
def convert_in(self, arg: Mapping[str, _MX]) -> list[MX]: ...
@overload
def convert_in(self, arg: Sequence[_MX]) -> dict[str, MX]: ...
@overload
def convert_out(self, arg: Mapping[str, _DM]) -> list[DM]: ...
@overload
def convert_out(self, arg: Sequence[_DM]) -> dict[str, DM]: ...
@overload
def convert_out(self, arg: Sequence[_SX]) -> dict[str, SX]: ...
@overload
def convert_out(self, arg: Mapping[str, _SX]) -> list[SX]: ...
@overload
def convert_out(self, arg: Mapping[str, _MX]) -> list[MX]: ...
@overload
def convert_out(self, arg: Sequence[_MX]) -> dict[str, MX]: ...
def has_free(self) -> bool: ...
def get_free(self) -> list[str]: ...
def free_sx(self) -> list[SX]: ...
def free_mx(self) -> list[MX]: ...
def generate_lifted(self) -> tuple[Function, Function]: ...
def n_nodes(self) -> int: ...
def n_instructions(self) -> int: ...
def instruction_id(self, k: int) -> int: ...
def instruction_input(self, k: int) -> list[int]: ...
def instruction_constant(self, k: int) -> float: ...
def instruction_output(self, k: int) -> list[int]: ...
def instruction_MX(self, k: int) -> MX: ...
def instructions_sx(self) -> SX: ...
def has_spfwd(self) -> bool: ...
def has_sprev(self) -> bool: ...
def sz_arg(self) -> int: ...
def sz_res(self) -> int: ...
def sz_iw(self) -> int: ...
def sz_w(self) -> int: ...
def name(self) -> str: ...
def is_a(self, type: str, recursive: bool = ...) -> bool: ...
@staticmethod
def check_name(name: str) -> bool: ...
@staticmethod
def fix_name(name: str) -> str: ...
@staticmethod
def load(filename: str) -> Function: ...
@overload
@staticmethod
def deserialize(stream: Any) -> Function: ...
@overload
@staticmethod
def deserialize(s: Any) -> Function: ...
@overload
@staticmethod
def deserialize(s: str) -> Function: ...
def assert_size_in(self, i: int, nrow: int, ncol: int) -> None: ...
def assert_size_out(self, i: int, nrow: int, ncol: int) -> None: ...
def assert_sparsity_out(self, i: int, sp: Sparsity, n: int = ..., allow_all_zero_sparse: bool = ...) -> None: ...
def checkout(self) -> int: ...
def release(self, mem: Any) -> None: ...
def cache(self) -> dict[str, _GenericType]: ...
@overload
def get_function(self) -> list[str]: ...
@overload
def get_function(self, name: str) -> Function: ...
def has_function(self, fname: str) -> bool: ...
def find_functions(self, max_depth: int = ...) -> list[Function]: ...
def find_function(self, name: str, max_depth: int = ...) -> Function: ...
def info(self) -> dict[str, _GenericType]: ...
def buffer(self) -> tuple[FunctionBuffer,Any]: ...
@overload
def __call__(self, arg0: _DM,/,*args: _DM) -> DM: ...
@overload
def __call__(self, arg0: _SX,/,*args: _SX) -> SX: ...
@overload
def __call__(self, arg0: _MX,/,*args: _MX) -> MX: ...
@overload
def __call__(self, **kwargs: _DM) -> dict[str,DM]: ...
@overload
def __call__(self, **kwargs: _SX) -> dict[str,SX]: ...
@overload
def __call__(self, **kwargs: _MX) -> dict[str,MX]: ...
@overload
def __call__(self, **kwargs: bool | int | float | DM | SX | MX) -> dict[str,DM | SX | MX]: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, fname: str) -> None: ...
@overload
def __init__(self, other: Function) -> None: ...
@overload
def __init__(self, name: str, ex_in: Sequence[_SX], ex_out: Sequence[_SX], opts: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def __init__(self, name: str, ex_in: Sequence[_MX], ex_out: Sequence[_MX], opts: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def __init__(self, name: str, dict: Mapping[str, _SX], name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def __init__(self, name: str, dict: Mapping[str, _MX], name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def __init__(self, name: str, ex_in: Sequence[_SX], ex_out: Sequence[_SX], name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def __init__(self, name: str, ex_in: Sequence[_MX], ex_out: Sequence[_MX], name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> None: ...
class FunctionBuffer:
def set_arg(self, i: int, a: memoryview, size: Any) -> None: ...
def set_res(self, i: int, a: memoryview, size: Any) -> None: ...
def ret(self) -> int: ...
def _eval(self) -> None: ...
def _self(self) -> Any: ...
def stats(self) -> dict[str, _GenericType]: ...
@overload
def __init__(self, other: Any) -> None: ...
@overload
def __init__(self, f: Function) -> None: ...
def _function_buffer_eval(raw: Any) -> None: ...
@overload
def external(name: str, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def external(name: str, li: Any, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def external(name: str, bin_name: str, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Mapping[str, _SX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Mapping[str, _MX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Function, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Mapping[str, _SX], t0: float, tout: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Mapping[str, _SX], t0: float, tf: float, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Mapping[str, _MX], t0: float, tout: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Mapping[str, _MX], t0: float, tf: float, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Function, t0: float, tout: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def integrator(name: str, solver: str, dae: Function, t0: float, tf: float, opts: Mapping[str, _GenericType] = ...) -> Function: ...
def has_integrator(name: str) -> bool: ...
def load_integrator(name: str) -> None: ...
def doc_integrator(name: str) -> str: ...
@overload
def integrator_in() -> list[str]: ...
@overload
def integrator_in(ind: int) -> str: ...
@overload
def integrator_out() -> list[str]: ...
@overload
def integrator_out(ind: int) -> str: ...
def integrator_n_in() -> int: ...
def integrator_n_out() -> int: ...
@overload
def dyn_in() -> list[str]: ...
@overload
def dyn_in(ind: int) -> str: ...
@overload
def dyn_out() -> list[str]: ...
@overload
def dyn_out(ind: int) -> str: ...
def dyn_n_in() -> int: ...
def dyn_n_out() -> int: ...
def event_in() -> list[str]: ...
def event_out() -> list[str]: ...
def conic(name: str, solver: str, qp: Mapping[str, Sparsity], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def qpsol(name: str, solver: str, qp: Mapping[str, _SX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def qpsol(name: str, solver: str, qp: Mapping[str, _MX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def conic_in() -> list[str]: ...
@overload
def conic_in(ind: int) -> str: ...
@overload
def conic_out() -> list[str]: ...
@overload
def conic_out(ind: int) -> str: ...
def conic_n_in() -> int: ...
def conic_n_out() -> int: ...
def conic_options(name: str) -> list[str]: ...
def conic_option_type(name: str, op: str) -> str: ...
def conic_option_info(name: str, op: str) -> str: ...
def has_conic(name: str) -> bool: ...
def load_conic(name: str) -> None: ...
def doc_conic(name: str) -> str: ...
@overload
def conic_debug(f: Function, file: Any) -> None: ...
@overload
def conic_debug(f: Function, filename: str) -> None: ...
@overload
def nlpsol(name: str, solver: str, compiler: Any, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def nlpsol(name: str, solver: str, nl: Any, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def nlpsol(name: str, solver: str, nlp: Mapping[str, _SX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def nlpsol(name: str, solver: str, nlp: Mapping[str, _MX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def nlpsol(name: str, solver: str, fname: str, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def nlpsol(name: str, solver: str, nlp: Function, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def nlpsol_in() -> list[str]: ...
@overload
def nlpsol_in(ind: int) -> str: ...
@overload
def nlpsol_out() -> list[str]: ...
@overload
def nlpsol_out(ind: int) -> str: ...
def nlpsol_n_in() -> int: ...
def nlpsol_n_out() -> int: ...
@overload
def nlpsol_default_in() -> list[float]: ...
@overload
def nlpsol_default_in(ind: int) -> float: ...
def nlpsol_options(name: str) -> list[str]: ...
def nlpsol_option_type(name: str, op: str) -> str: ...
def nlpsol_option_info(name: str, op: str) -> str: ...
def has_nlpsol(name: str) -> bool: ...
def load_nlpsol(name: str) -> None: ...
def doc_nlpsol(name: str) -> str: ...
@overload
def rootfinder(name: str, solver: str, rfp: Mapping[str, _SX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def rootfinder(name: str, solver: str, rfp: Mapping[str, _MX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def rootfinder(name: str, solver: str, f: Function, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def rootfinder_in() -> list[str]: ...
@overload
def rootfinder_in(ind: int) -> str: ...
@overload
def rootfinder_out() -> list[str]: ...
@overload
def rootfinder_out(ind: int) -> str: ...
def rootfinder_n_in() -> int: ...
def rootfinder_n_out() -> int: ...
def rootfinder_options(name: str) -> list[str]: ...
def rootfinder_option_type(name: str, op: str) -> str: ...
def rootfinder_option_info(name: str, op: str) -> str: ...
def has_rootfinder(name: str) -> bool: ...
def load_rootfinder(name: str) -> None: ...
def doc_rootfinder(name: str) -> str: ...
class Linsol(SharedObject, PrintableCommon):
@staticmethod
def type_name() -> str: ...
@staticmethod
def has_plugin(name: str) -> bool: ...
@staticmethod
def load_plugin(name: str) -> None: ...
@staticmethod
def doc(name: str) -> str: ...
def plugin_name(self) -> str: ...
def sparsity(self) -> Sparsity: ...
def sfact(self, A: _DM) -> None: ...
def nfact(self, A: _DM) -> None: ...
@overload
def solve(self, A: _DM, B: _DM, tr: bool = ...) -> DM: ...
@overload
def solve(self, A: _MX, B: _MX, tr: bool = ...) -> MX: ...
def neig(self, A: _DM) -> int: ...
def rank(self, A: _DM) -> int: ...
def stats(self, mem: Any = ...) -> dict[str, _GenericType]: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
@overload
def __init__(self, name: str, solver: str, sp: Sparsity, opts: Mapping[str, _GenericType] = ...) -> None: ...
def has_linsol(name: str) -> bool: ...
def load_linsol(name: str) -> None: ...
def doc_linsol(name: str) -> str: ...
@overload
def dplesol(A: Sequence[_DM], V: Sequence[_DM], solver: str, opts: Mapping[str, _GenericType] = ...) -> list[DM]: ...
@overload
def dplesol(A: _MX, V: _MX, solver: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def dplesol(A: Sequence[_MX], V: Sequence[_MX], solver: str, opts: Mapping[str, _GenericType] = ...) -> list[MX]: ...
@overload
def dplesol(name: str, solver: str, st: Mapping[str, Sparsity], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def dple_in() -> list[str]: ...
@overload
def dple_in(ind: int) -> str: ...
@overload
def dple_out() -> list[str]: ...
@overload
def dple_out(ind: int) -> str: ...
def dple_n_in() -> int: ...
def dple_n_out() -> int: ...
def has_dple(name: str) -> bool: ...
def load_dple(name: str) -> None: ...
def doc_dple(name: str) -> str: ...
def expmsol(name: str, solver: str, A: Sparsity, opts: Mapping[str, _GenericType] = ...) -> Function: ...
def expm_n_in() -> int: ...
def expm_n_out() -> int: ...
def has_expm(name: str) -> bool: ...
def load_expm(name: str) -> None: ...
def doc_expm(name: str) -> str: ...
@overload
def interpolant(name: str, solver: str, grid: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]], m: int = ..., opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def interpolant(name: str, solver: str, grid_dims: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], m: int = ..., opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def interpolant(name: str, solver: str, grid: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]], values: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def interpolant(name: str, solver: str, grid_dims: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], values: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
def has_interpolant(name: str) -> bool: ...
def load_interpolant(name: str) -> None: ...
def doc_interpolant(name: str) -> str: ...
@overload
def blazing_spline(name: str, knots: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def blazing_spline(name: str, knot_dims: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], opts: Mapping[str, _GenericType] = ...) -> Function: ...
class CodeGenerator:
def __init__(self, name: str, opts: Mapping[str, _GenericType] = ...) -> None: ...
def add(self, f: Function, with_jac_sparsity: bool = ...) -> None: ...
def dump(self) -> str: ...
def generate(self, prefix: str = ...) -> str: ...
def add_include(self, new_include: str, relative_path: bool = ..., use_ifdef: str = ...) -> None: ...
FLAG: int = ...
@overload
def _horzcat(v: Sequence[Sparsity]) -> Sparsity: ...
@overload
def _horzcat(v: Sequence[_DM]) -> DM: ...
@overload
def _horzcat(v: Sequence[_SX]) -> SX: ...
@overload
def _horzcat(v: Sequence[_MX]) -> MX: ...
@overload
def _vertcat(v: Sequence[Sparsity]) -> Sparsity: ...
@overload
def _vertcat(v: Sequence[_DM]) -> DM: ...
@overload
def _vertcat(v: Sequence[_SX]) -> SX: ...
@overload
def _vertcat(v: Sequence[_MX]) -> MX: ...
@overload
def horzsplit(v: Sparsity, incr: int = ...) -> list[Sparsity]: ...
@overload
def horzsplit(v: _DM, incr: int = ...) -> list[DM]: ...
@overload
def horzsplit(v: _SX, incr: int = ...) -> list[SX]: ...
@overload
def horzsplit(v: _MX, incr: int = ...) -> list[MX]: ...
@overload
def horzsplit(v: Sparsity, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[Sparsity]: ...
@overload
def horzsplit(v: _DM, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[DM]: ...
@overload
def horzsplit(v: _SX, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[SX]: ...
@overload
def horzsplit(v: _MX, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[MX]: ...
@overload
def horzsplit_n(v: Sparsity, n: int) -> list[Sparsity]: ...
@overload
def horzsplit_n(v: _DM, n: int) -> list[DM]: ...
@overload
def horzsplit_n(v: _SX, n: int) -> list[SX]: ...
@overload
def horzsplit_n(v: _MX, n: int) -> list[MX]: ...
@overload
def offset(v: Sequence[Sparsity], vert: bool = ...) -> list[int]: ...
@overload
def offset(v: Sequence[_DM], vert: bool = ...) -> list[int]: ...
@overload
def offset(v: Sequence[_SX], vert: bool = ...) -> list[int]: ...
@overload
def offset(v: Sequence[_MX], vert: bool = ...) -> list[int]: ...
@overload
def vertsplit(v: Sparsity, incr: int = ...) -> list[Sparsity]: ...
@overload
def vertsplit(v: _DM, incr: int = ...) -> list[DM]: ...
@overload
def vertsplit(v: _SX, incr: int = ...) -> list[SX]: ...
@overload
def vertsplit(v: _MX, incr: int = ...) -> list[MX]: ...
@overload
def vertsplit(v: Sparsity, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[Sparsity]: ...
@overload
def vertsplit(v: _DM, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[DM]: ...
@overload
def vertsplit(v: _SX, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[SX]: ...
@overload
def vertsplit(v: _MX, offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[MX]: ...
@overload
def vertsplit_n(v: Sparsity, n: int) -> list[Sparsity]: ...
@overload
def vertsplit_n(v: _DM, n: int) -> list[DM]: ...
@overload
def vertsplit_n(v: _SX, n: int) -> list[SX]: ...
@overload
def vertsplit_n(v: _MX, n: int) -> list[MX]: ...
@overload
def blocksplit(x: Sparsity, vert_incr: int = ..., horz_incr: int = ...) -> list[list[Sparsity]]: ...
@overload
def blocksplit(x: _DM, vert_incr: int = ..., horz_incr: int = ...) -> list[list[DM]]: ...
@overload
def blocksplit(x: _SX, vert_incr: int = ..., horz_incr: int = ...) -> list[list[SX]]: ...
@overload
def blocksplit(x: _MX, vert_incr: int = ..., horz_incr: int = ...) -> list[list[MX]]: ...
@overload
def blocksplit(x: Sparsity, vert_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], horz_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[list[Sparsity]]: ...
@overload
def blocksplit(x: _DM, vert_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], horz_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[list[DM]]: ...
@overload
def blocksplit(x: _SX, vert_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], horz_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[list[SX]]: ...
@overload
def blocksplit(x: _MX, vert_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], horz_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[list[MX]]: ...
@overload
def _diagcat(A: Sequence[Sparsity]) -> Sparsity: ...
@overload
def _diagcat(A: Sequence[_DM]) -> DM: ...
@overload
def _diagcat(A: Sequence[_SX]) -> SX: ...
@overload
def _diagcat(A: Sequence[_MX]) -> MX: ...
@overload
def diagsplit(x: Sparsity, incr: int = ...) -> list[Sparsity]: ...
@overload
def diagsplit(x: _DM, incr: int = ...) -> list[DM]: ...
@overload
def diagsplit(x: _SX, incr: int = ...) -> list[SX]: ...
@overload
def diagsplit(x: _MX, incr: int = ...) -> list[MX]: ...
@overload
def diagsplit(x: Sparsity, output_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[Sparsity]: ...
@overload
def diagsplit(x: _DM, output_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[DM]: ...
@overload
def diagsplit(x: _SX, output_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[SX]: ...
@overload
def diagsplit(x: _MX, output_offset: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[MX]: ...
@overload
def diagsplit(x: Sparsity, incr1: int, incr2: int) -> list[Sparsity]: ...
@overload
def diagsplit(x: Sparsity, output_offset1: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], output_offset2: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[Sparsity]: ...
@overload
def diagsplit(x: _DM, incr1: int, incr2: int) -> list[DM]: ...
@overload
def diagsplit(x: _DM, output_offset1: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], output_offset2: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[DM]: ...
@overload
def diagsplit(x: _SX, incr1: int, incr2: int) -> list[SX]: ...
@overload
def diagsplit(x: _SX, output_offset1: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], output_offset2: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[SX]: ...
@overload
def diagsplit(x: _MX, incr1: int, incr2: int) -> list[MX]: ...
@overload
def diagsplit(x: _MX, output_offset1: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], output_offset2: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> list[MX]: ...
@overload
def _veccat(x: Sequence[Sparsity]) -> Sparsity: ...
@overload
def _veccat(x: Sequence[_DM]) -> DM: ...
@overload
def _veccat(x: Sequence[_SX]) -> SX: ...
@overload
def _veccat(x: Sequence[_MX]) -> MX: ...
@overload
def mtimes(args: Sequence[Sparsity]) -> Sparsity: ...
@overload
def mtimes(args: Sequence[_DM]) -> DM: ...
@overload
def mtimes(args: Sequence[_SX]) -> SX: ...
@overload
def mtimes(args: Sequence[_MX]) -> MX: ...
@overload
def mtimes(x: Sparsity, y: Sparsity) -> Sparsity: ...
@overload
def mtimes(x: _DM, y: _DM) -> DM: ...
@overload
def mtimes(x: _SX, y: _SX) -> SX: ...
@overload
def mtimes(x: _MX, y: _MX) -> MX: ...
@overload
def mac(X: Sparsity, Y: Sparsity, Z: Sparsity) -> Sparsity: ...
@overload
def mac(X: _DM, Y: _DM, Z: _DM) -> DM: ...
@overload
def mac(X: _SX, Y: _SX, Z: _SX) -> SX: ...
@overload
def mac(X: _MX, Y: _MX, Z: _MX) -> MX: ...
@overload
def transpose(X: Sparsity) -> Sparsity: ...
@overload
def transpose(X: _DM) -> DM: ...
@overload
def transpose(X: _SX) -> SX: ...
@overload
def transpose(X: _MX) -> MX: ...
@overload
def vec(a: Sparsity) -> Sparsity: ...
@overload
def vec(a: _DM) -> DM: ...
@overload
def vec(a: _SX) -> SX: ...
@overload
def vec(a: _MX) -> MX: ...
@overload
def reshape(a: Sparsity, rc: tuple[int, int]) -> Sparsity: ...
@overload
def reshape(a: Sparsity, sp: Sparsity) -> Sparsity: ...
@overload
def reshape(a: _DM, rc: tuple[int, int]) -> DM: ...
@overload
def reshape(a: _DM, sp: Sparsity) -> DM: ...
@overload
def reshape(a: _SX, rc: tuple[int, int]) -> SX: ...
@overload
def reshape(a: _SX, sp: Sparsity) -> SX: ...
@overload
def reshape(a: _MX, rc: tuple[int, int]) -> MX: ...
@overload
def reshape(a: _MX, sp: Sparsity) -> MX: ...
@overload
def reshape(a: Sparsity, nrow: int, ncol: int) -> Sparsity: ...
@overload
def reshape(a: _DM, nrow: int, ncol: int) -> DM: ...
@overload
def reshape(a: _SX, nrow: int, ncol: int) -> SX: ...
@overload
def reshape(a: _MX, nrow: int, ncol: int) -> MX: ...
@overload
def sparsity_cast(a: Sparsity, sp: Sparsity) -> Sparsity: ...
@overload
def sparsity_cast(a: _DM, sp: Sparsity) -> DM: ...
@overload
def sparsity_cast(a: _SX, sp: Sparsity) -> SX: ...
@overload
def sparsity_cast(a: _MX, sp: Sparsity) -> MX: ...
@overload
def sprank(A: Sparsity) -> int: ...
@overload
def sprank(A: _DM) -> int: ...
@overload
def sprank(A: _SX) -> int: ...
@overload
def sprank(A: _MX) -> int: ...
@overload
def norm_0_mul(x: Sparsity, y: Sparsity) -> int: ...
@overload
def norm_0_mul(x: _DM, y: _DM) -> int: ...
@overload
def norm_0_mul(x: _SX, y: _SX) -> int: ...
@overload
def norm_0_mul(x: _MX, y: _MX) -> int: ...
@overload
def triu(a: Sparsity, includeDiagonal: bool = ...) -> Sparsity: ...
@overload
def triu(a: _DM, includeDiagonal: bool = ...) -> DM: ...
@overload
def triu(a: _SX, includeDiagonal: bool = ...) -> SX: ...
@overload
def triu(a: _MX, includeDiagonal: bool = ...) -> MX: ...
@overload
def tril(a: Sparsity, includeDiagonal: bool = ...) -> Sparsity: ...
@overload
def tril(a: _DM, includeDiagonal: bool = ...) -> DM: ...
@overload
def tril(a: _SX, includeDiagonal: bool = ...) -> SX: ...
@overload
def tril(a: _MX, includeDiagonal: bool = ...) -> MX: ...
@overload
def kron(a: Sparsity, b: Sparsity) -> Sparsity: ...
@overload
def kron(a: _DM, b: _DM) -> DM: ...
@overload
def kron(a: _SX, b: _SX) -> SX: ...
@overload
def kron(a: _MX, b: _MX) -> MX: ...
@overload
def repmat(A: Sparsity, n: int, m: int = ...) -> Sparsity: ...
@overload
def repmat(A: Sparsity, rc: tuple[int, int]) -> Sparsity: ...
@overload
def repmat(A: _DM, n: int, m: int = ...) -> DM: ...
@overload
def repmat(A: _DM, rc: tuple[int, int]) -> DM: ...
@overload
def repmat(A: _SX, n: int, m: int = ...) -> SX: ...
@overload
def repmat(A: _SX, rc: tuple[int, int]) -> SX: ...
@overload
def repmat(A: _MX, n: int, m: int = ...) -> MX: ...
@overload
def repmat(A: _MX, rc: tuple[int, int]) -> MX: ...
@overload
def sum2(x: Sparsity) -> Sparsity: ...
@overload
def sum2(x: _DM) -> DM: ...
@overload
def sum2(x: _SX) -> SX: ...
@overload
def sum2(x: _MX) -> MX: ...
@overload
def sum1(x: Sparsity) -> Sparsity: ...
@overload
def sum1(x: _DM) -> DM: ...
@overload
def sum1(x: _SX) -> SX: ...
@overload
def sum1(x: _MX) -> MX: ...
@overload
def sum(x: Sparsity) -> Sparsity: ...
@overload
def sum(x: _DM) -> DM: ...
@overload
def sum(x: _SX) -> SX: ...
@overload
def sum(x: _MX) -> MX: ...
@overload
def sum(x: Sparsity, dim: int) -> Sparsity: ...
@overload
def sum(x: _DM, dim: int) -> DM: ...
@overload
def sum(x: _SX, dim: int) -> SX: ...
@overload
def sum(x: _MX, dim: int) -> MX: ...
@overload
def plus(x: float, y: float) -> float: ...
@overload
def plus(x: _DM, y: _DM) -> DM: ...
@overload
def plus(x: _SX, y: _SX) -> SX: ...
@overload
def plus(x: _MX, y: _MX) -> MX: ...
@overload
def minus(x: float, y: float) -> float: ...
@overload
def minus(x: _DM, y: _DM) -> DM: ...
@overload
def minus(x: _SX, y: _SX) -> SX: ...
@overload
def minus(x: _MX, y: _MX) -> MX: ...
@overload
def times(x: float, y: float) -> float: ...
@overload
def times(x: _DM, y: _DM) -> DM: ...
@overload
def times(x: _SX, y: _SX) -> SX: ...
@overload
def times(x: _MX, y: _MX) -> MX: ...
@overload
def rdivide(x: float, y: float) -> float: ...
@overload
def rdivide(x: _DM, y: _DM) -> DM: ...
@overload
def rdivide(x: _SX, y: _SX) -> SX: ...
@overload
def rdivide(x: _MX, y: _MX) -> MX: ...
@overload
def ldivide(x: float, y: float) -> float: ...
@overload
def ldivide(x: _DM, y: _DM) -> DM: ...
@overload
def ldivide(x: _SX, y: _SX) -> SX: ...
@overload
def ldivide(x: _MX, y: _MX) -> MX: ...
@overload
def lt(x: float, y: float) -> float: ...
@overload
def lt(x: _DM, y: _DM) -> DM: ...
@overload
def lt(x: _SX, y: _SX) -> SX: ...
@overload
def lt(x: _MX, y: _MX) -> MX: ...
@overload
def le(x: float, y: float) -> float: ...
@overload
def le(x: _DM, y: _DM) -> DM: ...
@overload
def le(x: _SX, y: _SX) -> SX: ...
@overload
def le(x: _MX, y: _MX) -> MX: ...
@overload
def gt(x: float, y: float) -> float: ...
@overload
def gt(x: _DM, y: _DM) -> DM: ...
@overload
def gt(x: _SX, y: _SX) -> SX: ...
@overload
def gt(x: _MX, y: _MX) -> MX: ...
@overload
def ge(x: float, y: float) -> float: ...
@overload
def ge(x: _DM, y: _DM) -> DM: ...
@overload
def ge(x: _SX, y: _SX) -> SX: ...
@overload
def ge(x: _MX, y: _MX) -> MX: ...
@overload
def eq(x: float, y: float) -> float: ...
@overload
def eq(x: _DM, y: _DM) -> DM: ...
@overload
def eq(x: _SX, y: _SX) -> SX: ...
@overload
def eq(x: _MX, y: _MX) -> MX: ...
@overload
def ne(x: float, y: float) -> float: ...
@overload
def ne(x: _DM, y: _DM) -> DM: ...
@overload
def ne(x: _SX, y: _SX) -> SX: ...
@overload
def ne(x: _MX, y: _MX) -> MX: ...
@overload
def logic_and(x: float, y: float) -> float: ...
@overload
def logic_and(x: _DM, y: _DM) -> DM: ...
@overload
def logic_and(x: _SX, y: _SX) -> SX: ...
@overload
def logic_and(x: _MX, y: _MX) -> MX: ...
@overload
def logic_or(x: float, y: float) -> float: ...
@overload
def logic_or(x: _DM, y: _DM) -> DM: ...
@overload
def logic_or(x: _SX, y: _SX) -> SX: ...
@overload
def logic_or(x: _MX, y: _MX) -> MX: ...
@overload
def logic_not(x: float) -> float: ...
@overload
def logic_not(x: _DM) -> DM: ...
@overload
def logic_not(x: _SX) -> SX: ...
@overload
def logic_not(x: _MX) -> MX: ...
@overload
def fabs(x: float) -> float: ...
@overload
def fabs(x: _DM) -> DM: ...
@overload
def fabs(x: _SX) -> SX: ...
@overload
def fabs(x: _MX) -> MX: ...
@overload
def sqrt(x: float) -> float: ...
@overload
def sqrt(x: _DM) -> DM: ...
@overload
def sqrt(x: _SX) -> SX: ...
@overload
def sqrt(x: _MX) -> MX: ...
@overload
def sin(x: float) -> float: ...
@overload
def sin(x: _DM) -> DM: ...
@overload
def sin(x: _SX) -> SX: ...
@overload
def sin(x: _MX) -> MX: ...
@overload
def cos(x: float) -> float: ...
@overload
def cos(x: _DM) -> DM: ...
@overload
def cos(x: _SX) -> SX: ...
@overload
def cos(x: _MX) -> MX: ...
@overload
def tan(x: float) -> float: ...
@overload
def tan(x: _DM) -> DM: ...
@overload
def tan(x: _SX) -> SX: ...
@overload
def tan(x: _MX) -> MX: ...
@overload
def atan(x: float) -> float: ...
@overload
def atan(x: _DM) -> DM: ...
@overload
def atan(x: _SX) -> SX: ...
@overload
def atan(x: _MX) -> MX: ...
@overload
def asin(x: float) -> float: ...
@overload
def asin(x: _DM) -> DM: ...
@overload
def asin(x: _SX) -> SX: ...
@overload
def asin(x: _MX) -> MX: ...
@overload
def acos(x: float) -> float: ...
@overload
def acos(x: _DM) -> DM: ...
@overload
def acos(x: _SX) -> SX: ...
@overload
def acos(x: _MX) -> MX: ...
@overload
def tanh(x: float) -> float: ...
@overload
def tanh(x: _DM) -> DM: ...
@overload
def tanh(x: _SX) -> SX: ...
@overload
def tanh(x: _MX) -> MX: ...
@overload
def sinh(x: float) -> float: ...
@overload
def sinh(x: _DM) -> DM: ...
@overload
def sinh(x: _SX) -> SX: ...
@overload
def sinh(x: _MX) -> MX: ...
@overload
def cosh(x: float) -> float: ...
@overload
def cosh(x: _DM) -> DM: ...
@overload
def cosh(x: _SX) -> SX: ...
@overload
def cosh(x: _MX) -> MX: ...
@overload
def atanh(x: float) -> float: ...
@overload
def atanh(x: _DM) -> DM: ...
@overload
def atanh(x: _SX) -> SX: ...
@overload
def atanh(x: _MX) -> MX: ...
@overload
def asinh(x: float) -> float: ...
@overload
def asinh(x: _DM) -> DM: ...
@overload
def asinh(x: _SX) -> SX: ...
@overload
def asinh(x: _MX) -> MX: ...
@overload
def acosh(x: float) -> float: ...
@overload
def acosh(x: _DM) -> DM: ...
@overload
def acosh(x: _SX) -> SX: ...
@overload
def acosh(x: _MX) -> MX: ...
@overload
def exp(x: float) -> float: ...
@overload
def exp(x: _DM) -> DM: ...
@overload
def exp(x: _SX) -> SX: ...
@overload
def exp(x: _MX) -> MX: ...
@overload
def log(x: float) -> float: ...
@overload
def log(x: _DM) -> DM: ...
@overload
def log(x: _SX) -> SX: ...
@overload
def log(x: _MX) -> MX: ...
@overload
def log10(x: float) -> float: ...
@overload
def log10(x: _DM) -> DM: ...
@overload
def log10(x: _SX) -> SX: ...
@overload
def log10(x: _MX) -> MX: ...
@overload
def log1p(x: float) -> float: ...
@overload
def log1p(x: _DM) -> DM: ...
@overload
def log1p(x: _SX) -> SX: ...
@overload
def log1p(x: _MX) -> MX: ...
@overload
def expm1(x: float) -> float: ...
@overload
def expm1(x: _DM) -> DM: ...
@overload
def expm1(x: _SX) -> SX: ...
@overload
def expm1(x: _MX) -> MX: ...
@overload
def floor(x: float) -> float: ...
@overload
def floor(x: _DM) -> DM: ...
@overload
def floor(x: _SX) -> SX: ...
@overload
def floor(x: _MX) -> MX: ...
@overload
def ceil(x: float) -> float: ...
@overload
def ceil(x: _DM) -> DM: ...
@overload
def ceil(x: _SX) -> SX: ...
@overload
def ceil(x: _MX) -> MX: ...
@overload
def erf(x: float) -> float: ...
@overload
def erf(x: _DM) -> DM: ...
@overload
def erf(x: _SX) -> SX: ...
@overload
def erf(x: _MX) -> MX: ...
@overload
def erfinv(x: float) -> float: ...
@overload
def erfinv(x: _DM) -> DM: ...
@overload
def erfinv(x: _SX) -> SX: ...
@overload
def erfinv(x: _MX) -> MX: ...
@overload
def sign(x: float) -> float: ...
@overload
def sign(x: _DM) -> DM: ...
@overload
def sign(x: _SX) -> SX: ...
@overload
def sign(x: _MX) -> MX: ...
@overload
def power(x: float, n: float) -> float: ...
@overload
def power(x: _DM, n: _DM) -> DM: ...
@overload
def power(x: _SX, n: _SX) -> SX: ...
@overload
def power(x: _MX, n: _MX) -> MX: ...
@overload
def fmod(x: float, y: float) -> float: ...
@overload
def fmod(x: _DM, y: _DM) -> DM: ...
@overload
def fmod(x: _SX, y: _SX) -> SX: ...
@overload
def fmod(x: _MX, y: _MX) -> MX: ...
@overload
def remainder(x: float, y: float) -> float: ...
@overload
def remainder(x: _DM, y: _DM) -> DM: ...
@overload
def remainder(x: _SX, y: _SX) -> SX: ...
@overload
def remainder(x: _MX, y: _MX) -> MX: ...
@overload
def atan2(x: float, y: float) -> float: ...
@overload
def atan2(x: _DM, y: _DM) -> DM: ...
@overload
def atan2(x: _SX, y: _SX) -> SX: ...
@overload
def atan2(x: _MX, y: _MX) -> MX: ...
@overload
def fmin(x: float, y: float) -> float: ...
@overload
def fmin(x: _DM, y: _DM) -> DM: ...
@overload
def fmin(x: _SX, y: _SX) -> SX: ...
@overload
def fmin(x: _MX, y: _MX) -> MX: ...
@overload
def fmax(x: float, y: float) -> float: ...
@overload
def fmax(x: _DM, y: _DM) -> DM: ...
@overload
def fmax(x: _SX, y: _SX) -> SX: ...
@overload
def fmax(x: _MX, y: _MX) -> MX: ...
@overload
def hypot(x: float, y: float) -> float: ...
@overload
def hypot(x: _DM, y: _DM) -> DM: ...
@overload
def hypot(x: _SX, y: _SX) -> SX: ...
@overload
def hypot(x: _MX, y: _MX) -> MX: ...
@overload
def simplify(x: float) -> float: ...
@overload
def simplify(x: _DM) -> DM: ...
@overload
def simplify(x: _SX) -> SX: ...
@overload
def simplify(x: _MX) -> MX: ...
@overload
def is_equal(x: float, y: float, depth: int = ...) -> bool: ...
@overload
def is_equal(x: _DM, y: _DM, depth: int = ...) -> bool: ...
@overload
def is_equal(x: _SX, y: _SX, depth: int = ...) -> bool: ...
@overload
def is_equal(x: _MX, y: _MX, depth: int = ...) -> bool: ...
@overload
def copysign(x: float, y: float) -> float: ...
@overload
def copysign(x: _DM, y: _DM) -> DM: ...
@overload
def copysign(x: _SX, y: _SX) -> SX: ...
@overload
def copysign(x: _MX, y: _MX) -> MX: ...
@overload
def constpow(x: float, y: float) -> float: ...
@overload
def constpow(x: _DM, y: _DM) -> DM: ...
@overload
def constpow(x: _SX, y: _SX) -> SX: ...
@overload
def constpow(x: _MX, y: _MX) -> MX: ...
@overload
def mpower(x: _DM, n: _DM) -> DM: ...
@overload
def mpower(x: _SX, n: _SX) -> SX: ...
@overload
def mpower(x: _MX, n: _MX) -> MX: ...
@overload
def mrdivide(x: _DM, y: _DM) -> DM: ...
@overload
def mrdivide(x: _SX, y: _SX) -> SX: ...
@overload
def mrdivide(x: _MX, y: _MX) -> MX: ...
@overload
def mldivide(x: _DM, y: _DM) -> DM: ...
@overload
def mldivide(x: _SX, y: _SX) -> SX: ...
@overload
def mldivide(x: _MX, y: _MX) -> MX: ...
@overload
def symvar(x: _DM) -> list[DM]: ...
@overload
def symvar(x: _SX) -> list[SX]: ...
@overload
def symvar(x: _MX) -> list[MX]: ...
@overload
def bilin(A: _DM, x: _DM) -> DM: ...
@overload
def bilin(A: _SX, x: _SX) -> SX: ...
@overload
def bilin(A: _MX, x: _MX) -> MX: ...
@overload
def bilin(A: _DM, x: _DM, y: _DM) -> DM: ...
@overload
def bilin(A: _SX, x: _SX, y: _SX) -> SX: ...
@overload
def bilin(A: _MX, x: _MX, y: _MX) -> MX: ...
@overload
def rank1(A: _DM, alpha: _DM, x: _DM, y: _DM) -> DM: ...
@overload
def rank1(A: _SX, alpha: _SX, x: _SX, y: _SX) -> SX: ...
@overload
def rank1(A: _MX, alpha: _MX, x: _MX, y: _MX) -> MX: ...
@overload
def sumsqr(X: _DM) -> DM: ...
@overload
def sumsqr(X: _SX) -> SX: ...
@overload
def sumsqr(X: _MX) -> MX: ...
@overload
def linspace(a: _DM, b: _DM, nsteps: int) -> DM: ...
@overload
def linspace(a: _SX, b: _SX, nsteps: int) -> SX: ...
@overload
def linspace(a: _MX, b: _MX, nsteps: int) -> MX: ...
@overload
def logsumexp(a: _DM) -> DM: ...
@overload
def logsumexp(a: _SX) -> SX: ...
@overload
def logsumexp(a: _MX) -> MX: ...
@overload
def logsumexp(a: _DM, margin: _DM) -> DM: ...
@overload
def logsumexp(a: _SX, margin: _SX) -> SX: ...
@overload
def logsumexp(a: _MX, margin: _MX) -> MX: ...
@overload
def interp1d(x: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], v: _DM, xq: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], mode: str = ..., equidistant: bool = ...) -> DM: ...
@overload
def interp1d(x: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], v: _SX, xq: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], mode: str = ..., equidistant: bool = ...) -> SX: ...
@overload
def interp1d(x: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], v: _MX, xq: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_], mode: str = ..., equidistant: bool = ...) -> MX: ...
@overload
def soc(x: _DM, y: _DM) -> DM: ...
@overload
def soc(x: _SX, y: _SX) -> SX: ...
@overload
def soc(x: _MX, y: _MX) -> MX: ...
@overload
def cross(a: _DM, b: _DM, dim: int = ...) -> DM: ...
@overload
def cross(a: _SX, b: _SX, dim: int = ...) -> SX: ...
@overload
def cross(a: _MX, b: _MX, dim: int = ...) -> MX: ...
@overload
def skew(a: _DM) -> DM: ...
@overload
def skew(a: _SX) -> SX: ...
@overload
def skew(a: _MX) -> MX: ...
@overload
def inv_skew(a: _DM) -> DM: ...
@overload
def inv_skew(a: _SX) -> SX: ...
@overload
def inv_skew(a: _MX) -> MX: ...
@overload
def det(A: _DM) -> DM: ...
@overload
def det(A: _SX) -> SX: ...
@overload
def det(A: _MX) -> MX: ...
@overload
def inv_minor(A: _DM) -> DM: ...
@overload
def inv_minor(A: _SX) -> SX: ...
@overload
def inv_minor(A: _MX) -> MX: ...
@overload
def inv(A: _DM) -> DM: ...
@overload
def inv(A: _SX) -> SX: ...
@overload
def inv(A: _MX) -> MX: ...
@overload
def inv(A: _DM, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> DM: ...
@overload
def inv(A: _SX, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> SX: ...
@overload
def inv(A: _MX, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def trace(a: _DM) -> DM: ...
@overload
def trace(a: _SX) -> SX: ...
@overload
def trace(a: _MX) -> MX: ...
@overload
def tril2symm(a: _DM) -> DM: ...
@overload
def tril2symm(a: _SX) -> SX: ...
@overload
def tril2symm(a: _MX) -> MX: ...
@overload
def triu2symm(a: _DM) -> DM: ...
@overload
def triu2symm(a: _SX) -> SX: ...
@overload
def triu2symm(a: _MX) -> MX: ...
@overload
def norm_fro(x: _DM) -> DM: ...
@overload
def norm_fro(x: _SX) -> SX: ...
@overload
def norm_fro(x: _MX) -> MX: ...
@overload
def norm_2(x: _DM) -> DM: ...
@overload
def norm_2(x: _SX) -> SX: ...
@overload
def norm_2(x: _MX) -> MX: ...
@overload
def norm_1(x: _DM) -> DM: ...
@overload
def norm_1(x: _SX) -> SX: ...
@overload
def norm_1(x: _MX) -> MX: ...
@overload
def norm_inf(x: _DM) -> DM: ...
@overload
def norm_inf(x: _SX) -> SX: ...
@overload
def norm_inf(x: _MX) -> MX: ...
@overload
def dot(x: _DM, y: _DM) -> DM: ...
@overload
def dot(x: _SX, y: _SX) -> SX: ...
@overload
def dot(x: _MX, y: _MX) -> MX: ...
@overload
def nullspace(A: _DM) -> DM: ...
@overload
def nullspace(A: _SX) -> SX: ...
@overload
def nullspace(A: _MX) -> MX: ...
@overload
def polyval(p: _DM, x: _DM) -> DM: ...
@overload
def polyval(p: _SX, x: _SX) -> SX: ...
@overload
def polyval(p: _MX, x: _MX) -> MX: ...
@overload
def diag(A: _DM) -> DM: ...
@overload
def diag(A: _SX) -> SX: ...
@overload
def diag(A: _MX) -> MX: ...
@overload
def unite(A: _DM, B: _DM) -> DM: ...
@overload
def unite(A: _SX, B: _SX) -> SX: ...
@overload
def unite(A: _MX, B: _MX) -> MX: ...
@overload
def densify(x: _DM) -> DM: ...
@overload
def densify(x: _SX) -> SX: ...
@overload
def densify(x: _MX) -> MX: ...
@overload
def project(A: _DM, sp: Sparsity, intersect: bool = ...) -> DM: ...
@overload
def project(A: _SX, sp: Sparsity, intersect: bool = ...) -> SX: ...
@overload
def project(A: _MX, sp: Sparsity, intersect: bool = ...) -> MX: ...
@overload
def if_else(cond: _DM, if_true: _DM, if_false: _DM, short_circuit: bool = ...) -> DM: ...
@overload
def if_else(cond: _SX, if_true: _SX, if_false: _SX, short_circuit: bool = ...) -> SX: ...
@overload
def if_else(cond: _MX, if_true: _MX, if_false: _MX, short_circuit: bool = ...) -> MX: ...
@overload
def conditional(ind: _DM, x: Sequence[_DM], x_default: _DM, short_circuit: bool = ...) -> DM: ...
@overload
def conditional(ind: _SX, x: Sequence[_SX], x_default: _SX, short_circuit: bool = ...) -> SX: ...
@overload
def conditional(ind: _MX, x: Sequence[_MX], x_default: _MX, short_circuit: bool = ...) -> MX: ...
@overload
def depends_on(f: _DM, arg: _DM) -> bool: ...
@overload
def depends_on(f: _SX, arg: _SX) -> bool: ...
@overload
def depends_on(f: _MX, arg: _MX) -> bool: ...
@overload
def contains(v: Sequence[_DM], n: _DM) -> bool: ...
@overload
def contains(v: Sequence[_SX], n: _SX) -> bool: ...
@overload
def contains(v: Sequence[_MX], n: _MX) -> bool: ...
@overload
def contains_all(v: Sequence[_DM], n: Sequence[_DM]) -> bool: ...
@overload
def contains_all(v: Sequence[_SX], n: Sequence[_SX]) -> bool: ...
@overload
def contains_all(v: Sequence[_MX], n: Sequence[_MX]) -> bool: ...
@overload
def contains_any(v: Sequence[_DM], n: Sequence[_DM]) -> bool: ...
@overload
def contains_any(v: Sequence[_SX], n: Sequence[_SX]) -> bool: ...
@overload
def contains_any(v: Sequence[_MX], n: Sequence[_MX]) -> bool: ...
@overload
def solve(A: _DM, b: _DM) -> DM: ...
@overload
def solve(A: _SX, b: _SX) -> SX: ...
@overload
def solve(A: _MX, b: _MX) -> MX: ...
@overload
def solve(A: _DM, b: _DM, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> DM: ...
@overload
def solve(A: _SX, b: _SX, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> SX: ...
@overload
def solve(A: _MX, b: _MX, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def pinv(A: _DM) -> DM: ...
@overload
def pinv(A: _SX) -> SX: ...
@overload
def pinv(A: _MX) -> MX: ...
@overload
def pinv(A: _DM, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> DM: ...
@overload
def pinv(A: _SX, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> SX: ...
@overload
def pinv(A: _MX, lsolver: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def expm_const(A: _DM, t: _DM) -> DM: ...
@overload
def expm_const(A: _SX, t: _SX) -> SX: ...
@overload
def expm_const(A: _MX, t: _MX) -> MX: ...
@overload
def expm(A: _DM) -> DM: ...
@overload
def expm(A: _SX) -> SX: ...
@overload
def expm(A: _MX) -> MX: ...
@overload
def jacobian(ex: _DM, arg: _DM, opts: Mapping[str, _GenericType] = ...) -> DM: ...
@overload
def jacobian(ex: _SX, arg: _SX, opts: Mapping[str, _GenericType] = ...) -> SX: ...
@overload
def jacobian(ex: _MX, arg: _MX, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def jtimes(ex: _DM, arg: _DM, v: _DM, tr: bool = ..., opts: Mapping[str, _GenericType] = ...) -> DM: ...
@overload
def jtimes(ex: _SX, arg: _SX, v: _SX, tr: bool = ..., opts: Mapping[str, _GenericType] = ...) -> SX: ...
@overload
def jtimes(ex: _MX, arg: _MX, v: _MX, tr: bool = ..., opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def linearize(f: _DM, x: _DM, x0: _DM) -> DM: ...
@overload
def linearize(f: _SX, x: _SX, x0: _SX) -> SX: ...
@overload
def linearize(f: _MX, x: _MX, x0: _MX) -> MX: ...
@overload
def which_depends(expr: _DM, var: _DM, order: int = ..., tr: bool = ...) -> list[bool]: ...
@overload
def which_depends(expr: _SX, var: _SX, order: int = ..., tr: bool = ...) -> list[bool]: ...
@overload
def which_depends(expr: _MX, var: _MX, order: int = ..., tr: bool = ...) -> list[bool]: ...
@overload
def jacobian_sparsity(f: _DM, x: _DM) -> Sparsity: ...
@overload
def jacobian_sparsity(f: _SX, x: _SX) -> Sparsity: ...
@overload
def jacobian_sparsity(f: _MX, x: _MX) -> Sparsity: ...
@overload
def is_linear(expr: _DM, var: _DM) -> bool: ...
@overload
def is_linear(expr: _SX, var: _SX) -> bool: ...
@overload
def is_linear(expr: _MX, var: _MX) -> bool: ...
@overload
def is_quadratic(expr: _DM, var: _DM) -> bool: ...
@overload
def is_quadratic(expr: _SX, var: _SX) -> bool: ...
@overload
def is_quadratic(expr: _MX, var: _MX) -> bool: ...
@overload
def gradient(ex: _DM, arg: _DM, opts: Mapping[str, _GenericType] = ...) -> DM: ...
@overload
def gradient(ex: _SX, arg: _SX, opts: Mapping[str, _GenericType] = ...) -> SX: ...
@overload
def gradient(ex: _MX, arg: _MX, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def tangent(ex: _DM, arg: _DM, opts: Mapping[str, _GenericType] = ...) -> DM: ...
@overload
def tangent(ex: _SX, arg: _SX, opts: Mapping[str, _GenericType] = ...) -> SX: ...
@overload
def tangent(ex: _MX, arg: _MX, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def hessian(ex: _DM, arg: _DM, opts: Mapping[str, _GenericType] = ...) -> tuple[DM, DM]: ...
@overload
def hessian(ex: _SX, arg: _SX, opts: Mapping[str, _GenericType] = ...) -> tuple[SX, SX]: ...
@overload
def hessian(ex: _MX, arg: _MX, opts: Mapping[str, _GenericType] = ...) -> tuple[MX, MX]: ...
@overload
def quadratic_coeff(ex: _DM, arg: _DM, check: bool = ...) -> tuple[DM, DM, DM]: ...
@overload
def quadratic_coeff(ex: _SX, arg: _SX, check: bool = ...) -> tuple[SX, SX, SX]: ...
@overload
def quadratic_coeff(ex: _MX, arg: _MX, check: bool = ...) -> tuple[MX, MX, MX]: ...
@overload
def linear_coeff(ex: _DM, arg: _DM, check: bool = ...) -> tuple[DM, DM]: ...
@overload
def linear_coeff(ex: _SX, arg: _SX, check: bool = ...) -> tuple[SX, SX]: ...
@overload
def linear_coeff(ex: _MX, arg: _MX, check: bool = ...) -> tuple[MX, MX]: ...
@overload
def n_nodes(A: _DM) -> int: ...
@overload
def n_nodes(A: _SX) -> int: ...
@overload
def n_nodes(A: _MX) -> int: ...
@overload
def print_operator(xb: _DM, args: Sequence[str]) -> str: ...
@overload
def print_operator(xb: _SX, args: Sequence[str]) -> str: ...
@overload
def print_operator(xb: _MX, args: Sequence[str]) -> str: ...
@overload
def repsum(A: _DM, n: int, m: int = ...) -> DM: ...
@overload
def repsum(A: _SX, n: int, m: int = ...) -> SX: ...
@overload
def repsum(A: _MX, n: int, m: int = ...) -> MX: ...
@overload
def diff(A: _DM, n: int = ..., axis: int = ...) -> DM: ...
@overload
def diff(A: _SX, n: int = ..., axis: int = ...) -> SX: ...
@overload
def diff(A: _MX, n: int = ..., axis: int = ...) -> MX: ...
@overload
def cumsum(A: _DM, axis: int = ...) -> DM: ...
@overload
def cumsum(A: _SX, axis: int = ...) -> SX: ...
@overload
def cumsum(A: _MX, axis: int = ...) -> MX: ...
@overload
def einstein(A: _DM, B: _DM, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> DM: ...
@overload
def einstein(A: _SX, B: _SX, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> SX: ...
@overload
def einstein(A: _MX, B: _MX, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> MX: ...
@overload
def einstein(A: _DM, B: _DM, C: _DM, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> DM: ...
@overload
def einstein(A: _SX, B: _SX, C: _SX, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> SX: ...
@overload
def einstein(A: _MX, B: _MX, C: _MX, dim_a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], dim_c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], a: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], b: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], c: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> MX: ...
@overload
def mmin(x: _DM) -> DM: ...
@overload
def mmin(x: _SX) -> SX: ...
@overload
def mmin(x: _MX) -> MX: ...
@overload
def mmax(x: _DM) -> DM: ...
@overload
def mmax(x: _SX) -> SX: ...
@overload
def mmax(x: _MX) -> MX: ...
@overload
def evalf(x: _DM) -> DM: ...
@overload
def evalf(x: _SX) -> DM: ...
@overload
def evalf(x: _MX) -> DM: ...
@overload
def separate_linear(expr: _DM, sym_lin: _DM, sym_const: _DM) -> tuple[DM, DM, DM]: ...
@overload
def separate_linear(expr: _DM, sym_lin: Sequence[_DM], sym_const: Sequence[_DM]) -> tuple[DM, DM, DM]: ...
@overload
def separate_linear(expr: _SX, sym_lin: _SX, sym_const: _SX) -> tuple[SX, SX, SX]: ...
@overload
def separate_linear(expr: _SX, sym_lin: Sequence[_SX], sym_const: Sequence[_SX]) -> tuple[SX, SX, SX]: ...
@overload
def separate_linear(expr: _MX, sym_lin: _MX, sym_const: _MX) -> tuple[MX, MX, MX]: ...
@overload
def separate_linear(expr: _MX, sym_lin: Sequence[_MX], sym_const: Sequence[_MX]) -> tuple[MX, MX, MX]: ...
@overload
def cse(e: _DM) -> DM: ...
@overload
def cse(e: Sequence[_DM]) -> list[DM]: ...
@overload
def cse(e: Sequence[_SX]) -> list[SX]: ...
@overload
def cse(e: _SX) -> SX: ...
@overload
def cse(e: _MX) -> MX: ...
@overload
def cse(e: Sequence[_MX]) -> list[MX]: ...
@overload
def extract_parametric(expr: _DM, par: _DM, opts: Mapping[str, _GenericType] = ...) -> tuple[DM, list[DM], list[DM]]: ...
@overload
def extract_parametric(expr: _DM, par: Sequence[_DM], opts: Mapping[str, _GenericType] = ...) -> tuple[DM, list[DM], list[DM]]: ...
@overload
def extract_parametric(expr: Sequence[_DM], par: _DM, opts: Mapping[str, _GenericType] = ...) -> tuple[list[DM], list[DM], list[DM]]: ...
@overload
def extract_parametric(expr: Sequence[_DM], par: Sequence[_DM], opts: Mapping[str, _GenericType] = ...) -> tuple[list[DM], list[DM], list[DM]]: ...
@overload
def extract_parametric(expr: _SX, par: _SX, opts: Mapping[str, _GenericType] = ...) -> tuple[SX, list[SX], list[SX]]: ...
@overload
def extract_parametric(expr: _SX, par: Sequence[_SX], opts: Mapping[str, _GenericType] = ...) -> tuple[SX, list[SX], list[SX]]: ...
@overload
def extract_parametric(expr: Sequence[_SX], par: _SX, opts: Mapping[str, _GenericType] = ...) -> tuple[list[SX], list[SX], list[SX]]: ...
@overload
def extract_parametric(expr: Sequence[_SX], par: Sequence[_SX], opts: Mapping[str, _GenericType] = ...) -> tuple[list[SX], list[SX], list[SX]]: ...
@overload
def extract_parametric(expr: _MX, par: _MX, opts: Mapping[str, _GenericType] = ...) -> tuple[MX, list[MX], list[MX]]: ...
@overload
def extract_parametric(expr: _MX, par: Sequence[_MX], opts: Mapping[str, _GenericType] = ...) -> tuple[MX, list[MX], list[MX]]: ...
@overload
def extract_parametric(expr: Sequence[_MX], par: _MX, opts: Mapping[str, _GenericType] = ...) -> tuple[list[MX], list[MX], list[MX]]: ...
@overload
def extract_parametric(expr: Sequence[_MX], par: Sequence[_MX], opts: Mapping[str, _GenericType] = ...) -> tuple[list[MX], list[MX], list[MX]]: ...
@overload
def forward(ex: Sequence[_DM], arg: Sequence[_DM], v: Sequence[Sequence[_DM]], opts: Mapping[str, _GenericType] = ...) -> list[list[DM]]: ...
@overload
def forward(ex: Sequence[_SX], arg: Sequence[_SX], v: Sequence[Sequence[_SX]], opts: Mapping[str, _GenericType] = ...) -> list[list[SX]]: ...
@overload
def forward(ex: Sequence[_MX], arg: Sequence[_MX], v: Sequence[Sequence[_MX]], opts: Mapping[str, _GenericType] = ...) -> list[list[MX]]: ...
@overload
def reverse(ex: Sequence[_DM], arg: Sequence[_DM], v: Sequence[Sequence[_DM]], opts: Mapping[str, _GenericType] = ...) -> list[list[DM]]: ...
@overload
def reverse(ex: Sequence[_SX], arg: Sequence[_SX], v: Sequence[Sequence[_SX]], opts: Mapping[str, _GenericType] = ...) -> list[list[SX]]: ...
@overload
def reverse(ex: Sequence[_MX], arg: Sequence[_MX], v: Sequence[Sequence[_MX]], opts: Mapping[str, _GenericType] = ...) -> list[list[MX]]: ...
@overload
def substitute(ex: _DM, v: _DM, vdef: _DM) -> DM: ...
@overload
def substitute(ex: Sequence[_DM], v: Sequence[_DM], vdef: Sequence[_DM]) -> list[DM]: ...
@overload
def substitute(ex: _SX, v: _SX, vdef: _SX) -> SX: ...
@overload
def substitute(ex: Sequence[_SX], v: Sequence[_SX], vdef: Sequence[_SX]) -> list[SX]: ...
@overload
def substitute(ex: _MX, v: _MX, vdef: _MX) -> MX: ...
@overload
def substitute(ex: Sequence[_MX], v: Sequence[_MX], vdef: Sequence[_MX]) -> list[MX]: ...
@overload
def substitute_inplace(v: Sequence[_DM], INOUT1: Sequence[_DM], INOUT2: Sequence[_DM], reverse: bool = ...) -> tuple[[DM], [DM]]: ...
@overload
def substitute_inplace(v: Sequence[_SX], INOUT1: Sequence[_SX], INOUT2: Sequence[_SX], reverse: bool = ...) -> tuple[[SX], [SX]]: ...
@overload
def substitute_inplace(v: Sequence[_MX], INOUT1: Sequence[_MX], INOUT2: Sequence[_MX], reverse: bool = ...) -> tuple[[MX], [MX]]: ...
@overload
def extract(ex: Sequence[_DM], opts: Mapping[str, _GenericType] = ...) -> tuple[list[DM], list[DM], list[DM]]: ...
@overload
def extract(ex: Sequence[_SX], opts: Mapping[str, _GenericType] = ...) -> tuple[list[SX], list[SX], list[SX]]: ...
@overload
def extract(ex: Sequence[_MX], opts: Mapping[str, _GenericType] = ...) -> tuple[list[MX], list[MX], list[MX]]: ...
@overload
def shared(ex: Sequence[_DM], v_prefix: str = ..., v_suffix: str = ...) -> tuple[list[DM], list[DM], list[DM]]: ...
@overload
def shared(ex: Sequence[_SX], v_prefix: str = ..., v_suffix: str = ...) -> tuple[list[SX], list[SX], list[SX]]: ...
@overload
def shared(ex: Sequence[_MX], v_prefix: str = ..., v_suffix: str = ...) -> tuple[list[MX], list[MX], list[MX]]: ...
@overload
def blockcat(v: Sequence[Sequence[_DM]]) -> DM: ...
@overload
def blockcat(v: Sequence[Sequence[_SX]]) -> SX: ...
@overload
def blockcat(v: Sequence[Sequence[_MX]]) -> MX: ...
@overload
def blockcat(A: Sparsity, B: Sparsity, C: Sparsity, D: Sparsity) -> Sparsity: ...
@overload
def blockcat(A: _DM, B: _DM, C: _DM, D: _DM) -> DM: ...
@overload
def blockcat(A: _SX, B: _SX, C: _SX, D: _SX) -> SX: ...
@overload
def blockcat(A: _MX, B: _MX, C: _MX, D: _MX) -> MX: ...
@overload
def logic_all(x: _DM) -> DM: ...
@overload
def logic_all(x: _SX) -> SX: ...
@overload
def logic_any(x: _DM) -> DM: ...
@overload
def logic_any(x: _SX) -> SX: ...
@overload
def adj(A: _DM) -> DM: ...
@overload
def adj(A: _SX) -> SX: ...
@overload
def minor(x: _DM, i: int, j: int) -> DM: ...
@overload
def minor(x: _SX, i: int, j: int) -> SX: ...
@overload
def cofactor(x: _DM, i: int, j: int) -> DM: ...
@overload
def cofactor(x: _SX, i: int, j: int) -> SX: ...
@overload
def qr(A: _DM) -> tuple[DM, DM]: ...
@overload
def qr(A: _SX) -> tuple[SX, SX]: ...
@overload
def qr_sparse(A: _DM, amd: bool = ...) -> tuple[DM, DM, DM, list[int], list[int]]: ...
@overload
def qr_sparse(A: _SX, amd: bool = ...) -> tuple[SX, SX, SX, list[int], list[int]]: ...
@overload
def qr_solve(b: _DM, v: _DM, r: _DM, beta: _DM, prinv: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], pc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], tr: bool = ...) -> DM: ...
@overload
def qr_solve(b: _SX, v: _SX, r: _SX, beta: _SX, prinv: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], pc: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], tr: bool = ...) -> SX: ...
@overload
def ldl(A: _DM, amd: bool = ...) -> tuple[DM, DM, list[int]]: ...
@overload
def ldl(A: _SX, amd: bool = ...) -> tuple[SX, SX, list[int]]: ...
@overload
def ldl_solve(b: _DM, D: _DM, LT: _DM, p: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> DM: ...
@overload
def ldl_solve(b: _SX, D: _SX, LT: _SX, p: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> SX: ...
@overload
def chol(A: _DM) -> DM: ...
@overload
def chol(A: _SX) -> SX: ...
@overload
def norm_inf_mul(x: _DM, y: _DM) -> DM: ...
@overload
def norm_inf_mul(x: _SX, y: _SX) -> SX: ...
@overload
def sparsify(A: _DM, tol: float = ...) -> DM: ...
@overload
def sparsify(A: _SX, tol: float = ...) -> SX: ...
@overload
def expand(ex: _DM) -> tuple[DM, DM]: ...
@overload
def expand(ex: _SX) -> tuple[SX, SX]: ...
@overload
def pw_const(t: _DM, tval: _DM, val: _DM) -> DM: ...
@overload
def pw_const(t: _SX, tval: _SX, val: _SX) -> SX: ...
@overload
def pw_lin(t: _DM, tval: _DM, val: _DM) -> DM: ...
@overload
def pw_lin(t: _SX, tval: _SX, val: _SX) -> SX: ...
@overload
def heaviside(x: _DM) -> DM: ...
@overload
def heaviside(x: _SX) -> SX: ...
@overload
def rectangle(x: _DM) -> DM: ...
@overload
def rectangle(x: _SX) -> SX: ...
@overload
def triangle(x: _DM) -> DM: ...
@overload
def triangle(x: _SX) -> SX: ...
@overload
def ramp(x: _DM) -> DM: ...
@overload
def ramp(x: _SX) -> SX: ...
@overload
def gauss_quadrature(f: _DM, x: _DM, a: _DM, b: _DM, order: int = ...) -> DM: ...
@overload
def gauss_quadrature(f: _SX, x: _SX, a: _SX, b: _SX, order: int = ...) -> SX: ...
@overload
def gauss_quadrature(f: _DM, x: _DM, a: _DM, b: _DM, order: int, w: _DM) -> DM: ...
@overload
def gauss_quadrature(f: _SX, x: _SX, a: _SX, b: _SX, order: int, w: _SX) -> SX: ...
@overload
def taylor(ex: _DM, x: _DM, a: _DM = ..., order: int = ...) -> DM: ...
@overload
def taylor(ex: _SX, x: _SX, a: _SX = ..., order: int = ...) -> SX: ...
@overload
def mtaylor(ex: _DM, x: _DM, a: _DM, order: int = ...) -> DM: ...
@overload
def mtaylor(ex: _SX, x: _SX, a: _SX, order: int = ...) -> SX: ...
@overload
def mtaylor(ex: _DM, x: _DM, a: _DM, order: int, order_contributions: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> DM: ...
@overload
def mtaylor(ex: _SX, x: _SX, a: _SX, order: int, order_contributions: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> SX: ...
@overload
def poly_coeff(ex: _DM, x: _DM) -> DM: ...
@overload
def poly_coeff(ex: _SX, x: _SX) -> SX: ...
@overload
def poly_roots(p: _DM) -> DM: ...
@overload
def poly_roots(p: _SX) -> SX: ...
@overload
def eig_symbolic(m: _DM) -> DM: ...
@overload
def eig_symbolic(m: _SX) -> SX: ...
def find(x: _MX) -> MX: ...
def low(v: _MX, p: _MX, options: Mapping[str, _GenericType] = ...) -> MX: ...
def inv_node(x: _MX) -> MX: ...
@overload
def matrix_expand(e: _MX, boundary: Sequence[_MX] = ..., options: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def matrix_expand(e: Sequence[_MX], boundary: Sequence[_MX] = ..., options: Mapping[str, _GenericType] = ...) -> list[MX]: ...
@overload
def graph_substitute(ex: _MX, v: Sequence[_MX], vdef: Sequence[_MX]) -> MX: ...
@overload
def graph_substitute(ex: Sequence[_MX], v: Sequence[_MX], vdef: Sequence[_MX]) -> list[MX]: ...
@overload
def bspline(x: _MX, coeffs: _DM, knots: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]], degree: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], m: int, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def bspline(x: _MX, coeffs: _MX, knots: Sequence[Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]], degree: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], m: int, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def bspline(x: _MX, coeffs: _MX, knots: Sequence[_MX], degree: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_], m: int, opts: Mapping[str, _GenericType] = ...) -> MX: ...
def convexify(H: _MX, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def stop_diff(expr: _MX, order: int) -> MX: ...
@overload
def stop_diff(expr: _MX, var: _MX, order: int) -> MX: ...
def difference(a: Sequence[_MX], b: Sequence[_MX]) -> list[MX]: ...
def no_hess(expr: _MX) -> MX: ...
def no_grad(expr: _MX) -> MX: ...
class Importer(SharedObject, PrintableCommon):
@staticmethod
def type_name() -> str: ...
@staticmethod
def test_cast(ptr: Any) -> bool: ...
@staticmethod
def has_plugin(name: str) -> bool: ...
@staticmethod
def load_plugin(name: str) -> None: ...
@staticmethod
def doc(name: str) -> str: ...
def plugin_name(self) -> str: ...
def has_function(self, symname: str) -> bool: ...
def has_meta(self, cmd: str, ind: int = ...) -> bool: ...
def get_meta(self, cmd: str, ind: int = ...) -> str: ...
def inlined(self, symname: str) -> bool: ...
def body(self, symname: str) -> str: ...
def library(self) -> str: ...
def serialize(self, s: Any) -> None: ...
@staticmethod
def deserialize(s: Any) -> Importer: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
@overload
def __init__(self, name: str, compiler: str, opts: Mapping[str, _GenericType] = ...) -> None: ...
class Callback(Function):
@staticmethod
def type_name() -> str: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, obj: Any) -> None: ...
def construct(self, name: str, opts: Mapping[str, _GenericType] = ...) -> None: ...
def init(self) -> None: ...
def finalize(self) -> None: ...
def has_eval_buffer(self) -> bool: ...
def get_n_in(self) -> int: ...
def get_n_out(self) -> int: ...
def get_name_in(self, i: int) -> str: ...
def get_name_out(self, i: int) -> str: ...
def uses_output(self) -> bool: ...
def get_factory(self, name: str, s_in: Sequence[str], s_out: Sequence[str], aux: Mapping[str, Sequence[str]], opts: Mapping[str, _GenericType]) -> Function: ...
def has_jacobian(self) -> bool: ...
def get_jacobian(self, name: str, inames: Sequence[str], onames: Sequence[str], opts: Mapping[str, _GenericType]) -> Function: ...
def has_forward(self, nfwd: int) -> bool: ...
def get_forward(self, nfwd: int, name: str, inames: Sequence[str], onames: Sequence[str], opts: Mapping[str, _GenericType]) -> Function: ...
def has_reverse(self, nadj: int) -> bool: ...
def get_reverse(self, nadj: int, name: str, inames: Sequence[str], onames: Sequence[str], opts: Mapping[str, _GenericType]) -> Function: ...
def has_jac_sparsity(self, oind: int, iind: int) -> bool: ...
def get_jac_sparsity(self, oind: int, iind: int, symmetric: bool) -> Sparsity: ...
def eval(self, arg: Sequence[DM],/) -> Sequence[_DM]: ...
def eval_buffer(self, arg: tuple[memoryview,...],/,res: tuple[memoryview,...]) -> int: ...
def get_sparsity_in(self, i: int) -> Sparsity: ...
def get_sparsity_out(self, i: int) -> Sparsity: ...
class GlobalOptions:
@staticmethod
def setSimplificationOnTheFly(flag: bool) -> None: ...
@staticmethod
def getSimplificationOnTheFly() -> bool: ...
@staticmethod
def setHierarchicalSparsity(flag: bool) -> None: ...
@staticmethod
def getHierarchicalSparsity() -> bool: ...
@staticmethod
def setCasadiPath(path: str) -> None: ...
@staticmethod
def getCasadiPath() -> str: ...
@staticmethod
def setCasadiIncludePath(path: str) -> None: ...
@staticmethod
def getCasadiIncludePath() -> str: ...
@staticmethod
def setMaxNumDir(ndir: int) -> None: ...
@staticmethod
def getMaxNumDir() -> int: ...
@staticmethod
def setCopyElisionMinSize(sz: int) -> None: ...
@staticmethod
def getCopyElisionMinSize() -> int: ...
@staticmethod
def setTempWorkDir(dir: str) -> None: ...
@staticmethod
def getTempWorkDir() -> str: ...
def __init__(self, other: Any) -> None: ...
class CasadiMeta:
@staticmethod
def version() -> Any: ...
@staticmethod
def git_revision() -> Any: ...
@staticmethod
def git_describe() -> Any: ...
@staticmethod
def feature_list() -> Any: ...
@staticmethod
def build_type() -> Any: ...
@staticmethod
def compiler_id() -> Any: ...
@staticmethod
def compiler() -> Any: ...
@staticmethod
def compiler_flags() -> Any: ...
@staticmethod
def modules() -> Any: ...
@staticmethod
def plugins() -> Any: ...
@staticmethod
def install_prefix() -> Any: ...
@staticmethod
def shared_library_prefix() -> Any: ...
@staticmethod
def shared_library_suffix() -> Any: ...
@staticmethod
def object_file_suffix() -> Any: ...
@staticmethod
def swig_flags() -> Any: ...
def __init__(self, other: Any) -> None: ...
def collocation_points(order: int, scheme: str = ...) -> list[float]: ...
def collocation_interpolators(tau: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> tuple[list[list[float]], list[float]]: ...
def collocation_coeff(tau: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> tuple[DM, DM, DM]: ...
LEGENDRE: int = ...
RADAU: int = ...
def simpleRK(f: Function, N: int = ..., order: int = ...) -> Function: ...
def simpleIRK(f: Function, N: int = ..., order: int = ..., scheme: str = ..., solver: str = ..., solver_options: Mapping[str, _GenericType] = ...) -> Function: ...
def simpleIntegrator(f: Function, integrator: str = ..., integrator_options: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def dae_reduce_index(dae: Mapping[str, _SX], opts: Mapping[str, _GenericType] = ...) -> tuple[dict[str, SX], dict[str, _GenericType]]: ...
@overload
def dae_reduce_index(dae: Mapping[str, _MX], opts: Mapping[str, _GenericType] = ...) -> tuple[dict[str, MX], dict[str, _GenericType]]: ...
@overload
def dae_map_semi_expl(dae: Mapping[str, _SX], dae_red: Mapping[str, _SX]) -> tuple[dict[str, SX], Function, Function]: ...
@overload
def dae_map_semi_expl(dae: Mapping[str, _MX], dae_red: Mapping[str, _MX]) -> tuple[dict[str, MX], Function, Function]: ...
@overload
def dae_init_gen(dae: Mapping[str, _SX], dae_red: Mapping[str, _SX], init_solver: str, init_strength: Mapping[str, _DM] = ..., init_solver_options: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def dae_init_gen(dae: Mapping[str, _MX], dae_red: Mapping[str, _MX], init_solver: str, init_strength: Mapping[str, _DM] = ..., init_solver_options: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def detect_simple_bounds(xX: _SX, p: _SX, g: _SX, lbg: _SX, ubg: _SX) -> tuple[list[int], SX, SX, Function, Function]: ...
@overload
def detect_simple_bounds(xX: _MX, p: _MX, g: _MX, lbg: _MX, ubg: _MX) -> tuple[list[int], MX, MX, Function, Function]: ...
def external_transform(name: str, op: str, f: Function, opts: Mapping[str, _GenericType] = ...) -> Function: ...
class NlpBuilder(PrintableCommon):
x: list[MX]
f: MX
g: list[MX]
x_lb: list[float]
x_ub: list[float]
g_lb: list[float]
g_ub: list[float]
x_init: list[float]
lambda_init: list[float]
discrete: list[bool]
def import_nl(self, filename: str, opts: Mapping[str, _GenericType] = ...) -> None: ...
def type_name(self) -> str: ...
def disp(self, more: bool = ...) -> None: ...
def str(self, more: bool = ...) -> str: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class DaeBuilder(SharedObject, PrintableCommon):
def type_name(self) -> str: ...
def name(self) -> str: ...
def time(self) -> MX: ...
def t_new(self) -> list[str]: ...
def x(self) -> list[str]: ...
def y(self) -> list[str]: ...
def z(self) -> list[str]: ...
def q(self) -> list[str]: ...
def inputs(self, cat: str) -> list[MX]: ...
def ode(self) -> list[MX]: ...
def alg(self) -> list[MX]: ...
def quad(self) -> list[MX]: ...
def zero(self) -> list[MX]: ...
def ydef(self) -> list[MX]: ...
def set_y(self, name: Sequence[str]) -> None: ...
def u(self) -> list[str]: ...
def p(self) -> list[str]: ...
def c(self) -> list[str]: ...
def cdef(self) -> list[MX]: ...
def d(self) -> list[str]: ...
def ddef(self) -> list[MX]: ...
def w(self) -> list[str]: ...
def wdef(self) -> list[MX]: ...
def init_lhs(self) -> list[MX]: ...
def init_rhs(self) -> list[MX]: ...
@overload
def outputs(self) -> list[str]: ...
@overload
def outputs(self, cat: str) -> list[MX]: ...
def derivatives(self) -> list[str]: ...
def initial_unknowns(self) -> list[str]: ...
def has_t(self) -> bool: ...
def nx(self) -> int: ...
def nz(self) -> int: ...
def nq(self) -> int: ...
def nzero(self) -> int: ...
def ny(self) -> int: ...
def nu(self) -> int: ...
def np(self) -> int: ...
def nc(self) -> int: ...
def nd(self) -> int: ...
def nw(self) -> int: ...
@overload
def add(self, name: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def add(self, name: str, causality: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def add(self, name: str, causality: str, variability: str, opts: Mapping[str, _GenericType] = ...) -> MX: ...
@overload
def add(self, name: str, causality: str, variability: str, expr: _MX, opts: Mapping[str, _GenericType] = ...) -> None: ...
def eq(self, lhs: _MX, rhs: _MX, opts: Mapping[str, _GenericType] = ...) -> None: ...
def when(self, cond: _MX, eqs: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> None: ...
def assign(self, name: str, val: _MX) -> str: ...
def reinit(self, name: str, val: _MX) -> str: ...
def set_init(self, name: str, init_rhs: _MX) -> None: ...
def sanity_check(self) -> None: ...
def reorder(self, cat: str, v: Sequence[str]) -> None: ...
def set_all(self, v: str, name: Sequence[str]) -> None: ...
def eliminate(self, cat: str) -> None: ...
def sort(self, cat: str) -> None: ...
def lift(self, lift_shared: bool = ..., lift_calls: bool = ...) -> None: ...
def prune(self, prune_p: bool = ..., prune_u: bool = ...) -> None: ...
def tear(self) -> None: ...
@overload
def add_fun(self, f: Function) -> Function: ...
@overload
def add_fun(self, name: str, compiler: Any, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def add_fun(self, name: str, arg: Sequence[str], res: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> Function: ...
def has_fun(self, name: str) -> bool: ...
@overload
def fun(self) -> list[Function]: ...
@overload
def fun(self, name: str) -> Function: ...
def gather_fun(self, max_depth: int = ...) -> None: ...
def parse_fmi(self, filename: str) -> None: ...
def provides_directional_derivatives(self) -> bool: ...
def provides_directional_derivative(self) -> bool: ...
def load_fmi_description(self, filename: str) -> None: ...
def export_fmu(self, opts: Mapping[str, _GenericType] = ...) -> dict[str, _GenericType]: ...
def add_lc(self, name: str, f_out: Sequence[str]) -> None: ...
@overload
def create(self) -> Function: ...
@overload
def create(self, fname: str, opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def create(self, name: str, name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def create(self, fname: str, name_in: Sequence[str], name_out: Sequence[str], sx: bool, lifted_calls: bool = ...) -> Function: ...
def dependent_fun(self, fname: str, s_in: Sequence[str], s_out: Sequence[str]) -> Function: ...
@overload
def transition(self) -> Function: ...
@overload
def transition(self, fname: str) -> Function: ...
@overload
def transition(self, fname: str, index: int) -> Function: ...
def var(self, name: str) -> MX: ...
def __call__(self, name: str) -> MX: ...
def has_beq(self, name: str) -> bool: ...
def beq(self, name: str) -> MX: ...
def value_reference(self, name: str) -> int: ...
def set_value_reference(self, name: str, val: int) -> None: ...
def description(self, name: str) -> str: ...
def set_description(self, name: str, val: str) -> None: ...
def type(self, name: str, fmi_version: int = ...) -> str: ...
def set_type(self, name: str, val: str) -> None: ...
def causality(self, name: str) -> str: ...
def categories(self, name: str) -> list[str]: ...
def set_causality(self, name: str, val: str) -> None: ...
def variability(self, name: str) -> str: ...
def set_variability(self, name: str, val: str) -> None: ...
def category(self, name: str) -> str: ...
def set_category(self, name: str, val: str) -> None: ...
def initial(self, name: str) -> str: ...
def set_initial(self, name: str, val: str) -> None: ...
def unit(self, name: str) -> str: ...
def set_unit(self, name: str, val: str) -> None: ...
def display_unit(self, name: str) -> str: ...
def set_display_unit(self, name: str, val: str) -> None: ...
def numel(self, name: str) -> int: ...
def dimension(self, name: str) -> list[int]: ...
def start_time(self) -> float: ...
def set_start_time(self, val: float) -> None: ...
def stop_time(self) -> float: ...
def set_stop_time(self, val: float) -> None: ...
def tolerance(self) -> float: ...
def set_tolerance(self, val: float) -> None: ...
def step_size(self) -> float: ...
def set_step_size(self, val: float) -> None: ...
@overload
def der(self) -> list[str]: ...
@overload
def der(self, name: Sequence[str]) -> list[str]: ...
@overload
def der(self, v: _MX) -> MX: ...
@overload
def der(self, v: _MX) -> MX: ...
@overload
def der(self, name: str) -> str: ...
@overload
def pre(self, name: Sequence[str]) -> list[str]: ...
@overload
def pre(self, v: _MX) -> MX: ...
@overload
def pre(self, name: str) -> str: ...
def reset(self) -> None: ...
def symbolic(self) -> bool: ...
@overload
def attribute(self, a: str, name: Sequence[str]) -> list[float]: ...
@overload
def attribute(self, a: str, name: str) -> float: ...
@overload
def set_attribute(self, a: str, name: Sequence[str], val: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def set_attribute(self, a: str, name: str, val: float) -> None: ...
@overload
def min(self, name: Sequence[str]) -> list[float]: ...
@overload
def min(self, name: str) -> float: ...
@overload
def set_min(self, name: Sequence[str], val: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def set_min(self, name: str, val: float) -> None: ...
@overload
def max(self, name: Sequence[str]) -> list[float]: ...
@overload
def max(self, name: str) -> float: ...
@overload
def set_max(self, name: Sequence[str], val: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def set_max(self, name: str, val: float) -> None: ...
@overload
def nominal(self, name: Sequence[str]) -> list[float]: ...
@overload
def nominal(self, name: str) -> float: ...
@overload
def set_nominal(self, name: Sequence[str], val: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def set_nominal(self, name: str, val: float) -> None: ...
@overload
def start(self, name: Sequence[str]) -> list[float]: ...
@overload
def start(self, name: str) -> list[float]: ...
@overload
def set_start(self, name: Sequence[str], val: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def set_start(self, name: str, val: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def set_start(self, name: str, val: float) -> None: ...
@overload
def set(self, name: Sequence[str], val: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def set(self, name: Sequence[str], val: Sequence[str]) -> None: ...
@overload
def set(self, name: str, val: float) -> None: ...
@overload
def set(self, name: str, val: str) -> None: ...
@overload
def get(self, name: Sequence[str]) -> list[_GenericType]: ...
@overload
def get(self, name: str) -> _GenericType: ...
def has(self, name: str) -> bool: ...
@overload
def all(self) -> list[str]: ...
@overload
def all(self, cat: str) -> list[str]: ...
def oracle(self, sx: bool = ..., elim_w: bool = ..., lifted_calls: bool = ...) -> Function: ...
def jac_sparsity(self, onames: Sequence[str], inames: Sequence[str]) -> Sparsity: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
@overload
def __init__(self, name: str, path: str = ..., opts: Mapping[str, _GenericType] = ...) -> None: ...
class XmlFile(SharedObject, PrintableCommon):
@staticmethod
def type_name() -> str: ...
@staticmethod
def load_plugin(name: str) -> None: ...
@staticmethod
def doc(name: str) -> str: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
@overload
def __init__(self, name: str) -> None: ...
def has_archiver(name: str) -> bool: ...
def load_archiver(name: str) -> None: ...
def doc_archiver(name: str) -> str: ...
def has_filesystem(name: str) -> bool: ...
def load_filesystem(name: str) -> None: ...
def doc_filesystem(name: str) -> str: ...
class Options:
def all(self) -> list[str]: ...
def type(self, name: str) -> str: ...
def info(self, name: str) -> str: ...
@staticmethod
def word_distance(a: str, b: str) -> float: ...
def suggestions(self, word: str, amount: int = ...) -> list[str]: ...
def best_matches(self, word: str, best: Any) -> None: ...
@staticmethod
def has_dot(opts: Mapping[str, _GenericType]) -> bool: ...
@staticmethod
def has_null(opts: Mapping[str, _GenericType]) -> bool: ...
@staticmethod
def is_sane(opts: Mapping[str, _GenericType]) -> bool: ...
@staticmethod
def sanitize(opts: Mapping[str, _GenericType], top_level: bool = ...) -> dict[str, _GenericType]: ...
def check(self, opts: Mapping[str, _GenericType]) -> None: ...
def print_all(self) -> None: ...
def print_one(self, name: str) -> None: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class SerializerBase:
@overload
def pack(self, e: Any) -> None: ...
@overload
def pack(self, e: Any) -> None: ...
@overload
def pack(self, e: int) -> None: ...
@overload
def pack(self, e: float) -> None: ...
@overload
def pack(self, e: Sequence[Sparsity]) -> None: ...
@overload
def pack(self, e: Sparsity) -> None: ...
@overload
def pack(self, e: Sequence[bool | int | float] | NDArray[np.float64] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def pack(self, e: Sequence[bool | int] | NDArray[np.int_] | NDArray[np.bool_]) -> None: ...
@overload
def pack(self, e: Sequence[str]) -> None: ...
@overload
def pack(self, e: _DM) -> None: ...
@overload
def pack(self, e: Sequence[_DM]) -> None: ...
@overload
def pack(self, e: _SX) -> None: ...
@overload
def pack(self, e: Sequence[_SX]) -> None: ...
@overload
def pack(self, e: _MX) -> None: ...
@overload
def pack(self, e: Sequence[_MX]) -> None: ...
@overload
def pack(self, e: str) -> None: ...
@overload
def pack(self, e: Sequence[Function]) -> None: ...
@overload
def pack(self, e: Function) -> None: ...
@overload
def pack(self, e: Sequence[_GenericType]) -> None: ...
@overload
def pack(self, e: _GenericType) -> None: ...
@staticmethod
def type_to_string(type: Any) -> str: ...
def connect(self, s: Any) -> None: ...
def reset(self) -> None: ...
class DeserializerBase:
def _pop_type(self) -> Any: ...
def blind_unpack_sparsity(self) -> Sparsity: ...
def blind_unpack_mx(self) -> MX: ...
def blind_unpack_mx_v1(self) -> MX: ...
def blind_unpack_dm(self) -> DM: ...
def blind_unpack_sx(self) -> SX: ...
def blind_unpack_sx_v1(self) -> SX: ...
def blind_unpack_linsol(self) -> Linsol: ...
def blind_unpack_function(self) -> Function: ...
def blind_unpack_generictype(self) -> _GenericType: ...
def blind_unpack_int(self) -> int: ...
def blind_unpack_double(self) -> float: ...
def blind_unpack_string(self) -> str: ...
def blind_unpack_sparsity_vector(self) -> list[Sparsity]: ...
def blind_unpack_mx_vector(self) -> list[MX]: ...
def blind_unpack_mx_vector_v1(self) -> list[MX]: ...
def blind_unpack_dm_vector(self) -> list[DM]: ...
def blind_unpack_sx_vector(self) -> list[SX]: ...
def blind_unpack_sx_vector_v1(self) -> list[SX]: ...
def blind_unpack_linsol_vector(self) -> Any: ...
def blind_unpack_function_vector(self) -> list[Function]: ...
def blind_unpack_generictype_vector(self) -> list[_GenericType]: ...
def blind_unpack_int_vector(self) -> list[int]: ...
def blind_unpack_double_vector(self) -> list[float]: ...
def blind_unpack_string_vector(self) -> list[str]: ...
def unpack_sparsity(self) -> Sparsity: ...
def unpack_mx(self) -> MX: ...
def unpack_dm(self) -> DM: ...
def unpack_sx(self) -> SX: ...
def unpack_linsol(self) -> Linsol: ...
def unpack_function(self) -> Function: ...
def unpack_generictype(self) -> _GenericType: ...
def unpack_int(self) -> int: ...
def unpack_double(self) -> float: ...
def unpack_string(self) -> str: ...
def unpack_sparsity_vector(self) -> list[Sparsity]: ...
def unpack_mx_vector(self) -> list[MX]: ...
def unpack_dm_vector(self) -> list[DM]: ...
def unpack_sx_vector(self) -> list[SX]: ...
def unpack_linsol_vector(self) -> Any: ...
def unpack_function_vector(self) -> list[Function]: ...
def unpack_generictype_vector(self) -> list[_GenericType]: ...
def unpack_int_vector(self) -> list[int]: ...
def unpack_double_vector(self) -> list[float]: ...
def unpack_string_vector(self) -> list[str]: ...
def connect(self, s: Any) -> None: ...
def reset(self) -> None: ...
def unpack(self) -> Any: ...
class StringSerializer(SerializerBase):
def __init__(self, opts: Mapping[str, _GenericType] = ...) -> None: ...
def encode(self) -> str: ...
class FileSerializer(SerializerBase):
def __init__(self, fname: str, opts: Mapping[str, _GenericType] = ...) -> None: ...
class StringDeserializer(DeserializerBase):
def __init__(self, string: str = ...) -> None: ...
def decode(self, string: str) -> None: ...
class FileDeserializer(DeserializerBase):
def __init__(self, fname: str) -> None: ...
class Opti(PrintableCommon, SharedObject):
@overload
def _variable(self, n: int = ..., m: int = ..., attribute: str = ...) -> MX: ...
@overload
def _variable(self, sp: Sparsity, attribute: str = ...) -> MX: ...
@overload
def _variable(self, symbol: _MX, attribute: str = ...) -> MX: ...
@overload
def _parameter(self, n: int = ..., m: int = ..., attribute: str = ...) -> MX: ...
@overload
def _parameter(self, sp: Sparsity, attribute: str = ...) -> MX: ...
@overload
def _parameter(self, symbol: _MX, attribute: str = ...) -> MX: ...
def minimize(self, f: _MX, linear_scale: float = ...) -> None: ...
@overload
def _subject_to(self) -> None: ...
@overload
def _subject_to(self, g: _MX, options: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def _subject_to(self, g: Sequence[_MX], options: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def _subject_to(self, g: _MX, linear_scale: _DM, options: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def _subject_to(self, g: Sequence[_MX], linear_scale: _DM, options: Mapping[str, _GenericType] = ...) -> None: ...
def solver(self, solver: str, plugin_options: Mapping[str, _GenericType] = ..., solver_options: Mapping[str, _GenericType] = ...) -> None: ...
@overload
def set_initial(self, assignments: Sequence[_MX]) -> None: ...
@overload
def set_initial(self, x: _MX, v: _DM) -> None: ...
@overload
def set_value(self, assignments: Sequence[_MX]) -> None: ...
@overload
def set_value(self, x: _MX, v: _DM) -> None: ...
def set_domain(self, x: _MX, domain: str) -> None: ...
def set_linear_scale(self, x: _MX, scale: _DM, offset: _DM = ...) -> None: ...
def solve(self) -> OptiSol: ...
def solve_limited(self) -> OptiSol: ...
@overload
def value(self, x: _DM, values: Sequence[_MX] = ...) -> float: ...
@overload
def value(self, x: _SX, values: Sequence[_MX] = ...) -> float: ...
@overload
def value(self, x: _MX, values: Sequence[_MX] = ...) -> float: ...
def stats(self) -> dict[str, _GenericType]: ...
def return_status(self) -> str: ...
def initial(self) -> list[MX]: ...
def value_variables(self) -> list[MX]: ...
def value_parameters(self) -> list[MX]: ...
def scale_helper(self, h: Function) -> Function: ...
def dual(self, m: _MX) -> MX: ...
def _nx(self) -> int: ...
def _np(self) -> int: ...
def _ng(self) -> int: ...
def _x(self) -> MX: ...
def _p(self) -> MX: ...
def _g(self) -> MX: ...
def _f(self) -> MX: ...
def _lbg(self) -> MX: ...
def _ubg(self) -> MX: ...
def _x_linear_scale(self) -> DM: ...
def _x_linear_scale_offset(self) -> DM: ...
def _g_linear_scale(self) -> DM: ...
def _f_linear_scale(self) -> float: ...
def _lam_g(self) -> MX: ...
@overload
def to_function(self, name: str, args: Sequence[_MX], res: Sequence[_MX], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def to_function(self, name: str, dict: Mapping[str, _MX], name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@overload
def to_function(self, name: str, args: Sequence[_MX], res: Sequence[_MX], name_in: Sequence[str], name_out: Sequence[str], opts: Mapping[str, _GenericType] = ...) -> Function: ...
@staticmethod
def bounded(lb: _MX, expr: _MX, ub: _MX) -> MX: ...
def _debug(self) -> OptiAdvanced: ...
def _advanced(self) -> OptiAdvanced: ...
def copy(self) -> Opti: ...
@overload
def update_user_dict(self, m: _MX, meta: Mapping[str, _GenericType]) -> None: ...
@overload
def update_user_dict(self, m: Sequence[_MX], meta: Mapping[str, _GenericType]) -> None: ...
def user_dict(self, m: _MX) -> dict[str, _GenericType]: ...
def type_name(self) -> str: ...
def disp(self, more: bool = ...) -> None: ...
def str(self, more: bool = ...) -> str: ...
@overload
def callback_class(self) -> None: ...
@overload
def callback_class(self, callback: Any) -> None: ...
debug: OptiAdvanced
advanced: OptiAdvanced
f: MX
g: MX
x: MX
p: MX
lam_g: MX
lbg: MX
ubg: MX
nx: int
np: int
ng: int
x_linear_scale: DM
x_linear_scale_offset: DM
g_linear_scale: DM
f_linear_scale: float
casadi_solver: Function
@overload
def variable(self, n: int = ...,m: int = ...,attribute: str = ...) -> MX: ...
@overload
def variable(self, sp: Sparsity | DM,attribute: str = ...) -> MX: ...
@overload
def variable(self, symbol: MX | SX | DM,attribute: str = ...) -> MX: ...
@overload
def parameter(self, n: int = ...,m: int = ...,attribute: str = ...) -> MX: ...
@overload
def parameter(self, sp: Sparsity | DM,attribute: str = ...) -> MX: ...
@overload
def parameter(self, symbol: MX | SX | DM,attribute: str = ...) -> MX: ...
@overload
def subject_to(self) -> None: ...
@overload
def subject_to(self, g: MX | SX | DM | bool | int | float) -> None: ...
@overload
def subject_to(self, g: Sequence[MX | SX | DM | bool | int | float]) -> None: ...
@overload
def subject_to(self, g: MX | SX | DM | bool | int | float,options: dict) -> None: ...
@overload
def subject_to(self, g: Sequence[MX | SX | DM | bool | int | float],options: dict) -> None: ...
@overload
def subject_to(self, g: MX | SX | DM | bool | int | float,linear_scale: _DM) -> None: ...
@overload
def subject_to(self, g: Sequence[MX | SX | DM | bool | int | float],linear_scale: _DM) -> None: ...
@overload
def subject_to(self, g: MX | SX | DM | bool | int | float,linear_scale: _DM,options: dict) -> None: ...
@overload
def subject_to(self, g: Sequence[MX | SX | DM | bool | int | float],linear_scale: _DM,options: dict) -> None: ...
def callback(self, fh: "Callable[[int], Any] | None" = ...) -> None: ...
@overload
def __init__(self, problem_type: str = ...) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
OPTI_GENERIC_EQUALITY: int = ...
OPTI_GENERIC_INEQUALITY: int = ...
OPTI_EQUALITY: int = ...
OPTI_INEQUALITY: int = ...
OPTI_DOUBLE_INEQUALITY: int = ...
OPTI_PSD: int = ...
OPTI_UNKNOWN: int = ...
OPTI_VAR: int = ...
OPTI_PAR: int = ...
OPTI_DUAL_G: int = ...
OPTI_DOMAIN_REAL: int = ...
OPTI_DOMAIN_INTEGER: int = ...
class IndexAbstraction:
start: int
stop: int
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class MetaCon(IndexAbstraction):
original: MX
canon: MX
type: int
lb: MX
ub: MX
n: int
flipped: bool
dual_canon: MX
dual: MX
extra: dict[str, _GenericType]
linear_scale: DM
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class MetaVar(IndexAbstraction):
attribute: str
n: int
m: int
type: int
domain: int
count: int
i: int
active_i: int
extra: dict[str, _GenericType]
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
class OptiCallback:
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, obj: Any) -> None: ...
def call(self, i: int) -> None: ...
class OptiAdvanced(Opti):
def _casadi_solver(self) -> Function: ...
def is_parametric(self, expr: _MX) -> bool: ...
@overload
def symvar(self) -> list[MX]: ...
@overload
def symvar(self, expr: _MX) -> list[MX]: ...
@overload
def symvar(self, expr: _MX, type: Any) -> list[MX]: ...
def canon_expr(self, expr: _MX) -> MetaCon: ...
def get_meta(self, m: _MX) -> MetaVar: ...
def get_meta_con(self, m: _MX) -> MetaCon: ...
def set_meta(self, m: _MX, meta: Any) -> None: ...
def set_meta_con(self, m: _MX, meta: Any) -> None: ...
def assert_active_symbol(self, m: _MX) -> None: ...
def active_symvar(self, type: Any) -> list[MX]: ...
def active_values(self, type: Any) -> list[DM]: ...
def x_lookup(self, i: int) -> MX: ...
def g_lookup(self, i: int) -> MX: ...
def g_index_reduce_g(self, i: int) -> int: ...
def g_index_reduce_x(self, i: int) -> int: ...
def g_index_unreduce_g(self, i: int) -> int: ...
def x_describe(self, i: int, opts: Mapping[str, _GenericType] = ...) -> str: ...
def g_describe(self, i: int, opts: Mapping[str, _GenericType] = ...) -> str: ...
def describe(self, x: _MX, indent: int = ..., opts: Mapping[str, _GenericType] = ...) -> str: ...
def show_infeasibilities(self, tol: float = ..., opts: Mapping[str, _GenericType] = ...) -> None: ...
def solve_prepare(self) -> None: ...
def solve_actual(self, args: Mapping[str, _DM]) -> dict[str, DM]: ...
def arg(self) -> dict[str, DM]: ...
@overload
def res(self) -> dict[str, DM]: ...
@overload
def res(self, res: Mapping[str, _DM]) -> None: ...
def constraints(self) -> list[MX]: ...
def objective(self) -> MX: ...
def baked_copy(self) -> OptiAdvanced: ...
def assert_empty(self) -> None: ...
def bake(self) -> None: ...
problem_dirty_: bool
def mark_problem_dirty(self, flag: bool = ...) -> None: ...
def problem_dirty(self) -> bool: ...
solver_dirty_: bool
def mark_solver_dirty(self, flag: bool = ...) -> None: ...
def solver_dirty(self) -> bool: ...
solved_: bool
def mark_solved(self, flag: bool = ...) -> None: ...
def solved(self) -> bool: ...
def assert_solved(self) -> None: ...
def assert_baked(self) -> None: ...
def instance_number(self) -> int: ...
@overload
def __init__(self, other: Any) -> None: ...
@overload
def __init__(self, x: Any) -> None: ...
class OptiSol(PrintableCommon):
def type_name(self) -> str: ...
def disp(self, more: bool = ...) -> None: ...
def str(self, more: bool = ...) -> str: ...
@overload
def value(self, x: _DM, values: Sequence[_MX] = ...) -> float: ...
@overload
def value(self, x: _SX, values: Sequence[_MX] = ...) -> float: ...
@overload
def value(self, x: _MX, values: Sequence[_MX] = ...) -> float: ...
def value_variables(self) -> list[MX]: ...
def value_parameters(self) -> list[MX]: ...
def stats(self) -> dict[str, _GenericType]: ...
def _opti(self) -> Opti: ...
opti: Opti
debug: OptiAdvanced
def __init__(self, other: Any) -> None: ...
class Resource(SharedObject, PrintableCommon):
@staticmethod
def type_name() -> str: ...
@staticmethod
def test_cast(ptr: Any) -> bool: ...
def path(self) -> str: ...
def serialize(self, s: Any) -> None: ...
def change_option(self, option_name: str, option_value: _GenericType) -> None: ...
@staticmethod
def deserialize(s: Any) -> Resource: ...
@overload
def __init__(self) -> None: ...
@overload
def __init__(self, other: Any) -> None: ...
@overload
def __init__(self, path: str) -> None: ...
__all__ = [
"CASADI_INT_TYPE_STR",
"SOLVER_RET_SUCCESS",
"SOLVER_RET_UNKNOWN",
"SOLVER_RET_LIMITED",
"SOLVER_RET_NAN",
"SOLVER_RET_INFEASIBLE",
"SOLVER_RET_EXCEPTION",
"MNAME",
"SwigPyIterator",
"L_INT",
"L_BOOL",
"LL",
"LR",
"L_DICT",
"L_DOUBLE",
"L_STR",
"LABEL",
"arcsin",
"arccos",
"arctan",
"arctanh",
"arcsinh",
"arccosh",
"arctan2",
"veccat",
"vertcat",
"horzcat",
"diagcat",
"vvcat",
"vcat",
"hcat",
"dcat",
"NZproxy",
"PrintableCommon",
"GenSharedObject",
"GenWeakRef",
"SharedObject",
"WeakRef",
"complement",
"lookupvector",
"temporary_file",
"normalized_setup",
"StreamStateGuard",
"normalized_out",
"normalized_in",
"SWIG_IND1",
"GenericType",
"OP_ASSIGN",
"OP_ADD",
"OP_SUB",
"OP_MUL",
"OP_DIV",
"OP_NEG",
"OP_EXP",
"OP_LOG",
"OP_POW",
"OP_CONSTPOW",
"OP_SQRT",
"OP_SQ",
"OP_TWICE",
"OP_SIN",
"OP_COS",
"OP_TAN",
"OP_ASIN",
"OP_ACOS",
"OP_ATAN",
"OP_LT",
"OP_LE",
"OP_EQ",
"OP_NE",
"OP_NOT",
"OP_AND",
"OP_OR",
"OP_FLOOR",
"OP_CEIL",
"OP_FMOD",
"OP_FABS",
"OP_SIGN",
"OP_COPYSIGN",
"OP_IF_ELSE_ZERO",
"OP_ERF",
"OP_FMIN",
"OP_FMAX",
"OP_INV",
"OP_SINH",
"OP_COSH",
"OP_TANH",
"OP_ASINH",
"OP_ACOSH",
"OP_ATANH",
"OP_ATAN2",
"OP_CONST",
"OP_INPUT",
"OP_OUTPUT",
"OP_PARAMETER",
"OP_CALL",
"OP_FIND",
"OP_LOW",
"OP_MAP",
"OP_MTIMES",
"OP_SOLVE",
"OP_TRANSPOSE",
"OP_DETERMINANT",
"OP_INVERSE",
"OP_DOT",
"OP_BILIN",
"OP_RANK1",
"OP_HORZCAT",
"OP_VERTCAT",
"OP_DIAGCAT",
"OP_HORZSPLIT",
"OP_VERTSPLIT",
"OP_DIAGSPLIT",
"OP_RESHAPE",
"OP_SUBREF",
"OP_SUBASSIGN",
"OP_GETNONZEROS",
"OP_GETNONZEROS_PARAM",
"OP_ADDNONZEROS",
"OP_ADDNONZEROS_PARAM",
"OP_SETNONZEROS",
"OP_SETNONZEROS_PARAM",
"OP_PROJECT",
"OP_ASSERTION",
"OP_MONITOR",
"OP_NORM2",
"OP_NORM1",
"OP_NORMINF",
"OP_NORMF",
"OP_MMIN",
"OP_MMAX",
"OP_HORZREPMAT",
"OP_HORZREPSUM",
"OP_ERFINV",
"OP_PRINTME",
"OP_LIFT",
"OP_EINSTEIN",
"OP_BSPLINE",
"OP_CONVEXIFY",
"OP_SPARSITY_CAST",
"OP_LOG1P",
"OP_EXPM1",
"OP_HYPOT",
"OP_LOGSUMEXP",
"OP_REMAINDER",
"OP_DUMP",
"SparsityInterfaceCommon",
"Sparsity",
"hash_sparsity",
"Slice",
"to_slice",
"to_slice2",
"is_slice",
"is_slice2",
"GenericMatrixCommon",
"index_interp1d",
"GenDM",
"GenSX",
"GenMX",
"GenericExpressionCommon",
"IS_GLOBAL",
"IS_MEMBER",
"IS_SPARSITY",
"IS_DMATRIX",
"IS_IMATRIX",
"IS_SX",
"IS_MX",
"IS_DOUBLE",
"MatrixCommon",
"DM",
"SXElem",
"SX",
"MX",
"Function",
"FunctionBuffer",
"external",
"integrator",
"has_integrator",
"load_integrator",
"doc_integrator",
"integrator_in",
"integrator_out",
"integrator_n_in",
"integrator_n_out",
"dyn_in",
"dyn_out",
"dyn_n_in",
"dyn_n_out",
"event_in",
"event_out",
"conic",
"qpsol",
"conic_in",
"conic_out",
"conic_n_in",
"conic_n_out",
"conic_options",
"conic_option_type",
"conic_option_info",
"has_conic",
"load_conic",
"doc_conic",
"conic_debug",
"nlpsol",
"nlpsol_in",
"nlpsol_out",
"nlpsol_n_in",
"nlpsol_n_out",
"nlpsol_default_in",
"nlpsol_options",
"nlpsol_option_type",
"nlpsol_option_info",
"has_nlpsol",
"load_nlpsol",
"doc_nlpsol",
"rootfinder",
"rootfinder_in",
"rootfinder_out",
"rootfinder_n_in",
"rootfinder_n_out",
"rootfinder_options",
"rootfinder_option_type",
"rootfinder_option_info",
"has_rootfinder",
"load_rootfinder",
"doc_rootfinder",
"Linsol",
"has_linsol",
"load_linsol",
"doc_linsol",
"dplesol",
"dple_in",
"dple_out",
"dple_n_in",
"dple_n_out",
"has_dple",
"load_dple",
"doc_dple",
"expmsol",
"expm_n_in",
"expm_n_out",
"has_expm",
"load_expm",
"doc_expm",
"interpolant",
"has_interpolant",
"load_interpolant",
"doc_interpolant",
"blazing_spline",
"CodeGenerator",
"FLAG",
"horzsplit",
"horzsplit_n",
"offset",
"vertsplit",
"vertsplit_n",
"blocksplit",
"diagsplit",
"mtimes",
"mac",
"transpose",
"vec",
"reshape",
"sparsity_cast",
"sprank",
"norm_0_mul",
"triu",
"tril",
"kron",
"repmat",
"sum2",
"sum1",
"sum",
"plus",
"minus",
"times",
"rdivide",
"ldivide",
"lt",
"le",
"gt",
"ge",
"eq",
"ne",
"logic_and",
"logic_or",
"logic_not",
"fabs",
"sqrt",
"sin",
"cos",
"tan",
"atan",
"asin",
"acos",
"tanh",
"sinh",
"cosh",
"atanh",
"asinh",
"acosh",
"exp",
"log",
"log10",
"log1p",
"expm1",
"floor",
"ceil",
"erf",
"erfinv",
"sign",
"power",
"fmod",
"remainder",
"atan2",
"fmin",
"fmax",
"hypot",
"simplify",
"is_equal",
"copysign",
"constpow",
"mpower",
"mrdivide",
"mldivide",
"symvar",
"bilin",
"rank1",
"sumsqr",
"linspace",
"logsumexp",
"interp1d",
"soc",
"cross",
"skew",
"inv_skew",
"det",
"inv_minor",
"inv",
"trace",
"tril2symm",
"triu2symm",
"norm_fro",
"norm_2",
"norm_1",
"norm_inf",
"dot",
"nullspace",
"polyval",
"diag",
"unite",
"densify",
"project",
"if_else",
"conditional",
"depends_on",
"contains",
"contains_all",
"contains_any",
"solve",
"pinv",
"expm_const",
"expm",
"jacobian",
"jtimes",
"linearize",
"which_depends",
"jacobian_sparsity",
"is_linear",
"is_quadratic",
"gradient",
"tangent",
"hessian",
"quadratic_coeff",
"linear_coeff",
"n_nodes",
"print_operator",
"repsum",
"diff",
"cumsum",
"einstein",
"mmin",
"mmax",
"evalf",
"separate_linear",
"cse",
"extract_parametric",
"forward",
"reverse",
"substitute",
"substitute_inplace",
"extract",
"shared",
"blockcat",
"logic_all",
"logic_any",
"adj",
"minor",
"cofactor",
"qr",
"qr_sparse",
"qr_solve",
"ldl",
"ldl_solve",
"chol",
"norm_inf_mul",
"sparsify",
"expand",
"pw_const",
"pw_lin",
"heaviside",
"rectangle",
"triangle",
"ramp",
"gauss_quadrature",
"taylor",
"mtaylor",
"poly_coeff",
"poly_roots",
"eig_symbolic",
"find",
"low",
"inv_node",
"matrix_expand",
"graph_substitute",
"bspline",
"convexify",
"stop_diff",
"difference",
"no_hess",
"no_grad",
"Importer",
"Callback",
"GlobalOptions",
"CasadiMeta",
"collocation_points",
"collocation_interpolators",
"collocation_coeff",
"LEGENDRE",
"RADAU",
"simpleRK",
"simpleIRK",
"simpleIntegrator",
"dae_reduce_index",
"dae_map_semi_expl",
"dae_init_gen",
"detect_simple_bounds",
"external_transform",
"NlpBuilder",
"DaeBuilder",
"XmlFile",
"has_archiver",
"load_archiver",
"doc_archiver",
"has_filesystem",
"load_filesystem",
"doc_filesystem",
"Options",
"SerializerBase",
"DeserializerBase",
"StringSerializer",
"FileSerializer",
"StringDeserializer",
"FileDeserializer",
"Opti",
"OPTI_GENERIC_EQUALITY",
"OPTI_GENERIC_INEQUALITY",
"OPTI_EQUALITY",
"OPTI_INEQUALITY",
"OPTI_DOUBLE_INEQUALITY",
"OPTI_PSD",
"OPTI_UNKNOWN",
"OPTI_VAR",
"OPTI_PAR",
"OPTI_DUAL_G",
"OPTI_DOMAIN_REAL",
"OPTI_DOMAIN_INTEGER",
"IndexAbstraction",
"MetaCon",
"MetaVar",
"OptiCallback",
"OptiAdvanced",
"OptiSol",
"Resource",
]
```
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment