## 1. Expression tools¶

acos(*args)

Arc cosine: x -> acos(x)

acos(float x) -> float
acos(DM x) -> DM
acos(SX x) -> SX
acos(MX x) -> MX

acosh(*args)

Inverse hyperbolic cosine: x -> acosh(x)

acosh(float x) -> float
acosh(DM x) -> DM
acosh(SX x) -> SX
acosh(MX x) -> MX


adj(DM A) -> DM

asin(*args)

Arc sine: x -> asin(x)

asin(float x) -> float
asin(DM x) -> DM
asin(SX x) -> SX
asin(MX x) -> MX

asinh(*args)

Inverse hyperbolic sin: x -> asinh(x)

asinh(float x) -> float
asinh(DM x) -> DM
asinh(SX x) -> SX
asinh(MX x) -> MX

atan(*args)

Arc tangent: x -> atan(x)

atan(float x) -> float
atan(DM x) -> DM
atan(SX x) -> SX
atan(MX x) -> MX

atan2(*args)

Two argument arc tangent: (y,x) -> atan2(y,x)

atan2(float x, float y) -> float
atan2(DM x, DM y) -> DM
atan2(SX x, SX y) -> SX
atan2(MX x, MX y) -> MX


theta = atan2(y,x) corresponds to x = r cos(theta), y = r sin(theta)

atanh(*args)

Inverse hyperbolic tangent: x -> atanh(x)

atanh(float x) -> float
atanh(DM x) -> DM
atanh(SX x) -> SX
atanh(MX x) -> MX

bilin(*args)

Calculate bilinear/quadratic form x^T A y.

bilin(DM A, DM x) -> DM
bilin(SX A, SX x) -> SX
bilin(MX A, MX x) -> MX
bilin(DM A, DM x, DM y) -> DM
bilin(SX A, SX x, SX y) -> SX
bilin(MX A, MX x, MX y) -> MX


### 1. Parameters:¶

y: can be omitted, in which case x^T A x is calculated

blockcat(*args)

Construct a matrix from 4 blocks.

blockcat([[DM]] v) -> DM
blockcat([[SX]] v) -> SX
blockcat([[MX]] v) -> MX
blockcat(Sparsity A, Sparsity B, Sparsity C, Sparsity D) -> Sparsity
blockcat(DM A, DM B, DM C, DM D) -> DM
blockcat(SX A, SX B, SX C, SX D) -> SX
blockcat(MX A, MX B, MX C, MX D) -> MX

bspline(*args)
bspline(MX x, DM coeffs, [[float]] knots, [int] degree, int m, dict opts) -> MX
bspline(MX x, MX coeffs, [[float]] knots, [int] degree, int m, dict opts) -> MX

ceil(*args)

Round up to nearest integer: x -> ceil(x)

ceil(float x) -> float
ceil(DM x) -> DM
ceil(SX x) -> SX
ceil(MX x) -> MX

chol(*args)

Obtain a Cholesky factorisation of a matrix.

chol(DM A) -> DM
chol(SX A) -> SX


Performs and LDL transformation [L,D] = ldl(A) and returns diag(sqrt(D))*L’

cofactor(*args)

Get the (i,j) cofactor matrix.

cofactor(DM x, int i, int j) -> DM
cofactor(SX x, int i, int j) -> SX

collocation_coeff(*args)

[INTERNAL]

collocation_coeff([float] tau) -> (DM OUTPUT, DM OUTPUT, DM OUTPUT)


Obtain collocation interpolating matrices.

A collocation method poses a polynomial Pi that interpolates exactly

through an initial state (0,X_0) and helper states at collocation points (tau_j,Xc_j) with j=1..degree.

This function computes the linear mapping between dPi/dt and coefficients Z=[X_0 Xc].

### 1. Parameters:¶

tau: location of collocation points (length: degree), as obtained from

collocation_points

C: interpolating coefficients to obtain derivatives. Size: (degree+1)-by-

degree

You may find the slopes of Pi at the collocation points as

dPi/dt @ Xc = (1/h) Z*C,

with h the length of the integration interval.

### 1. Parameters:¶

D: interpolating coefficients to obtain end state. Size: (degree+1)-by-1

You may find the end point of Pi as

Pi @X_f = Z*D

### 1. Parameters:¶

points, you may find the integrated quadratures as

collocation_points(*args)

[INTERNAL]

collocation_points(int order, str scheme) -> [float]


Obtain collocation points of specific order and scheme.

### 1. Parameters:¶

order: Which order (1 to 9 supported)

conditional(*args)

Create a switch.

conditional(DM ind, [DM] x, DM x_default, bool short_circuit) -> DM
conditional(SX ind, [SX] x, SX x_default, bool short_circuit) -> SX
conditional(MX ind, [MX] x, MX x_default, bool short_circuit) -> MX


If the condition

### 1. Parameters:¶

ind: evaluates to the integer k, where 0<=k<f.size(), then x[k] will be

returned, otherwise

x_default: will be returned.

constpow(*args)

Elementwise power with const power

constpow(float x, float y) -> float
constpow(DM x, DM y) -> DM
constpow(SX x, SX y) -> SX
constpow(MX x, MX y) -> MX

convexify(*args)
convexify(MX H, dict opts) -> MX

copysign(*args)

Copy sign

copysign(float x, float y) -> float
copysign(DM x, DM y) -> DM
copysign(SX x, SX y) -> SX
copysign(MX x, MX y) -> MX

cos(*args)

Cosine: x -> cos(x)

cos(float x) -> float
cos(DM x) -> DM
cos(SX x) -> SX
cos(MX x) -> MX

cosh(*args)

Hyperbolic cosine: x -> cosh(x)

cosh(float x) -> float
cosh(DM x) -> DM
cosh(SX x) -> SX
cosh(MX x) -> MX

cross(*args)

Matlab’s cross command.

cross(DM a, DM b, int dim) -> DM
cross(SX a, SX b, int dim) -> SX
cross(MX a, MX b, int dim) -> MX

cse(*args)

Common subexpression elimination.

cse(DM e) -> DM
cse([DM] e) -> [DM]
cse([SX] e) -> [SX]
cse(SX e) -> SX
cse(MX e) -> MX
cse([MX] e) -> [MX]

cumsum(*args)

cumulative sum

cumsum(DM A, int axis) -> DM
cumsum(SX A, int axis) -> SX
cumsum(MX A, int axis) -> MX

dae_init_gen(*args)

[INTERNAL]

dae_init_gen(dict:SX dae, dict:SX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options) -> Function
dae_init_gen(dict:MX dae, dict:MX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options) -> Function


Obtain a generator Function for producing consistent initial guesses of a reduced DAE.

### 1. Parameters:¶

dae: Original (unreduced) DAE structure

dae_red: Reduced DAE (see dae_reduce_index)

init_solver: NLP solver plugin name for nlpsol used to construct an initial

guess

init_strength: Influence the nature of the NLP Structure with keys x_impl, dx_impl, z

corresponding to inputs of init_gen Each key maps to a DM that

should

match the variable size corresponding to that key. For each variable

the meaning of the corresponding DM value is as follows: When >=0,

indicates that the provided initial guess is used in a quadratic penalty (value used as weight) When -1, indicates that the provided initial guess must be observed (simple bound on variable)

init_solver_options: NLP solver options to be passed to nlpsol

init_gen A function to generate a consistent initial guess that can be

used to pass to an integrator constructed from a semi explict reduced DAE

Inputs: x_impl, dx_impl, z: initial guesses in the original DAE space

p: parameters

t: time Outputs:

x0, z0: (semi explicit) integrator states and algebraic variables;

typically used as input for integrators

See:

dae_reduce_index

dae_init_gen(dict:SX dae, dict:SX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options)


[INTERNAL] Obtain a generator Function for producing consistent initial guesses of a reduced DAE.

### 1. Parameters:¶

dae: Original (unreduced) DAE structure

dae_red: Reduced DAE (see dae_reduce_index)

init_solver: NLP solver plugin name for nlpsol used to construct an initial

guess

init_strength: Influence the nature of the NLP Structure with keys x_impl, dx_impl, z

corresponding to inputs of init_gen Each key maps to a DM that

should

match the variable size corresponding to that key. For each variable

the meaning of the corresponding DM value is as follows: When >=0,

indicates that the provided initial guess is used in a quadratic penalty (value used as weight) When -1, indicates that the provided initial guess must be observed (simple bound on variable)

init_solver_options: NLP solver options to be passed to nlpsol

init_gen A function to generate a consistent initial guess that can be

used to pass to an integrator constructed from a semi explict reduced DAE

Inputs: x_impl, dx_impl, z: initial guesses in the original DAE space

p: parameters

t: time Outputs:

x0, z0: (semi explicit) integrator states and algebraic variables;

typically used as input for integrators

See:

dae_reduce_index

dae_init_gen(dict:MX dae, dict:MX dae_red, str init_solver, dict:DM init_strength, dict init_solver_options)


[INTERNAL] Obtain a generator Function for producing consistent initial guesses of a reduced DAE.

### 1. Parameters:¶

dae: Original (unreduced) DAE structure

dae_red: Reduced DAE (see dae_reduce_index)

init_solver: NLP solver plugin name for nlpsol used to construct an initial

guess

init_strength: Influence the nature of the NLP Structure with keys x_impl, dx_impl, z

corresponding to inputs of init_gen Each key maps to a DM that

should

match the variable size corresponding to that key. For each variable

the meaning of the corresponding DM value is as follows: When >=0,

indicates that the provided initial guess is used in a quadratic penalty (value used as weight) When -1, indicates that the provided initial guess must be observed (simple bound on variable)

init_solver_options: NLP solver options to be passed to nlpsol

init_gen A function to generate a consistent initial guess that can be

used to pass to an integrator constructed from a semi explict reduced DAE

Inputs: x_impl, dx_impl, z: initial guesses in the original DAE space

p: parameters

t: time Outputs:

x0, z0: (semi explicit) integrator states and algebraic variables;

typically used as input for integrators

See:

dae_reduce_index

dae_map_semi_expl(*args)

[INTERNAL]

dae_map_semi_expl(dict:SX dae, dict:SX dae_red) -> (dict:SX , Function OUTPUT, Function OUTPUT)
dae_map_semi_expl(dict:MX dae, dict:MX dae_red) -> (dict:MX , Function OUTPUT, Function OUTPUT)


Turn a reduced DAE into a semi explicit form suitable for CasADi

integrator.

### 1. Parameters:¶

dae: Original (unreduced) DAE structure

dae_red: Reduced DAE (see dae_reduce_index)

state_to_orig: A mapping of integrator (semi explicit) states to states of the original DAE

phi: A function to compute the invariants of the reduced DAE Inputs: x and z: (semi explicit) integrator states; typically integrator outputs xf and zf

p: parameters

t: time

Semi explicit DAE dictionary, suitable to pass to a CasADi integrator

See:

dae_reduce_index

dae_map_semi_expl(dict:SX dae, dict:SX dae_red)


[INTERNAL] Turn a reduced DAE into a semi explicit form suitable for CasADi

integrator.

### 1. Parameters:¶

dae: Original (unreduced) DAE structure

dae_red: Reduced DAE (see dae_reduce_index)

state_to_orig: A mapping of integrator (semi explicit) states to states of the original DAE

phi: A function to compute the invariants of the reduced DAE Inputs: x and z: (semi explicit) integrator states; typically integrator outputs xf and zf

p: parameters

t: time

Semi explicit DAE dictionary, suitable to pass to a CasADi integrator

See:

dae_reduce_index

dae_map_semi_expl(dict:MX dae, dict:MX dae_red)


[INTERNAL] Turn a reduced DAE into a semi explicit form suitable for CasADi

integrator.

### 1. Parameters:¶

dae: Original (unreduced) DAE structure

dae_red: Reduced DAE (see dae_reduce_index)

state_to_orig: A mapping of integrator (semi explicit) states to states of the original DAE

phi: A function to compute the invariants of the reduced DAE Inputs: x and z: (semi explicit) integrator states; typically integrator outputs xf and zf

p: parameters

t: time

Semi explicit DAE dictionary, suitable to pass to a CasADi integrator

See:

dae_reduce_index

dae_reduce_index(*args)

[INTERNAL]

dae_reduce_index(dict:SX dae, dict opts) -> (dict:SX , dict OUTPUT)
dae_reduce_index(dict:MX dae, dict opts) -> (dict:MX , dict OUTPUT)


Reduce index.

Index reduction leads to a new set of variables and equations.

In the process, a set of constraints (algebraic equations or derivatives) a.k.a invariants is constructed that are invariant to the

problem: whenever an initial point satisfies these constraints, the

boundary-value-problem outcome will keep satisfying those constraints automatically, even though they are not part of the reduced DAE.

For any practical numerical integration method, there will be numerical drift away from satisfaction of those constraints. In other words, you will

see the value of invariants slowly moving away from

original zero.

A classic mitigation technique is Baumgarte stabilization: you add these invariants to the reduced DAE as a correction term that acts in a way to make small (numerical) perturbations to the invariants decay to the origin as a dampened linear system.

in which a certain set of constraints (algebraic equations or derivatives) has been dropped in favour of

### 1. Parameters:¶

dae: Expression dictionary describing the DAE

Each value must be a dense column vector.

keys: x_impl: symbol for implicit differential states

dx_impl: symbol for implicit differential state derivatives

z: symbol for algebraic variables

alg: expression for algebraic equations

t: symbol for time

p: symbol for parameters

### 1. Parameters:¶

opts: Option dictionary

‘baumgarte_pole’: double Poles (inverse time constants) of the Baumgarte invariant correction term. Must be <0 to dampen out perturbations 0 (default) amounts to no correction. Corresponds to -gamma of equation (1.5)

in Ascher, Uri M., Hongsheng Chin, and

Sebastian Reich. “Stabilization of

DAEs and invariant manifolds.”

Numerische Mathematik 67.2 (1994): 131-149.

### 1. Parameters:¶

stats: Statistics

Expression dictionary describing the reduced DAE

In addition the fields allowed in the input DAE, the following keys occur:

x: symbol for explicit differential states

ode: expression for right-hand-side of explicit differential states

I: expression for invariants

dae_reduce_index(dict:SX dae, dict opts)


[INTERNAL] Reduce index.

Index reduction leads to a new set of variables and equations.

In the process, a set of constraints (algebraic equations or derivatives) a.k.a invariants is constructed that are invariant to the

problem: whenever an initial point satisfies these constraints, the

boundary-value-problem outcome will keep satisfying those constraints automatically, even though they are not part of the reduced DAE.

For any practical numerical integration method, there will be numerical drift away from satisfaction of those constraints. In other words, you will

see the value of invariants slowly moving away from

original zero.

A classic mitigation technique is Baumgarte stabilization: you add these invariants to the reduced DAE as a correction term that acts in a way to make small (numerical) perturbations to the invariants decay to the origin as a dampened linear system.

in which a certain set of constraints (algebraic equations or derivatives) has been dropped in favour of

### 1. Parameters:¶

dae: Expression dictionary describing the DAE

Each value must be a dense column vector.

keys: x_impl: symbol for implicit differential states

dx_impl: symbol for implicit differential state derivatives

z: symbol for algebraic variables

alg: expression for algebraic equations

t: symbol for time

p: symbol for parameters

### 1. Parameters:¶

opts: Option dictionary

‘baumgarte_pole’: double Poles (inverse time constants) of the Baumgarte invariant correction term. Must be <0 to dampen out perturbations 0 (default) amounts to no correction. Corresponds to -gamma of equation (1.5)

in Ascher, Uri M., Hongsheng Chin, and

Sebastian Reich. “Stabilization of

DAEs and invariant manifolds.”

Numerische Mathematik 67.2 (1994): 131-149.

### 1. Parameters:¶

stats: Statistics

Expression dictionary describing the reduced DAE

In addition the fields allowed in the input DAE, the following keys occur:

x: symbol for explicit differential states

ode: expression for right-hand-side of explicit differential states

I: expression for invariants

dae_reduce_index(dict:MX dae, dict opts)


[INTERNAL] Reduce index.

Index reduction leads to a new set of variables and equations.

In the process, a set of constraints (algebraic equations or derivatives) a.k.a invariants is constructed that are invariant to the

problem: whenever an initial point satisfies these constraints, the

boundary-value-problem outcome will keep satisfying those constraints automatically, even though they are not part of the reduced DAE.

For any practical numerical integration method, there will be numerical drift away from satisfaction of those constraints. In other words, you will

see the value of invariants slowly moving away from

original zero.

A classic mitigation technique is Baumgarte stabilization: you add these invariants to the reduced DAE as a correction term that acts in a way to make small (numerical) perturbations to the invariants decay to the origin as a dampened linear system.

in which a certain set of constraints (algebraic equations or derivatives) has been dropped in favour of

### 1. Parameters:¶

dae: Expression dictionary describing the DAE

Each value must be a dense column vector.

keys: x_impl: symbol for implicit differential states

dx_impl: symbol for implicit differential state derivatives

z: symbol for algebraic variables

alg: expression for algebraic equations

t: symbol for time

p: symbol for parameters

### 1. Parameters:¶

opts: Option dictionary

‘baumgarte_pole’: double Poles (inverse time constants) of the Baumgarte invariant correction term. Must be <0 to dampen out perturbations 0 (default) amounts to no correction. Corresponds to -gamma of equation (1.5)

in Ascher, Uri M., Hongsheng Chin, and

Sebastian Reich. “Stabilization of

DAEs and invariant manifolds.”

Numerische Mathematik 67.2 (1994): 131-149.

### 1. Parameters:¶

stats: Statistics

Expression dictionary describing the reduced DAE

In addition the fields allowed in the input DAE, the following keys occur:

x: symbol for explicit differential states

ode: expression for right-hand-side of explicit differential states

I: expression for invariants

densify(*args)

Make the matrix dense and assign nonzeros to a value.

densify(DM x) -> DM
densify(SX x) -> SX
densify(MX x) -> MX

depends_on(*args)

Check if expression depends on the argument.

depends_on(DM f, DM arg) -> bool
depends_on(SX f, SX arg) -> bool
depends_on(MX f, MX arg) -> bool


The argument must be symbolic

det(*args)

Matrix determinant (experimental)

det(DM A) -> DM
det(SX A) -> SX
det(MX A) -> MX

detect_simple_bounds(*args)

[INTERNAL]

detect_simple_bounds(SX xX, SX p, SX g, SX lbg, SX ubg) -> ([int] OUTPUT, SX OUTPUT, SX OUTPUT, Function OUTPUT, Function OUTPUT)
detect_simple_bounds(MX xX, MX p, MX g, MX lbg, MX ubg) -> ([int] OUTPUT, MX OUTPUT, MX OUTPUT, Function OUTPUT, Function OUTPUT)


detect_simple_bounds(SX xX, SX p, SX g, SX lbg, SX ubg)


[INTERNAL] Detect simple bounds from general constraints.

Given parametric constraints:

*   subject to lbg(p) <= g(x,p) <= ubg(p)
*


Returns an equivalent set

*   subject to  lbg(p)(gi) <= g(x,p)(gi) <= ubg(p)(gi)
*               lbx(p) <= x                 <= ubx(p)
*


### 1. Parameters:¶

lam_forward: (lam_g,p)->(lam_sg,lam_x)

lam_backward: (lam_sg,lam_x,p)->(lam_g)

detect_simple_bounds(MX xX, MX p, MX g, MX lbg, MX ubg)


[INTERNAL]

diag(*args)

Get the diagonal of a matrix or construct a diagonal.

diag(DM A) -> DM
diag(SX A) -> SX
diag(MX A) -> MX


When the input is square, the diagonal elements are returned. If the input is vector-like, a diagonal matrix is constructed with it.

diagsplit(*args)

split diagonally, retaining fixed-sized matrices

diagsplit(Sparsity x, int incr) -> [Sparsity]
diagsplit(DM x, int incr) -> [DM]
diagsplit(SX x, int incr) -> [SX]
diagsplit(MX x, int incr) -> [MX]
diagsplit(Sparsity x, [int] output_offset) -> [Sparsity]
diagsplit(DM x, [int] output_offset) -> [DM]
diagsplit(SX x, [int] output_offset) -> [SX]
diagsplit(MX x, [int] output_offset) -> [MX]
diagsplit(Sparsity x, int incr1, int incr2) -> [Sparsity]
diagsplit(Sparsity x, [int] output_offset1, [int] output_offset2) -> [Sparsity]
diagsplit(DM x, int incr1, int incr2) -> [DM]
diagsplit(DM x, [int] output_offset1, [int] output_offset2) -> [DM]
diagsplit(SX x, int incr1, int incr2) -> [SX]
diagsplit(SX x, [int] output_offset1, [int] output_offset2) -> [SX]
diagsplit(MX x, int incr1, int incr2) -> [MX]
diagsplit(MX x, [int] output_offset1, [int] output_offset2) -> [MX]


### 1. Parameters:¶

incr1: Row dimension of each matrix

incr2: Column dimension of each matrix

diagsplit(diagsplit(x, …)) = x

diff(*args)

diff

diff(DM A, int n, int axis) -> DM
diff(SX A, int n, int axis) -> SX
diff(MX A, int n, int axis) -> MX

dot(*args)

Inner product of two matrices.

dot(DM x, DM y) -> DM
dot(SX x, SX y) -> SX
dot(MX x, MX y) -> MX


with x and y matrices of the same dimension

eig_symbolic(*args)

Attempts to find the eigenvalues of a symbolic matrix.

eig_symbolic(DM m) -> DM
eig_symbolic(SX m) -> SX


This will only work for up to 3x3 matrices

einstein(*args)

Computes an einstein dense tensor contraction.

einstein(DM A, DM B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> DM
einstein(SX A, SX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> SX
einstein(MX A, MX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX
einstein(DM A, DM B, DM C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> DM
einstein(SX A, SX B, SX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> SX
einstein(MX A, MX B, MX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX


Computes the product: C_c = A_a + B_b where a b c are index/einstein

notation in an encoded form

For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj

The encoded form uses strictly negative numbers to indicate labels. For the

above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}

eq(*args)

Logical equal to: (x,y) -> x == y.

eq(float x, float y) -> float
eq(DM x, DM y) -> DM
eq(SX x, SX y) -> SX
eq(MX x, MX y) -> MX

erf(*args)

Error function: x -> erf(x)

erf(float x) -> float
erf(DM x) -> DM
erf(SX x) -> SX
erf(MX x) -> MX

erfinv(*args)

Inverse error function: x -> erfinv(x)

erfinv(float x) -> float
erfinv(DM x) -> DM
erfinv(SX x) -> SX
erfinv(MX x) -> MX

evalf(*args)

Evaluates the expression numerically.

evalf(DM x) -> DM
evalf(SX x) -> DM
evalf(MX x) -> DM


An error is raised when the expression contains symbols

exp(*args)

Elementwise exponential: x -> exp(x)

exp(float x) -> float
exp(DM x) -> DM
exp(SX x) -> SX
exp(MX x) -> MX

expand(*args)

Expand the expression as a weighted sum (with constant weights)

expand(DM ex) -> (DM OUTPUT1, DM OUTPUT2)
expand(SX ex) -> (SX OUTPUT1, SX OUTPUT2)

expm(*args)

Calculate Matrix exponential.

expm(DM A) -> DM
expm(SX A) -> SX
expm(MX A) -> MX

expm1(*args)

Precision variant for elementwise exponential: x -> exp(x)-1.

expm1(float x) -> float
expm1(DM x) -> DM
expm1(SX x) -> SX
expm1(MX x) -> MX

expm_const(*args)

Calculate Matrix exponential.

expm_const(DM A, DM t) -> DM
expm_const(SX A, SX t) -> SX
expm_const(MX A, MX t) -> MX


Computes expm(A*t) with A constant

### 1. Parameters:¶

A[in]: Square matrix

t[in]: Scalar

extract(*args)

Introduce intermediate variables for selected nodes in a graph.

extract([DM] ex, dict opts) -> ([DM] OUTPUT1, [DM] OUTPUT2, [DM] OUTPUT3)
extract([SX] ex, dict opts) -> ([SX] OUTPUT1, [SX] OUTPUT2, [SX] OUTPUT3)
extract([MX] ex, dict opts) -> ([MX] OUTPUT1, [MX] OUTPUT2, [MX] OUTPUT3)

find(*args)

find nonzeros

find(MX x) -> MX

floor(*args)

Round down to nearest integer: x -> floor(x)

floor(float x) -> float
floor(DM x) -> DM
floor(SX x) -> SX
floor(MX x) -> MX

fmax(*args)

Largest of two values: (x,y) -> max(x,y)

fmax(float x, float y) -> float
fmax(DM x, DM y) -> DM
fmax(SX x, SX y) -> SX
fmax(MX x, MX y) -> MX

fmin(*args)

Smallest of two values: (x,y) -> min(x,y)

fmin(float x, float y) -> float
fmin(DM x, DM y) -> DM
fmin(SX x, SX y) -> SX
fmin(MX x, MX y) -> MX

fmod(*args)

Remainder after division: (x,y) -> fmod(x,y)

fmod(float x, float y) -> float
fmod(DM x, DM y) -> DM
fmod(SX x, SX y) -> SX
fmod(MX x, MX y) -> MX


This Function follows the convention of https://en.cppreference.com/w/c/numeric/math/fmod

Notably: fmod(5,3) -> 2

fmod(5,-3) -> 2

fmod(-5,3) -> -2

fmod(-5,-3) -> -2

This is equivalent to Python’s numpy.fmod and Matlab’s rem.

seealso remainder

Extra doc: https://github.com/casadi/casadi/wiki/L_pq


Integrate f from a to b using Gaussian quadrature with n points.

gauss_quadrature(DM f, DM x, DM a, DM b, int order) -> DM
gauss_quadrature(SX f, SX x, SX a, SX b, int order) -> SX
gauss_quadrature(DM f, DM x, DM a, DM b, int order, DM w) -> DM
gauss_quadrature(SX f, SX x, SX a, SX b, int order, SX w) -> SX

ge(*args)

Logical greater or equal to: (x,y) -> x <= y.

ge(float x, float y) -> float
ge(DM x, DM y) -> DM
ge(SX x, SX y) -> SX
ge(MX x, MX y) -> MX


Calculate the gradient of an expression.

gradient(DM ex, DM arg) -> DM
gradient(SX ex, SX arg) -> SX
gradient(MX ex, MX arg) -> MX


### 1. Parameters:¶

ex[in]: Scalar expression to take the gradient of

arg[in]: Vector expression of symbols

opts[in]: Options

Dense column vector

graph_substitute(*args)

Substitute multiple expressions in graph.

graph_substitute(MX ex, [MX] v, [MX] vdef) -> MX
graph_substitute([MX] ex, [MX] v, [MX] vdef) -> [MX]


Substitute variable var with expression expr in multiple expressions,

preserving nodes

gt(*args)

Logical greater than: (x,y) -> x > y.

gt(float x, float y) -> float
gt(DM x, DM y) -> DM
gt(SX x, SX y) -> SX
gt(MX x, MX y) -> MX

heaviside(*args)

Heaviside function.

heaviside(DM x) -> DM
heaviside(SX x) -> SX


[ begin {cases} H(x) = 0 & x<0 \ H(x) = 1/2 & x=0 \ H(x) = 1 & x>0 \ end {cases} ]

hessian(*args)

hessian(DM ex, DM arg, dict opts) -> (DM , DM OUTPUT1)
hessian(SX ex, SX arg, dict opts) -> (SX , SX OUTPUT1)
hessian(MX ex, MX arg, dict opts) -> (MX , MX OUTPUT1)

horzsplit(*args)

split horizontally, retaining fixed-sized groups of columns

horzsplit(Sparsity v, int incr) -> [Sparsity]
horzsplit(DM v, int incr) -> [DM]
horzsplit(SX v, int incr) -> [SX]
horzsplit(MX v, int incr) -> [MX]
horzsplit(Sparsity v, [int] offset) -> [Sparsity]
horzsplit(DM v, [int] offset) -> [DM]
horzsplit(SX v, [int] offset) -> [SX]
horzsplit(MX v, [int] offset) -> [MX]


### 1. Parameters:¶

incr: Size (width) of each group of columns

horzcat(horzsplit(x, …)) = x

seealso horzsplit_n

horzsplit_n(*args)

split horizontally, retaining fixed-sized groups of columns

horzsplit_n(Sparsity v, int n) -> [Sparsity]
horzsplit_n(DM v, int n) -> [DM]
horzsplit_n(SX v, int n) -> [SX]
horzsplit_n(MX v, int n) -> [MX]


### 1. Parameters:¶

n: Number of groups of columns

Will error when the number of columns is not a multiple of n

horzcat(horzsplit(x, …)) = x

seealso horzsplit

hypot(*args)

Precision variant for 2 norm: (x,y) -> sqrt(x^2+y^2)

hypot(float x, float y) -> float
hypot(DM x, DM y) -> DM
hypot(SX x, SX y) -> SX
hypot(MX x, MX y) -> MX

if_else(*args)

Ternary if_else: x ? y : z.

if_else(DM cond, DM if_true, DM if_false, bool short_circuit) -> DM
if_else(SX cond, SX if_true, SX if_false, bool short_circuit) -> SX
if_else(MX cond, MX if_true, MX if_false, bool short_circuit) -> MX

interp1d(*args)

Performs 1d linear interpolation.

interp1d([float] x, DM v, [float] xq, str mode, bool equidistant) -> DM
interp1d([float] x, SX v, [float] xq, str mode, bool equidistant) -> SX
interp1d([float] x, MX v, [float] xq, str mode, bool equidistant) -> MX

The data-points to be interpolated are given as (x[i], v[i]). xq[j] is

used as interplating value

inv(*args)

Element-wise inverse.

inv(DM A) -> DM
inv(SX A) -> SX
inv(MX A) -> MX
inv(DM A, str lsolver, dict opts) -> DM
inv(SX A, str lsolver, dict opts) -> SX
inv(MX A, str lsolver, dict opts) -> MX

inv_minor(*args)

Matrix inverse (experimental)

inv_minor(DM A) -> DM
inv_minor(SX A) -> SX
inv_minor(MX A) -> MX

inv_node(*args)

Inverse node.

inv_node(MX x) -> MX

inv_skew(*args)

Generate the 3-vector progenitor of a skew symmetric matrix.

inv_skew(DM a) -> DM
inv_skew(SX a) -> SX
inv_skew(MX a) -> MX

is_equal(*args)

Check if two nodes are equivalent up to a given depth.

is_equal(float x, float y, int depth) -> bool
is_equal(DM x, DM y, int depth) -> bool
is_equal(SX x, SX y, int depth) -> bool
is_equal(MX x, MX y, int depth) -> bool


Depth=0 checks if the expressions are identical, i.e. points to the same node.

a = x*x b = x*x

is_equal(a,b,0) will return false, but a.is_equal(a,b,1) will return true

is_linear(*args)

Is expr linear in var?

is_linear(DM expr, DM var) -> bool
is_linear(SX expr, SX var) -> bool
is_linear(MX expr, MX var) -> bool


False negatives are possible (an expression may not be recognised as linear

while it really is), false positives not.

is_quadratic(DM expr, DM var) -> bool
is_quadratic(SX expr, SX var) -> bool
is_quadratic(MX expr, MX var) -> bool


False negatives are possible (an expression may not be recognised as

quadratic while it really is), false positives not.

jacobian(*args)

Calculate Jacobian.

jacobian(DM ex, DM arg, dict opts) -> DM
jacobian(SX ex, SX arg, dict opts) -> SX
jacobian(MX ex, MX arg, dict opts) -> MX


Sparse matrix

jacobian_sparsity(*args)

Get the sparsity pattern of a jacobian.

jacobian_sparsity(DM f, DM x) -> Sparsity
jacobian_sparsity(SX f, SX x) -> Sparsity
jacobian_sparsity(MX f, MX x) -> Sparsity


Equivalent to, but cheaper to compute than, jacobian(f,x). sparsity()

jtimes(*args)

Calculate the Jacobian and multiply by a vector from the right.

jtimes(DM ex, DM arg, DM v, bool tr) -> DM
jtimes(SX ex, SX arg, SX v, bool tr) -> SX
jtimes(MX ex, MX arg, MX v, bool tr) -> MX


This is equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for tr set to false and true respectively. If contrast to these

expressions, it will use directional derivatives which is typically (but not necessarily) more efficient if the complete Jacobian is not needed and v has few rows.

kron(*args)

Kronecker tensor product.

kron(Sparsity a, Sparsity b) -> Sparsity
kron(DM a, DM b) -> DM
kron(SX a, SX b) -> SX
kron(MX a, MX b) -> MX


Creates a block matrix in which each element (i, j) is a_ij*b

ldivide(*args)
ldivide(float x, float y) -> float
ldivide(DM x, DM y) -> DM
ldivide(SX x, SX y) -> SX
ldivide(MX x, MX y) -> MX

ldl(*args)

Sparse LDL^T factorization.

ldl(DM A, bool amd) -> (DM OUTPUT1, DM OUTPUT2, [int] OUTPUT3)
ldl(SX A, bool amd) -> (SX OUTPUT1, SX OUTPUT2, [int] OUTPUT3)


Returns D and the strictly upper triangular entries of L^T I.e. ones on the

diagonal are ignored. Only guarenteed to work for positive

definite matrices.

ldl_solve(*args)

Solve using a sparse LDL^T factorization.

ldl_solve(DM b, DM D, DM LT, [int] p) -> DM
ldl_solve(SX b, SX D, SX LT, [int] p) -> SX

le(*args)

Logical less or equal to: (x,y) -> x <= y.

le(float x, float y) -> float
le(DM x, DM y) -> DM
le(SX x, SX y) -> SX
le(MX x, MX y) -> MX

linear_coeff(*args)

Recognizes linear form in vector expression.

linear_coeff(DM ex, DM arg, bool check) -> (DM OUTPUT1, DM OUTPUT2)
linear_coeff(SX ex, SX arg, bool check) -> (SX OUTPUT1, SX OUTPUT2)
linear_coeff(MX ex, MX arg, bool check) -> (MX OUTPUT1, MX OUTPUT2)


A x + b

### 1. Parameters:¶

check[in]: When true (default)m, A is checked to be independent of x. Provided to

deal with false positive dependency checks.

linearize(*args)

Linearize an expression.

linearize(DM f, DM x, DM x0) -> DM
linearize(SX f, SX x, SX x0) -> SX
linearize(MX f, MX x, MX x0) -> MX

linspace(*args)

Matlab’s linspace.

linspace(DM a, DM b, int nsteps) -> DM
linspace(SX a, SX b, int nsteps) -> SX
linspace(MX a, MX b, int nsteps) -> MX

log(*args)

Natural logarithm: x -> log(x)

log(float x) -> float
log(DM x) -> DM
log(SX x) -> SX
log(MX x) -> MX

log10(*args)

Base-10 logarithm: x -> log10(x)

log10(float x) -> float
log10(DM x) -> DM
log10(SX x) -> SX
log10(MX x) -> MX

log1p(*args)

Precision variant for natural logarithm: x -> log(x+1)

log1p(float x) -> float
log1p(DM x) -> DM
log1p(SX x) -> SX
log1p(MX x) -> MX

logsumexp(*args)

Scaled version of logsumexp.

logsumexp(DM a) -> DM
logsumexp(SX a) -> SX
logsumexp(MX a) -> MX
logsumexp(DM a, DM margin) -> DM
logsumexp(SX a, SX margin) -> SX
logsumexp(MX a, MX margin) -> MX


Scaled such that max(x) <= logsumexp(x, margin) <= max(x)+margin

low(*args)

Find first nonzero.

low(MX v, MX p, dict options) -> MX


If failed, returns the number of rows

lt(*args)

Logical less than: (x,y) -> x < y.

lt(float x, float y) -> float
lt(DM x, DM y) -> DM
lt(SX x, SX y) -> SX
lt(MX x, MX y) -> MX

mac(*args)

Multiply-accumulate operation.

mac(Sparsity X, Sparsity Y, Sparsity Z) -> Sparsity
mac(DM X, DM Y, DM Z) -> DM
mac(SX X, SX Y, SX Z) -> SX
mac(MX X, MX Y, MX Z) -> MX


Matrix product of two matrices (x and y), adding the result to a third

matrix z. The result has the same sparsity pattern as C meaning that other entries of (x*y) are ignored. The operation is equivalent to:

z+mtimes(x,y).project(z.sparsity()).

matrix_expand(*args)

Expand MX graph to SXFunction call.

matrix_expand(MX e, [MX] boundary, dict options) -> MX
matrix_expand([MX] e, [MX] boundary, dict options) -> [MX]


Expand the given expression e, optionally supplying expressions contained in it at which expansion should stop.

minor(*args)

Get the (i,j) minor matrix.

minor(DM x, int i, int j) -> DM
minor(SX x, int i, int j) -> SX

minus(*args)

Subtraction: (x,y) -> x - y.

minus(float x, float y) -> float
minus(DM x, DM y) -> DM
minus(SX x, SX y) -> SX
minus(MX x, MX y) -> MX

mldivide(*args)

Matrix divide (cf. backslash ‘' in MATLAB)

mldivide(DM x, DM y) -> DM
mldivide(SX x, SX y) -> SX
mldivide(MX x, MX y) -> MX

mmax(*args)

Largest element in a matrix.

mmax(DM x) -> DM
mmax(SX x) -> SX
mmax(MX x) -> MX

mmin(*args)

Smallest element in a matrix.

mmin(DM x) -> DM
mmin(SX x) -> SX
mmin(MX x) -> MX

mpower(*args)

Matrix power x^n.

mpower(DM x, DM n) -> DM
mpower(SX x, SX n) -> SX
mpower(MX x, MX n) -> MX

mrdivide(*args)

Matrix divide (cf. slash ‘/’ in MATLAB)

mrdivide(DM x, DM y) -> DM
mrdivide(SX x, SX y) -> SX
mrdivide(MX x, MX y) -> MX

mtaylor(*args)

multivariate Taylor series expansion

mtaylor(DM ex, DM x, DM a, int order) -> DM
mtaylor(SX ex, SX x, SX a, int order) -> SX
mtaylor(DM ex, DM x, DM a, int order, [int] order_contributions) -> DM
mtaylor(SX ex, SX x, SX a, int order, [int] order_contributions) -> SX


Do Taylor expansions until the aggregated order of a term is equal to

‘order’. The aggregated order of $x^n y^m$ equals $n+m$.

The argument order_contributions can denote how match each variable

contributes to the aggregated order. If x=[x, y] and

order_contributions=[1, 2], then the aggregated order of $x^n y^m$ equals $1n+2m$.

Example usage

>>> taylor(sin(x+y),[x, y],[a, b], 1)


$sin(b+a)+cos(b+a)(x-a)+cos(b+a)(y-b)$

>>> taylor(sin(x+y),[x, y],[0, 0], 4)


$y+x-(x^3+3y x^2+3 y^2 x+y^3)/6$

>>> taylor(sin(x+y),[x, y],[0, 0], 4,[1, 2])


$(-3 x^2 y-x^3)/6+y+x$

mtimes(*args)

Matrix product of n matrices.

mtimes([Sparsity] args) -> Sparsity
mtimes([DM] args) -> DM
mtimes([SX] args) -> SX
mtimes([MX] args) -> MX
mtimes(Sparsity x, Sparsity y) -> Sparsity
mtimes(DM x, DM y) -> DM
mtimes(SX x, SX y) -> SX
mtimes(MX x, MX y) -> MX

n_nodes(*args)
n_nodes(DM A) -> int
n_nodes(SX A) -> int
n_nodes(MX A) -> int

ne(*args)

Logical not equal to: (x,y) -> x != y.

ne(float x, float y) -> float
ne(DM x, DM y) -> DM
ne(SX x, SX y) -> SX
ne(MX x, MX y) -> MX


Stop first derivatives of an expression wrt to all its symbolic

no_grad(MX expr) -> MX


variables.

seealso stop_diff

no_hess(*args)

Stop second derivatives of an expression wrt to all its symbolic

no_hess(MX expr) -> MX


variables.

seealso stop_diff

norm_0_mul(*args)
norm_0_mul(Sparsity x, Sparsity y) -> int
norm_0_mul(DM x, DM y) -> int
norm_0_mul(SX x, SX y) -> int
norm_0_mul(MX x, MX y) -> int

norm_1(*args)

1-norm

norm_1(DM x) -> DM
norm_1(SX x) -> SX
norm_1(MX x) -> MX

norm_2(*args)

2-norm

norm_2(DM x) -> DM
norm_2(SX x) -> SX
norm_2(MX x) -> MX

norm_fro(*args)

Frobenius norm.

norm_fro(DM x) -> DM
norm_fro(SX x) -> SX
norm_fro(MX x) -> MX

norm_inf(*args)

Infinity-norm.

norm_inf(DM x) -> DM
norm_inf(SX x) -> SX
norm_inf(MX x) -> MX

norm_inf_mul(*args)

Inf-norm of a Matrix-Matrix product.

norm_inf_mul(DM x, DM y) -> DM
norm_inf_mul(SX x, SX y) -> SX

nullspace(*args)

Computes the nullspace of a matrix A.

nullspace(DM A) -> DM
nullspace(SX A) -> SX
nullspace(MX A) -> MX


Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n

Assumes A is full rank

Inspired by Numerical Methods in Scientific Computing by Ake Bjorck

pinv(*args)

Computes the Moore-Penrose pseudo-inverse.

pinv(DM A) -> DM
pinv(SX A) -> SX
pinv(MX A) -> MX
pinv(DM A, str lsolver, dict opts) -> DM
pinv(SX A, str lsolver, dict opts) -> SX
pinv(MX A, str lsolver, dict opts) -> MX


If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the

matrix A is slender (size2<size1), mul(pinv(A), A) is unity.

plus(*args)
plus(float x, float y) -> float
plus(DM x, DM y) -> DM
plus(SX x, SX y) -> SX
plus(MX x, MX y) -> MX

poly_coeff(*args)

extracts polynomial coefficients from an expression

poly_coeff(DM ex, DM x) -> DM
poly_coeff(SX ex, SX x) -> SX


### 1. Parameters:¶

ex: Scalar expression that represents a polynomial

x: Scalar symbol that the polynomial is build up with

poly_roots(*args)

Attempts to find the roots of a polynomial.

poly_roots(DM p) -> DM
poly_roots(SX p) -> SX


This will only work for polynomials up to order 3 It is assumed that the roots are real.

polyval(*args)

Evaluate a polynomial with coefficients p in x.

polyval(DM p, DM x) -> DM
polyval(SX p, SX x) -> SX
polyval(MX p, MX x) -> MX

power(*args)
power(float x, float n) -> float
power(DM x, DM n) -> DM
power(SX x, SX n) -> SX
power(MX x, MX n) -> MX

print_operator(*args)

Get a string representation for a binary MatType, using custom

print_operator(DM xb, [str] args) -> str
print_operator(SX xb, [str] args) -> str
print_operator(MX xb, [str] args) -> str


arguments.

project(*args)

Create a new matrix with a given sparsity pattern but with the.

project(DM A, Sparsity sp, bool intersect) -> DM
project(SX A, Sparsity sp, bool intersect) -> SX
project(MX A, Sparsity sp, bool intersect) -> MX


nonzeros taken from an existing matrix

pw_const(*args)

Create a piecewise constant function.

pw_const(DM t, DM tval, DM val) -> DM
pw_const(SX t, SX tval, SX val) -> SX


Create a piecewise constant function with n=val.size() intervals

Inputs:

### 1. Parameters:¶

t: a scalar variable (e.g. time)

tval: vector with the discrete values of t at the interval transitions

(length n-1)

val: vector with the value of the function for each interval (length n)

pw_lin(*args)

t a scalar variable (e.g. time)

pw_lin(DM t, DM tval, DM val) -> DM
pw_lin(SX t, SX tval, SX val) -> SX


Create a piecewise linear function

Create a piecewise linear function:

Inputs:

tval vector with the the discrete values of t (monotonically increasing)

val vector with the corresponding function values (same length as tval)

Extra doc: https://github.com/casadi/casadi/wiki/L_194

qr(*args)

QR factorization using the modified Gram-Schmidt algorithm.

qr(DM A) -> (DM OUTPUT1, DM OUTPUT2)
qr(SX A) -> (SX OUTPUT1, SX OUTPUT2)

More stable than the classical Gram-Schmidt, but may break down if the

rows of A are nearly linearly dependent See J. Demmel: Applied

Numerical Linear

Algebra (algorithm 3.1.). Note that in SWIG, Q and R

are returned by value.

qr_solve(*args)

Solve using a sparse QR factorization.

qr_solve(DM b, DM v, DM r, DM beta, [int] prinv, [int] pc, bool tr) -> DM
qr_solve(SX b, SX v, SX r, SX beta, [int] prinv, [int] pc, bool tr) -> SX

qr_sparse(*args)

Sparse direct QR factorization.

qr_sparse(DM A, bool amd) -> (DM OUTPUT1, DM OUTPUT2, DM OUTPUT3, [int] OUTPUT4, [int] OUTPUT5)
qr_sparse(SX A, bool amd) -> (SX OUTPUT1, SX OUTPUT2, SX OUTPUT3, [int] OUTPUT4, [int] OUTPUT5)


See T. Davis: Direct Methods for Sparse Linear Systems

Recognizes quadratic form in scalar expression.

quadratic_coeff(DM ex, DM arg, bool check) -> (DM OUTPUT1, DM OUTPUT2, DM OUTPUT3)
quadratic_coeff(SX ex, SX arg, bool check) -> (SX OUTPUT1, SX OUTPUT2, SX OUTPUT3)
quadratic_coeff(MX ex, MX arg, bool check) -> (MX OUTPUT1, MX OUTPUT2, MX OUTPUT3)


1/2*x’ A x + b’ x + c

e = 0.5*bilin(A,x,x)+dot(b,x)+c

### 1. Parameters:¶

check[in]: When true (default), A is checked to be independent of x. Provided to deal with false positive dependency checks.

ramp(*args)

ramp function

ramp(DM x) -> DM
ramp(SX x) -> SX


[ begin {cases} R(x) = 0 & x <= 1 \ R(x) = x & x > 1

\ end {cases} ]

Also called: slope function

rank1(*args)

Make a rank-1 update to a matrix A.

rank1(DM A, DM alpha, DM x, DM y) -> DM
rank1(SX A, SX alpha, SX x, SX y) -> SX
rank1(MX A, MX alpha, MX x, MX y) -> MX


Calculates A + 1/2 * alpha * x*y’

rdivide(*args)

Elementwise division: (x,y) -> x ./ y.

rdivide(float x, float y) -> float
rdivide(DM x, DM y) -> DM
rdivide(SX x, SX y) -> SX
rdivide(MX x, MX y) -> MX

rectangle(*args)

rectangle function

rectangle(DM x) -> DM
rectangle(SX x) -> SX

[ begin {cases} Pi(x) = 1 & |x| < 1/2 \ Pi(x) =

1/2

& |x| = 1/2 \ Pi(x) = 0 & |x| > 1/2 \ end {cases} ]

Also called: gate function, block function, band function, pulse function, window function

remainder(*args)

Remainder after division: (x,y) -> remainder(x,y)

remainder(float x, float y) -> float
remainder(DM x, DM y) -> DM
remainder(SX x, SX y) -> SX
remainder(MX x, MX y) -> MX


This Function follows the convention of https://en.cppreference.com/w/c/numeric/math/remainder

Notably: remainder(5,3) -> -1

remainder(5,-3) -> -1

remainder(-5,3) -> 1

remainder(-5,-3) -> 1

This is equivalent to Python’s math.remainder. There is no equivalence

in

Matlab.

seealso fmod

Extra doc: https://github.com/casadi/casadi/wiki/L_24x

repmat(*args)

Repeat matrix A n times vertically and m times horizontally.

repmat(Sparsity A, int n, int m) -> Sparsity
repmat(Sparsity A, (int,int) rc) -> Sparsity
repmat(DM A, int n, int m) -> DM
repmat(DM A, (int,int) rc) -> DM
repmat(SX A, int n, int m) -> SX
repmat(SX A, (int,int) rc) -> SX
repmat(MX A, int n, int m) -> MX
repmat(MX A, (int,int) rc) -> MX

repsum(*args)

Given a repeated matrix, computes the sum of repeated parts.

repsum(DM A, int n, int m) -> DM
repsum(SX A, int n, int m) -> SX
repsum(MX A, int n, int m) -> MX

reshape(*args)

Reshape the matrix.

reshape(Sparsity a, (int,int) rc) -> Sparsity
reshape(Sparsity a, Sparsity sp) -> Sparsity
reshape(DM a, (int,int) rc) -> DM
reshape(DM a, Sparsity sp) -> DM
reshape(SX a, (int,int) rc) -> SX
reshape(SX a, Sparsity sp) -> SX
reshape(MX a, (int,int) rc) -> MX
reshape(MX a, Sparsity sp) -> MX
reshape(Sparsity a, int nrow, int ncol) -> Sparsity
reshape(DM a, int nrow, int ncol) -> DM
reshape(SX a, int nrow, int ncol) -> SX
reshape(MX a, int nrow, int ncol) -> MX

shared(*args)

Get a shared (owning) reference.

shared([DM] ex, str v_prefix, str v_suffix) -> ([DM] OUTPUT1, [DM] OUTPUT2, [DM] OUTPUT3)
shared([SX] ex, str v_prefix, str v_suffix) -> ([SX] OUTPUT1, [SX] OUTPUT2, [SX] OUTPUT3)
shared([MX] ex, str v_prefix, str v_suffix) -> ([MX] OUTPUT1, [MX] OUTPUT2, [MX] OUTPUT3)

sign(*args)

Sign function:

sign(float x) -> float
sign(DM x) -> DM
sign(SX x) -> SX
sign(MX x) -> MX


sign(x) := -1 for x<0 sign(x) := 1 for x>0, sign(0) := 0 sign(NaN) := NaN

simplify(*args)

Simplify an expression.

simplify(float x) -> float
simplify(DM x) -> DM
simplify(SX x) -> SX
simplify(MX x) -> MX

sin(*args)

Sine: x -> sin(x)

sin(float x) -> float
sin(DM x) -> DM
sin(SX x) -> SX
sin(MX x) -> MX

sinh(*args)

Hyperbolic sin: x -> sinh(x)

sinh(float x) -> float
sinh(DM x) -> DM
sinh(SX x) -> SX
sinh(MX x) -> MX

skew(*args)

Generate a skew symmetric matrix from a 3-vector.

skew(DM a) -> DM
skew(SX a) -> SX
skew(MX a) -> MX

soc(*args)

Construct second-order-convex.

soc(DM x, DM y) -> DM
soc(SX x, SX y) -> SX
soc(MX x, MX y) -> MX


### 1. Parameters:¶

x: vector expression of size n

y: scalar expression

soc(x,y) computes [y*eye(n) x; x’ y]

soc(x,y) positive semi definite <=> || x ||_2 <= y

solve(*args)

Crunch the numbers; solve the problem.

solve(DM A, DM b) -> DM
solve(SX A, SX b) -> SX
solve(MX A, MX b) -> MX
solve(DM A, DM b, str lsolver, dict opts) -> DM
solve(SX A, SX b, str lsolver, dict opts) -> SX
solve(MX A, MX b, str lsolver, dict opts) -> MX

sparsify(*args)

Make a matrix sparse by removing numerical zeros.

sparsify(DM A, float tol) -> DM
sparsify(SX A, float tol) -> SX

sparsity_cast(*args)

Cast matrix nonzeros to different Sparsity.

sparsity_cast(Sparsity a, Sparsity sp) -> Sparsity
sparsity_cast(DM a, Sparsity sp) -> DM
sparsity_cast(SX a, Sparsity sp) -> SX
sparsity_cast(MX a, Sparsity sp) -> MX

sprank(*args)
sprank(Sparsity A) -> int
sprank(DM A) -> int
sprank(SX A) -> int
sprank(MX A) -> int

sqrt(*args)

Square root: x -> sqrt(x)

sqrt(float x) -> float
sqrt(DM x) -> DM
sqrt(SX x) -> SX
sqrt(MX x) -> MX

stop_diff(*args)

Stop derivatives of an expression wrt to a select set of symbolic

stop_diff(MX expr, int order) -> MX
stop_diff(MX expr, MX var, int order) -> MX


variables.

substitute(*args)

Substitute variable var with expression expr in multiple expressions.

substitute(DM ex, DM v, DM vdef) -> DM
substitute([DM] ex, [DM] v, [DM] vdef) -> [DM]
substitute(SX ex, SX v, SX vdef) -> SX
substitute([SX] ex, [SX] v, [SX] vdef) -> [SX]
substitute(MX ex, MX v, MX vdef) -> MX
substitute([MX] ex, [MX] v, [MX] vdef) -> [MX]

substitute_inplace(*args)

Inplace substitution with piggyback expressions.

substitute_inplace([DM] v, bool reverse) -> ([DM] INOUT1, [DM] INOUT2)
substitute_inplace([SX] v, bool reverse) -> ([SX] INOUT1, [SX] INOUT2)
substitute_inplace([MX] v, bool reverse) -> ([MX] INOUT1, [MX] INOUT2)


Substitute variables v out of the expressions vdef sequentially, as well as

out of a number of other expressions piggyback

sum1(*args)

Return a row-wise summation of elements.

sum1(Sparsity x) -> Sparsity
sum1(DM x) -> DM
sum1(SX x) -> SX
sum1(MX x) -> MX

sum2(*args)

Return a column-wise summation of elements.

sum2(Sparsity x) -> Sparsity
sum2(DM x) -> DM
sum2(SX x) -> SX
sum2(MX x) -> MX

sumsqr(*args)

Calculate sum of squares: sum_ij X_ij^2.

sumsqr(DM X) -> DM
sumsqr(SX X) -> SX
sumsqr(MX X) -> MX

symvar(*args)

Get symbols present in expression.

symvar(DM x) -> [DM]
symvar(SX x) -> [SX]
symvar(MX x) -> [MX]

Returned vector is ordered according to the order of variable()/parameter()

calls used to create the variables

tan(*args)

Tangent: x -> tan(x)

tan(float x) -> float
tan(DM x) -> DM
tan(SX x) -> SX
tan(MX x) -> MX

tangent(*args)

Calculate the tangent of an expression.

tangent(DM ex, DM arg) -> DM
tangent(SX ex, SX arg) -> SX
tangent(MX ex, MX arg) -> MX

tanh(*args)

Hyperbolic tangent: x -> tanh(x)

tanh(float x) -> float
tanh(DM x) -> DM
tanh(SX x) -> SX
tanh(MX x) -> MX

taylor(*args)

univariate Taylor series expansion

taylor(DM ex, DM x, DM a, int order) -> DM
taylor(SX ex, SX x, SX a, int order) -> SX


Calculate the Taylor expansion of expression ‘ex’ up to order ‘order’ with respect to variable ‘x’ around the point ‘a’

$(x)=f(a)+f’(a)(x-a)+f’’(a)frac {(x-a)^2}{2!}+f’’’(a)frac{(x-a)^3}{3!}+ldots$

Example usage:

>>> taylor(sin(x), x)

>>   x

times(*args)

Elementwise multiplication: (x,y) -> x .* y.

times(float x, float y) -> float
times(DM x, DM y) -> DM
times(SX x, SX y) -> SX
times(MX x, MX y) -> MX

trace(*args)

Matrix trace.

trace(DM a) -> DM
trace(SX a) -> SX
trace(MX a) -> MX

transpose(*args)

Transpose.

transpose(Sparsity X) -> Sparsity
transpose(DM X) -> DM
transpose(SX X) -> SX
transpose(MX X) -> MX

triangle(*args)

triangle function

triangle(DM x) -> DM
triangle(SX x) -> SX


[ begin {cases} Lambda(x) = 0 & |x| >= 1 \ Lambda(x)

= 1-|x| & |x| < 1 end {cases} ]

tril(*args)

Get the lower triangular part of a matrix.

tril(Sparsity a, bool includeDiagonal) -> Sparsity
tril(DM a, bool includeDiagonal) -> DM
tril(SX a, bool includeDiagonal) -> SX
tril(MX a, bool includeDiagonal) -> MX

tril2symm(*args)

Convert a lower triangular matrix to a symmetric one.

tril2symm(DM a) -> DM
tril2symm(SX a) -> SX
tril2symm(MX a) -> MX

triu(*args)

Get the upper triangular part of a matrix.

triu(Sparsity a, bool includeDiagonal) -> Sparsity
triu(DM a, bool includeDiagonal) -> DM
triu(SX a, bool includeDiagonal) -> SX
triu(MX a, bool includeDiagonal) -> MX

triu2symm(*args)

Convert a upper triangular matrix to a symmetric one.

triu2symm(DM a) -> DM
triu2symm(SX a) -> SX
triu2symm(MX a) -> MX

unite(*args)

Unite two matrices no overlapping sparsity.

unite(DM A, DM B) -> DM
unite(SX A, SX B) -> SX
unite(MX A, MX B) -> MX

vec(*args)

make a vector

vec(Sparsity a) -> Sparsity
vec(DM a) -> DM
vec(SX a) -> SX
vec(MX a) -> MX


Reshapes/vectorizes the matrix such that the shape becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as reshape(expr, expr.numel(), 1)

a c b d

turns into

a b c d

which_depends(*args)

Find out which variables enter with some order.

which_depends(DM expr, DM var, int order, bool tr) -> [bool]
which_depends(SX expr, SX var, int order, bool tr) -> [bool]
which_depends(MX expr, MX var, int order, bool tr) -> [bool]


## 2. Classes¶

### 2.1. DM¶

class DM(*args)
.. py:method:: DM.assign(*args)

module:

assign(self, DM rhs)

static binary(*args)
binary(int op, DM x, DM y) -> DM

clear(*args)

[INTERNAL]

clear(self)

dep(*args)
dep(self, int ch) -> DM

static deserialize(*args)
deserialize(std::istream & stream) -> DM
deserialize(str s) -> DM

disp(*args)

[INTERNAL]

disp(self, bool more)


Print a representation of the object.

element_hash(*args)
element_hash(self) -> int

elements(*args)

[INTERNAL]

elements(self) -> [float]


Get all elements.

enlarge(*args)

[INTERNAL]

enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)


Enlarge matrix.

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

erase(*args)

[INTERNAL]

erase(self, [int] rr, bool ind1)
erase(self, [int] rr, [int] cc, bool ind1)


Erase a submatrix (leaving structural zeros in its place)

Erase elements of a matrix

erase(self, [int] rr, bool ind1)


[INTERNAL] Erase a submatrix (leaving structural zeros in its place)

Erase elements of a matrix

erase(self, [int] rr, [int] cc, bool ind1)


[INTERNAL] Erase a submatrix (leaving structural zeros in its place)

Erase rows and/or columns of a matrix

export_code(*args)
export_code(self, str lang, dict options)

static eye(*args)
eye(int n) -> DM

static from_file(*args)
from_file(str filename, str format_hint) -> DM

full(*args)
full(self) -> PyObject *

get(*args)
get(self, bool ind1, Sparsity sp) -> DM
get(self, bool ind1, Slice rr) -> DM
get(self, bool ind1, IM rr) -> DM
get(self, bool ind1, Slice rr, Slice cc) -> DM
get(self, bool ind1, Slice rr, IM cc) -> DM
get(self, bool ind1, IM rr, Slice cc) -> DM
get(self, bool ind1, IM rr, IM cc) -> DM

static get_free(*args)
get_free(Function f) -> [DM]

static get_input(*args)
get_input(Function f) -> [DM]

static get_max_depth(*args)
get_max_depth() -> int

get_nz(*args)
get_nz(self, bool ind1, Slice k) -> DM
get_nz(self, bool ind1, IM k) -> DM

has_duplicates(*args)
has_duplicates(self) -> bool

has_nz(*args)

[INTERNAL]

has_nz(self, int rr, int cc) -> bool


Returns true if the matrix has a non-zero at location rr, cc.

has_zeros(*args)

[INTERNAL]

has_zeros(self) -> bool


Check if the matrix has any zero entries which are not structural zeros.

static inf(*args)

[INTERNAL]

inf(int nrow, int ncol) -> DM
inf((int,int) rc) -> DM
inf(Sparsity sp) -> DM


create a matrix with all inf

inf(int nrow, int ncol)


[INTERNAL] create a matrix with all inf

inf((int,int) rc)


[INTERNAL] create a matrix with all inf

inf(Sparsity sp)


[INTERNAL] create a matrix with all inf

info(*args)
info(self) -> dict

is_commutative(*args)
is_commutative(self) -> bool

is_constant(*args)

[INTERNAL]

is_constant(self) -> bool


Check if the matrix is constant (note that false negative answers are possible)

is_eye(*args)

[INTERNAL]

is_eye(self) -> bool


check if the matrix is an identity matrix (note that false negative answers

are possible)

is_integer(*args)

[INTERNAL]

is_integer(self) -> bool


Check if the matrix is integer-valued.

(note that false negative answers are possible)

is_leaf(*args)
is_leaf(self) -> bool

is_minus_one(*args)

[INTERNAL]

is_minus_one(self) -> bool


check if the matrix is -1 (note that false negative answers are

possible)

is_one(*args)

[INTERNAL]

is_one(self) -> bool


check if the matrix is 1 (note that false negative answers are

possible)

is_op(*args)
is_op(self, int op) -> bool

is_regular(*args)
is_regular(self) -> bool

is_smooth(*args)
is_smooth(self) -> bool

is_symbolic(*args)
is_symbolic(self) -> bool

is_valid_input(*args)
is_valid_input(self) -> bool

is_zero(*args)

[INTERNAL]

is_zero(self) -> bool


check if the matrix is 0 (note that false negative answers are

possible)

static matrix_matrix(*args)
matrix_matrix(int op, DM x, DM y) -> DM

static matrix_scalar(*args)
matrix_scalar(int op, DM x, DM y) -> DM

n_dep(*args)
n_dep(self) -> int

name(*args)
name(self) -> str

static nan(*args)

[INTERNAL]

nan(int nrow, int ncol) -> DM
nan((int,int) rc) -> DM
nan(Sparsity sp) -> DM


create a matrix with all nan

nan(int nrow, int ncol)


[INTERNAL] create a matrix with all nan

nan((int,int) rc)


[INTERNAL] create a matrix with all nan

nan(Sparsity sp)


[INTERNAL] create a matrix with all nan

nonzeros(*args)

[INTERNAL]

nonzeros(self) -> [float]


Get all nonzeros.

op(*args)
op(self) -> int

print_dense(*args)

[INTERNAL]

print_dense(self, bool truncate)


Print dense matrix-stype.

print_scalar(*args)

[INTERNAL]

print_scalar(self)


Print scalar.

print_sparse(*args)

[INTERNAL]

print_sparse(self, bool truncate)


Print sparse matrix style.

print_split(*args)

[INTERNAL]

print_split(self) -> ([str] OUTPUT, [str] OUTPUT)


Get strings corresponding to the nonzeros and the interdependencies.

print_vector(*args)

[INTERNAL]

print_vector(self, bool truncate)


Print vector-style.

printme(*args)
printme(self, DM y) -> DM

static rand(*args)

[INTERNAL]

rand(int nrow, int ncol) -> DM
rand((int,int) rc) -> DM
rand(Sparsity sp) -> DM


Create a matrix with uniformly distributed random numbers.

rand(Sparsity sp)


rand(int nrow, int ncol)


[INTERNAL] Create a matrix with uniformly distributed random numbers.

rand((int,int) rc)


[INTERNAL] Create a matrix with uniformly distributed random numbers.

remove(*args)

[INTERNAL]

remove(self, [int] rr, [int] cc)


Remove columns and rows.

Remove/delete rows and/or columns of a matrix

reserve(*args)

[INTERNAL]

reserve(self, int nnz)
reserve(self, int nnz, int ncol)

reset_input(*args)
reset_input(self)

resize(*args)

[INTERNAL]

resize(self, int nrow, int ncol)

static rng(*args)
rng(int seed)

static scalar_matrix(*args)
scalar_matrix(int op, DM x, DM y) -> DM

serialize(*args)

[INTERNAL]

serialize(self) -> str


Serialize an object.

serialize(self, casadi::SerializingStream & s)


[INTERNAL] Serialize an object.

serialize(self)


[INTERNAL] Serialize.

set(*args)
set(self, DM m, bool ind1, Sparsity sp)
set(self, DM m, bool ind1, Slice rr)
set(self, DM m, bool ind1, IM rr)
set(self, DM m, bool ind1, Slice rr, Slice cc)
set(self, DM m, bool ind1, Slice rr, IM cc)
set(self, DM m, bool ind1, IM rr, Slice cc)
set(self, DM m, bool ind1, IM rr, IM cc)

static set_max_depth(*args)
set_max_depth(int eq_depth)

set_nz(*args)
set_nz(self, DM m, bool ind1, Slice k)
set_nz(self, DM m, bool ind1, IM k)

static set_precision(*args)
set_precision(int precision)

static set_scientific(*args)
set_scientific(bool scientific)

static set_width(*args)
set_width(int width)

sparse(*args)
sparse(self) -> PyObject *

sparsity(*args)

[INTERNAL]

sparsity(self) -> Sparsity


Get an owning reference to the sparsity pattern.

str(*args)

[INTERNAL]

str(self, bool more) -> str


Get string representation.

to_file(*args)

[INTERNAL]

to_file(self, str filename, str format)


Export numerical matrix to file

Supported formats:

*   - .mtx   Matrix Market (sparse)
*   - .txt   Ascii full precision representation (sparse)
*            Whitespace separated, aligned.
*            Comments with # % or /
*            Uses C locale
*            Structural zeros represented by 00
*            Does not scale well for large sparse matrices
*

static triplet(*args)
triplet([int] row, [int] col, DM d) -> DM
triplet([int] row, [int] col, DM d, (int,int) rc) -> DM
triplet([int] row, [int] col, DM d, int nrow, int ncol) -> DM

static type_name(*args)
type_name() -> str

static unary(*args)
unary(int op, DM x) -> DM


### 2.2. SX¶

class SX(*args)
.. py:method:: SX.binary(*args)

module:

staticmethod:

binary(int op, SX x, SX y) -> SX

clear(*args)

[INTERNAL]

clear(self)

dep(*args)
dep(self, int ch) -> SX

static deserialize(*args)
deserialize(std::istream & stream) -> SX
deserialize(str s) -> SX

disp(*args)

[INTERNAL]

disp(self, bool more)


Print a representation of the object.

element_hash(*args)
element_hash(self) -> int

elements(*args)

[INTERNAL]

elements(self) -> [SXElem]


Get all elements.

enlarge(*args)

[INTERNAL]

enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)


Enlarge matrix.

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

erase(*args)

[INTERNAL]

erase(self, [int] rr, bool ind1)
erase(self, [int] rr, [int] cc, bool ind1)


Erase a submatrix (leaving structural zeros in its place)

Erase elements of a matrix

erase(self, [int] rr, bool ind1)


[INTERNAL] Erase a submatrix (leaving structural zeros in its place)

Erase elements of a matrix

erase(self, [int] rr, [int] cc, bool ind1)


[INTERNAL] Erase a submatrix (leaving structural zeros in its place)

Erase rows and/or columns of a matrix

export_code(*args)
export_code(self, str lang, dict options)

static eye(*args)
eye(int n) -> SX

static from_file(*args)
from_file(str filename, str format_hint) -> DM

get(*args)
get(self, bool ind1, Sparsity sp) -> SX
get(self, bool ind1, Slice rr) -> SX
get(self, bool ind1, IM rr) -> SX
get(self, bool ind1, Slice rr, Slice cc) -> SX
get(self, bool ind1, Slice rr, IM cc) -> SX
get(self, bool ind1, IM rr, Slice cc) -> SX
get(self, bool ind1, IM rr, IM cc) -> SX

static get_free(*args)
get_free(Function f) -> [SX]

static get_input(*args)
get_input(Function f) -> [SX]

static get_max_depth(*args)
get_max_depth() -> int

get_nz(*args)
get_nz(self, bool ind1, Slice k) -> SX
get_nz(self, bool ind1, IM k) -> SX

has_duplicates(*args)
has_duplicates(self) -> bool

has_nz(*args)

[INTERNAL]

has_nz(self, int rr, int cc) -> bool


Returns true if the matrix has a non-zero at location rr, cc.

has_zeros(*args)

[INTERNAL]

has_zeros(self) -> bool


Check if the matrix has any zero entries which are not structural zeros.

static inf(*args)

[INTERNAL]

inf(int nrow, int ncol) -> SX
inf((int,int) rc) -> SX
inf(Sparsity sp) -> SX


create a matrix with all inf

inf(int nrow, int ncol)


[INTERNAL] create a matrix with all inf

inf((int,int) rc)


[INTERNAL] create a matrix with all inf

inf(Sparsity sp)


[INTERNAL] create a matrix with all inf

info(*args)
info(self) -> dict

is_commutative(*args)
is_commutative(self) -> bool

is_constant(*args)

[INTERNAL]

is_constant(self) -> bool


Check if the matrix is constant (note that false negative answers are possible)

is_eye(*args)

[INTERNAL]

is_eye(self) -> bool


check if the matrix is an identity matrix (note that false negative answers

are possible)

is_integer(*args)

[INTERNAL]

is_integer(self) -> bool


Check if the matrix is integer-valued.

(note that false negative answers are possible)

is_leaf(*args)
is_leaf(self) -> bool

is_minus_one(*args)

[INTERNAL]

is_minus_one(self) -> bool


check if the matrix is -1 (note that false negative answers are

possible)

is_one(*args)

[INTERNAL]

is_one(self) -> bool


check if the matrix is 1 (note that false negative answers are

possible)

is_op(*args)
is_op(self, int op) -> bool

is_regular(*args)
is_regular(self) -> bool

is_smooth(*args)
is_smooth(self) -> bool

is_symbolic(*args)
is_symbolic(self) -> bool

is_valid_input(*args)
is_valid_input(self) -> bool

is_zero(*args)

[INTERNAL]

is_zero(self) -> bool


check if the matrix is 0 (note that false negative answers are

possible)

static matrix_matrix(*args)
matrix_matrix(int op, SX x, SX y) -> SX

static matrix_scalar(*args)
matrix_scalar(int op, SX x, SX y) -> SX

n_dep(*args)
n_dep(self) -> int

name(*args)
name(self) -> str

static nan(*args)

[INTERNAL]

nan(int nrow, int ncol) -> SX
nan((int,int) rc) -> SX
nan(Sparsity sp) -> SX


create a matrix with all nan

nan(int nrow, int ncol)


[INTERNAL] create a matrix with all nan

nan((int,int) rc)


[INTERNAL] create a matrix with all nan

nan(Sparsity sp)


[INTERNAL] create a matrix with all nan

nonzeros(*args)

[INTERNAL]

nonzeros(self) -> [SXElem]


Get all nonzeros.

op(*args)
op(self) -> int

print_dense(*args)

[INTERNAL]

print_dense(self, bool truncate)


Print dense matrix-stype.

print_scalar(*args)

[INTERNAL]

print_scalar(self)


Print scalar.

print_sparse(*args)

[INTERNAL]

print_sparse(self, bool truncate)


Print sparse matrix style.

print_split(*args)

[INTERNAL]

print_split(self) -> ([str] OUTPUT, [str] OUTPUT)


Get strings corresponding to the nonzeros and the interdependencies.

print_vector(*args)

[INTERNAL]

print_vector(self, bool truncate)


Print vector-style.

printme(*args)
printme(self, SX y) -> SX

static rand(*args)

[INTERNAL]

rand(int nrow, int ncol) -> SX
rand((int,int) rc) -> SX
rand(Sparsity sp) -> SX


Create a matrix with uniformly distributed random numbers.

rand(Sparsity sp)


rand(int nrow, int ncol)


[INTERNAL] Create a matrix with uniformly distributed random numbers.

rand((int,int) rc)


[INTERNAL] Create a matrix with uniformly distributed random numbers.

remove(*args)

[INTERNAL]

remove(self, [int] rr, [int] cc)


Remove columns and rows.

Remove/delete rows and/or columns of a matrix

reserve(*args)

[INTERNAL]

reserve(self, int nnz)
reserve(self, int nnz, int ncol)

reset_input(*args)
reset_input(self)

resize(*args)

[INTERNAL]

resize(self, int nrow, int ncol)

static rng(*args)
rng(int seed)

static scalar_matrix(*args)
scalar_matrix(int op, SX x, SX y) -> SX

serialize(*args)

[INTERNAL]

serialize(self) -> str


Serialize an object.

serialize(self, casadi::SerializingStream & s)


[INTERNAL] Serialize an object.

serialize(self)


[INTERNAL] Serialize.

set(*args)
set(self, SX m, bool ind1, Sparsity sp)
set(self, SX m, bool ind1, Slice rr)
set(self, SX m, bool ind1, IM rr)
set(self, SX m, bool ind1, Slice rr, Slice cc)
set(self, SX m, bool ind1, Slice rr, IM cc)
set(self, SX m, bool ind1, IM rr, Slice cc)
set(self, SX m, bool ind1, IM rr, IM cc)

static set_max_depth(*args)
set_max_depth(int eq_depth)

set_nz(*args)
set_nz(self, SX m, bool ind1, Slice k)
set_nz(self, SX m, bool ind1, IM k)

static set_precision(*args)
set_precision(int precision)

static set_scientific(*args)
set_scientific(bool scientific)

static set_width(*args)
set_width(int width)

sparsity(*args)

[INTERNAL]

sparsity(self) -> Sparsity


Get an owning reference to the sparsity pattern.

str(*args)

[INTERNAL]

str(self, bool more) -> str


Get string representation.

to_file(*args)

[INTERNAL]

to_file(self, str filename, str format)


Export numerical matrix to file

Supported formats:

*   - .mtx   Matrix Market (sparse)
*   - .txt   Ascii full precision representation (sparse)
*            Whitespace separated, aligned.
*            Comments with # % or /
*            Uses C locale
*            Structural zeros represented by 00
*            Does not scale well for large sparse matrices
*

static triplet(*args)
triplet([int] row, [int] col, SX d) -> SX
triplet([int] row, [int] col, SX d, (int,int) rc) -> SX
triplet([int] row, [int] col, SX d, int nrow, int ncol) -> SX

static type_name(*args)
type_name() -> str

static unary(*args)
unary(int op, SX x) -> SX


### 2.3. MX¶

class MX(*args)

[INTERNAL]

MX -  Matrix expression.


The MX class is used to build up trees made up from MXNodes. It is a more

general graph representation than the scalar expression, SX, and much less efficient for small objects. On the other hand, the class allows much more general operations than does SX, in particular matrix valued

operations and calls to arbitrary differentiable functions.

The MX class is designed to have identical syntax with the Matrix<> template

class, and uses DM (i.e. Matrix<double>) as its internal

representation of the values at a node. By keeping the syntaxes identical, it is possible to switch from one class to the other, as well as inlining MX functions to SXElem functions.

Note that an operation is always “lazy”, making a matrix multiplication will create a matrix multiplication node, not perform the actual multiplication.

C++ includes: mx.hpp

attachAssert(*args)

[INTERNAL]

attachAssert(self, MX y, str fail_message) -> MX


returns itself, but with an assertion attached

If y does not evaluate to 1, a runtime error is raised

static binary(*args)

[INTERNAL]

binary(int op, MX x, MX y) -> MX


Create nodes by their ID.

static bspline_dual(*args)

[INTERNAL]

bspline_dual([float] x, [[float]] knots, [int] degree, dict opts) -> DM

dep(*args)

[INTERNAL]

dep(self, int ch) -> MX


Get the nth dependency as MX.

static deserialize(*args)
deserialize(casadi::DeserializingStream & s) -> MX

static einstein(*args)

[INTERNAL]

einstein(MX A, MX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX
einstein(MX A, MX B, MX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c) -> MX


Computes an einstein dense tensor contraction.

Computes the product: C_c = A_a + B_b where a b c are index/einstein

notation in an encoded form

For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj

The encoded form uses strictly negative numbers to indicate labels. For the

above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}

einstein(MX A, MX B, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c)


[INTERNAL] Computes an einstein dense tensor contraction.

Computes the product: C_c = A_a + B_b where a b c are index/einstein

notation in an encoded form

For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj

The encoded form uses strictly negative numbers to indicate labels. For the

above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}

einstein(MX A, MX B, MX C, [int] dim_a, [int] dim_b, [int] dim_c, [int] a, [int] b, [int] c)


[INTERNAL] Computes an einstein dense tensor contraction.

Computes the product: C_c = A_a + B_b where a b c are index/einstein

notation in an encoded form

For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj

The encoded form uses strictly negative numbers to indicate labels. For the

above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}

enlarge(*args)

[INTERNAL]

enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)


Enlarge matrix.

Make the matrix larger by inserting empty rows and columns, keeping the existing non-zeros

erase(*args)

[INTERNAL]

erase(self, [int] rr, bool ind1)
erase(self, [int] rr, [int] cc, bool ind1)


Erase a submatrix (leaving structural zeros in its place)

Erase elements of a matrix

erase(self, [int] rr, bool ind1)


[INTERNAL] Erase a submatrix (leaving structural zeros in its place)

Erase elements of a matrix

erase(self, [int] rr, [int] cc, bool ind1)


[INTERNAL] Erase a submatrix (leaving structural zeros in its place)

Erase rows and/or columns of a matrix

eval_mx(*args)

[INTERNAL]

eval_mx(self, [MX] arg) -> [MX]


Evaluate the MX node with new symbolic dependencies.

static eye(*args)
eye(int n) -> MX

get(*args)

[INTERNAL]

get(self, bool ind1, int rr) -> MX
get(self, bool ind1, Sparsity sp) -> MX
get(self, bool ind1, Slice rr) -> MX
get(self, bool ind1, IM rr) -> MX
get(self, bool ind1, MX rr) -> MX
get(self, bool ind1, int rr, int cc) -> MX
get(self, bool ind1, int rr, Slice cc) -> MX
get(self, bool ind1, Slice rr, int cc) -> MX
get(self, bool ind1, Slice rr, Slice cc) -> MX
get(self, bool ind1, Slice rr, IM cc) -> MX
get(self, bool ind1, Slice rr, MX cc) -> MX
get(self, bool ind1, IM rr, Slice cc) -> MX
get(self, bool ind1, IM rr, IM cc) -> MX
get(self, bool ind1, MX rr, Slice cc) -> MX
get(self, bool ind1, MX rr, MX cc) -> MX


Get a submatrix, two arguments

get(self, bool ind1, IM rr)
get(self, bool ind1, Slice rr, IM cc)
get(self, bool ind1, IM rr, Slice cc)
get(self, bool ind1, IM rr, IM cc)


get(self, bool ind1, int rr)


[INTERNAL] Get a submatrix, single argument

get(self, bool ind1, Sparsity sp)


[INTERNAL] Get a submatrix, single argument

get(self, bool ind1, Slice rr)


[INTERNAL] Get a submatrix, single argument

get(self, bool ind1, MX rr)


[INTERNAL] Get a submatrix, single argument

get(self, bool ind1, int rr, int cc)


[INTERNAL] Get a submatrix, two arguments

get(self, bool ind1, int rr, Slice cc)


[INTERNAL] Get a submatrix, two arguments

get(self, bool ind1, Slice rr, int cc)


[INTERNAL] Get a submatrix, two arguments

get(self, bool ind1, Slice rr, Slice cc)


[INTERNAL] Get a submatrix, two arguments

get(self, bool ind1, Slice rr, MX cc)


[INTERNAL] Get a submatrix, two arguments

get(self, bool ind1, MX rr, Slice cc)


[INTERNAL] Get a submatrix, two arguments

get(self, bool ind1, MX rr, MX cc)


[INTERNAL] Get a submatrix, two arguments

static get_free(*args)
get_free(Function f) -> [MX]

static get_input(*args)
get_input(Function f) -> [MX]

static get_max_depth(*args)
get_max_depth() -> int

get_nz(*args)

[INTERNAL]

get_nz(self, bool ind1, int kk) -> MX
get_nz(self, bool ind1, Slice kk) -> MX
get_nz(self, bool ind1, IM kk) -> MX
get_nz(self, bool ind1, MX kk) -> MX
get_nz(self, bool ind1, Slice inner, MX outer) -> MX
get_nz(self, bool ind1, MX inner, Slice outer) -> MX
get_nz(self, bool ind1, MX inner, MX outer) -> MX


Get a set of nonzeros

get_nz(self, bool ind1, IM kk)


get_nz(self, bool ind1, int kk)


[INTERNAL] Get a set of nonzeros

get_nz(self, bool ind1, Slice kk)


[INTERNAL] Get a set of nonzeros

get_nz(self, bool ind1, MX kk)


[INTERNAL] Get a set of nonzeros

get_nz(self, bool ind1, Slice inner, MX outer)


[INTERNAL] Get a set of nonzeros

get_nz(self, bool ind1, MX inner, Slice outer)


[INTERNAL] Get a set of nonzeros

get_nz(self, bool ind1, MX inner, MX outer)


[INTERNAL] Get a set of nonzeros

get_output(*args)

[INTERNAL]

get_output(self, int oind) -> MX


Get an output.

get_temp(*args)
get_temp(self) -> int

has_duplicates(*args)
has_duplicates(self) -> bool

static inf(*args)

[INTERNAL]

inf(int nrow, int ncol) -> MX
inf((int,int) rc) -> MX
inf(Sparsity sp) -> MX


create a matrix with all inf

inf(int nrow, int ncol)


[INTERNAL] create a matrix with all inf

inf((int,int) rc)


[INTERNAL] create a matrix with all inf

inf(Sparsity sp)


[INTERNAL] create a matrix with all inf

info(*args)

[INTERNAL]

info(self) -> dict


static interpn_linear(*args)
interpn_linear([MX] x, MX v, [MX] xq, dict opts) -> MX

is_binary(*args)

[INTERNAL]

is_binary(self) -> bool


Is binary operation.

is_call(*args)

[INTERNAL]

is_call(self) -> bool


Check if evaluation.

is_commutative(*args)

[INTERNAL]

is_commutative(self) -> bool


Check if commutative operation.

is_constant(*args)

[INTERNAL]

is_constant(self) -> bool


Check if constant.

is_eye(*args)

[INTERNAL]

is_eye(self) -> bool


check if identity

is_minus_one(*args)

[INTERNAL]

is_minus_one(self) -> bool


check if zero (note that false negative answers are possible)

is_multiplication(*args)

[INTERNAL]

is_multiplication(self) -> bool


Check if multiplication.

is_norm(*args)

[INTERNAL]

is_norm(self) -> bool


Check if norm.

is_one(*args)

[INTERNAL]

is_one(self) -> bool


check if zero (note that false negative answers are possible)

is_op(*args)

[INTERNAL]

is_op(self, int op) -> bool


Is it a certain operation.

is_output(*args)

[INTERNAL]

is_output(self) -> bool


Check if evaluation output.

is_regular(*args)

[INTERNAL]

is_regular(self) -> bool


Checks if expression does not contain NaN or Inf.

is_symbolic(*args)

[INTERNAL]

is_symbolic(self) -> bool


Check if symbolic.

is_transpose(*args)

[INTERNAL]

is_transpose(self) -> bool


Is the expression a transpose?

is_unary(*args)

[INTERNAL]

is_unary(self) -> bool


Is unary operation.

is_valid_input(*args)

[INTERNAL]

is_valid_input(self) -> bool


Check if matrix can be used to define function inputs.

Valid inputs for MXFunctions are combinations of Reshape, concatenations and SymbolicMX

is_zero(*args)

[INTERNAL]

is_zero(self) -> bool


check if zero (note that false negative answers are possible)

join_primitives(*args)

[INTERNAL]

join_primitives(self, [MX] v) -> MX


Join an expression along symbolic primitives.

mapping(*args)

[INTERNAL]

mapping(self) -> IM


Get an IM representation of a GetNonzeros or SetNonzeros node.

monitor(*args)

[INTERNAL]

monitor(self, str comment) -> MX


Monitor an expression.

Returns itself, but with the side effect of printing the nonzeros along with a comment

n_dep(*args)

[INTERNAL]

n_dep(self) -> int


Get the number of dependencies of a binary SXElem.

n_out(*args)

[INTERNAL]

n_out(self) -> int


Number of outputs.

n_primitives(*args)

[INTERNAL]

n_primitives(self) -> int


Get the number of primitives for MXFunction inputs/outputs.

name(*args)

[INTERNAL]

name(self) -> str


Get the name.

static nan(*args)

[INTERNAL]

nan(int nrow, int ncol) -> MX
nan((int,int) rc) -> MX
nan(Sparsity sp) -> MX


create a matrix with all nan

nan(int nrow, int ncol)


[INTERNAL] create a matrix with all nan

nan((int,int) rc)


[INTERNAL] create a matrix with all nan

nan(Sparsity sp)


[INTERNAL] create a matrix with all nan

op(*args)

[INTERNAL]

op(self) -> int


Get operation type.

primitives(*args)

[INTERNAL]

primitives(self) -> [MX]


Get primitives.

printme(*args)

[INTERNAL]

printme(self, MX b) -> MX

reset_input(*args)
reset_input(self)

serialize(*args)

[INTERNAL]

serialize(self, casadi::SerializingStream & s)


Serialize an object.

set(*args)
set(self, MX m, bool ind1, Sparsity sp)
set(self, MX m, bool ind1, Slice rr)
set(self, MX m, bool ind1, IM rr)
set(self, MX m, bool ind1, Slice rr, Slice cc)
set(self, MX m, bool ind1, Slice rr, IM cc)
set(self, MX m, bool ind1, IM rr, Slice cc)
set(self, MX m, bool ind1, IM rr, IM cc)


set(self, MX m, bool ind1, IM rr)
set(self, MX m, bool ind1, Slice rr, IM cc)
set(self, MX m, bool ind1, IM rr, Slice cc)
set(self, MX m, bool ind1, IM rr, IM cc)


set(self, MX m, bool ind1, Sparsity sp)


[INTERNAL] Set a submatrix, single argument

set(self, MX m, bool ind1, Slice rr)


[INTERNAL] Set a submatrix, single argument

set(self, MX m, bool ind1, Slice rr, Slice cc)


[INTERNAL] Set a submatrix, two arguments

static set_max_depth(*args)
set_max_depth(int eq_depth)

set_nz(*args)

[INTERNAL]

set_nz(self, MX m, bool ind1, int kk)
set_nz(self, MX m, bool ind1, Slice kk)
set_nz(self, MX m, bool ind1, IM kk)
set_nz(self, MX m, bool ind1, MX kk)


Set a set of nonzeros

set_nz(self, MX m, bool ind1, IM kk)


set_nz(self, MX m, bool ind1, int kk)


[INTERNAL] Set a set of nonzeros

set_nz(self, MX m, bool ind1, Slice kk)


[INTERNAL] Set a set of nonzeros

set_nz(self, MX m, bool ind1, MX kk)


[INTERNAL] Set a set of nonzeros

set_temp(*args)
set_temp(self, int t)

sparsity(*args)

[INTERNAL]

sparsity(self) -> Sparsity


Get an owning reference to the sparsity pattern.

split_primitives(*args)

[INTERNAL]

split_primitives(self, MX x) -> [MX]


Split up an expression along symbolic primitives.

static test_cast(*args)
test_cast(casadi::SharedObjectInternal const * ptr) -> bool

to_DM(*args)
to_DM(self) -> DM

static type_name(*args)
type_name() -> str

static unary(*args)

[INTERNAL]

unary(int op, MX x) -> MX


Create nodes by their ID.

which_function(*args)

[INTERNAL]

which_function(self) -> Function


Get function - only valid when is_call() is true.

which_output(*args)

[INTERNAL]

which_output(self) -> int


Get the index of evaluation output - only valid when is_output() is true.

### 2.4. Sparsity¶

class Sparsity(*args)
.. py:method:: Sparsity.add_nz(*args)

module:

add_nz(self, int rr, int cc) -> int

amd(*args)
amd(self) -> [int]

append(*args)
append(self, Sparsity sp)

appendColumns(*args)
appendColumns(self, Sparsity sp)

static band(*args)
band(int n, int p) -> Sparsity

static banded(*args)
banded(int n, int p) -> Sparsity

btf(*args)
btf(self) -> (int , [int] OUTPUT, [int] OUTPUT, [int] OUTPUT, [int] OUTPUT, [int] OUTPUT, [int] OUTPUT)

bw_lower(*args)
bw_lower(self) -> int

bw_upper(*args)
bw_upper(self) -> int

colind(*args)
colind(self) -> [int]
colind(self, int cc) -> int

columns(*args)
columns(self) -> int

combine(*args)
combine(self, Sparsity y, bool f0x_is_zero, bool function0_is_zero) -> Sparsity

compress(*args)
compress(self) -> [int]

static compressed(*args)
compressed([int] v, bool order_rows) -> Sparsity

static dense(*args)
dense(int nrow, int ncol) -> Sparsity
dense((int,int) rc) -> Sparsity

density(*args)
density(self) -> float

static deserialize(*args)
deserialize(std::istream & stream) -> Sparsity
deserialize(str s) -> Sparsity

dfs(*args)
dfs(self, int j, int top, [int] pinv) -> (int , [int] INOUT, [int] INOUT, [bool] INOUT)

static diag(*args)
diag(int nrow) -> Sparsity
diag((int,int) rc) -> Sparsity
diag(int nrow, int ncol) -> Sparsity

dim(*args)
dim(self, bool with_nz) -> str

enlarge(*args)
enlarge(self, int nrow, int ncol, [int] rr, [int] cc, bool ind1)

enlargeColumns(*args)
enlargeColumns(self, int ncol, [int] cc, bool ind1)

enlargeRows(*args)
enlargeRows(self, int nrow, [int] rr, bool ind1)

erase(*args)
erase(self, [int] rr, bool ind1) -> [int]
erase(self, [int] rr, [int] cc, bool ind1) -> [int]

etree(*args)
etree(self, bool ata) -> [int]

export_code(*args)
export_code(self, str lang, dict options)

find(*args)
find(self, bool ind1) -> [int]

static from_file(*args)
from_file(str filename, str format_hint) -> Sparsity

get_ccs(*args)
get_ccs(self) -> ([int] OUTPUT, [int] OUTPUT)

get_col(*args)
get_col(self) -> [int]

get_crs(*args)
get_crs(self) -> ([int] OUTPUT, [int] OUTPUT)

get_diag(*args)
get_diag(self) -> (Sparsity , [int] OUTPUT)

get_lower(*args)
get_lower(self) -> [int]

get_nz(*args)
get_nz(self) -> [int]
get_nz(self, int rr, int cc) -> int
get_nz(self, [int] rr, [int] cc) -> [int]

get_triplet(*args)
get_triplet(self) -> ([int] OUTPUT, [int] OUTPUT)

get_upper(*args)
get_upper(self) -> [int]

has_nz(*args)
has_nz(self, int rr, int cc) -> bool

hash(*args)
hash(self) -> std::size_t

info(*args)
info(self) -> dict

intersect(*args)
intersect(self, Sparsity y) -> Sparsity

is_column(*args)
is_column(self) -> bool

is_dense(*args)
is_dense(self) -> bool

is_diag(*args)
is_diag(self) -> bool

is_empty(*args)
is_empty(self, bool both) -> bool

is_equal(*args)
is_equal(self, Sparsity y) -> bool
is_equal(self, int nrow, int ncol, [int] colind, [int] row) -> bool

is_orthonormal(*args)
is_orthonormal(self, bool allow_empty) -> bool

is_orthonormal_columns(*args)
is_orthonormal_columns(self, bool allow_empty) -> bool

is_orthonormal_rows(*args)
is_orthonormal_rows(self, bool allow_empty) -> bool

is_permutation(*args)
is_permutation(self) -> bool

is_reshape(*args)
is_reshape(self, Sparsity y) -> bool

is_row(*args)
is_row(self) -> bool

is_scalar(*args)
is_scalar(self, bool scalar_and_dense) -> bool

is_selection(*args)
is_selection(self, bool allow_empty) -> bool

is_singular(*args)
is_singular(self) -> bool

is_square(*args)
is_square(self) -> bool

is_stacked(*args)
is_stacked(self, Sparsity y, int n) -> bool

is_subset(*args)
is_subset(self, Sparsity rhs) -> bool

is_symmetric(*args)
is_symmetric(self) -> bool

is_transpose(*args)
is_transpose(self, Sparsity y) -> bool

is_tril(*args)
is_tril(self, bool strictly) -> bool

is_triu(*args)
is_triu(self, bool strictly) -> bool

is_vector(*args)
is_vector(self) -> bool

static kkt(*args)
kkt(Sparsity H, Sparsity J, bool with_x_diag, bool with_lam_g_diag) -> Sparsity

largest_first(*args)
largest_first(self) -> [int]

ldl(*args)
ldl(self, bool amd) -> (Sparsity , [int] OUTPUT)

static lower(*args)
lower(int n) -> Sparsity

makeDense(*args)
makeDense(self) -> (Sparsity , [int] OUTPUT)

nnz(*args)
nnz(self) -> int

nnz_diag(*args)
nnz_diag(self) -> int

nnz_lower(*args)
nnz_lower(self, bool strictly) -> int

nnz_upper(*args)
nnz_upper(self, bool strictly) -> int

static nonzeros(*args)
nonzeros(int nrow, int ncol, [int] nz, bool ind1) -> Sparsity

numel(*args)
numel(self) -> int

pattern_inverse(*args)
pattern_inverse(self) -> Sparsity

static permutation(*args)
permutation([int] p, bool invert) -> Sparsity

permutation_vector(*args)
permutation_vector(self, bool invert) -> [int]

pmult(*args)
pmult(self, [int] p, bool permute_rows, bool permute_columns, bool invert_permutation) -> Sparsity

postfix_dim(*args)
postfix_dim(self) -> str

qr_sparse(*args)
qr_sparse(self, bool amd) -> (Sparsity OUTPUT, Sparsity OUTPUT, [int] OUTPUT, [int] OUTPUT)

removeDuplicates(*args)
removeDuplicates(self) -> [int]

repr_el(*args)
repr_el(self, int k) -> str

resize(*args)
resize(self, int nrow, int ncol)

row(*args)
row(self) -> [int]
row(self, int el) -> int

static rowcol(*args)
rowcol([int] row, [int] col, int nrow, int ncol) -> Sparsity

rows(*args)
rows(self) -> int

rowsSequential(*args)
rowsSequential(self, bool strictly) -> bool

static scalar(*args)
scalar(bool dense_scalar) -> Sparsity

scc(*args)
scc(self) -> (int , [int] OUTPUT, [int] OUTPUT)

serialize(*args)
serialize(self) -> str

size(*args)
size(self) -> (int,int)
size(self, int axis) -> int

size1(*args)
size1(self) -> int

size2(*args)
size2(self) -> int

sparsity_cast_mod(*args)
sparsity_cast_mod(self, Sparsity X, Sparsity Y) -> Sparsity

spy(*args)
spy(self)

spy_matlab(*args)
spy_matlab(self, str mfile)

star_coloring(*args)
star_coloring(self, int ordering, int cutoff) -> Sparsity

star_coloring2(*args)
star_coloring2(self, int ordering, int cutoff) -> Sparsity

sub(*args)
sub(self, [int] rr, Sparsity sp, bool ind1) -> (Sparsity , [int] OUTPUT)
sub(self, [int] rr, [int] cc, bool ind1) -> (Sparsity , [int] OUTPUT)

static test_cast(*args)
test_cast(casadi::SharedObjectInternal const * ptr) -> bool

to_file(*args)
to_file(self, str filename, str format_hint)

transpose(*args)
transpose(self, bool invert_mapping) -> (Sparsity , [int] OUTPUT)

static triplet(*args)
triplet(int nrow, int ncol, [int] row, [int] col) -> Sparsity
triplet(int nrow, int ncol, [int] row, [int] col, bool invert_mapping) -> (Sparsity , [int] OUTPUT)

static type_name(*args)
type_name() -> str

uni_coloring(*args)
uni_coloring(self, Sparsity AT, int cutoff) -> Sparsity

static unit(*args)
unit(int n, int el) -> Sparsity

unite(*args)
unite(self, Sparsity y) -> Sparsity

static upper(*args)
upper(int n) -> Sparsity


### 2.5. Function¶

class Function(*args)

[INTERNAL]

Function object.


A Function instance is a general multiple-input, multiple-output function where each input and output can be a sparse matrix.

For an introduction to this class, see the CasADi user guide. Function is a reference counted and

immutable class; copying a class instance is very cheap and its behavior (with some exceptions) is not affected by calling its member functions.

>List of available options

Id

Type

Description

Used in

OT_DOUBLE

Weighting factor for derivative calculation.When there is an option of either using forward or reverse mode directional derivatives, the condition ad_wei ght*nf<=(1- ad_weight)*na is used where nf and na are estimates of the number of forward/reverse mode directional derivatives needed. By default, ad_weight is calculated automatically, but this can be overridden by setting this option. In particular, 0 means forcing forward mode and 1 forcing reverse mode. Leave unset for (class specific) heuristics.

OT_DOUBLE

Weighting factor for sparsity pattern calculation calc ulation.Override s default behavior. Set to 0 and 1 to force forward and reverse mode respectively. Cf. option “ad_weight”. When set to -1, sparsity is completely ignored and dense matrices are used.

always_inline

OT_BOOL

Force inlining.

cache

OT_DICT

Prepopulate the function cache. Default: empty

compiler

OT_STRING

Just-in-time compiler plugin to be used.

custom_jacobian

OT_FUNCTION

Override CasADi’s AD. Use together with ‘jac_penalty’: 0. Note: Highly experimental. Syntax may break often.

der_options

OT_DICT

Default options to be used to populate forward_options, reverse_options, and jacobian_options before those options are merged in.

derivative_of

OT_FUNCTION

The function is a derivative of another function. The type of derivative (directional derivative, Jacobian) is inferred from the function name.

dump

OT_BOOL

Dump function to file upon first evaluation. [false]

dump_dir

OT_STRING

Directory to dump inputs/outputs to. Make sure the directory exists [.]

dump_format

OT_STRING

Choose file format to dump matrices. See DM.from_file [mtx]

dump_in

OT_BOOL

Dump numerical values of inputs to file (readable with DM.from_file ) [default: false]

dump_out

OT_BOOL

Dump numerical values of outputs to file (readable with DM.from_file ) [default: false]

enable_fd

OT_BOOL

Enable derivative calculation by finite differencing. [default: false]]

enable_forward

OT_BOOL

Enable derivative calculation using generated functions for Jacobian-times- vector products - typically using forward mode AD - if available. [default: true]

enable_jacobian

OT_BOOL

Enable derivative calculation using generated functions for Jacobians of all differentiable outputs with respect to all differentiable inputs - if available. [default: true]

enable_reverse

OT_BOOL

Enable derivative calculation using generated functions for transposed Jacobian-times- vector products - typically using reverse mode AD - if available. [default: true]

error_on_fail

OT_BOOL

Throw exceptions when function evaluation fails (default true).

fd_method

OT_STRING

Method for finite differencing [default ‘central’]

fd_options

OT_DICT

Options to be passed to the finite difference instance

forward_options

OT_DICT

Options to be passed to a forward mode constructor

gather_stats

OT_BOOL

Deprecated option (ignored): Statistics are now always collected.

input_scheme

OT_STRINGVECTOR

Deprecated option (ignored)

inputs_check

OT_BOOL

Throw exceptions when the numerical values of the inputs don’t make sense

is_diff_in

OT_BOOLVECTOR

Indicate for each input if it should be differentiable.

is_diff_out

OT_BOOLVECTOR

Indicate for each output if it should be differentiable.

jac_penalty

OT_DOUBLE

When requested for a number of forward/reverse directions, it may be cheaper to compute first the full jacobian and then multiply with seeds, rather than obtain the requested directions in a straightforward manner. Casadi uses a heuristic to decide which is cheaper. A high value of ‘jac_penalty’ makes it less likely for the heurstic to chose the full Jacobian strategy. The special value -1 indicates never to use the full Jacobian strategy

jacobian_options

OT_DICT

Options to be passed to a Jacobian constructor

jit

OT_BOOL

Use just-in-time compiler to speed up the evaluation

jit_cleanup

OT_BOOL

Cleanup up the temporary source file that jit creates. Default: true

jit_name

OT_STRING

The file name used to write out code. The actual file names used depend on ‘jit_t emp_suffix’ and include extensions. Default: ‘jit_tmp’

jit_options

OT_DICT

Options to be passed to the jit compiler.

jit_serialize

OT_STRING

Specify behaviour when serializing a jitted function: SOURCE|link|embe d.

jit_temp_suffix

OT_BOOL

Use a temporary (seemingly random) filename suffix for generated code and libraries. This is desired for thread- safety. This behaviour may defeat caching compiler wrappers. Default: true

max_io

OT_INT

Acceptable number of inputs and outputs. Warn if exceeded.

max_num_dir

OT_INT

Specify the maximum number of directions for derivative functions. Overrules the builtin optimize d_num_dir.

never_inline

OT_BOOL

Forbid inlining.

output_scheme

OT_STRINGVECTOR

Deprecated option (ignored)

post_expand

OT_BOOL

After construction, expand this Function . Default: False

post_expand_opti ons

OT_DICT

Options to be passed to post- construction expansion. Default: empty

print_in

OT_BOOL

Print numerical values of inputs [default: false]

print_out

OT_BOOL

Print numerical values of outputs [default: false]

print_time

OT_BOOL

print information about execution time. Implies record_time.

record_time

OT_BOOL

record information about execution time, for retrieval with stats() .

regularity_check

OT_BOOL

Throw exceptions when NaN or Inf appears during evaluation

reverse_options

OT_DICT

Options to be passed to a reverse mode constructor

user_data

OT_VOIDPTR

A user-defined field that can be used to identify the function or pass additional information

verbose

OT_BOOL

Verbose evaluation for debugging

C++ includes: function.hpp

assert_size_in(*args)

[INTERNAL]

assert_size_in(self, int i, int nrow, int ncol)


Assert that an input dimension is equal so some given value.

assert_size_out(*args)

[INTERNAL]

assert_size_out(self, int i, int nrow, int ncol)


Assert that an output dimension is equal so some given value.

assert_sparsity_out(*args)

[INTERNAL]

assert_sparsity_out(self, int i, Sparsity sp, int n, bool allow_all_zero_sparse)


Assert that an output sparsity is a multiple of some given sparsity.

static bspline(*args)
bspline(str name, [[float]] knots, [float] coeffs, [int] degree, int m, dict opts) -> Function

buffer()

Create a FunctionBuffer object for evaluating with minimal overhead

cache(*args)

[INTERNAL]

cache(self) -> dict


Get all functions in the cache.

call(*args)

[INTERNAL]

call(self, dict:DM arg, bool always_inline, bool never_inline) -> dict:DM
call(self, [DM] arg, bool always_inline, bool never_inline) -> [DM]
call(self, [SX] arg, bool always_inline, bool never_inline) -> [SX]
call(self, dict:SX arg, bool always_inline, bool never_inline) -> dict:SX
call(self, dict:MX arg, bool always_inline, bool never_inline) -> dict:MX
call(self, [MX] arg, bool always_inline, bool never_inline) -> [MX]


Evaluate the function symbolically or numerically.

call(self, dict:DM arg, bool always_inline, bool never_inline)


[INTERNAL] Evaluate the function symbolically or numerically.

call(self, [DM] arg, bool always_inline, bool never_inline)


[INTERNAL] Evaluate the function symbolically or numerically.

call(self, [SX] arg, bool always_inline, bool never_inline)


[INTERNAL] Evaluate the function symbolically or numerically.

call(self, dict:SX arg, bool always_inline, bool never_inline)


[INTERNAL] Evaluate the function symbolically or numerically.

call(self, dict:MX arg, bool always_inline, bool never_inline)


[INTERNAL] Evaluate the function symbolically or numerically.

call(self, [MX] arg, bool always_inline, bool never_inline)


[INTERNAL] Evaluate the function symbolically or numerically.

change_option(*args)

[INTERNAL]

change_option(self, str option_name, GenericType option_value)


Change option after object creation for debugging.

This is only possible for a selected number of options that do not change the numerical results of the computation, e.g. to enable a more

verbose

output or saving to file.

static check_name(*args)
check_name(str name) -> bool

checkout(*args)

[INTERNAL]

checkout(self) -> int


Checkout a memory object.

static conditional(*args)
conditional(str name, Function f, dict opts) -> Function
conditional(str name, [Function] f, Function f_def, dict opts) -> Function

convert_in(*args)

[INTERNAL]

convert_in(self, dict:DM arg) -> [DM]
convert_in(self, [DM] arg) -> dict:DM
convert_in(self, [SX] arg) -> dict:SX
convert_in(self, dict:SX arg) -> [SX]
convert_in(self, dict:MX arg) -> [MX]
convert_in(self, [MX] arg) -> dict:MX


Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_in(self, dict:DM arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_in(self, [DM] arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_in(self, [SX] arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_in(self, dict:SX arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_in(self, dict:MX arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_in(self, [MX] arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_out(*args)

[INTERNAL]

convert_out(self, dict:DM arg) -> [DM]
convert_out(self, [DM] arg) -> dict:DM
convert_out(self, [SX] arg) -> dict:SX
convert_out(self, dict:SX arg) -> [SX]
convert_out(self, dict:MX arg) -> [MX]
convert_out(self, [MX] arg) -> dict:MX


Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_out(self, dict:DM arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_out(self, [DM] arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_out(self, [SX] arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_out(self, dict:SX arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_out(self, dict:MX arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

convert_out(self, [MX] arg)


[INTERNAL] Convert from/to input/output lists/map.

Will raise an error when an unknown key is used or a list has incorrect size. Does not perform sparsity checking.

default_in(*args)

[INTERNAL]

default_in(self, int ind) -> float


Get default input value.

static deserialize(*args)
deserialize(std::istream & stream) -> Function
deserialize(str s) -> Function

expand(*args)

[INTERNAL]

expand(self) -> Function
expand(self, str name, dict opts) -> Function


Expand a function to SX.

expand(self)


[INTERNAL] Expand a function to SX.

expand(self, str name, dict opts)


[INTERNAL] Expand a function to SX.

export_code(*args)

[INTERNAL]

export_code(self, str lang, dict options) -> str
export_code(self, str lang, str fname, dict options)


Export function in specific language.

Only allowed for (a subset of) SX/MX Functions

export_code(self, str lang, dict options)


[INTERNAL] Export function in specific language.

Only allowed for (a subset of) SX/MX Functions

export_code(self, str lang, str fname, dict options)


[INTERNAL] Export function in specific language.

Only allowed for (a subset of) SX/MX Functions

factory(*args)

[INTERNAL]

factory(self, str name, [str] s_in, [str] s_out, dict:[str] aux, dict opts) -> Function

find_function(*args)

[INTERNAL]

find_function(self, str name, int max_depth) -> Function


Get a specific function embedded in the expression graphs.

#### 1. Parameters:¶

name: Name of function needed

max_depth: Maximum depth - a negative number indicates no maximum

find_functions(*args)

[INTERNAL]

find_functions(self, int max_depth) -> [Function]


Get all functions embedded in the expression graphs.

#### 1. Parameters:¶

max_depth: Maximum depth - a negative number indicates no maximum

static fix_name(*args)
fix_name(str name) -> str

fold(*args)

[INTERNAL]

fold(self, int N, dict opts) -> Function


Create a mapaccumulated version of this function.

Suppose the function has a signature of:

f: (x, u) -> (x_next , y )


The the mapaccumulated version has the signature:

F: (x0, U) -> (X , Y )

with
U: horzcat([u0, u1, ..., u_(N-1)])
X: horzcat([x1, x2, ..., x_N])
Y: horzcat([y0, y1, ..., y_(N-1)])

and
x1, y0 <- f(x0, u0)
x2, y1 <- f(x1, u1)
...
x_N, y_(N-1) <- f(x_(N-1), u_(N-1))


Mapaccum has the following benefits over writing an equivalent for- loop:

much faster at construction time

potentially much faster compilation times (for codegen)

offers a trade-off between memory and evaluation time

The base (settable through the options dictionary, default 10), is used to create a tower of function calls, containing unrolled for- loops of length maximum base.

This technique is much more scalable in terms of memory-usage, but slightly

slower at evaluation, than a plain for-loop. The effect is

similar to that

of a for-loop with a check-pointing instruction after

each chunk of iterations with size base.

Set base to -1 to unroll all the way; no gains in memory efficiency here.

forward(*args)

[INTERNAL]

forward(self, int nfwd) -> Function


Get a function that calculates nfwd forward derivatives.

 Returns a function with <tt>n_in + n_out + n_in</tt> inputs
and <tt>nfwd</tt> outputs.
The first <tt>n_in</tt> inputs correspond to nondifferentiated inputs.
The next <tt>n_out</tt> inputs correspond to nondifferentiated outputs.
and the last <tt>n_in</tt> inputs correspond to forward seeds,
stacked horizontally
The  <tt>n_out</tt> outputs correspond to forward sensitivities,
stacked horizontally.     *
<tt>(n_in = n_in(), n_out = n_out())</tt>

The functions returned are cached, meaning that if called multiple timed
with the same value, then multiple references to the same function will be returned.

free_mx(*args)

[INTERNAL]

free_mx(self) -> [MX]


Get all the free variables of the function.

free_sx(*args)

[INTERNAL]

free_sx(self) -> [SX]


Get all the free variables of the function.

generate(*args)

[INTERNAL]

generate(self, dict opts) -> str
generate(self, str fname, dict opts) -> str


Export / Generate C code for the function.

generate(self, dict opts)


[INTERNAL] Export / Generate C code for the function.

generate(self, str fname, dict opts)


[INTERNAL] Export / Generate C code for the function.

generate_dependencies(*args)

[INTERNAL]

generate_dependencies(self, str fname, dict opts) -> str


Export / Generate C code for the dependency function.

generate_in(*args)

[INTERNAL]

generate_in(self, str fname) -> [DM]
generate_in(self, str fname, [DM] arg)


Export an input file that can be passed to generate C code with a main.

See:

generate_out

See:

convert_in to convert between dict/map and vector

generate_in(self, str fname)


[INTERNAL] Export an input file that can be passed to generate C code with a main.

See:

generate_out

See:

convert_in to convert between dict/map and vector

generate_in(self, str fname, [DM] arg)


[INTERNAL] Export an input file that can be passed to generate C code with a main.

See:

generate_out

See:

convert_in to convert between dict/map and vector

generate_lifted(*args)

[INTERNAL]

generate_lifted(self) -> (Function OUTPUT, Function OUTPUT)


Extract the functions needed for the Lifted Newton method.

generate_out(*args)

[INTERNAL]

generate_out(self, str fname) -> [DM]
generate_out(self, str fname, [DM] arg)


Export an output file that can be checked with generated C code

output.

See:

generate_in

See:

convert_out to convert between dict/map and vector

generate_out(self, str fname)


[INTERNAL] Export an output file that can be checked with generated C code

output.

See:

generate_in

See:

convert_out to convert between dict/map and vector

generate_out(self, str fname, [DM] arg)


[INTERNAL] Export an output file that can be checked with generated C code

output.

See:

generate_in

See:

convert_out to convert between dict/map and vector

get_free(*args)

[INTERNAL]

get_free(self) -> [str]


Get free variables as a string.

get_function(*args)

[INTERNAL]

get_function(self) -> [str]
get_function(self, str name) -> Function


Get a dependency function.

get_function(self, str name)


[INTERNAL] Get a dependency function.

get_function(self)


[INTERNAL] Get a list of all functions.

has_free(*args)

[INTERNAL]

has_free(self) -> bool


Does the function have free variables.

has_function(*args)

[INTERNAL]

has_function(self, str fname) -> bool


Check if a particular dependency exists.

has_option(*args)

[INTERNAL]

has_option(self, str option_name) -> bool


Does a particular option exist.

has_spfwd(*args)

[INTERNAL]

has_spfwd(self) -> bool


Is the class able to propagate seeds through the algorithm?

has_sprev(*args)

[INTERNAL]

has_sprev(self) -> bool


Is the class able to propagate seeds through the algorithm?

hessian_old(*args)

[DEPRECATED] Replaced by Function::factory.

hessian_old(self, int iind, int oind) -> Function

static if_else(*args)
if_else(str name, Function f_true, Function f_false, dict opts) -> Function

index_in(*args)

[INTERNAL]

index_in(self, str name) -> int


Find the index for a string describing a particular entry of an input scheme.

example: schemeEntry(“x_opt”) -> returns NLPSOL_X if FunctionInternal adheres to SCHEME_NLPINput

index_out(*args)

[INTERNAL]

index_out(self, str name) -> int


Find the index for a string describing a particular entry of an output

scheme.

example: schemeEntry(“x_opt”) -> returns NLPSOL_X if FunctionInternal adheres to SCHEME_NLPINput

info(*args)

[INTERNAL]

info(self) -> dict


instruction_MX(*args)

[INTERNAL]

instruction_MX(self, int k) -> MX


Get the MX node corresponding to an instruction (MXFunction)

instruction_constant(*args)

[INTERNAL]

instruction_constant(self, int k) -> float


Get the floating point output argument of an instruction (SXFunction)

instruction_id(*args)

[INTERNAL]

instruction_id(self, int k) -> int


Identifier index of the instruction (SXFunction/MXFunction)

instruction_input(*args)

[INTERNAL]

instruction_input(self, int k) -> [int]


Locations in the work vector for the inputs of the instruction.

(SXFunction/MXFunction)

instruction_output(*args)

[INTERNAL]

instruction_output(self, int k) -> [int]


Location in the work vector for the output of the instruction.

(SXFunction/MXFunction)

instructions_sx(*args)

[INTERNAL]

instructions_sx(self) -> SX


Get the SX node corresponding to all instructions (SXFunction)

Note: input and output instructions have no SX representation. This method returns nan for those instructions.

is_a(*args)

[INTERNAL]

is_a(self, str type, bool recursive) -> bool


Check if the function is of a particular type.

Optionally check if name matches one of the base classes (default true)

is_diff_in(*args)

[INTERNAL]

is_diff_in(self) -> [bool]
is_diff_in(self, int ind) -> bool


Get differentiability of inputs/output.

is_diff_in(self)


[INTERNAL] Get differentiability of inputs/output.

is_diff_in(self, int ind)


[INTERNAL] Get differentiability of inputs/output.

is_diff_out(*args)

[INTERNAL]

is_diff_out(self) -> [bool]
is_diff_out(self, int ind) -> bool


Get differentiability of inputs/output.

is_diff_out(self)


[INTERNAL] Get differentiability of inputs/output.

is_diff_out(self, int ind)


[INTERNAL] Get differentiability of inputs/output.

jac_sparsity(*args)

[INTERNAL]

jac_sparsity(self, bool compact) -> [Sparsity]
jac_sparsity(self, int oind, int iind, bool compact) -> Sparsity


Get, if necessary generate, the sparsity of a single Jacobian block.

jac_sparsity(self, bool compact)


[INTERNAL] Get, if necessary generate, the sparsity of all Jacobian blocks.

jac_sparsity(self, int oind, int iind, bool compact)


[INTERNAL] Get, if necessary generate, the sparsity of a single Jacobian block.

jacobian(*args)

[INTERNAL]

jacobian(self) -> Function


Calculate all Jacobian blocks.

Generates a function that takes all non-differentiated inputs and outputs and calculates all Jacobian blocks. Inputs that are not needed

by the

routine are all-zero sparse matrices with the correct dimensions. Output blocks that are not calculated, e.g. if the corresponding input or output is marked non-differentiated are also all-zero sparse. The Jacobian blocks are sorted starting by all the blocks for the first output, then all the blocks for the second output and so on. E.g. f : (x, y) -> (r, s) results in the function jac_f : (x, y, out_r, out_s) -> (jac_r_x, jac_r_y, jac_s_x,

jac_s_y)

This function is cached.

jacobian_old(*args)

[DEPRECATED] Replaced by Function::factory.

jacobian_old(self, int iind, int oind) -> Function

static jit(*args)

[INTERNAL]

jit(str name, str body, [str] name_in, [str] name_out, dict opts) -> Function
jit(str name, str body, [str] name_in, [str] name_out, [Sparsity] sparsity_in, [Sparsity] sparsity_out, dict opts) -> Function


Create a just-in-time compiled function from a C language string.

The names and sparsity patterns of all the inputs and outputs must be

provided. If sparsities are not provided, all inputs and outputs are

assumed to be scalar. Only specify the function body, assuming that input and output nonzeros are stored in arrays with the specified naming convension. The data type used is ‘casadi_real’, which is typically equal to ‘double or another data type with the same API as ‘double.

Inputs may be null pointers. This means that the all entries are zero.

Outputs may be null points. This means that the corresponding result can be

ignored.

If an error occurs in the evaluation, issue “return 1;”;

The final generated function will have a structure similar to:

*res++;

<FUNCTION_BODY> return 0; }

jit(str name, str body, [str] name_in, [str] name_out, dict opts)


[INTERNAL] Create a just-in-time compiled function from a C language string.

The names and sparsity patterns of all the inputs and outputs must be

provided. If sparsities are not provided, all inputs and outputs are

assumed to be scalar. Only specify the function body, assuming that input and output nonzeros are stored in arrays with the specified naming convension. The data type used is ‘casadi_real’, which is typically equal to ‘double or another data type with the same API as ‘double.

Inputs may be null pointers. This means that the all entries are zero.

Outputs may be null points. This means that the corresponding result can be

ignored.

If an error occurs in the evaluation, issue “return 1;”;

The final generated function will have a structure similar to:

*res++;

<FUNCTION_BODY> return 0; }

jit(str name, str body, [str] name_in, [str] name_out, [Sparsity] sparsity_in, [Sparsity] sparsity_out, dict opts)


[INTERNAL] Create a just-in-time compiled function from a C language string.

The names and sparsity patterns of all the inputs and outputs must be

provided. If sparsities are not provided, all inputs and outputs are

assumed to be scalar. Only specify the function body, assuming that input and output nonzeros are stored in arrays with the specified naming convension. The data type used is ‘casadi_real’, which is typically equal to ‘double or another data type with the same API as ‘double.

Inputs may be null pointers. This means that the all entries are zero.

Outputs may be null points. This means that the corresponding result can be

ignored.

If an error occurs in the evaluation, issue “return 1;”;

The final generated function will have a structure similar to:

*res++;

<FUNCTION_BODY> return 0; }

load(str filename) -> Function

map(*args)

[INTERNAL]

map(self, int n, str parallelization) -> Function
map(self, int n, [bool] reduce_in, [bool] reduce_out, dict opts) -> Function
map(self, int n, str parallelization, int max_num_threads) -> Function
map(self, str name, str parallelization, int n, [str] reduce_in, [str] reduce_out, dict opts) -> Function
map(self, str name, str parallelization, int n, [int] reduce_in, [int] reduce_out, dict opts) -> Function


Map with reduction.

A subset of the inputs are non-repeated and a subset of the outputs summed up.

map(self, int n, [bool] reduce_in, [bool] reduce_out, dict opts)


[INTERNAL] Map with reduction.

A subset of the inputs are non-repeated and a subset of the outputs summed up.

map(self, str name, str parallelization, int n, [str] reduce_in, [str] reduce_out, dict opts)


[INTERNAL] Map with reduction.

A subset of the inputs are non-repeated and a subset of the outputs summed up.

map(self, str name, str parallelization, int n, [int] reduce_in, [int] reduce_out, dict opts)


[INTERNAL] Map with reduction.

A subset of the inputs are non-repeated and a subset of the outputs summed up.

map(self, int n, str parallelization, int max_num_threads)


[INTERNAL]

map(self, int n, str parallelization)


[INTERNAL] Create a mapped version of this function.

Suppose the function has a signature of:

f: (a, p) -> ( s )


The the mapped version has the signature:

F: (A, P) -> (S )

with
A: horzcat([a0, a1, ..., a_(N-1)])
P: horzcat([p0, p1, ..., p_(N-1)])
S: horzcat([s0, s1, ..., s_(N-1)])
and
s0 <- f(a0, p0)
s1 <- f(a1, p1)
...
s_(N-1) <- f(a_(N-1), p_(N-1))


#### 1. Parameters:¶

parallelization: Type of parallelization used: unroll|serial|openmp

mapaccum(*args)

[INTERNAL]

mapaccum(self, int N, dict opts) -> Function
mapaccum(self, str name, int N, dict opts) -> Function
mapaccum(self, str name, int N, int n_accum, dict opts) -> Function
mapaccum(self, str name, int n, [str] accum_in, [str] accum_out, dict opts) -> Function
mapaccum(self, str name, int n, [int] accum_in, [int] accum_out, dict opts) -> Function


Create a mapaccumulated version of this function.

Suppose the function has a signature of:

f: (x, u) -> (x_next , y )


The the mapaccumulated version has the signature:

F: (x0, U) -> (X , Y )

with
U: horzcat([u0, u1, ..., u_(N-1)])
X: horzcat([x1, x2, ..., x_N])
Y: horzcat([y0, y1, ..., y_(N-1)])

and
x1, y0 <- f(x0, u0)
x2, y1 <- f(x1, u1)
...
x_N, y_(N-1) <- f(x_(N-1), u_(N-1))


Mapaccum has the following benefits over writing an equivalent for- loop:

much faster at construction time

potentially much faster compilation times (for codegen)

offers a trade-off between memory and evaluation time

The base (settable through the options dictionary, default 10), is used to create a tower of function calls, containing unrolled for- loops of length maximum base.

This technique is much more scalable in terms of memory-usage, but slightly

slower at evaluation, than a plain for-loop. The effect is

similar to that

of a for-loop with a check-pointing instruction after

each chunk of iterations with size base.

Set base to -1 to unroll all the way; no gains in memory efficiency here.

mapaccum(self, int N, dict opts)


[INTERNAL] Create a mapaccumulated version of this function.

Suppose the function has a signature of:

f: (x, u) -> (x_next , y )


The the mapaccumulated version has the signature:

F: (x0, U) -> (X , Y )

with
U: horzcat([u0, u1, ..., u_(N-1)])
X: horzcat([x1, x2, ..., x_N])
Y: horzcat([y0, y1, ..., y_(N-1)])

and
x1, y0 <- f(x0, u0)
x2, y1 <- f(x1, u1)
...
x_N, y_(N-1) <- f(x_(N-1), u_(N-1))


Mapaccum has the following benefits over writing an equivalent for- loop:

much faster at construction time

potentially much faster compilation times (for codegen)

offers a trade-off between memory and evaluation time

The base (settable through the options dictionary, default 10), is used to create a tower of function calls, containing unrolled for- loops of length maximum base.

This technique is much more scalable in terms of memory-usage, but slightly

slower at evaluation, than a plain for-loop. The effect is

similar to that

of a for-loop with a check-pointing instruction after

each chunk of iterations with size base.

Set base to -1 to unroll all the way; no gains in memory efficiency here.

mapaccum(self, str name, int N, dict opts)


[INTERNAL] Create a mapaccumulated version of this function.

Suppose the function has a signature of:

f: (x, u) -> (x_next , y )


The the mapaccumulated version has the signature:

F: (x0, U) -> (X , Y )

with
U: horzcat([u0, u1, ..., u_(N-1)])
X: horzcat([x1, x2, ..., x_N])
Y: horzcat([y0, y1, ..., y_(N-1)])

and
x1, y0 <- f(x0, u0)
x2, y1 <- f(x1, u1)
...
x_N, y_(N-1) <- f(x_(N-1), u_(N-1))


Mapaccum has the following benefits over writing an equivalent for- loop:

much faster at construction time

potentially much faster compilation times (for codegen)

offers a trade-off between memory and evaluation time

The base (settable through the options dictionary, default 10), is used to create a tower of function calls, containing unrolled for- loops of length maximum base.

This technique is much more scalable in terms of memory-usage, but slightly

slower at evaluation, than a plain for-loop. The effect is

similar to that

of a for-loop with a check-pointing instruction after

each chunk of iterations with size base.

Set base to -1 to unroll all the way; no gains in memory efficiency here.

mapaccum(self, str name, int N, int n_accum, dict opts)


[INTERNAL] Create a mapaccumulated version of this function.

Suppose the function has a signature of:

f: (x, u) -> (x_next , y )


The the mapaccumulated version has the signature:

F: (x0, U) -> (X , Y )

with
U: horzcat([u0, u1, ..., u_(N-1)])
X: horzcat([x1, x2, ..., x_N])
Y: horzcat([y0, y1, ..., y_(N-1)])

and
x1, y0 <- f(x0, u0)
x2, y1 <- f(x1, u1)
...
x_N, y_(N-1) <- f(x_(N-1), u_(N-1))


Mapaccum has the following benefits over writing an equivalent for- loop:

much faster at construction time

potentially much faster compilation times (for codegen)

offers a trade-off between memory and evaluation time

The base (settable through the options dictionary, default 10), is used to create a tower of function calls, containing unrolled for- loops of length maximum base.

This technique is much more scalable in terms of memory-usage, but slightly

slower at evaluation, than a plain for-loop. The effect is

similar to that

of a for-loop with a check-pointing instruction after

each chunk of iterations with size base.

Set base to -1 to unroll all the way; no gains in memory efficiency here.

mapaccum(self, str name, int n, [str] accum_in, [str] accum_out, dict opts)


[INTERNAL] Create a mapaccumulated version of this function.

Suppose the function has a signature of:

f: (x, u) -> (x_next , y )


The the mapaccumulated version has the signature:

F: (x0, U) -> (X , Y )

with
U: horzcat([u0, u1, ..., u_(N-1)])
X: horzcat([x1, x2, ..., x_N])
Y: horzcat([y0, y1, ..., y_(N-1)])

and
x1, y0 <- f(x0, u0)
x2, y1 <- f(x1, u1)
...
x_N, y_(N-1) <- f(x_(N-1), u_(N-1))


Mapaccum has the following benefits over writing an equivalent for- loop:

much faster at construction time

potentially much faster compilation times (for codegen)

offers a trade-off between memory and evaluation time

The base (settable through the options dictionary, default 10), is used to create a tower of function calls, containing unrolled for- loops of length maximum base.

This technique is much more scalable in terms