Functions
static ExType	casadi::GenericExpression< ExType >::plus (const ExType &x, const ExType &y)
	Addition: (x,y) -> x + y. More...

ExType &	casadi::GenericExpression< ExType >::operator+= (const ExType &y)

static MatType	casadi::GenericMatrix< MatType >::logsumexp (const MatType &x)

Friends
ExType	casadi::GenericExpression< ExType >::plus (const ExType &x, const ExType &y)

ExType	casadi::GenericExpression< ExType >::operator+ (const ExType &x, const ExType &y)

MatType	casadi::GenericMatrix< MatType >::interp1d (const std::vector< double > &x, const MatType &v, const std::vector< double > &xq, const std::string &mode, bool equidistant=false)
	Performs 1d linear interpolation. More...

MatType	casadi::GenericMatrix< MatType >::mpower (const MatType &x, const MatType &n)
	Matrix power x^n. More...

MatType	casadi::GenericMatrix< MatType >::soc (const MatType &x, const MatType &y)
	Construct second-order-convex. More...

MatType	casadi::GenericMatrix< MatType >::mrdivide (const MatType &x, const MatType &n)
	Matrix divide (cf. slash '/' in MATLAB) More...

MatType	casadi::GenericMatrix< MatType >::mldivide (const MatType &x, const MatType &n)
	Matrix divide (cf. backslash '\' in MATLAB) More...

std::vector< MatType >	casadi::GenericMatrix< MatType >::symvar (const MatType &x)
	Get all symbols contained in the supplied expression. More...

MatType	casadi::GenericMatrix< MatType >::sumsqr (const MatType &x)
	Calculate sum of squares: sum_ij X_ij^2. More...

MatType	casadi::GenericMatrix< MatType >::logsumexp (const MatType &x)
	x -> log(sum_i exp(x_i)) More...

MatType	casadi::GenericMatrix< MatType >::logsumexp (const MatType &x, const MatType &margin)
	Scaled version of logsumexp. More...

MatType	casadi::GenericMatrix< MatType >::linspace (const MatType &a, const MatType &b, casadi_int nsteps)
	Matlab's `linspace` command. More...

MatType	casadi::GenericMatrix< MatType >::cross (const MatType &a, const MatType &b, casadi_int dim=-1)
	Matlab's `cross` command. More...

MatType	casadi::GenericMatrix< MatType >::skew (const MatType &a)
	Generate a skew symmetric matrix from a 3-vector. More...

MatType	casadi::GenericMatrix< MatType >::inv_skew (const MatType &a)
	Generate the 3-vector progenitor of a skew symmetric matrix. More...

MatType	casadi::GenericMatrix< MatType >::det (const MatType &A)
	Matrix determinant (experimental) More...

MatType	casadi::GenericMatrix< MatType >::inv_minor (const MatType &A)
	Matrix inverse (experimental) More...

MatType	casadi::GenericMatrix< MatType >::inv (const MatType &A)
	Matrix inverse. More...

MatType	casadi::GenericMatrix< MatType >::inv (const MatType &A, const std::string &lsolver, const Dict &options=Dict())
	Matrix inverse. More...

MatType	casadi::GenericMatrix< MatType >::trace (const MatType &x)
	Matrix trace. More...

MatType	casadi::GenericMatrix< MatType >::tril2symm (const MatType &a)
	Convert a lower triangular matrix to a symmetric one. More...

MatType	casadi::GenericMatrix< MatType >::triu2symm (const MatType &a)
	Convert a upper triangular matrix to a symmetric one. More...

MatType	casadi::GenericMatrix< MatType >::norm_fro (const MatType &x)
	Frobenius norm. More...

MatType	casadi::GenericMatrix< MatType >::norm_2 (const MatType &x)
	2-norm More...

MatType	casadi::GenericMatrix< MatType >::norm_1 (const MatType &x)
	1-norm More...

MatType	casadi::GenericMatrix< MatType >::norm_inf (const MatType &x)
	Infinity-norm. More...

MatType	casadi::GenericMatrix< MatType >::diff (const MatType &x, casadi_int n=1, casadi_int axis=-1)
	Returns difference (n-th order) along given axis (MATLAB convention) More...

MatType	casadi::GenericMatrix< MatType >::cumsum (const MatType &x, casadi_int axis=-1)
	Returns cumulative sum along given axis (MATLAB convention) More...

MatType	casadi::GenericMatrix< MatType >::dot (const MatType &x, const MatType &y)
	Inner product of two matrices. More...

MatType	casadi::GenericMatrix< MatType >::nullspace (const MatType &A)
	Computes the nullspace of a matrix A. More...

MatType	casadi::GenericMatrix< MatType >::polyval (const MatType &p, const MatType &x)
	Evaluate a polynomial with coefficients p in x. More...

MatType	casadi::GenericMatrix< MatType >::diag (const MatType &A)
	Get the diagonal of a matrix or construct a diagonal. More...

MatType	casadi::GenericMatrix< MatType >::unite (const MatType &A, const MatType &B)
	Unite two matrices no overlapping sparsity. More...

MatType	casadi::GenericMatrix< MatType >::densify (const MatType &x)
	Make the matrix dense if not already. More...

MatType	casadi::GenericMatrix< MatType >::densify (const MatType &x, const MatType &val)
	Make the matrix dense and assign nonzeros to a value. More...

MatType	casadi::GenericMatrix< MatType >::project (const MatType &A, const Sparsity &sp, bool intersect=false)
	Create a new matrix with a given sparsity pattern but with the. More...

MatType	casadi::GenericMatrix< MatType >::if_else (const MatType &cond, const MatType &if_true, const MatType &if_false, bool short_circuit=false)
	Branching on MX nodes. More...

MatType	casadi::GenericMatrix< MatType >::conditional (const MatType &ind, const std::vector< MatType > &x, const MatType &x_default, bool short_circuit=false)
	Create a switch. More...

bool	casadi::GenericMatrix< MatType >::depends_on (const MatType &f, const MatType &arg)
	Check if expression depends on the argument. More...

MatType	casadi::GenericMatrix< MatType >::substitute (const MatType &ex, const MatType &v, const MatType &vdef)
	Substitute variable v with expression vdef in an expression ex. More...

std::vector< MatType >	casadi::GenericMatrix< MatType >::substitute (const std::vector< MatType > &ex, const std::vector< MatType > &v, const std::vector< MatType > &vdef)
	Substitute variable var with expression expr in multiple expressions. More...

void	casadi::GenericMatrix< MatType >::substitute_inplace (const std::vector< MatType > &v, std::vector< MatType > &inout_vdef, std::vector< MatType > &inout_ex, bool reverse=false)
	Inplace substitution with piggyback expressions. More...

MatType	casadi::GenericMatrix< MatType >::cse (const MatType &e)
	Common subexpression elimination. More...

std::vector< MatType >	casadi::GenericMatrix< MatType >::cse (const std::vector< MatType > &e)
	Common subexpression elimination. More...

MatType	casadi::GenericMatrix< MatType >::solve (const MatType &A, const MatType &b)
	Solve a system of equations: A*x = b. More...

MatType	casadi::GenericMatrix< MatType >::solve (const MatType &A, const MatType &b, const std::string &lsolver, const Dict &dict=Dict())
	Solve a system of equations: A*x = b. More...

MatType	casadi::GenericMatrix< MatType >::linearize (const MatType &f, const MatType &x, const MatType &x0, const Dict &opts=Dict())
	Linearize an expression. More...

MatType	casadi::GenericMatrix< MatType >::pinv (const MatType &A)
	Computes the Moore-Penrose pseudo-inverse. More...

MatType	casadi::GenericMatrix< MatType >::pinv (const MatType &A, const std::string &lsolver, const Dict &dict=Dict())
	Computes the Moore-Penrose pseudo-inverse. More...

MatType	casadi::GenericMatrix< MatType >::expm_const (const MatType &A, const MatType &t)
	Calculate Matrix exponential. More...

MatType	casadi::GenericMatrix< MatType >::expm (const MatType &A)
	Calculate Matrix exponential. More...

MatType	casadi::GenericMatrix< MatType >::jacobian (const MatType &ex, const MatType &arg, const Dict &opts=Dict())
	Calculate Jacobian. More...

MatType	casadi::GenericMatrix< MatType >::gradient (const MatType &ex, const MatType &arg, const Dict &opts=Dict())
	Calculate the gradient of an expression. More...

MatType	casadi::GenericMatrix< MatType >::tangent (const MatType &ex, const MatType &arg, const Dict &opts=Dict())
	Calculate the tangent of an expression. More...

MatType	casadi::GenericMatrix< MatType >::jtimes (const MatType &ex, const MatType &arg, const MatType &v, bool tr=false, const Dict &opts=Dict())
	Calculate the Jacobian and multiply by a vector from the right. More...

std::vector< std::vector< MatType > >	casadi::GenericMatrix< MatType >::forward (const std::vector< MatType > &ex, const std::vector< MatType > &arg, const std::vector< std::vector< MatType > > &v, const Dict &opts=Dict())
	Forward directional derivative. More...

std::vector< std::vector< MatType > >	casadi::GenericMatrix< MatType >::reverse (const std::vector< MatType > &ex, const std::vector< MatType > &arg, const std::vector< std::vector< MatType > > &v, const Dict &opts=Dict())
	Reverse directional derivative. More...

std::vector< bool >	casadi::GenericMatrix< MatType >::which_depends (const MatType &expr, const MatType &var, casadi_int order, bool tr)
	Find out which variables enter with some order. More...

Sparsity	casadi::GenericMatrix< MatType >::jacobian_sparsity (const MatType &f, const MatType &x)
	Get the sparsity pattern of a jacobian. More...

bool	casadi::GenericMatrix< MatType >::is_linear (const MatType &expr, const MatType &var)
	Is expr linear in var? More...

bool	casadi::GenericMatrix< MatType >::is_quadratic (const MatType &expr, const MatType &var)
	Is expr quadratic in var? More...

void	casadi::GenericMatrix< MatType >::quadratic_coeff (const MatType &expr, const MatType &var, MatType &A, MatType &b, MatType &c, bool check=true)
	Recognizes quadratic form in scalar expression. More...

void	casadi::GenericMatrix< MatType >::linear_coeff (const MatType &expr, const MatType &var, MatType &A, MatType &b, bool check=true)
	Recognizes linear form in vector expression. More...

void	casadi::GenericMatrix< MatType >::extract_parametric (const MatType &expr, const MatType &par, MatType &expr_ret, std::vector< MatType > &symbols, std::vector< MatType > &parametric, const Dict &opts=Dict())
	Extract purely parametric parts from an expression graph. More...

void	casadi::GenericMatrix< MatType >::extract_parametric (const std::vector< MatType > &expr, const MatType &par, std::vector< MatType > &expr_ret, std::vector< MatType > &symbols, std::vector< MatType > &parametric, const Dict &opts=Dict())

void	casadi::GenericMatrix< MatType >::extract_parametric (const std::vector< MatType > &expr, const std::vector< MatType > &par, std::vector< MatType > &expr_ret, std::vector< MatType > &symbols, std::vector< MatType > &parametric, const Dict &opts=Dict())

void	casadi::GenericMatrix< MatType >::extract_parametric (const MatType &expr, const std::vector< MatType > &par, MatType &expr_ret, std::vector< MatType > &symbols, std::vector< MatType > &parametric, const Dict &opts=Dict())

void	casadi::GenericMatrix< MatType >::separate_linear (const MatType &expr, const MatType &sym_lin, const MatType &sym_const, MatType &expr_const, MatType &expr_lin, MatType &expr_nonlin)

void	casadi::GenericMatrix< MatType >::separate_linear (const MatType &expr, const std::vector< MatType > &sym_lin, const std::vector< MatType > &sym_const, MatType &expr_const, MatType &expr_lin, MatType &expr_nonlin)

casadi_int	casadi::GenericMatrix< MatType >::n_nodes (const MatType &A)

MatType	casadi::GenericMatrix< MatType >::simplify (const MatType &x)
	Simplify an expression. More...

std::string	casadi::GenericMatrix< MatType >::print_operator (const MatType &xb, const std::vector< std::string > &args)
	Get a string representation for a binary MatType, using custom arguments. More...

void	casadi::GenericMatrix< MatType >::extract (std::vector< MatType > &ex, std::vector< MatType > &v, std::vector< MatType > &vdef, const Dict &opts=Dict())
	Introduce intermediate variables for selected nodes in a graph. More...

void	casadi::GenericMatrix< MatType >::shared (std::vector< MatType > &ex, std::vector< MatType > &v, std::vector< MatType > &vdef, const std::string &v_prefix="v_", const std::string &v_suffix="")
	Extract shared subexpressions from an set of expressions. More...

MatType	casadi::GenericMatrix< MatType >::repsum (const MatType &A, casadi_int n, casadi_int m=1)
	Given a repeated matrix, computes the sum of repeated parts. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::adj (const Matrix< Scalar > &A)
	Matrix adjoint. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::minor (const Matrix< Scalar > &x, casadi_int i, casadi_int j)
	Get the (i,j) minor matrix. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::cofactor (const Matrix< Scalar > &x, casadi_int i, casadi_int j)
	Get the (i,j) cofactor matrix. More...

void	casadi::Matrix< Scalar >::qr (const Matrix< Scalar > &A, Matrix< Scalar > &Q, Matrix< Scalar > &R)
	QR factorization using the modified Gram-Schmidt algorithm. More...

void	casadi::Matrix< Scalar >::qr_sparse (const Matrix< Scalar > &A, Matrix< Scalar > &V, Matrix< Scalar > &R, Matrix< Scalar > &beta, std::vector< casadi_int > &prinv, std::vector< casadi_int > &pc, bool amd=true)
	Sparse direct QR factorization. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::qr_solve (const Matrix< Scalar > &b, const Matrix< Scalar > &v, const Matrix< Scalar > &r, const Matrix< Scalar > &beta, const std::vector< casadi_int > &prinv, const std::vector< casadi_int > &pc, bool tr=false)
	Solve using a sparse QR factorization. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::chol (const Matrix< Scalar > &A)
	Obtain a Cholesky factorisation of a matrix. More...

void	casadi::Matrix< Scalar >::ldl (const Matrix< Scalar > &A, Matrix< Scalar > &D, Matrix< Scalar > &LT, std::vector< casadi_int > &p, bool amd=true)
	Sparse LDL^T factorization. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::ldl_solve (const Matrix< Scalar > &b, const Matrix< Scalar > &D, const Matrix< Scalar > &LT, const std::vector< casadi_int > &p)
	Solve using a sparse LDL^T factorization. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::any (const Matrix< Scalar > &x)
	Returns true only if any element in the matrix is true. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::all (const Matrix< Scalar > &x)
	Returns true only if every element in the matrix is true. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::norm_inf_mul (const Matrix< Scalar > &x, const Matrix< Scalar > &y)
	Inf-norm of a Matrix-Matrix product. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::sparsify (const Matrix< Scalar > &A, double tol=0)
	Make a matrix sparse by removing numerical zeros. More...

void	casadi::Matrix< Scalar >::expand (const Matrix< Scalar > &ex, Matrix< Scalar > &weights, Matrix< Scalar > &terms)
	Expand the expression as a weighted sum (with constant weights) More...

Matrix< Scalar >	casadi::Matrix< Scalar >::pw_const (const Matrix< Scalar > &t, const Matrix< Scalar > &tval, const Matrix< Scalar > &val)
	Create a piecewise constant function. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::pw_lin (const Matrix< Scalar > &t, const Matrix< Scalar > &tval, const Matrix< Scalar > &val)
	t a scalar variable (e.g. time) More...

Matrix< Scalar >	casadi::Matrix< Scalar >::heaviside (const Matrix< Scalar > &x)
	Heaviside function. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::rectangle (const Matrix< Scalar > &x)
	rectangle function More...

Matrix< Scalar >	casadi::Matrix< Scalar >::triangle (const Matrix< Scalar > &x)
	triangle function More...

Matrix< Scalar >	casadi::Matrix< Scalar >::ramp (const Matrix< Scalar > &x)
	ramp function More...

Matrix< Scalar >	casadi::Matrix< Scalar >::mtaylor (const Matrix< Scalar > &ex, const Matrix< Scalar > &x, const Matrix< Scalar > &a, casadi_int order=1)
	multivariate Taylor series expansion More...

Matrix< Scalar >	casadi::Matrix< Scalar >::mtaylor (const Matrix< Scalar > &ex, const Matrix< Scalar > &x, const Matrix< Scalar > &a, casadi_int order, const std::vector< casadi_int > &order_contributions)
	multivariate Taylor series expansion More...

Matrix< Scalar >	casadi::Matrix< Scalar >::poly_coeff (const Matrix< Scalar > &f, const Matrix< Scalar > &x)
	extracts polynomial coefficients from an expression More...

Matrix< Scalar >	casadi::Matrix< Scalar >::poly_roots (const Matrix< Scalar > &p)
	Attempts to find the roots of a polynomial. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::eig_symbolic (const Matrix< Scalar > &m)
	Attempts to find the eigenvalues of a symbolic matrix. More...

Matrix< double >	casadi::Matrix< Scalar >::evalf (const Matrix< Scalar > &expr)
	Evaluates the expression numerically. More...

MX	casadi::MX::find (const MX &x)
	Find first nonzero, returned as row index. More...

MX	casadi::MX::low (const MX &v, const MX &p, const Dict &options=Dict())
	Find first nonzero. More...

MX	casadi::MX::graph_substitute (const MX &ex, const std::vector< MX > &v, const std::vector< MX > &vdef)
	Substitute single expression in graph. More...

MX	casadi::MX::graph_substitute (const MX &ex, const std::vector< MX > &v, const std::vector< MX > &vdef, bool &updated)

std::vector< MX >	casadi::MX::graph_substitute (const std::vector< MX > &ex, const std::vector< MX > &v, const std::vector< MX > &vdef)
	Substitute multiple expressions in graph. More...

std::vector< MX >	casadi::MX::graph_substitute (const std::vector< MX > &ex, const std::vector< MX > &v, const std::vector< MX > &vdef, bool &updated)

MX	casadi::MX::matrix_expand (const MX &e, const std::vector< MX > &boundary=std::vector< MX >(), const Dict &options=Dict())
	Expand MX graph to SXFunction call. More...

std::vector< MX >	casadi::MX::matrix_expand (const std::vector< MX > &e, const std::vector< MX > &boundary=std::vector< MX >(), const Dict &options=Dict())
	Expand MX graph to SXFunction call. More...

MX	casadi::MX::bspline (const MX &x, const DM &coeffs, const std::vector< std::vector< double > > &knots, const std::vector< casadi_int > &degree, casadi_int m, const Dict &opts=Dict())

MX	casadi::MX::bspline (const MX &x, const MX &coeffs, const std::vector< std::vector< double > > &knots, const std::vector< casadi_int > &degree, casadi_int m, const Dict &opts=Dict())

DM	casadi::MX::bspline_dual (const std::vector< double > &x, const std::vector< std::vector< double > > &knots, const std::vector< casadi_int > &degree, const Dict &opts=Dict())

MX	casadi::MX::convexify (const MX &H, const Dict &opts=Dict())

MX	casadi::MX::lift (const MX &x, const MX &x_guess)
	Lift the expression. More...

MX	casadi::MX::inv_node (const MX &x)
	Inverse node. More...

DM	casadi::MX::evalf (const MX &expr)
	Evaluates the expression numerically. More...

MX	casadi::MX::stop_diff (const MX &expr, casadi_int order)
	Stop derivatives of an expression wrt to all its symbolic variables. More...

MX	casadi::MX::no_grad (const MX &expr)
	Stop first derivatives of an expression wrt to all its symbolic variables. More...

MX	casadi::MX::no_hess (const MX &expr)
	Stop second derivatives of an expression wrt to all its symbolic variables. More...

MX	casadi::MX::stop_diff (const MX &expr, const MX &var, casadi_int order)
	Stop derivatives of an expression wrt to a select set of symbolic variables. More...

std::vector< MX >	casadi::MX::difference (const std::vector< MX > &a, const std::vector< MX > &b)

MatType	casadi::SparsityInterface< MatType >::horzcat (const std::vector< MatType > &v)
	Concatenate a list of matrices horizontally. More...

MatType	casadi::SparsityInterface< MatType >::vertcat (const std::vector< MatType > &v)
	Concatenate a list of matrices vertically. More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::horzsplit (const MatType &x, const std::vector< casadi_int > &offset)
	split horizontally, retaining groups of columns More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::horzsplit (const MatType &x, casadi_int incr=1)
	split horizontally, retaining fixed-sized groups of columns More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::horzsplit_n (const MatType &x, casadi_int n)
	split horizontally, retaining fixed-sized groups of columns More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::vertsplit (const MatType &x, const std::vector< casadi_int > &offset)
	split vertically, retaining groups of rows More...

std::vector< casadi_int >	casadi::SparsityInterface< MatType >::offset (const std::vector< MatType > &v, bool vert=true)
	Helper function, get offsets corresponding to a vector of matrices. More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::vertsplit (const MatType &x, casadi_int incr=1)
	split vertically, retaining fixed-sized groups of rows More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::vertsplit_n (const MatType &x, casadi_int n)
	split vertically, retaining fixed-sized groups of rows More...

MatType	casadi::SparsityInterface< MatType >::blockcat (const std::vector< std::vector< MatType > > &v)
	Construct a matrix from a list of list of blocks. More...

MatType	casadi::SparsityInterface< MatType >::blockcat (const MatType &A, const MatType &B, const MatType &C, const MatType &D)
	Construct a matrix from 4 blocks. More...

std::vector< std::vector< MatType > >	casadi::SparsityInterface< MatType >::blocksplit (const MatType &x, const std::vector< casadi_int > &vert_offset, const std::vector< casadi_int > &horz_offset)
	chop up into blocks More...

std::vector< std::vector< MatType > >	casadi::SparsityInterface< MatType >::blocksplit (const MatType &x, casadi_int vert_incr=1, casadi_int horz_incr=1)
	chop up into blocks More...

MatType	casadi::SparsityInterface< MatType >::diagcat (const std::vector< MatType > &A)
	Construct a matrix with given block on the diagonal. More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::diagsplit (const MatType &x, const std::vector< casadi_int > &output_offset1, const std::vector< casadi_int > &output_offset2)
	split diagonally, retaining square matrices More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::diagsplit (const MatType &x, const std::vector< casadi_int > &output_offset)
	split diagonally, retaining square matrices More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::diagsplit (const MatType &x, casadi_int incr=1)
	split diagonally, retaining groups of square matrices More...

std::vector< MatType >	casadi::SparsityInterface< MatType >::diagsplit (const MatType &x, casadi_int incr1, casadi_int incr2)
	split diagonally, retaining fixed-sized matrices More...

MatType	casadi::SparsityInterface< MatType >::veccat (const std::vector< MatType > &x)
	concatenate vertically while vectorizing all arguments with vec More...

MatType	casadi::SparsityInterface< MatType >::mtimes (const MatType &x, const MatType &y)
	Matrix product of two matrices. More...

MatType	casadi::SparsityInterface< MatType >::mtimes (const std::vector< MatType > &args)
	Matrix product of n matrices. More...

MatType	casadi::SparsityInterface< MatType >::mac (const MatType &x, const MatType &y, const MatType &z)
	Multiply-accumulate operation. More...

MatType	casadi::SparsityInterface< MatType >::transpose (const MatType &X)
	Transpose. More...

MatType	casadi::SparsityInterface< MatType >::vec (const MatType &x)
	make a vector More...

MatType	casadi::SparsityInterface< MatType >::reshape (const MatType &x, casadi_int nrow, casadi_int ncol)
	Returns a reshaped version of the matrix. More...

MatType	casadi::SparsityInterface< MatType >::reshape (const MatType &x, std::pair< casadi_int, casadi_int > rc)
	Returns a reshaped version of the matrix, dimensions as a vector. More...

MatType	casadi::SparsityInterface< MatType >::reshape (const MatType &x, const Sparsity &sp)
	Reshape the matrix. More...

MatType	casadi::SparsityInterface< MatType >::sparsity_cast (const MatType &x, const Sparsity &sp)
	Cast matrix nonzeros to different Sparsity. More...

casadi_int	casadi::SparsityInterface< MatType >::sprank (const MatType &x)
	Obtain the structural rank of a sparsity-pattern. More...

casadi_int	casadi::SparsityInterface< MatType >::norm_0_mul (const MatType &x, const MatType &y)
	0-norm (nonzero count) of a Matrix-matrix product More...

MatType	casadi::SparsityInterface< MatType >::triu (const MatType &x, bool includeDiagonal=true)
	Get the upper triangular part of a matrix. More...

MatType	casadi::SparsityInterface< MatType >::tril (const MatType &x, bool includeDiagonal=true)
	Get the lower triangular part of a matrix. More...

MatType	casadi::SparsityInterface< MatType >::kron (const MatType &a, const MatType &b)
	Kronecker tensor product. More...

MatType	casadi::SparsityInterface< MatType >::repmat (const MatType &A, casadi_int n, casadi_int m=1)
	Repeat matrix A n times vertically and m times horizontally. More...

MatType	casadi::SparsityInterface< MatType >::repmat (const MatType &A, const std::pair< casadi_int, casadi_int > &rc)
	Repeat matrix A n times vertically and m times horizontally. More...

MatType	casadi::SparsityInterface< MatType >::horzcat (const MatType &x, const MatType &y)
	Concatenate horizontally, two matrices. More...

MatType	casadi::SparsityInterface< MatType >::horzcat (const MatType &x, const MatType &y, const MatType &z)
	Concatenate horizontally, three matrices. More...

MatType	casadi::SparsityInterface< MatType >::horzcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w)
	Concatenate horizontally, four matrices. More...

MatType	casadi::SparsityInterface< MatType >::horzcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w, const MatType &v)
	Concatenate horizontally, five matrices. More...

MatType	casadi::SparsityInterface< MatType >::horzcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w, const MatType &v, const MatType &u)
	Concatenate horizontally, six matrices. More...

MatType	casadi::SparsityInterface< MatType >::vertcat (const MatType &x, const MatType &y)
	Concatenate vertically, two matrices. More...

MatType	casadi::SparsityInterface< MatType >::vertcat (const MatType &x, const MatType &y, const MatType &z)
	Concatenate vertically, three matrices. More...

MatType	casadi::SparsityInterface< MatType >::vertcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w)
	Concatenate vertically, four matrices. More...

MatType	casadi::SparsityInterface< MatType >::vertcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w, const MatType &v)
	Concatenate vertically, five matrices. More...

MatType	casadi::SparsityInterface< MatType >::vertcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w, const MatType &v, const MatType &u)
	Concatenate vertically, six matrices. More...

MatType	casadi::SparsityInterface< MatType >::diagcat (const MatType &x, const MatType &y)
	Concatenate along diagonal, two matrices. More...

MatType	casadi::SparsityInterface< MatType >::diagcat (const MatType &x, const MatType &y, const MatType &z)
	Concatenate along diagonal, three matrices. More...

MatType	casadi::SparsityInterface< MatType >::diagcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w)
	Concatenate along diagonal, four matrices. More...

MatType	casadi::SparsityInterface< MatType >::diagcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w, const MatType &v)
	Concatenate along diagonal, five matrices. More...

MatType	casadi::SparsityInterface< MatType >::diagcat (const MatType &x, const MatType &y, const MatType &z, const MatType &w, const MatType &v, const MatType &u)
	Concatenate along diagonal, six matrices. More...

MatType	casadi::SparsityInterface< MatType >::sum1 (const MatType &x)
	Return a row-wise summation of elements. More...

MatType	casadi::SparsityInterface< MatType >::sum2 (const MatType &x)
	Return a column-wise summation of elements. More...

MatType	casadi::SparsityInterface< MatType >::sum (const MatType &x)
	Returns summation of all elements. More...

static ExType	casadi::GenericExpression< ExType >::minus (const ExType &x, const ExType &y)
	Subtraction: (x,y) -> x - y. More...

ExType &	casadi::GenericExpression< ExType >::operator-= (const ExType &y)
	Subtraction: (x,y) -> x - y. More...

ExType	casadi::GenericExpression< ExType >::minus (const ExType &x, const ExType &y)
	Subtraction: (x,y) -> x - y. More...

ExType	casadi::GenericExpression< ExType >::operator- (const ExType &x, const ExType &y)
	Subtraction: (x,y) -> x - y. More...

static ExType	casadi::GenericExpression< ExType >::times (const ExType &x, const ExType &y)
	Elementwise multiplication: (x,y) -> x .* y. More...

ExType &	casadi::GenericExpression< ExType >::operator*= (const ExType &y)
	Elementwise multiplication: (x,y) -> x .* y. More...

ExType	casadi::GenericExpression< ExType >::times (const ExType &x, const ExType &y)
	Elementwise multiplication: (x,y) -> x .* y. More...

ExType	casadi::GenericExpression< ExType >::operator* (const ExType &x, const ExType &y)
	Elementwise multiplication: (x,y) -> x .* y. More...

static ExType	casadi::GenericExpression< ExType >::rdivide (const ExType &x, const ExType &y)
	Elementwise division: (x,y) -> x ./ y. More...

ExType &	casadi::GenericExpression< ExType >::operator/= (const ExType &y)
	Elementwise division: (x,y) -> x ./ y. More...

ExType	casadi::GenericExpression< ExType >::rdivide (const ExType &x, const ExType &y)
	Elementwise division: (x,y) -> x ./ y. More...

ExType	casadi::GenericExpression< ExType >::operator/ (const ExType &x, const ExType &y)
	Elementwise division: (x,y) -> x ./ y. More...

static ExType	casadi::GenericExpression< ExType >::lt (const ExType &x, const ExType &y)
	Logical less than: (x,y) -> x < y. More...

ExType	casadi::GenericExpression< ExType >::lt (const ExType &x, const ExType &y)
	Logical less than: (x,y) -> x < y. More...

ExType	casadi::GenericExpression< ExType >::operator< (const ExType &x, const ExType &y)
	Logical less than: (x,y) -> x < y. More...

static ExType	casadi::GenericExpression< ExType >::le (const ExType &x, const ExType &y)
	Logical less or equal to: (x,y) -> x <= y. More...

ExType	casadi::GenericExpression< ExType >::le (const ExType &x, const ExType &y)
	Logical less or equal to: (x,y) -> x <= y. More...

ExType	casadi::GenericExpression< ExType >::operator<= (const ExType &x, const ExType &y)
	Logical less or equal to: (x,y) -> x <= y. More...

static ExType	casadi::GenericExpression< ExType >::gt (const ExType &x, const ExType &y)
	Logical greater than: (x,y) -> x > y. More...

ExType	casadi::GenericExpression< ExType >::gt (const ExType &x, const ExType &y)
	Logical greater than: (x,y) -> x > y. More...

ExType	casadi::GenericExpression< ExType >::operator> (const ExType &x, const ExType &y)
	Logical greater than: (x,y) -> x > y. More...

static ExType	casadi::GenericExpression< ExType >::ge (const ExType &x, const ExType &y)
	Logical greater or equal to: (x,y) -> x >= y. More...

ExType	casadi::GenericExpression< ExType >::ge (const ExType &x, const ExType &y)
	Logical greater or equal to: (x,y) -> x >= y. More...

ExType	casadi::GenericExpression< ExType >::operator>= (const ExType &x, const ExType &y)
	Logical greater or equal to: (x,y) -> x >= y. More...

static ExType	casadi::GenericExpression< ExType >::eq (const ExType &x, const ExType &y)
	Logical equal to: (x,y) -> x == y. More...

ExType	casadi::GenericExpression< ExType >::eq (const ExType &x, const ExType &y)
	Logical equal to: (x,y) -> x == y. More...

ExType	casadi::GenericExpression< ExType >::operator== (const ExType &x, const ExType &y)
	Logical equal to: (x,y) -> x == y. More...

static ExType	casadi::GenericExpression< ExType >::ne (const ExType &x, const ExType &y)
	Logical not equal to: (x,y) -> x != y. More...

ExType	casadi::GenericExpression< ExType >::ne (const ExType &x, const ExType &y)
	Logical not equal to: (x,y) -> x != y. More...

ExType	casadi::GenericExpression< ExType >::operator!= (const ExType &x, const ExType &y)
	Logical not equal to: (x,y) -> x != y. More...

static ExType	casadi::GenericExpression< ExType >::logic_and (const ExType &x, const ExType &y)
	Logical `and` More...

ExType	casadi::GenericExpression< ExType >::logic_and (const ExType &x, const ExType &y)
	Logical `and` More...

ExType	casadi::GenericExpression< ExType >::operator&& (const ExType &x, const ExType &y)
	Logical `and` More...

static ExType	casadi::GenericExpression< ExType >::logic_or (const ExType &x, const ExType &y)
	Logical `or` More...

ExType	casadi::GenericExpression< ExType >::logic_or (const ExType &x, const ExType &y)
	Logical `or` More...

ExType	casadi::GenericExpression< ExType >::operator\|\| (const ExType &x, const ExType &y)
	Logical `or` More...

static ExType	casadi::GenericExpression< ExType >::logic_not (const ExType &x)
	Logical `not` x -> !x. More...

ExType	casadi::GenericExpression< ExType >::operator! () const
	Logical `not` x -> !x. More...

ExType	casadi::GenericExpression< ExType >::logic_not (const ExType &x)
	Logical `not` x -> !x. More...

static ExType	casadi::GenericExpression< ExType >::abs (const ExType &x)
	Absolute value: x -> abs(x) More...

ExType	casadi::GenericExpression< ExType >::abs (const ExType &x)
	Absolute value: x -> abs(x) More...

ExType	casadi::GenericExpression< ExType >::fabs (const ExType &x)
	Absolute value: x -> abs(x) More...

static ExType	casadi::GenericExpression< ExType >::sqrt (const ExType &x)
	Square root: x -> sqrt(x) More...

ExType	casadi::GenericExpression< ExType >::sqrt (const ExType &x)
	Square root: x -> sqrt(x) More...

static ExType	casadi::GenericExpression< ExType >::sq (const ExType &x)
	Square: x -> x^2. More...

ExType	casadi::GenericExpression< ExType >::sq (const ExType &x)
	Square: x -> x^2. More...

static ExType	casadi::GenericExpression< ExType >::sin (const ExType &x)
	Sine: x -> sin(x) More...

ExType	casadi::GenericExpression< ExType >::sin (const ExType &x)
	Sine: x -> sin(x) More...

static ExType	casadi::GenericExpression< ExType >::cos (const ExType &x)
	Cosine: x -> cos(x) More...

ExType	casadi::GenericExpression< ExType >::cos (const ExType &x)
	Cosine: x -> cos(x) More...

static ExType	casadi::GenericExpression< ExType >::tan (const ExType &x)
	Tangent: x -> tan(x) More...

ExType	casadi::GenericExpression< ExType >::tan (const ExType &x)
	Tangent: x -> tan(x) More...

static ExType	casadi::GenericExpression< ExType >::atan (const ExType &x)
	Arc tangent: x -> atan(x) More...

ExType	casadi::GenericExpression< ExType >::atan (const ExType &x)
	Arc tangent: x -> atan(x) More...

static ExType	casadi::GenericExpression< ExType >::asin (const ExType &x)
	Arc sine: x -> asin(x) More...

ExType	casadi::GenericExpression< ExType >::asin (const ExType &x)
	Arc sine: x -> asin(x) More...

static ExType	casadi::GenericExpression< ExType >::acos (const ExType &x)
	Arc cosine: x -> acos(x) More...

ExType	casadi::GenericExpression< ExType >::acos (const ExType &x)
	Arc cosine: x -> acos(x) More...

static ExType	casadi::GenericExpression< ExType >::tanh (const ExType &x)
	Hyperbolic tangent: x -> tanh(x) More...

ExType	casadi::GenericExpression< ExType >::tanh (const ExType &x)
	Hyperbolic tangent: x -> tanh(x) More...

static ExType	casadi::GenericExpression< ExType >::sinh (const ExType &x)
	Hyperbolic sin: x -> sinh(x) More...

ExType	casadi::GenericExpression< ExType >::sinh (const ExType &x)
	Hyperbolic sin: x -> sinh(x) More...

static ExType	casadi::GenericExpression< ExType >::cosh (const ExType &x)
	Hyperbolic cosine: x -> cosh(x) More...

ExType	casadi::GenericExpression< ExType >::cosh (const ExType &x)
	Hyperbolic cosine: x -> cosh(x) More...

static ExType	casadi::GenericExpression< ExType >::atanh (const ExType &x)
	Inverse hyperbolic tangent: x -> atanh(x) More...

ExType	casadi::GenericExpression< ExType >::atanh (const ExType &x)
	Inverse hyperbolic tangent: x -> atanh(x) More...

static ExType	casadi::GenericExpression< ExType >::asinh (const ExType &x)
	Inverse hyperbolic sin: x -> asinh(x) More...

ExType	casadi::GenericExpression< ExType >::asinh (const ExType &x)
	Inverse hyperbolic sin: x -> asinh(x) More...

static ExType	casadi::GenericExpression< ExType >::acosh (const ExType &x)
	Inverse hyperbolic cosine: x -> acosh(x) More...

ExType	casadi::GenericExpression< ExType >::acosh (const ExType &x)
	Inverse hyperbolic cosine: x -> acosh(x) More...

static ExType	casadi::GenericExpression< ExType >::exp (const ExType &x)
	Elementwise exponential: x -> exp(x) More...

ExType	casadi::GenericExpression< ExType >::exp (const ExType &x)
	Elementwise exponential: x -> exp(x) More...

static ExType	casadi::GenericExpression< ExType >::log (const ExType &x)
	Natural logarithm: x -> log(x) More...

ExType	casadi::GenericExpression< ExType >::log (const ExType &x)
	Natural logarithm: x -> log(x) More...

static ExType	casadi::GenericExpression< ExType >::log10 (const ExType &x)
	Base-10 logarithm: x -> log10(x) More...

ExType	casadi::GenericExpression< ExType >::log10 (const ExType &x)
	Base-10 logarithm: x -> log10(x) More...

static ExType	casadi::GenericExpression< ExType >::log1p (const ExType &x)
	Precision variant for natural logarithm: x -> log(x+1) More...

ExType	casadi::GenericExpression< ExType >::log1p (const ExType &x)
	Precision variant for natural logarithm: x -> log(x+1) More...

static ExType	casadi::GenericExpression< ExType >::expm1 (const ExType &x)
	Precision variant for elementwise exponential: x -> exp(x)-1. More...

ExType	casadi::GenericExpression< ExType >::expm1 (const ExType &x)
	Precision variant for elementwise exponential: x -> exp(x)-1. More...

static ExType	casadi::GenericExpression< ExType >::floor (const ExType &x)
	Round down to nearest integer: x -> floor(x) More...

ExType	casadi::GenericExpression< ExType >::floor (const ExType &x)
	Round down to nearest integer: x -> floor(x) More...

static ExType	casadi::GenericExpression< ExType >::ceil (const ExType &x)
	Round up to nearest integer: x -> ceil(x) More...

ExType	casadi::GenericExpression< ExType >::ceil (const ExType &x)
	Round up to nearest integer: x -> ceil(x) More...

static ExType	casadi::GenericExpression< ExType >::erf (const ExType &x)
	Error function: x -> erf(x) More...

ExType	casadi::GenericExpression< ExType >::erf (const ExType &x)
	Error function: x -> erf(x) More...

static ExType	casadi::GenericExpression< ExType >::erfinv (const ExType &x)
	Inverse error function: x -> erfinv(x) More...

ExType	casadi::GenericExpression< ExType >::erfinv (const ExType &x)
	Inverse error function: x -> erfinv(x) More...

static ExType	casadi::GenericExpression< ExType >::sign (const ExType &x)
	Sign function: More...

ExType	casadi::GenericExpression< ExType >::sign (const ExType &x)
	Sign function: More...

static ExType	casadi::GenericExpression< ExType >::pow (const ExType &x, const ExType &y)
	Elementwise power: (x,y) -> x.^y. More...

ExType	casadi::GenericExpression< ExType >::pow (const ExType &x, const ExType &y)
	Elementwise power: (x,y) -> x.^y. More...

static ExType	casadi::GenericExpression< ExType >::mod (const ExType &x, const ExType &y)
	Remainder after division: (x,y) -> fmod(x,y) More...

ExType	casadi::GenericExpression< ExType >::mod (const ExType &x, const ExType &y)
	Remainder after division: (x,y) -> fmod(x,y) More...

ExType	casadi::GenericExpression< ExType >::fmod (const ExType &x, const ExType &y)
	Remainder after division: (x,y) -> fmod(x,y) More...

static ExType	casadi::GenericExpression< ExType >::remainder (const ExType &x, const ExType &y)
	Remainder after division: (x,y) -> remainder(x,y) More...

ExType	casadi::GenericExpression< ExType >::remainder (const ExType &x, const ExType &y)
	Remainder after division: (x,y) -> remainder(x,y) More...

static ExType	casadi::GenericExpression< ExType >::atan2 (const ExType &y, const ExType &x)
	Two argument arc tangent: (y,x) -> atan2(y,x) More...

ExType	casadi::GenericExpression< ExType >::atan2 (const ExType &y, const ExType &x)
	Two argument arc tangent: (y,x) -> atan2(y,x) More...

static ExType	casadi::GenericExpression< ExType >::if_else_zero (const ExType &x, const ExType &y)
	Conditional assignment: (x,y) -> x ? y : 0. More...

ExType	casadi::GenericExpression< ExType >::if_else_zero (const ExType &x, const ExType &y)
	Conditional assignment: (x,y) -> x ? y : 0. More...

static ExType	casadi::GenericExpression< ExType >::fmin (const ExType &x, const ExType &y)
	Smallest of two values: (x,y) -> min(x,y) More...

ExType	casadi::GenericExpression< ExType >::fmin (const ExType &x, const ExType &y)
	Smallest of two values: (x,y) -> min(x,y) More...

static ExType	casadi::GenericExpression< ExType >::fmax (const ExType &x, const ExType &y)
	Largest of two values: (x,y) -> max(x,y) More...

ExType	casadi::GenericExpression< ExType >::fmax (const ExType &x, const ExType &y)
	Largest of two values: (x,y) -> max(x,y) More...

static ExType	casadi::GenericExpression< ExType >::copysign (const ExType &x, const ExType &y)

ExType	casadi::GenericExpression< ExType >::copysign (const ExType &x, const ExType &y)

static ExType	casadi::GenericExpression< ExType >::constpow (const ExType &x, const ExType &y)

ExType	casadi::GenericExpression< ExType >::constpow (const ExType &x, const ExType &y)

static ExType	casadi::GenericExpression< ExType >::printme (const ExType &x, const ExType &y)

ExType	casadi::GenericExpression< ExType >::printme (const ExType &x, const ExType &y)

static ExType	casadi::GenericExpression< ExType >::hypot (const ExType &x, const ExType &y)
	Precision variant for 2 norm: (x,y) -> sqrt(x^2+y^2) More...

ExType	casadi::GenericExpression< ExType >::hypot (const ExType &x, const ExType &y)
	Precision variant for 2 norm: (x,y) -> sqrt(x^2+y^2) More...

static MatType	casadi::GenericMatrix< MatType >::bilin (const MatType &A, const MatType &x, const MatType &y)
	Calculate bilinear/quadratic form x^T A y. More...

MatType	casadi::GenericMatrix< MatType >::bilin (const MatType &A, const MatType &x, const MatType &y)
	Calculate bilinear/quadratic form x^T A y. More...

MatType	casadi::GenericMatrix< MatType >::bilin (const MatType &A, const MatType &x)
	Calculate bilinear/quadratic form x^T A y. More...

static MatType	casadi::GenericMatrix< MatType >::rank1 (const MatType &A, const MatType &alpha, const MatType &x, const MatType &y)
	Make a rank-1 update to a matrix A. More...

MatType	casadi::GenericMatrix< MatType >::rank1 (const MatType &A, const MatType &alpha, const MatType &x, const MatType &y)
	Make a rank-1 update to a matrix A. More...

static MatType	casadi::GenericMatrix< MatType >::jtimes (const MatType &ex, const MatType &arg, const MatType &v, bool tr=false, const Dict &opts=Dict())

static MatType	casadi::GenericMatrix< MatType >::gradient (const MatType &ex, const MatType &arg, const Dict &opts=Dict())

static MatType	casadi::GenericMatrix< MatType >::tangent (const MatType &ex, const MatType &arg, const Dict &opts=Dict())

static MatType	casadi::GenericMatrix< MatType >::linearize (const MatType &f, const MatType &x, const MatType &x0, const Dict &opts=Dict())

static MatType	casadi::GenericMatrix< MatType >::mpower (const MatType &x, const MatType &y)

static MatType	casadi::GenericMatrix< MatType >::soc (const MatType &x, const MatType &y)

bool	casadi::GenericExpression< ExType >::is_equal (const ExType &x, const ExType &y, casadi_int depth=0)
	Check if two nodes are equivalent up to a given depth. More...

MatType	casadi::GenericMatrix< MatType >::einstein (const MatType &A, const MatType &B, const MatType &C, const std::vector< casadi_int > &dim_a, const std::vector< casadi_int > &dim_b, const std::vector< casadi_int > &dim_c, const std::vector< casadi_int > &a, const std::vector< casadi_int > &b, const std::vector< casadi_int > &c)
	Compute any contraction of two dense tensors, using index/einstein notation. More...

MatType	casadi::GenericMatrix< MatType >::einstein (const MatType &A, const MatType &B, const std::vector< casadi_int > &dim_a, const std::vector< casadi_int > &dim_b, const std::vector< casadi_int > &dim_c, const std::vector< casadi_int > &a, const std::vector< casadi_int > &b, const std::vector< casadi_int > &c)
	Compute any contraction of two dense tensors, using index/einstein notation. More...

bool	casadi::GenericMatrix< MatType >::contains (const std::vector< MatType > &v, const MatType &n)
	Check if expression n is listed in v. More...

bool	casadi::GenericMatrix< MatType >::contains_all (const std::vector< MatType > &v, const std::vector< MatType > &n)
	Check if expression n is listed in v. More...

bool	casadi::GenericMatrix< MatType >::contains_any (const std::vector< MatType > &v, const std::vector< MatType > &n)
	Check if expression n is listed in v. More...

MatType	casadi::GenericMatrix< MatType >::hessian (const MatType &ex, const MatType &arg, const Dict &opts=Dict())
	Hessian and (optionally) gradient. More...

MatType	casadi::GenericMatrix< MatType >::hessian (const MatType &ex, const MatType &arg, MatType &output_g, const Dict &opts=Dict())
	Hessian and (optionally) gradient. More...

MatType	casadi::GenericMatrix< MatType >::mmin (const MatType &x)
	Smallest element in a matrix. More...

MatType	casadi::GenericMatrix< MatType >::mmax (const MatType &x)
	Largest element in a matrix. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::gauss_quadrature (const Matrix< Scalar > &f, const Matrix< Scalar > &x, const Matrix< Scalar > &a, const Matrix< Scalar > &b, casadi_int order=5)
	Integrate f from a to b using Gaussian quadrature with n points. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::gauss_quadrature (const Matrix< Scalar > &f, const Matrix< Scalar > &x, const Matrix< Scalar > &a, const Matrix< Scalar > &b, casadi_int order, const Matrix< Scalar > &w)
	Integrate f from a to b using Gaussian quadrature with n points. More...

Matrix< Scalar >	casadi::Matrix< Scalar >::taylor (const Matrix< Scalar > &ex, const Matrix< Scalar > &x, const Matrix< Scalar > &a, casadi_int order=1)
	univariate Taylor series expansion More...

Matrix< Scalar >	casadi::Matrix< Scalar >::taylor (const Matrix< Scalar > &ex, const Matrix< Scalar > &x)
	univariate Taylor series expansion More...

Detailed Description

Functions for manipulating DM, SX, MX or Sparsity

Function Documentation

◆ abs()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::abs ( const ExType & x )

inlinestatic

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

Definition at line 275 of file generic_expression.hpp.

                                        {
       return ExType::unary(OP_FABS, x);
     }

References casadi::OP_FABS.

◆ acos()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::acos ( const ExType & x )

inlinestatic

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

Definition at line 374 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_ACOS, x);
     }

References casadi::OP_ACOS.

◆ acosh()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::acosh ( const ExType & x )

inlinestatic

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

Definition at line 446 of file generic_expression.hpp.

                                          {
       return ExType::unary(OP_ACOSH, x);
     }

References casadi::OP_ACOSH.

◆ asin()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::asin ( const ExType & x )

inlinestatic

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

Definition at line 362 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_ASIN, x);
     }

References casadi::OP_ASIN.

◆ asinh()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::asinh ( const ExType & x )

inlinestatic

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

Definition at line 434 of file generic_expression.hpp.

                                          {
       return ExType::unary(OP_ASINH, x);
     }

References casadi::OP_ASINH.

◆ atan()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::atan ( const ExType & x )

inlinestatic

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

Definition at line 350 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_ATAN, x);
     }

References casadi::OP_ATAN.

◆ atan2()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::atan2	(	const ExType &	y,
		const ExType &	x
	)

inlinestatic

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

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

Definition at line 648 of file generic_expression.hpp.

                                                           {
       return ExType::binary(OP_ATAN2, y, x);
     }

References casadi::OP_ATAN2.

◆ atanh()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::atanh ( const ExType & x )

inlinestatic

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

Definition at line 422 of file generic_expression.hpp.

                                          {
       return ExType::unary(OP_ATANH, x);
     }

References casadi::OP_ATANH.

◆ bilin()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::bilin	(	const MatType &	A,
		const MatType &	x,
		const MatType &	y
	)

static

Parameters

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

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

◆ ceil()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::ceil ( const ExType & x )

inlinestatic

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

Definition at line 530 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_CEIL, x);
     }

References casadi::OP_CEIL.

◆ constpow()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::constpow	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

Elementwise power with const power

Definition at line 720 of file generic_expression.hpp.

                                                               {
        return ExType::binary(OP_CONSTPOW, x, y);
      }

References casadi::OP_CONSTPOW.

◆ copysign()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::copysign	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

Copy sign

Definition at line 710 of file generic_expression.hpp.

                                                               {
        return ExType::binary(OP_COPYSIGN, x, y);
      }

References casadi::OP_COPYSIGN.

◆ cos()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::cos ( const ExType & x )

inlinestatic

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

Definition at line 326 of file generic_expression.hpp.

                                        {
       return ExType::unary(OP_COS, x);
     }

References casadi::OP_COS.

◆ cosh()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::cosh ( const ExType & x )

inlinestatic

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

Definition at line 410 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_COSH, x);
     }

References casadi::OP_COSH.

◆ eq()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::eq	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 191 of file generic_expression.hpp.

                                                      {
     return ExType::binary(OP_EQ, x, y);
   }

References casadi::OP_EQ.

◆ erf()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::erf ( const ExType & x )

inlinestatic

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

Definition at line 542 of file generic_expression.hpp.

                                        {
       return ExType::unary(OP_ERF, x);
     }

References casadi::OP_ERF.

◆ erfinv()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::erfinv ( const ExType & x )

inlinestatic

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

Definition at line 554 of file generic_expression.hpp.

                                           {
       return ExType::unary(OP_ERFINV, x);
     }

References casadi::OP_ERFINV.

◆ exp()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::exp ( const ExType & x )

inlinestatic

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

Definition at line 458 of file generic_expression.hpp.

                                        {
       return ExType::unary(OP_EXP, x);
     }

References casadi::OP_EXP.

◆ expm1()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::expm1 ( const ExType & x )

inlinestatic

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

Definition at line 506 of file generic_expression.hpp.

                                          {
       return ExType::unary(OP_EXPM1, x);
     }

References casadi::OP_EXPM1.

◆ floor()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::floor ( const ExType & x )

inlinestatic

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

Definition at line 518 of file generic_expression.hpp.

                                          {
       return ExType::unary(OP_FLOOR, x);
     }

References casadi::OP_FLOOR.

◆ fmax()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::fmax	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 684 of file generic_expression.hpp.

                                                          {
       return ExType::binary(OP_FMAX, x, y);
     }

References casadi::OP_FMAX.

◆ fmin()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::fmin	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 672 of file generic_expression.hpp.

                                                          {
       return ExType::binary(OP_FMIN, x, y);
     }

References casadi::OP_FMIN.

◆ ge()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::ge	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 176 of file generic_expression.hpp.

                                                      {
     return ExType::le(y, x);
   }

◆ gradient()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::gradient	(	const MatType &	ex,
		const MatType &	arg,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined here

◆ gt()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::gt	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 161 of file generic_expression.hpp.

                                                      {
     return ExType::lt(y, x);
   }

◆ hypot()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::hypot	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 742 of file generic_expression.hpp.

                                                           {
       return ExType::binary(OP_HYPOT, x, y);
     }

References casadi::OP_HYPOT.

◆ if_else_zero()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::if_else_zero	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 660 of file generic_expression.hpp.

                                                                  {
       return ExType::binary(OP_IF_ELSE_ZERO, x, y);
     }

References casadi::OP_IF_ELSE_ZERO.

◆ jtimes()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::jtimes	(	const MatType &	ex,
		const MatType &	arg,
		const MatType &	v,
		bool	tr = `false`,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined here

◆ le()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::le	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 146 of file generic_expression.hpp.

                                                      {
     return ExType::binary(OP_LE, x, y);
   }

References casadi::OP_LE.

◆ linearize()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::linearize	(	const MatType &	f,
		const MatType &	x,
		const MatType &	x0,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined here

◆ log()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::log ( const ExType & x )

inlinestatic

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

Definition at line 470 of file generic_expression.hpp.

                                        {
       return ExType::unary(OP_LOG, x);
     }

References casadi::OP_LOG.

Referenced by casadi::GenericExpression< ExType >::log10().

◆ log10()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::log10 ( const ExType & x )

inlinestatic

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

Definition at line 482 of file generic_expression.hpp.

                                          {
       return log(x)*(1/std::log(10.));
     }

References casadi::GenericExpression< ExType >::log().

◆ log1p()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::log1p ( const ExType & x )

inlinestatic

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

Definition at line 494 of file generic_expression.hpp.

                                          {
       return ExType::unary(OP_LOG1P, x);
     }

References casadi::OP_LOG1P.

◆ logic_and()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::logic_and	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

Returns (an expression evaluating to) 1 if both expressions are nonzero and 0 otherwise

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

Definition at line 224 of file generic_expression.hpp.

                                                              {
      return ExType::binary(OP_AND, x, y);
    }

References casadi::OP_AND.

◆ logic_not()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::logic_not ( const ExType & x )

inlinestatic

Returns (an expression evaluating to) 1 if expression is zero and 0 otherwise

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

Definition at line 260 of file generic_expression.hpp.

                                              {
       return ExType::unary(OP_NOT, x);
     }

References casadi::OP_NOT.

Referenced by casadi::GenericExpression< ExType >::operator!().

◆ logic_or()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::logic_or	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

returns (an expression evaluating to) 1 if at least one expression is nonzero and 0 otherwise

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

Definition at line 242 of file generic_expression.hpp.

                                                             {
      return ExType::binary(OP_OR, x, y);
    }

References casadi::OP_OR.

◆ logsumexp()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::logsumexp ( const MatType & x )

static

◆ lt()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::lt	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 131 of file generic_expression.hpp.

                                                      {
     return ExType::binary(OP_LT, x, y);
   }

References casadi::OP_LT.

◆ minus()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::minus	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 83 of file generic_expression.hpp.

                                                         {
     return ExType::binary(OP_SUB, x, y);
   }

References casadi::OP_SUB.

◆ mod()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::mod	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 607 of file generic_expression.hpp.

                                                         {
       return ExType::binary(OP_FMOD, x, y);
     }

References casadi::OP_FMOD.

◆ mpower()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::mpower	(	const MatType &	x,
		const MatType &	y
	)

static

Functions called by friend functions defined here

◆ ne()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::ne	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 206 of file generic_expression.hpp.

                                                      {
     return ExType::binary(OP_NE, x, y);
   }

References casadi::OP_NE.

◆ operator!()

template<typename ExType >

ExType casadi::GenericExpression< ExType >::operator! ( ) const

inline

Returns (an expression evaluating to) 1 if expression is zero and 0 otherwise

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

Definition at line 266 of file generic_expression.hpp.

                                     {
       return logic_not(self());
     }

References casadi::GenericExpression< ExType >::logic_not().

◆ operator*=()

template<typename ExType >

ExType& casadi::GenericExpression< ExType >::operator*= ( const ExType & y )

inline

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

Definition at line 108 of file generic_expression.hpp.

108 {return self() = self() * y;}

◆ operator+=()

template<typename ExType >

ExType& casadi::GenericExpression< ExType >::operator+= ( const ExType & y )

inline

Definition at line 76 of file generic_expression.hpp.

76 { return self() = self() + y; }

◆ operator-=()

template<typename ExType >

ExType& casadi::GenericExpression< ExType >::operator-= ( const ExType & y )

inline

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

Definition at line 92 of file generic_expression.hpp.

92 { return self() = self() - y; }

◆ operator/=()

template<typename ExType >

ExType& casadi::GenericExpression< ExType >::operator/= ( const ExType & y )

inline

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

Definition at line 124 of file generic_expression.hpp.

124 {return self() = self() / y;}

◆ plus()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::plus	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 67 of file generic_expression.hpp.

                                                        {
     return ExType::binary(OP_ADD, x, y);
   }

References casadi::OP_ADD.

◆ pow()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::pow	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 583 of file generic_expression.hpp.

                                                         {
       return ExType::binary(OP_POW, x, y);
     }

References casadi::OP_POW.

◆ printme()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::printme	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

Debug printing

Definition at line 730 of file generic_expression.hpp.

                                                              {
        return ExType::binary(OP_PRINTME, x, y);
      }

References casadi::OP_PRINTME.

◆ rank1()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::rank1	(	const MatType &	A,
		const MatType &	alpha,
		const MatType &	x,
		const MatType &	y
	)

static

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

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

◆ rdivide()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::rdivide	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 115 of file generic_expression.hpp.

                                                           {
     return ExType::binary(OP_DIV, x, y);
   }

References casadi::OP_DIV.

◆ remainder()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::remainder	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 634 of file generic_expression.hpp.

                                                               {
       return ExType::binary(OP_REMAINDER, x, y);
     }

References casadi::OP_REMAINDER.

◆ sign()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::sign ( const ExType & x )

inlinestatic

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

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

Definition at line 571 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_SIGN, x);
     }

References casadi::OP_SIGN.

◆ sin()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::sin ( const ExType & x )

inlinestatic

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

Definition at line 314 of file generic_expression.hpp.

                                        {
       return ExType::unary(OP_SIN, x);
     }

References casadi::OP_SIN.

◆ sinh()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::sinh ( const ExType & x )

inlinestatic

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

Definition at line 398 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_SINH, x);
     }

References casadi::OP_SINH.

◆ soc()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::soc	(	const MatType &	x,
		const MatType &	y
	)

static

Functions called by friend functions defined here

◆ sq()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::sq ( const ExType & x )

inlinestatic

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

Definition at line 302 of file generic_expression.hpp.

                                       {
       return ExType::unary(OP_SQ, x);
     }

References casadi::OP_SQ.

◆ sqrt()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::sqrt ( const ExType & x )

inlinestatic

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

Definition at line 290 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_SQRT, x);
     }

References casadi::OP_SQRT.

◆ tan()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::tan ( const ExType & x )

inlinestatic

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

Definition at line 338 of file generic_expression.hpp.

                                        {
       return ExType::unary(OP_TAN, x);
     }

References casadi::OP_TAN.

◆ tangent()

template<typename MatType >

static MatType casadi::GenericMatrix< MatType >::tangent	(	const MatType &	ex,
		const MatType &	arg,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined here

◆ tanh()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::tanh ( const ExType & x )

inlinestatic

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

Definition at line 386 of file generic_expression.hpp.

                                         {
       return ExType::unary(OP_TANH, x);
     }

References casadi::OP_TANH.

◆ times()

template<typename ExType >

static ExType casadi::GenericExpression< ExType >::times	(	const ExType &	x,
		const ExType &	y
	)

inlinestatic

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

Definition at line 99 of file generic_expression.hpp.

                                                         {
     return ExType::binary(OP_MUL, x, y);
   }

References casadi::OP_MUL.

Friends

◆ abs

template<typename ExType >

ExType abs ( const ExType & x )

friend

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

Definition at line 278 of file generic_expression.hpp.

                                               {
       return ExType::abs(x);
     }

◆ acos

template<typename ExType >

ExType acos ( const ExType & x )

friend

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

Definition at line 377 of file generic_expression.hpp.

                                                {
       return ExType::acos(x);
     }

◆ acosh

template<typename ExType >

ExType acosh ( const ExType & x )

friend

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

Definition at line 449 of file generic_expression.hpp.

                                                 {
       return ExType::acosh(x);
     }

◆ adj

template<typename Scalar >

Matrix<Scalar> adj ( const Matrix< Scalar > & A )

friend

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

Definition at line 529 of file matrix_decl.hpp.

                                                               {
       return Matrix<Scalar>::adj(A);
     }

◆ all

template<typename Scalar >

Matrix<Scalar> all ( const Matrix< Scalar > & x )

friend

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

Definition at line 622 of file matrix_decl.hpp.

                                                               {
       return Matrix<Scalar>::all(x);
     }

◆ any

template<typename Scalar >

Matrix<Scalar> any ( const Matrix< Scalar > & x )

friend

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

Definition at line 615 of file matrix_decl.hpp.

                                                               {
       return Matrix<Scalar>::any(x);
     }

◆ asin

template<typename ExType >

ExType asin ( const ExType & x )

friend

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

Definition at line 365 of file generic_expression.hpp.

                                                {
       return ExType::asin(x);
     }

◆ asinh

template<typename ExType >

ExType asinh ( const ExType & x )

friend

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

Definition at line 437 of file generic_expression.hpp.

                                                 {
       return ExType::asinh(x);
     }

◆ atan

template<typename ExType >

ExType atan ( const ExType & x )

friend

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

Definition at line 353 of file generic_expression.hpp.

                                                {
       return ExType::atan(x);
     }

◆ atan2

template<typename ExType >

ExType atan2	(	const ExType &	y,
		const ExType &	x
	)

friend

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

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

Definition at line 651 of file generic_expression.hpp.

                                                                  {
       return ExType::atan2(y, x);
     }

◆ atanh

template<typename ExType >

ExType atanh ( const ExType & x )

friend

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

Definition at line 425 of file generic_expression.hpp.

                                                 {
       return ExType::atanh(x);
     }

◆ bilin [1/2]

template<typename MatType >

MatType bilin	(	const MatType &	A,
		const MatType &	x
	)

friend

Parameters

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

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

Definition at line 406 of file generic_matrix.hpp.

                                                                     {
       return MatType::bilin(A, x, x);
     }

◆ bilin [2/2]

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::bilin	(	const MatType &	A,
		const MatType &	x,
		const MatType &	y
	)

friend

Parameters

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

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

Definition at line 403 of file generic_matrix.hpp.

                                                                                       {
       return MatType::bilin(A, x, y);
     }

◆ blockcat [1/2]

template<typename MatType >

MatType blockcat	(	const MatType &	A,
		const MatType &	B,
		const MatType &	C,
		const MatType &	D
	)

friend

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

Definition at line 234 of file sparsity_interface.hpp.

                                                                                        {
       return vertcat(horzcat(A, B), horzcat(C, D));
     }

◆ blockcat [2/2]

template<typename MatType >

MatType blockcat ( const std::vector< std::vector< MatType > > & v )

friend

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

Definition at line 226 of file sparsity_interface.hpp.

                                                                               {
       return MatType::blockcat(v);
     }

◆ blocksplit [1/2]

template<typename MatType >

std::vector< std::vector< MatType > > blocksplit	(	const MatType &	x,
		casadi_int	vert_incr = `1`,
		casadi_int	horz_incr = `1`
	)

friend

Parameters

vert_incr	Defines the increment for block boundaries in row dimension
horz_incr	Defines the increment for block boundaries in column dimension

blockcat(blocksplit(x,..., ...)) = x

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

Definition at line 262 of file sparsity_interface.hpp.

                                                                                    {
       return MatType::blocksplit(x, vert_incr, horz_incr);
     }

◆ blocksplit [2/2]

template<typename MatType >

std::vector< std::vector< MatType > > blocksplit	(	const MatType &	x,
		const std::vector< casadi_int > &	vert_offset,
		const std::vector< casadi_int > &	horz_offset
	)

friend

Parameters

vert_offset	Defines the boundaries of the block rows
horz_offset	Defines the boundaries of the block columns

blockcat(blocksplit(x,..., ...)) = x

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

Definition at line 247 of file sparsity_interface.hpp.

                                                            {
       return MatType::blocksplit(x, vert_offset, horz_offset);
     }

◆ bspline [1/2]

MX bspline	(	const MX &	x,
		const DM &	coeffs,
		const std::vector< std::vector< double > > &	knots,
		const std::vector< casadi_int > &	degree,
		casadi_int	m,
		const Dict &	opts = `Dict()`
	)

friend

Definition at line 823 of file mx.hpp.

                                        {
       return MX::bspline(x, coeffs, knots, degree, m, opts);
     }

◆ bspline [2/2]

MX bspline	(	const MX &	x,
		const MX &	coeffs,
		const std::vector< std::vector< double > > &	knots,
		const std::vector< casadi_int > &	degree,
		casadi_int	m,
		const Dict &	opts = `Dict()`
	)

friend

Definition at line 832 of file mx.hpp.

                                        {
       return MX::bspline(x, coeffs, knots, degree, m, opts);
     }

◆ bspline_dual

DM bspline_dual	(	const std::vector< double > &	x,
		const std::vector< std::vector< double > > &	knots,
		const std::vector< casadi_int > &	degree,
		const Dict &	opts = `Dict()`
	)

friend

Definition at line 840 of file mx.hpp.

                                        {
       return MX::bspline_dual(x, knots, degree, opts);
     }

◆ ceil

template<typename ExType >

ExType ceil ( const ExType & x )

friend

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

Definition at line 533 of file generic_expression.hpp.

                                                {
       return ExType::ceil(x);
     }

◆ chol

template<typename Scalar >

Matrix<Scalar> chol ( const Matrix< Scalar > & A )

friend

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

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

Definition at line 587 of file matrix_decl.hpp.

                                                                {
       return Matrix<Scalar>::chol(A);
     }

◆ cofactor

template<typename Scalar >

Matrix<Scalar> cofactor	(	const Matrix< Scalar > &	x,
		casadi_int	i,
		casadi_int	j
	)

friend

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

Definition at line 543 of file matrix_decl.hpp.

                                                                                                {
       return Matrix<Scalar>::cofactor(x, i, j);
     }

◆ conditional

template<typename MatType >

MatType conditional	(	const MatType &	ind,
		const std::vector< MatType > &	x,
		const MatType &	x_default,
		bool	short_circuit = `false`
	)

friend

If the condition

Parameters

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

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

Definition at line 647 of file generic_matrix.hpp.

                                                                                           {
       return MatType::conditional(ind, x, x_default, short_circuit);
     }

◆ constpow

template<typename ExType >

ExType constpow	(	const ExType &	x,
		const ExType &	y
	)

friend

Elementwise power with const power

Definition at line 723 of file generic_expression.hpp.

                                                                      {
        return ExType::constpow(x, y);
      }

◆ contains

template<typename MatType >

bool contains	(	const std::vector< MatType > &	v,
		const MatType &	n
	)

friend

This function checks for correspondence between nodes. The detection does not descend into the expression graph.

contains({a,b},b) -> true contains({a+b},b) -> false

e = a+b contains({e},e) -> true

For mathematical dependency, see depends_on

See also: depends_on

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

Definition at line 685 of file generic_matrix.hpp.

                                                                                {
       return contains_all(v, std::vector<MatType>{n});
     }

◆ contains_all

template<typename MatType >

bool contains_all	(	const std::vector< MatType > &	v,
		const std::vector< MatType > &	n
	)

friend

This function checks for correspondence between nodes. The detection does not descend into the expression graph.

contains({a,b},b) -> true contains({a+b},b) -> false

e = a+b contains({e},e) -> true

For mathematical dependency, see depends_on

See also: depends_on

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

Definition at line 689 of file generic_matrix.hpp.

                                                                                               {
       return MatType::contains_all(v, n);
     }

◆ contains_any

template<typename MatType >

bool contains_any	(	const std::vector< MatType > &	v,
		const std::vector< MatType > &	n
	)

friend

This function checks for correspondence between nodes. The detection does not descend into the expression graph.

contains({a,b},b) -> true contains({a+b},b) -> false

e = a+b contains({e},e) -> true

For mathematical dependency, see depends_on

See also: depends_on

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

Definition at line 693 of file generic_matrix.hpp.

                                                                                               {
       return MatType::contains_any(v, n);
     }

◆ convexify

MX convexify	(	const MX &	H,
		const Dict &	opts = `Dict()`
	)

friend

Definition at line 847 of file mx.hpp.

                                        {
       return MX::convexify(H, opts);
     }

◆ copysign

template<typename ExType >

ExType copysign	(	const ExType &	x,
		const ExType &	y
	)

friend

Copy sign

Definition at line 713 of file generic_expression.hpp.

                                                                      {
        return ExType::copysign(x, y);
      }

◆ cos

template<typename ExType >

ExType cos ( const ExType & x )

friend

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

Definition at line 329 of file generic_expression.hpp.

                                               {
       return ExType::cos(x);
     }

◆ cosh

template<typename ExType >

ExType cosh ( const ExType & x )

friend

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

Definition at line 413 of file generic_expression.hpp.

                                                {
       return ExType::cosh(x);
     }

◆ cross

template<typename MatType >

MatType cross	(	const MatType &	a,
		const MatType &	b,
		casadi_int	dim = `-1`
	)

friend

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

Definition at line 467 of file generic_matrix.hpp.

                                                                                          {
       return MatType::cross(a, b, dim);
     }

◆ cse [1/2]

template<typename MatType >

MatType cse ( const MatType & e )

friend

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

Definition at line 731 of file generic_matrix.hpp.

                                                 {
       return MatType::cse({e}).at(0);
     }

◆ cse [2/2]

template<typename MatType >

std::vector<MatType> cse ( const std::vector< MatType > & e )

friend

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

Definition at line 739 of file generic_matrix.hpp.

                                                                       {
       return MatType::cse(e);
     }

◆ cumsum

template<typename MatType >

MatType cumsum	(	const MatType &	x,
		casadi_int	axis = `-1`
	)

friend

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

Definition at line 556 of file generic_matrix.hpp.

                                                                        {
       return MatType::cumsum(x, axis);
     }

◆ densify [1/2]

template<typename MatType >

MatType densify ( const MatType & x )

friend

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

Definition at line 610 of file generic_matrix.hpp.

                                                     {
       return MatType::densify(x);
     }

◆ densify [2/2]

template<typename MatType >

MatType densify	(	const MatType &	x,
		const MatType &	val
	)

friend

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

Definition at line 617 of file generic_matrix.hpp.

                                                                         {
       return MatType::densify(x, val);
     }

◆ depends_on

template<typename MatType >

bool depends_on	(	const MatType &	f,
		const MatType &	arg
	)

friend

The argument must be symbolic

The dependency is in a mathematical way: Does the value of the argument affect the value of the expression? Equivalently, will the corresponding entry of the Jacobian by a non-zero?

The symbol could still be present in the expression graph.

To check that kind of dependency, use contains(symvar(f),arg)

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

Definition at line 665 of file generic_matrix.hpp.

                                                                         {
       return MatType::depends_on(f, arg);
     }

◆ det

template<typename MatType >

MatType det ( const MatType & A )

friend

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

Definition at line 488 of file generic_matrix.hpp.

488 { return MatType::det(A);}

◆ diag

template<typename MatType >

MatType diag ( const MatType & A )

friend

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

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

Definition at line 596 of file generic_matrix.hpp.

                                                  {
       return MatType::diag(A);
     }

◆ diagcat [1/6]

template<typename MatType >

MatType diagcat	(	const MatType &	x,
		const MatType &	y
	)

friend

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

Definition at line 548 of file sparsity_interface.hpp.

                                                                       {
       return diagcat(std::vector<MatType>{x, y});
     }

◆ diagcat [2/6]

template<typename MatType >

MatType diagcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z
	)

friend

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

Definition at line 555 of file sparsity_interface.hpp.

                                                                                         {
       return diagcat(std::vector<MatType>{x, y, z});
     }

◆ diagcat [3/6]

template<typename MatType >

MatType diagcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w
	)

friend

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

Definition at line 562 of file sparsity_interface.hpp.

                                                     {
       return diagcat(std::vector<MatType>{x, y, z, w});
     }

◆ diagcat [4/6]

template<typename MatType >

MatType diagcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w,
		const MatType &	v
	)

friend

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

Definition at line 570 of file sparsity_interface.hpp.

                                                                       {
       return diagcat(std::vector<MatType>{x, y, z, w, v});
     }

◆ diagcat [5/6]

template<typename MatType >

MatType diagcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w,
		const MatType &	v,
		const MatType &	u
	)

friend

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

Definition at line 578 of file sparsity_interface.hpp.

                                                                                         {
       return diagcat(std::vector<MatType>{x, y, z, w, v, u});
     }

◆ diagcat [6/6]

template<typename MatType >

MatType diagcat ( const std::vector< MatType > & A )

friend

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

Definition at line 269 of file sparsity_interface.hpp.

                                                                {
       return MatType::diagcat(A);
     }

◆ diagsplit [1/4]

template<typename MatType >

std::vector< MatType > diagsplit	(	const MatType &	x,
		casadi_int	incr1,
		casadi_int	incr2
	)

friend

Parameters

incr1	Row dimension of each matrix
incr2	Column dimension of each matrix

diagsplit(diagsplit(x, ...)) = x

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

Definition at line 324 of file sparsity_interface.hpp.

                                                                       {
       return MatType::diagsplit(x, incr1, incr2);
     }

◆ diagsplit [2/4]

template<typename MatType >

std::vector< MatType > diagsplit	(	const MatType &	x,
		casadi_int	incr = `1`
	)

friend

Parameters

incr	Size of each matrix

diagsplit(diagsplit(x, ...)) = x

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

Definition at line 311 of file sparsity_interface.hpp.

                                                      {
       return MatType::diagsplit(x, incr);
     }

◆ diagsplit [3/4]

template<typename MatType >

std::vector< MatType > diagsplit	(	const MatType &	x,
		const std::vector< casadi_int > &	output_offset
	)

friend

Parameters

output_offset List of all start locations for each group the last matrix will run to the end.

diagcat(diagsplit(x, ...)) = x

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

Definition at line 299 of file sparsity_interface.hpp.

                                                                               {
       return MatType::diagsplit(x, output_offset);
     }

◆ diagsplit [4/4]

template<typename MatType >

std::vector< MatType > diagsplit	(	const MatType &	x,
		const std::vector< casadi_int > &	output_offset1,
		const std::vector< casadi_int > &	output_offset2
	)

friend

Parameters

output_offset1	List of all start locations (row) for each group the last matrix will run to the end.
output_offset2	List of all start locations (row) for each group the last matrix will run to the end.

diagcat(diagsplit(x, ...)) = x

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

Definition at line 284 of file sparsity_interface.hpp.

                                                              {
       return MatType::diagsplit(x, output_offset1, output_offset2);
     }

◆ diff

template<typename MatType >

MatType diff	(	const MatType &	x,
		casadi_int	n = `1`,
		casadi_int	axis = `-1`
	)

friend

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

Definition at line 549 of file generic_matrix.hpp.

                                                                                      {
       return MatType::diff(x, n, axis);
     }

◆ difference

std::vector<MX> difference	(	const std::vector< MX > &	a,
		const std::vector< MX > &	b
	)

friend

\bried Return all elements of a that do not occur in b, preserving order

Definition at line 911 of file mx.hpp.

                                                                                            {
       return MX::difference(a, b);
     }

◆ dot

template<typename MatType >

MatType dot	(	const MatType &	x,
		const MatType &	y
	)

friend

with x and y matrices of the same dimension

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

Definition at line 565 of file generic_matrix.hpp.

                                                                   {
       return MatType::dot(x, y);
     }

Referenced by casadi::GenericMatrix< MatType >::sumsqr().

◆ eig_symbolic

template<typename Scalar >

Matrix<Scalar> eig_symbolic ( const Matrix< Scalar > & m )

friend

This will only work for up to 3x3 matrices

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

Definition at line 866 of file matrix_decl.hpp.

                                                                        {
       return Matrix<Scalar>::eig_symbolic(m);
     }

◆ einstein [1/2]

template<typename MatType >

MatType einstein	(	const MatType &	A,
		const MatType &	B,
		const MatType &	C,
		const std::vector< casadi_int > &	dim_a,
		const std::vector< casadi_int > &	dim_b,
		const std::vector< casadi_int > &	dim_c,
		const std::vector< casadi_int > &	a,
		const std::vector< casadi_int > &	b,
		const std::vector< casadi_int > &	c
	)

friend

einstein(A, B, a, b, c) -> C

Given two tensors, A and B, computes a third tensor C such that:

C_c = A_a * B_b

With a, b, c representing einstein indices. Instead of the classical index labels i,j,k,... we employ -1,-2,-3,...

A, B, C are represented as CasADi vectors, with dim_a, dim_b, dim_c indictating theire tensorial dimensions.

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

Definition at line 355 of file generic_matrix.hpp.

                                         {
       return MatType::einstein(A, B, C, dim_a, dim_b, dim_c, a, b, c);
     }

◆ einstein [2/2]

template<typename MatType >

MatType einstein	(	const MatType &	A,
		const MatType &	B,
		const std::vector< casadi_int > &	dim_a,
		const std::vector< casadi_int > &	dim_b,
		const std::vector< casadi_int > &	dim_c,
		const std::vector< casadi_int > &	a,
		const std::vector< casadi_int > &	b,
		const std::vector< casadi_int > &	c
	)

friend

einstein(A, B, a, b, c) -> C

Given two tensors, A and B, computes a third tensor C such that:

C_c = A_a * B_b

With a, b, c representing einstein indices. Instead of the classical index labels i,j,k,... we employ -1,-2,-3,...

A, B, C are represented as CasADi vectors, with dim_a, dim_b, dim_c indictating theire tensorial dimensions.

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

Definition at line 364 of file generic_matrix.hpp.

                                         {
       return MatType::einstein(A, B, dim_a, dim_b, dim_c, a, b, c);
     }

◆ eq

template<typename ExType >

ExType eq	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 194 of file generic_expression.hpp.

                                                             {
     return ExType::eq(x, y);
   }

◆ erf

template<typename ExType >

ExType erf ( const ExType & x )

friend

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

Definition at line 545 of file generic_expression.hpp.

                                               {
       return ExType::erf(x);
     }

◆ erfinv

template<typename ExType >

ExType erfinv ( const ExType & x )

friend

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

Definition at line 557 of file generic_expression.hpp.

                                                  {
       return ExType::erfinv(x);
     }

◆ evalf [1/2]

template<typename Scalar >

Matrix<double> evalf ( const Matrix< Scalar > & expr )

friend

An error is raised when the expression contains symbols

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

Definition at line 876 of file matrix_decl.hpp.

                                                                    {
       return Matrix<Scalar>::evalf(expr);
     }

◆ evalf [2/2]

DM evalf ( const MX & expr )

friend

An error is raised when the expression contains symbols

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

Definition at line 873 of file mx.hpp.

                                            {
       return MX::evalf(expr);
     }

◆ exp

template<typename ExType >

ExType exp ( const ExType & x )

friend

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

Definition at line 461 of file generic_expression.hpp.

                                               {
       return ExType::exp(x);
     }

◆ expand

template<typename Scalar >

void expand	(	const Matrix< Scalar > &	ex,
		Matrix< Scalar > &	weights,
		Matrix< Scalar > &	terms
	)

friend

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

Definition at line 645 of file matrix_decl.hpp.

                                                      {
       Matrix<Scalar>::expand(ex, weights, terms);
     }

◆ expm

template<typename MatType >

MatType expm ( const MatType & A )

friend

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

Definition at line 846 of file generic_matrix.hpp.

                                                  {
       return MatType::expm(A);
     }

◆ expm1

template<typename ExType >

ExType expm1 ( const ExType & x )

friend

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

Definition at line 509 of file generic_expression.hpp.

                                                 {
       return ExType::expm1(x);
     }

◆ expm_const

template<typename MatType >

MatType expm_const	(	const MatType &	A,
		const MatType &	t
	)

friend

Computes expm(A*t) with A constant

Parameters

A[in]	Square matrix
t[in]	Scalar

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

Definition at line 838 of file generic_matrix.hpp.

                                                                          {
       return MatType::expm_const(A, t);
     }

◆ extract

template<typename MatType >

void extract	(	std::vector< MatType > &	ex,
		std::vector< MatType > &	v,
		std::vector< MatType > &	vdef,
		const Dict &	opts = `Dict()`
	)

friend

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

Definition at line 1138 of file generic_matrix.hpp.

                                    {
       MatType::extract(ex, v, vdef, opts);
     }

◆ extract_parametric [1/4]

template<typename MatType >

void extract_parametric	(	const MatType &	expr,
		const MatType &	par,
		MatType &	expr_ret,
		std::vector< MatType > &	symbols,
		std::vector< MatType > &	parametric,
		const Dict &	opts = `Dict()`
	)

friend

The purpose of extract_parametric is ultimately to save on evaluation time of an expression, by extracting out the parts that are only solely dependent on parameters.

For any: [expr_ret, symbols, parametric] = extract_parametric(expr, par) It holds that: substitute(expr_ret,symbols,parametric) == expr

parametric is only dependant on par expr_ret is not dependant on par, but is dependant on symbols

Example: [expr_ret, symbols, parametric] = extract_parametric((x-sqrt(p))*y+cos(p)**2, p)

expr_ret: (((x-extracted1)*y)+extracted2) symbols: [extracted1, extracted2] parametric: [sqrt(p),cos(p)**2]

Options to control the name of new symbols:

offset (int), default 0: Offset for new symbol counter
prefix (str), default 'e_': Prefix for new symbols
suffix (str), default '': Suffix for new symbols

Option 'extract_trivial' controls the behaviour for extracted parts that consist of pure symbols. If false (default), these parts are not extracted.

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

Definition at line 1025 of file generic_matrix.hpp.

                                  {
       MatType::extract_parametric(expr, par, expr_ret, symbols, parametric, opts);
     }

◆ extract_parametric [2/4]

template<typename MatType >

void extract_parametric	(	const MatType &	expr,
		const std::vector< MatType > &	par,
		MatType &	expr_ret,
		std::vector< MatType > &	symbols,
		std::vector< MatType > &	parametric,
		const Dict &	opts = `Dict()`
	)

friend

Definition at line 1069 of file generic_matrix.hpp.

                                  {
       extract_parametric(expr, veccat(par), expr_ret, symbols, parametric, opts);
     }

◆ extract_parametric [3/4]

template<typename MatType >

void extract_parametric	(	const std::vector< MatType > &	expr,
		const MatType &	par,
		std::vector< MatType > &	expr_ret,
		std::vector< MatType > &	symbols,
		std::vector< MatType > &	parametric,
		const Dict &	opts = `Dict()`
	)

friend

Definition at line 1033 of file generic_matrix.hpp.

                                  {
       // Concatenate all vector elements
       MatType expr_cat = veccat(expr);
       MatType expr_ret_cat;
  
       // Concatenated extract_parametric
       MatType::extract_parametric(expr_cat, par, expr_ret_cat, symbols, parametric, opts);
  
       // Compute edges of vertsplit needed to undo concatenate
       std::vector<casadi_int> edges = {0};
       for (const MatType& e : expr) {
         edges.push_back(edges.back() + e.numel());
       }
       // Perform vertsplit
       std::vector<MatType> expr_ret_catv = MatType::vertsplit(expr_ret_cat, edges);
  
       // Reshape all elements back into original size
       expr_ret.resize(expr_ret_catv.size());
       for (casadi_int i=0; i<expr_ret_catv.size(); ++i) {
         expr_ret[i] = reshape(expr_ret_catv[i], expr[i].size1(), expr[i].size2());
       }
     }

◆ extract_parametric [4/4]

template<typename MatType >

void extract_parametric	(	const std::vector< MatType > &	expr,
		const std::vector< MatType > &	par,
		std::vector< MatType > &	expr_ret,
		std::vector< MatType > &	symbols,
		std::vector< MatType > &	parametric,
		const Dict &	opts = `Dict()`
	)

friend

Definition at line 1060 of file generic_matrix.hpp.

                                  {
       extract_parametric(expr, veccat(par), expr_ret, symbols, parametric, opts);
     }

◆ fabs

template<typename ExType >

ExType fabs ( const ExType & x )

friend

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

Definition at line 281 of file generic_expression.hpp.

                                                {
       return abs(x);
     }

◆ find

MX find ( const MX & x )

friend

If failed, returns the number of rows

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

Definition at line 748 of file mx.hpp.

                                        {
       return MX::find(x);
     }

◆ floor

template<typename ExType >

ExType floor ( const ExType & x )

friend

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

Definition at line 521 of file generic_expression.hpp.

                                                 {
       return ExType::floor(x);
     }

◆ fmax

template<typename ExType >

ExType fmax	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 687 of file generic_expression.hpp.

                                                                 {
       return ExType::fmax(x, y);
     }

◆ fmin

template<typename ExType >

ExType fmin	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 675 of file generic_expression.hpp.

                                                                 {
       return ExType::fmin(x, y);
     }

◆ fmod

template<typename ExType >

ExType fmod	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 613 of file generic_expression.hpp.

                                                                 {
       return mod(x, y);
     }

◆ forward

template<typename MatType >

std::vector<std::vector<MatType> > forward	(	const std::vector< MatType > &	ex,
		const std::vector< MatType > &	arg,
		const std::vector< std::vector< MatType > > &	v,
		const Dict &	opts = `Dict()`
	)

friend

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

Definition at line 897 of file generic_matrix.hpp.

                                        {
       return MatType::forward(ex, arg, v, opts);
     }

◆ gauss_quadrature [1/2]

template<typename Scalar >

Matrix<Scalar> gauss_quadrature	(	const Matrix< Scalar > &	f,
		const Matrix< Scalar > &	x,
		const Matrix< Scalar > &	a,
		const Matrix< Scalar > &	b,
		casadi_int	order,
		const Matrix< Scalar > &	w
	)

friend

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

Definition at line 757 of file matrix_decl.hpp.

                                                                   {
       return Matrix<Scalar>::gauss_quadrature(f, x, a, b, order, w);
     }

◆ gauss_quadrature [2/2]

template<typename Scalar >

Matrix<Scalar> gauss_quadrature	(	const Matrix< Scalar > &	f,
		const Matrix< Scalar > &	x,
		const Matrix< Scalar > &	a,
		const Matrix< Scalar > &	b,
		casadi_int	order = `5`
	)

friend

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

Definition at line 751 of file matrix_decl.hpp.

                                            {
       return Matrix<Scalar>::gauss_quadrature(f, x, a, b, order);
     }

◆ ge

template<typename ExType >

ExType ge	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 179 of file generic_expression.hpp.

                                                             {
     return ExType::ge(x, y);
   }

◆ gradient

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::gradient	(	const MatType &	ex,
		const MatType &	arg,
		const Dict &	opts = `Dict()`
	)

friend

Parameters

ex[in]	Scalar expression to take the gradient of
arg[in]	Vector expression of symbols
opts[in]	Options

Returns: Dense column vector

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

Definition at line 868 of file generic_matrix.hpp.

                                                                                                    {
       return MatType::gradient(ex, arg, opts);
     }

◆ graph_substitute [1/4]

MX graph_substitute	(	const MX &	ex,
		const std::vector< MX > &	v,
		const std::vector< MX > &	vdef
	)

friend

Substitute variable v with expression vdef in an expression ex, preserving nodes

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

Definition at line 766 of file mx.hpp.

                                                                  {
       return MX::graph_substitute(ex, v, vdef);
     }

◆ graph_substitute [2/4]

MX graph_substitute	(	const MX &	ex,
		const std::vector< MX > &	v,
		const std::vector< MX > &	vdef,
		bool &	updated
	)

friend

Definition at line 771 of file mx.hpp.

                                                                                 {
       return MX::graph_substitute(ex, v, vdef, updated);
     }

◆ graph_substitute [3/4]

std::vector<MX> graph_substitute	(	const std::vector< MX > &	ex,
		const std::vector< MX > &	v,
		const std::vector< MX > &	vdef
	)

friend

Substitute variable var with expression expr in multiple expressions, preserving nodes

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

Definition at line 783 of file mx.hpp.

                                                   {
       return MX::graph_substitute(ex, v, vdef);
     }

◆ graph_substitute [4/4]

std::vector<MX> graph_substitute	(	const std::vector< MX > &	ex,
		const std::vector< MX > &	v,
		const std::vector< MX > &	vdef,
		bool &	updated
	)

friend

Definition at line 790 of file mx.hpp.

                                       {
       return MX::graph_substitute(ex, v, vdef, updated);
     }

◆ gt

template<typename ExType >

ExType gt	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 164 of file generic_expression.hpp.

                                                             {
     return ExType::gt(x, y);
   }

◆ heaviside

template<typename Scalar >

Matrix<Scalar> heaviside ( const Matrix< Scalar > & x )

friend

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

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

Definition at line 693 of file matrix_decl.hpp.

                                                                     {
       return Matrix<Scalar>::heaviside(x);
     }

◆ hessian [1/2]

template<typename MatType >

MatType hessian	(	const MatType &	ex,
		const MatType &	arg,
		const Dict &	opts = `Dict()`
	)

friend

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

Definition at line 917 of file generic_matrix.hpp.

                                    {
       return MatType::hessian(ex, arg, opts);
     }

◆ hessian [2/2]

template<typename MatType >

MatType hessian	(	const MatType &	ex,
		const MatType &	arg,
		MatType &	output_g,
		const Dict &	opts = `Dict()`
	)

friend

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

Definition at line 921 of file generic_matrix.hpp.

                                    {
       return MatType::hessian(ex, arg, output_g, opts);
     }

◆ horzcat [1/6]

template<typename MatType >

MatType horzcat	(	const MatType &	x,
		const MatType &	y
	)

friend

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

Definition at line 472 of file sparsity_interface.hpp.

                                                                       {
       return horzcat(std::vector<MatType>{x, y});
     }

◆ horzcat [2/6]

template<typename MatType >

MatType horzcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z
	)

friend

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

Definition at line 479 of file sparsity_interface.hpp.

                                                                                         {
       return horzcat(std::vector<MatType>{x, y, z});
     }

◆ horzcat [3/6]

template<typename MatType >

MatType horzcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w
	)

friend

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

Definition at line 486 of file sparsity_interface.hpp.

                                                     {
       return horzcat(std::vector<MatType>{x, y, z, w});
     }

◆ horzcat [4/6]

template<typename MatType >

MatType horzcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w,
		const MatType &	v
	)

friend

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

Definition at line 494 of file sparsity_interface.hpp.

                                                                       {
       return horzcat(std::vector<MatType>{x, y, z, w, v});
     }

◆ horzcat [5/6]

template<typename MatType >

MatType horzcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w,
		const MatType &	v,
		const MatType &	u
	)

friend

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

Definition at line 502 of file sparsity_interface.hpp.

                                                                                         {
       return horzcat(std::vector<MatType>{x, y, z, w, v, u});
     }

◆ horzcat [6/6]

template<typename MatType >

MatType horzcat ( const std::vector< MatType > & v )

friend

Alternative terminology: horizontal stack, hstack, horizontal append, [a b]

horzcat(horzsplit(x, ...)) = x

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

Definition at line 97 of file sparsity_interface.hpp.

                                                                {
       return MatType::horzcat(v);
     }

◆ horzsplit [1/2]

template<typename MatType >

std::vector<MatType > horzsplit	(	const MatType &	x,
		casadi_int	incr = `1`
	)

friend

Parameters

incr	Size (width) of each group of columns

horzcat(horzsplit(x, ...)) = x

\seealso horzsplit_n

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

Definition at line 134 of file sparsity_interface.hpp.

                                                                                      {
       return MatType::horzsplit(x, incr);
     }

◆ horzsplit [2/2]

template<typename MatType >

std::vector<MatType > horzsplit	(	const MatType &	x,
		const std::vector< casadi_int > &	offset
	)

friend

Parameters

offset List of all start columns for each group the last column group will run to the end.

horzcat(horzsplit(x, ...)) = x

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

Definition at line 121 of file sparsity_interface.hpp.

                                                                        {
       return MatType::horzsplit(x, offset);
     }

◆ horzsplit_n

template<typename MatType >

std::vector<MatType > horzsplit_n	(	const MatType &	x,
		casadi_int	n
	)

friend

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

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

Definition at line 149 of file sparsity_interface.hpp.

                                                                                   {
       return MatType::horzsplit_n(x, n);
     }

◆ hypot

template<typename ExType >

ExType hypot	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 745 of file generic_expression.hpp.

                                                                  {
       return ExType::hypot(x, y);
     }

◆ if_else

template<typename MatType >

MatType if_else	(	const MatType &	cond,
		const MatType &	if_true,
		const MatType &	if_false,
		bool	short_circuit = `false`
	)

friend

Ternary operator, "cond ? if_true : if_false"

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

Definition at line 636 of file generic_matrix.hpp.

                                                                                      {
       return MatType::if_else(cond, if_true, if_false, short_circuit);
     }

◆ if_else_zero

template<typename ExType >

ExType if_else_zero	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 663 of file generic_expression.hpp.

                                                                         {
       return ExType::if_else_zero(x, y);
     }

◆ interp1d

template<typename MatType >

MatType interp1d	(	const std::vector< double > &	x,
		const MatType &	v,
		const std::vector< double > &	xq,
		const std::string &	mode,
		bool	equidistant = `false`
	)

friend

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

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

Definition at line 311 of file generic_matrix.hpp.

                                                                                      {
        return MatType::interp1d(x, v, xq, mode, equidistant);
      }

◆ inv [1/2]

template<typename MatType >

MatType inv ( const MatType & A )

friend

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

Definition at line 498 of file generic_matrix.hpp.

                                                 {
         return MatType::inv(A);
     }

◆ inv [2/2]

template<typename MatType >

MatType inv	(	const MatType &	A,
		const std::string &	lsolver,
		const Dict &	options = `Dict()`
	)

friend

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

Definition at line 505 of file generic_matrix.hpp.

                                   {
         return MatType::inv(A, lsolver, options);
     }

◆ inv_minor

template<typename MatType >

MatType inv_minor ( const MatType & A )

friend

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

Definition at line 493 of file generic_matrix.hpp.

493 { return MatType::inv_minor(A);}

◆ inv_node

MX inv_node ( const MX & x )

friend

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

Definition at line 864 of file mx.hpp.

                                            {
       return MX::inv_node(x);
     }

◆ inv_skew

template<typename MatType >

MatType inv_skew ( const MatType & a )

friend

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

Definition at line 481 of file generic_matrix.hpp.

                                                      {
       return MatType::inv_skew(a);
     }

◆ is_equal

template<typename ExType >

bool is_equal	(	const ExType &	x,
		const ExType &	y,
		casadi_int	depth = `0`
	)

friend

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

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

Definition at line 703 of file generic_expression.hpp.

                                                                                        {
        return ExType::is_equal(x, y, depth);
      }

◆ is_linear

template<typename MatType >

bool is_linear	(	const MatType &	expr,
		const MatType &	var
	)

friend

False negatives are possible (an expression may not be recognised as linear while it really is), false positives not.

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

Definition at line 951 of file generic_matrix.hpp.

                                                                           {
       return MatType::is_linear(expr, var);
     }

◆ is_quadratic

template<typename MatType >

bool is_quadratic	(	const MatType &	expr,
		const MatType &	var
	)

friend

False negatives are possible (an expression may not be recognised as quadratic while it really is), false positives not.

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

Definition at line 962 of file generic_matrix.hpp.

                                                                              {
       return MatType::is_quadratic(expr, var);
     }

◆ jacobian

template<typename MatType >

MatType jacobian	(	const MatType &	ex,
		const MatType &	arg,
		const Dict &	opts = `Dict()`
	)

friend

Returns: Sparse matrix

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

Definition at line 855 of file generic_matrix.hpp.

                                                               {
       return MatType::jacobian(ex, arg, opts);
     }

◆ jacobian_sparsity

template<typename MatType >

Sparsity jacobian_sparsity	(	const MatType &	f,
		const MatType &	x
	)

friend

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

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

Definition at line 940 of file generic_matrix.hpp.

                                                                                  {
       return MatType::jacobian_sparsity(f, x);
     }

◆ jtimes

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::jtimes	(	const MatType &	ex,
		const MatType &	arg,
		const MatType &	v,
		bool	tr = `false`,
		const Dict &	opts = `Dict()`
	)

friend

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.

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

Definition at line 888 of file generic_matrix.hpp.

                                                                                            {
       return MatType::jtimes(ex, arg, v, tr, opts);
     }

◆ kron

template<typename MatType >

MatType kron	(	const MatType &	a,
		const MatType &	b
	)

friend

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

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

Definition at line 451 of file sparsity_interface.hpp.

                                                                    {
       return MatType::kron(a, b);
     }

◆ ldl

template<typename Scalar >

void ldl	(	const Matrix< Scalar > &	A,
		Matrix< Scalar > &	D,
		Matrix< Scalar > &	LT,
		std::vector< casadi_int > &	p,
		bool	amd = `true`
	)

friend

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.

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

Definition at line 598 of file matrix_decl.hpp.

                                                                     {
       return Matrix<Scalar>::ldl(A, D, LT, p, amd);
     }

◆ ldl_solve

template<typename Scalar >

Matrix<Scalar> ldl_solve	(	const Matrix< Scalar > &	b,
		const Matrix< Scalar > &	D,
		const Matrix< Scalar > &	LT,
		const std::vector< casadi_int > &	p
	)

friend

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

Definition at line 607 of file matrix_decl.hpp.

                                               {
       return Matrix<Scalar>::ldl_solve(b, D, LT, p);
     }

◆ le

template<typename ExType >

ExType le	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 149 of file generic_expression.hpp.

                                                             {
     return ExType::le(x, y);
   }

◆ lift

MX lift	(	const MX &	x,
		const MX &	x_guess
	)

friend

Experimental feature

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

Definition at line 857 of file mx.hpp.

                                                           {
       return MX::lift(x, x_guess);
     }

◆ linear_coeff

template<typename MatType >

void linear_coeff	(	const MatType &	expr,
		const MatType &	var,
		MatType &	A,
		MatType &	b,
		bool	check = `true`
	)

friend

A x + b

Parameters

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

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

Definition at line 989 of file generic_matrix.hpp.

                                                  {
       MatType::linear_coeff(expr, var, A, b, check);
     }

◆ linearize

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::linearize	(	const MatType &	f,
		const MatType &	x,
		const MatType &	x0,
		const Dict &	opts = `Dict()`
	)

friend

[DEPRECATED] confusing behaviour

This function linearizes an expression around a point x0, using x as delta around that point.

linearize(sin(x),x,x0) -> sin(x0)+cos(x0)*x

casadi::GenericMatrix::linearize

friend MatType linearize(const MatType &f, const MatType &x, const MatType &x0, const Dict &opts=Dict())

Linearize an expression.

Definition: generic_matrix.hpp:795

For a variant that returns sin(x0)+cos(x0)*(x-x0), see taylor.

See also: taylor, linear_coeff

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

Definition at line 795 of file generic_matrix.hpp.

                                  {
       return MatType::linearize(f, x, x0, opts);
     }

◆ linspace

template<typename MatType >

MatType linspace	(	const MatType &	a,
		const MatType &	b,
		casadi_int	nsteps
	)

friend

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

Definition at line 460 of file generic_matrix.hpp.

                                                                                           {
       return MatType::linspace(a, b, nsteps);
     }

◆ log

template<typename ExType >

ExType log ( const ExType & x )

friend

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

Definition at line 473 of file generic_expression.hpp.

                                               {
       return ExType::log(x);
     }

◆ log10

template<typename ExType >

ExType log10 ( const ExType & x )

friend

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

Definition at line 485 of file generic_expression.hpp.

                                                 {
       return ExType::log10(x);
     }

◆ log1p

template<typename ExType >

ExType log1p ( const ExType & x )

friend

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

Definition at line 497 of file generic_expression.hpp.

                                                 {
       return ExType::log1p(x);
     }

◆ logic_and

template<typename ExType >

ExType logic_and	(	const ExType &	x,
		const ExType &	y
	)

friend

Returns (an expression evaluating to) 1 if both expressions are nonzero and 0 otherwise

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

Definition at line 227 of file generic_expression.hpp.

                                                                     {
      return ExType::logic_and(x, y);
    }

◆ logic_not

template<typename ExType >

ExType logic_not ( const ExType & x )

friend

Returns (an expression evaluating to) 1 if expression is zero and 0 otherwise

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

Definition at line 263 of file generic_expression.hpp.

                                                     {
       return ExType::logic_not(x);
     }

◆ logic_or

template<typename ExType >

ExType logic_or	(	const ExType &	x,
		const ExType &	y
	)

friend

returns (an expression evaluating to) 1 if at least one expression is nonzero and 0 otherwise

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

Definition at line 245 of file generic_expression.hpp.

                                                                    {
      return ExType::logic_or(x, y);
    }

◆ logsumexp [1/2]

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::logsumexp ( const MatType & x )

friend

Can be used to achieve a smooth max.

Implementations for DM/SX/MX are hardened against overflow Implementations for DM/MX are more accurate with log1p (*)

(*) https://nhigham.com/2021/01/05/what-is-the-log-sum-exp-function/

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

Definition at line 443 of file generic_matrix.hpp.

                                                       {
       return MatType::logsumexp(x);
     }

◆ logsumexp [2/2]

template<typename MatType >

MatType logsumexp	(	const MatType &	x,
		const MatType &	margin
	)

friend

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

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

Definition at line 451 of file generic_matrix.hpp.

                                                                              {
       MatType alpha = log(x.size1()) / margin;
       return MatType::logsumexp(alpha*x)/alpha;
     }

◆ low

MX low	(	const MX &	v,
		const MX &	p,
		const Dict &	options = `Dict()`
	)

friend

If failed, returns the number of rows

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

Definition at line 757 of file mx.hpp.

                                                                                {
       return MX::low(v, p, options);
     }

◆ lt

template<typename ExType >

ExType lt	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 134 of file generic_expression.hpp.

                                                             {
     return ExType::lt(x, y);
   }

◆ mac

template<typename MatType >

MatType mac	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z
	)

friend

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

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

Definition at line 358 of file sparsity_interface.hpp.

                                                                 {
       return MatType::mac(x, y, z);
     }

◆ matrix_expand [1/2]

MX matrix_expand	(	const MX &	e,
		const std::vector< MX > &	boundary = `std::vector<MX>()`,
		const Dict &	options = `Dict()`
	)

friend

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

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

Definition at line 804 of file mx.hpp.

                                       {
       return MX::matrix_expand(e, boundary, options);
     }

◆ matrix_expand [2/2]

std::vector<MX> matrix_expand	(	const std::vector< MX > &	e,
		const std::vector< MX > &	boundary = `std::vector<MX>()`,
		const Dict &	options = `Dict()`
	)

friend

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

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

Definition at line 816 of file mx.hpp.

                                                   {
       return MX::matrix_expand(e, boundary, options);
     }

◆ minor

template<typename Scalar >

Matrix<Scalar> minor	(	const Matrix< Scalar > &	x,
		casadi_int	i,
		casadi_int	j
	)

friend

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

Definition at line 536 of file matrix_decl.hpp.

                                                                                             {
       return Matrix<Scalar>::minor(x, i, j);
     }

◆ minus

template<typename ExType >

ExType minus	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 86 of file generic_expression.hpp.

                                                                {
     return ExType::minus(x, y);
   }

◆ mldivide

template<typename MatType >

MatType mldivide	(	const MatType &	x,
		const MatType &	n
	)

friend

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

Definition at line 383 of file generic_matrix.hpp.

                                                                        {
       return MatType::mldivide(x, n);
     }

◆ mmax

template<typename MatType >

MatType mmax ( const MatType & x )

friend

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

Definition at line 1176 of file generic_matrix.hpp.

                                                  {
       return MatType::mmax(x);
     }

◆ mmin

template<typename MatType >

MatType mmin ( const MatType & x )

friend

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

Definition at line 1167 of file generic_matrix.hpp.

                                                  {
       return MatType::mmin(x);
     }

◆ mod

template<typename ExType >

ExType mod	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 610 of file generic_expression.hpp.

                                                                {
       return ExType::mod(x, y);
     }

◆ mpower

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::mpower	(	const MatType &	x,
		const MatType &	n
	)

friend

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

Definition at line 319 of file generic_matrix.hpp.

                                                                      {
       return MatType::mpower(x, n);
     }

◆ mrdivide

template<typename MatType >

MatType mrdivide	(	const MatType &	x,
		const MatType &	n
	)

friend

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

Definition at line 376 of file generic_matrix.hpp.

                                                                        {
       return MatType::mrdivide(x, n);
     }

◆ mtaylor [1/2]

template<typename Scalar >

Matrix<Scalar> mtaylor	(	const Matrix< Scalar > &	ex,
		const Matrix< Scalar > &	x,
		const Matrix< Scalar > &	a,
		casadi_int	order,
		const std::vector< casadi_int > &	order_contributions
	)

friend

Do Taylor expansions until the aggregated order of a term is equal to 'order'. The aggregated order of equals .

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

Example usage

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

casadi::Matrix::taylor

static Matrix< Scalar > taylor(const Matrix< Scalar > &ex, const Matrix< Scalar > &x, const Matrix< Scalar > &a, casadi_int order)

casadi::GenericExpression< Matrix< Scalar > >::sin

static Matrix< Scalar > sin(const Matrix< Scalar > &x)

Sine: x -> sin(x)

Definition: generic_expression.hpp:314

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

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

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

See also: taylor

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

Definition at line 834 of file matrix_decl.hpp.

                                                                                              {
       return Matrix<Scalar>::mtaylor(ex, x, a, order, order_contributions);
     }

◆ mtaylor [2/2]

template<typename Scalar >

Matrix<Scalar> mtaylor	(	const Matrix< Scalar > &	ex,
		const Matrix< Scalar > &	x,
		const Matrix< Scalar > &	a,
		casadi_int	order = `1`
	)

friend

Do Taylor expansions until the aggregated order of a term is equal to 'order'. The aggregated order of equals .

See also: taylor

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

Definition at line 802 of file matrix_decl.hpp.

                                                                                         {
       return Matrix<Scalar>::mtaylor(ex, x, a, order);
     }

◆ mtimes [1/2]

template<typename MatType >

MatType mtimes	(	const MatType &	x,
		const MatType &	y
	)

friend

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

Definition at line 338 of file sparsity_interface.hpp.

                                                                      {
       return MatType::mtimes(x, y);
     }

◆ mtimes [2/2]

template<typename MatType >

MatType mtimes ( const std::vector< MatType > & args )

friend

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

Definition at line 345 of file sparsity_interface.hpp.

                                                                  {
       return MatType::mtimes(args);
     }

◆ n_nodes

template<typename MatType >

casadi_int n_nodes ( const MatType & A )

friend

Count number of nodes

Definition at line 1118 of file generic_matrix.hpp.

                                                        {
       return MatType::n_nodes(A);
     }

◆ ne

template<typename ExType >

ExType ne	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 209 of file generic_expression.hpp.

                                                             {
     return ExType::ne(x, y);
   }

◆ no_grad

MX no_grad ( const MX & expr )

friend

\seealso stop_diff

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

Definition at line 889 of file mx.hpp.

                                              {
       return MX::stop_diff(expr, 1);
     }

◆ no_hess

MX no_hess ( const MX & expr )

friend

\seealso stop_diff

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

Definition at line 898 of file mx.hpp.

                                              {
       return MX::stop_diff(expr, 2);
     }

◆ norm_0_mul

template<typename MatType >

casadi_int norm_0_mul	(	const MatType &	x,
		const MatType &	y
	)

friend

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

Definition at line 428 of file sparsity_interface.hpp.

                                                                             {
       return MatType::norm_0_mul(x, y);
     }

◆ norm_1

template<typename MatType >

MatType norm_1 ( const MatType & x )

friend

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

Definition at line 539 of file generic_matrix.hpp.

539 { return MatType::norm_1(x);}

◆ norm_2

template<typename MatType >

MatType norm_2 ( const MatType & x )

friend

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

Definition at line 534 of file generic_matrix.hpp.

534 { return MatType::norm_2(x);}

◆ norm_fro

template<typename MatType >

MatType norm_fro ( const MatType & x )

friend

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

Definition at line 529 of file generic_matrix.hpp.

529 { return MatType::norm_fro(x);}

◆ norm_inf

template<typename MatType >

MatType norm_inf ( const MatType & x )

friend

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

Definition at line 544 of file generic_matrix.hpp.

544 { return MatType::norm_inf(x);}

◆ norm_inf_mul

template<typename Scalar >

Matrix<Scalar> norm_inf_mul	(	const Matrix< Scalar > &	x,
		const Matrix< Scalar > &	y
	)

friend

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

Definition at line 630 of file matrix_decl.hpp.

                                                                      {
       return Matrix<Scalar>::norm_inf_mul(x, y);
     }

◆ nullspace

template<typename MatType >

MatType nullspace ( const MatType & A )

friend

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

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

Definition at line 579 of file generic_matrix.hpp.

                                                       {
       return MatType::nullspace(A);
     }

◆ offset

template<typename MatType >

std::vector<casadi_int > offset	(	const std::vector< MatType > &	v,
		bool	vert = `true`
	)

friend

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

Definition at line 169 of file sparsity_interface.hpp.

                                                                                              {
       return MatType::offset(v, vert);
     }

◆ operator!=

template<typename ExType >

ExType operator!=	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 212 of file generic_expression.hpp.

                                                                     {
     return ne(x, y);
   }

◆ operator&&

template<typename ExType >

ExType operator&&	(	const ExType &	x,
		const ExType &	y
	)

friend

Returns (an expression evaluating to) 1 if both expressions are nonzero and 0 otherwise

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

Definition at line 230 of file generic_expression.hpp.

                                                                      {
      return logic_and(x, y);
    }

◆ operator*

template<typename ExType >

ExType operator*	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 105 of file generic_expression.hpp.

                                                                    {
     return times(x, y);
   }

◆ operator+

template<typename ExType >

ExType operator+	(	const ExType &	x,
		const ExType &	y
	)

friend

Definition at line 73 of file generic_expression.hpp.

                                                                    {
     return plus(x, y);
   }

◆ operator-

template<typename ExType >

ExType operator-	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 89 of file generic_expression.hpp.

                                                                    {
     return minus(x, y);
   }

◆ operator/

template<typename ExType >

ExType operator/	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 121 of file generic_expression.hpp.

                                                                    {
     return rdivide(x, y);
   }

◆ operator<

template<typename ExType >

ExType operator<	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 137 of file generic_expression.hpp.

                                                                    {
     return lt(x, y);
   }

◆ operator<=

template<typename ExType >

ExType operator<=	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 152 of file generic_expression.hpp.

                                                                     {
     return le(x, y);
   }

◆ operator==

template<typename ExType >

ExType operator==	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 197 of file generic_expression.hpp.

                                                                     {
     return eq(x, y);
   }

◆ operator>

template<typename ExType >

ExType operator>	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 167 of file generic_expression.hpp.

                                                                    {
     return gt(x, y);
   }

◆ operator>=

template<typename ExType >

ExType operator>=	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 182 of file generic_expression.hpp.

                                                                     {
     return ge(x, y);
   }

◆ operator||

template<typename ExType >

ExType operator\|\|	(	const ExType &	x,
		const ExType &	y
	)

friend

returns (an expression evaluating to) 1 if at least one expression is nonzero and 0 otherwise

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

Definition at line 248 of file generic_expression.hpp.

                                                                      {
      return logic_or(x, y);
    }

◆ pinv [1/2]

template<typename MatType >

MatType pinv ( const MatType & A )

friend

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

pinv(A)' = (AA')^(-1) A

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

pinv(A) = (A'A)^(-1) A'

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

Definition at line 813 of file generic_matrix.hpp.

                                                  {
       return MatType::pinv(A);
     }

◆ pinv [2/2]

template<typename MatType >

MatType pinv	(	const MatType &	A,
		const std::string &	lsolver,
		const Dict &	dict = `Dict()`
	)

friend

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.

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

Definition at line 823 of file generic_matrix.hpp.

                                                           {
       return MatType::pinv(A, lsolver, dict);
     }

◆ plus

template<typename ExType >

ExType plus	(	const ExType &	x,
		const ExType &	y
	)

friend

Definition at line 70 of file generic_expression.hpp.

                                                               {
     return ExType::plus(x, y);
   }

◆ poly_coeff

template<typename Scalar >

Matrix<Scalar> poly_coeff	(	const Matrix< Scalar > &	f,
		const Matrix< Scalar > &	x
	)

friend

Parameters

ex	Scalar expression that represents a polynomial
x	Scalar symbol that the polynomial is build up with

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

Definition at line 846 of file matrix_decl.hpp.

                                                                        {
       return Matrix<Scalar>::poly_coeff(f, x);
     }

◆ poly_roots

template<typename Scalar >

Matrix<Scalar> poly_roots ( const Matrix< Scalar > & p )

friend

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

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

Definition at line 857 of file matrix_decl.hpp.

                                                                      {
       return Matrix<Scalar>::poly_roots(p);
     }

◆ polyval

template<typename MatType >

MatType polyval	(	const MatType &	p,
		const MatType &	x
	)

friend

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

Definition at line 586 of file generic_matrix.hpp.

                                                                       {
       return MatType::polyval(p, x);
     }

◆ pow

template<typename ExType >

ExType pow	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 586 of file generic_expression.hpp.

                                                                {
       return ExType::pow(x, y);
     }

◆ print_operator

template<typename MatType >

std::string print_operator	(	const MatType &	xb,
		const std::vector< std::string > &	args
	)

friend

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

Definition at line 1131 of file generic_matrix.hpp.

                                                                           {
       return MatType::print_operator(xb, args);
     }

◆ printme

template<typename ExType >

ExType printme	(	const ExType &	x,
		const ExType &	y
	)

friend

Debug printing

Definition at line 733 of file generic_expression.hpp.

                                                                     {
        return ExType::binary(OP_PRINTME, x, y);
      }

◆ project

template<typename MatType >

MatType project	(	const MatType &	A,
		const Sparsity &	sp,
		bool	intersect = `false`
	)

friend

nonzeros taken from an existing matrix

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

Definition at line 626 of file generic_matrix.hpp.

                                                         {
       return MatType::project(A, sp, intersect);
     }

Referenced by casadi::GenericMatrix< MatType >::tril(), and casadi::GenericMatrix< MatType >::triu().

◆ pw_const

template<typename Scalar >

Matrix<Scalar> pw_const	(	const Matrix< Scalar > &	t,
		const Matrix< Scalar > &	tval,
		const Matrix< Scalar > &	val
	)

friend

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

Inputs:

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)

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

Definition at line 660 of file matrix_decl.hpp.

                                                                        {
       return Matrix<Scalar>::pw_const(t, tval, val);
     }

◆ pw_lin

template<typename Scalar >

Matrix<Scalar> pw_lin	(	const Matrix< Scalar > &	t,
		const Matrix< Scalar > &	tval,
		const Matrix< Scalar > &	val
	)

friend

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

Definition at line 677 of file matrix_decl.hpp.

                                         {
       return Matrix<Scalar>::pw_lin(t, tval, val);
     }

◆ qr

template<typename Scalar >

void qr	(	const Matrix< Scalar > &	A,
		Matrix< Scalar > &	Q,
		Matrix< Scalar > &	R
	)

friend

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.

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

Definition at line 555 of file matrix_decl.hpp.

                                                                                          {
       return Matrix<Scalar>::qr(A, Q, R);
     }

◆ qr_solve

template<typename Scalar >

Matrix<Scalar> qr_solve	(	const Matrix< Scalar > &	b,
		const Matrix< Scalar > &	v,
		const Matrix< Scalar > &	r,
		const Matrix< Scalar > &	beta,
		const std::vector< casadi_int > &	prinv,
		const std::vector< casadi_int > &	pc,
		bool	tr = `false`
	)

friend

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

Definition at line 574 of file matrix_decl.hpp.

                                                              {
         return Matrix<Scalar>::qr_solve(b, v, r, beta, prinv, pc, tr);
     }

◆ qr_sparse

template<typename Scalar >

void qr_sparse	(	const Matrix< Scalar > &	A,
		Matrix< Scalar > &	V,
		Matrix< Scalar > &	R,
		Matrix< Scalar > &	beta,
		std::vector< casadi_int > &	prinv,
		std::vector< casadi_int > &	pc,
		bool	amd = `true`
	)

friend

See T. Davis: Direct Methods for Sparse Linear Systems

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

Definition at line 564 of file matrix_decl.hpp.

                                                                            {
       return Matrix<Scalar>::qr_sparse(A, V, R, beta, prinv, pc, amd);
     }

◆ quadratic_coeff

template<typename MatType >

void quadratic_coeff	(	const MatType &	expr,
		const MatType &	var,
		MatType &	A,
		MatType &	b,
		MatType &	c,
		bool	check = `true`
	)

friend

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

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

Parameters

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

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

Definition at line 976 of file generic_matrix.hpp.

                                                              {
       MatType::quadratic_coeff(expr, var, A, b, c, check);
     }

◆ ramp

template<typename Scalar >

Matrix<Scalar> ramp ( const Matrix< Scalar > & x )

friend

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

Also called: slope function

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

Definition at line 742 of file matrix_decl.hpp.

                                                                {
       return Matrix<Scalar>::ramp(x);
     }

◆ rank1

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::rank1	(	const MatType &	A,
		const MatType &	alpha,
		const MatType &	x,
		const MatType &	y
	)

friend

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

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

Definition at line 418 of file generic_matrix.hpp.

                                                                     {
       return MatType::rank1(A, alpha, x, y);
     }

◆ rdivide

template<typename ExType >

ExType rdivide	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 118 of file generic_expression.hpp.

                                                                  {
     return ExType::rdivide(x, y);
   }

◆ rectangle

template<typename Scalar >

Matrix<Scalar> rectangle ( const Matrix< Scalar > & x )

friend

$\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

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

Definition at line 710 of file matrix_decl.hpp.

                                                                     {
       return Matrix<Scalar>::rectangle(x);
     }

◆ remainder

template<typename ExType >

ExType remainder	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 637 of file generic_expression.hpp.

                                                                      {
       return ExType::remainder(x, y);
     }

◆ repmat [1/2]

template<typename MatType >

MatType repmat	(	const MatType &	A,
		casadi_int	n,
		casadi_int	m = `1`
	)

friend

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

Definition at line 458 of file sparsity_interface.hpp.

                                                                                  {
       return MatType::repmat(A, n, m);
     }

◆ repmat [2/2]

template<typename MatType >

MatType repmat	(	const MatType &	A,
		const std::pair< casadi_int, casadi_int > &	rc
	)

friend

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

Definition at line 465 of file sparsity_interface.hpp.

                                                                                               {
       return MatType::repmat(A, rc);
     }

◆ repsum

template<typename MatType >

MatType repsum	(	const MatType &	A,
		casadi_int	n,
		casadi_int	m = `1`
	)

friend

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

Definition at line 1159 of file generic_matrix.hpp.

                                                                                  {
       return MatType::repsum(A, n, m);
     }

◆ reshape [1/3]

template<typename MatType >

MatType reshape	(	const MatType &	x,
		casadi_int	nrow,
		casadi_int	ncol
	)

friend

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

Definition at line 393 of file sparsity_interface.hpp.

                                                                                       {
       return MatType::reshape(x, nrow, ncol);
     }

◆ reshape [2/3]

template<typename MatType >

MatType reshape	(	const MatType &	x,
		const Sparsity &	sp
	)

friend

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

Definition at line 407 of file sparsity_interface.hpp.

                                                                         {
       return MatType::reshape(x, sp);
     }

◆ reshape [3/3]

template<typename MatType >

MatType reshape	(	const MatType &	x,
		std::pair< casadi_int, casadi_int >	rc
	)

friend

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

Definition at line 400 of file sparsity_interface.hpp.

                                                                                         {
       return MatType::reshape(x, rc.first, rc.second);
     }

◆ reverse

template<typename MatType >

std::vector<std::vector<MatType> > reverse	(	const std::vector< MatType > &	ex,
		const std::vector< MatType > &	arg,
		const std::vector< std::vector< MatType > > &	v,
		const Dict &	opts = `Dict()`
	)

friend

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

Definition at line 907 of file generic_matrix.hpp.

                                        {
       return MatType::reverse(ex, arg, v, opts);
     }

◆ separate_linear [1/2]

template<typename MatType >

void separate_linear	(	const MatType &	expr,
		const MatType &	sym_lin,
		const MatType &	sym_const,
		MatType &	expr_const,
		MatType &	expr_lin,
		MatType &	expr_nonlin
	)

friend

Definition at line 1104 of file generic_matrix.hpp.

                                                                     {
         MatType::separate_linear(expr, sym_lin, sym_const, expr_const, expr_lin, expr_nonlin);
     }

◆ separate_linear [2/2]

template<typename MatType >

void separate_linear	(	const MatType &	expr,
		const std::vector< MatType > &	sym_lin,
		const std::vector< MatType > &	sym_const,
		MatType &	expr_const,
		MatType &	expr_lin,
		MatType &	expr_nonlin
	)

friend

Definition at line 1110 of file generic_matrix.hpp.

                                                                     {
       separate_linear(expr, veccat(sym_lin), veccat(sym_const),
         expr_const, expr_lin, expr_nonlin);
     }

◆ shared

template<typename MatType >

void shared	(	std::vector< MatType > &	ex,
		std::vector< MatType > &	v,
		std::vector< MatType > &	vdef,
		const std::string &	v_prefix = `"v_"`,
		const std::string &	v_suffix = `""`
	)

friend

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

Definition at line 1148 of file generic_matrix.hpp.

                                       {
       return MatType::shared(ex, v, vdef, v_prefix, v_suffix);
     }

◆ sign

template<typename ExType >

ExType sign ( const ExType & x )

friend

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

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

Definition at line 574 of file generic_expression.hpp.

                                                {
       return ExType::sign(x);
     }

◆ simplify

template<typename MatType >

MatType simplify ( const MatType & x )

friend

Definition at line 1123 of file generic_matrix.hpp.

                                                      {
       return MatType::simplify(x);
     }

◆ sin

template<typename ExType >

ExType sin ( const ExType & x )

friend

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

Definition at line 317 of file generic_expression.hpp.

                                               {
       return ExType::sin(x);
     }

◆ sinh

template<typename ExType >

ExType sinh ( const ExType & x )

friend

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

Definition at line 401 of file generic_expression.hpp.

                                                {
       return ExType::sinh(x);
     }

◆ skew

template<typename MatType >

MatType skew ( const MatType & a )

friend

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

Definition at line 474 of file generic_matrix.hpp.

                                                  {
       return MatType::skew(a);
     }

◆ soc

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::soc	(	const MatType &	x,
		const MatType &	y
	)

friend

Parameters

[in]	x	vector expression of size n
[in]	y	scalar expression

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

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

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

Definition at line 334 of file generic_matrix.hpp.

                                                                   {
       return MatType::soc(x, y);
     }

◆ solve [1/2]

template<typename MatType >

MatType solve	(	const MatType &	A,
		const MatType &	b
	)

friend

The solve routine works similar to Matlab's backslash when A is square and nonsingular. The algorithm used is the following:

A simple forward or backward substitution if A is upper or lower triangular
If the linear system is at most 3-by-3, form the inverse via minor expansion and multiply
Permute the variables and equations as to get a (structurally) nonzero diagonal, then perform a QR factorization without pivoting and solve the factorized system.

Note 1: If there are entries of the linear system known to be zero, these will be removed. Elements that are very small, or will evaluate to be zero, can still cause numerical errors, due to the lack of pivoting (which is not possible since cannot compare the size of entries)

Note 2: When permuting the linear system, a BLT (block lower triangular) transformation is formed. Only the permutation part of this is however used. An improvement would be to solve block-by-block if there are multiple BLT blocks.

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

Definition at line 761 of file generic_matrix.hpp.

                                                                     {
       // If A is scalar, just divide
       if (A.is_scalar()) return b/A;
       return MatType::solve(A, b);
     }

◆ solve [2/2]

template<typename MatType >

MatType solve	(	const MatType &	A,
		const MatType &	b,
		const std::string &	lsolver,
		const Dict &	dict = `Dict()`
	)

friend

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

Definition at line 770 of file generic_matrix.hpp.

                                                            {
       // If A is scalar, just divide
       if (A.is_scalar()) return b/A;
       return MatType::solve(A, b, lsolver, dict);
     }

◆ sparsify

template<typename Scalar >

Matrix<Scalar> sparsify	(	const Matrix< Scalar > &	A,
		double	tol = `0`
	)

friend

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

Definition at line 638 of file matrix_decl.hpp.

                                                       {
       return Matrix<Scalar>::sparsify(A, tol);
     }

◆ sparsity_cast

template<typename MatType >

MatType sparsity_cast	(	const MatType &	x,
		const Sparsity &	sp
	)

friend

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

Definition at line 414 of file sparsity_interface.hpp.

                                                                               {
       return MatType::sparsity_cast(x, sp);
     }

◆ sprank

template<typename MatType >

casadi_int sprank ( const MatType & x )

friend

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

Definition at line 421 of file sparsity_interface.hpp.

                                                       {
       return MatType::sprank(x);
     }

◆ sq

template<typename ExType >

ExType sq ( const ExType & x )

friend

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

Definition at line 305 of file generic_expression.hpp.

                                              {
       return ExType::sq(x);
     }

◆ sqrt

template<typename ExType >

ExType sqrt ( const ExType & x )

friend

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

Definition at line 293 of file generic_expression.hpp.

                                                {
       return ExType::sqrt(x);
     }

◆ stop_diff [1/2]

MX stop_diff	(	const MX &	expr,
		casadi_int	order
	)

friend

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

Definition at line 880 of file mx.hpp.

                                                                  {
       return MX::stop_diff(expr, order);
     }

◆ stop_diff [2/2]

MX stop_diff	(	const MX &	expr,
		const MX &	var,
		casadi_int	order
	)

friend

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

Definition at line 906 of file mx.hpp.

                                                                                 {
       return MX::stop_diff(expr, var, order);
     }

◆ substitute [1/2]

template<typename MatType >

MatType substitute	(	const MatType &	ex,
		const MatType &	v,
		const MatType &	vdef
	)

friend

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

Definition at line 701 of file generic_matrix.hpp.

                                                           {
       return MatType::substitute(ex, v, vdef);
     }

◆ substitute [2/2]

template<typename MatType >

std::vector<MatType> substitute	(	const std::vector< MatType > &	ex,
		const std::vector< MatType > &	v,
		const std::vector< MatType > &	vdef
	)

friend

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

Definition at line 710 of file generic_matrix.hpp.

                                                  {
       return MatType::substitute(ex, v, vdef);
     }

◆ substitute_inplace

template<typename MatType >

void substitute_inplace	(	const std::vector< MatType > &	v,
		std::vector< MatType > &	inout_vdef,
		std::vector< MatType > &	inout_ex,
		bool	reverse = `false`
	)

friend

Substitute variables v out of the expressions vdef sequentially, as well as out of a number of other expressions piggyback

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

Definition at line 722 of file generic_matrix.hpp.

                                                                           {
       return MatType::substitute_inplace(v, inout_vdef, inout_ex, reverse);
     }

◆ sum

template<typename MatType >

MatType sum ( const MatType & x )

friend

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

Definition at line 596 of file sparsity_interface.hpp.

                                                 {
       if (x.is_vector()) {
         if (x.is_column()) {
           return MatType::sum1(x);
         } else {
           return MatType::sum2(x);
         }
       }
       if (x.size1()>x.size2()) {
         return MatType::sum2(MatType::sum1(x));
       } else {
         return MatType::sum1(MatType::sum2(x));
       }
     }

◆ sum1

template<typename MatType >

MatType sum1 ( const MatType & x )

friend

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

Definition at line 586 of file sparsity_interface.hpp.

586 { return MatType::sum1(x);}

◆ sum2

template<typename MatType >

MatType sum2 ( const MatType & x )

friend

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

Definition at line 591 of file sparsity_interface.hpp.

591 { return MatType::sum2(x);}

◆ sumsqr

template<typename MatType >

MatType sumsqr ( const MatType & x )

friend

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

Definition at line 429 of file generic_matrix.hpp.

                                                    {
       return MatType::sumsqr(x);
     }

◆ symvar

template<typename MatType >

std::vector<MatType> symvar ( const MatType & x )

friend

Get all symbols on which the supplied expression depends

See also: SXFunction::getFree(), MXFunction::getFree()

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

Definition at line 393 of file generic_matrix.hpp.

                                                               {
       return MatType::symvar(x);
     }

◆ tan

template<typename ExType >

ExType tan ( const ExType & x )

friend

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

Definition at line 341 of file generic_expression.hpp.

                                               {
       return ExType::tan(x);
     }

◆ tangent

template<typename MatType >

MatType casadi::GenericMatrix< MatType >::tangent	(	const MatType &	ex,
		const MatType &	arg,
		const Dict &	opts = `Dict()`
	)

friend

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

Definition at line 875 of file generic_matrix.hpp.

                                                                                                   {
       return MatType::tangent(ex, arg, opts);
     }

◆ tanh

template<typename ExType >

ExType tanh ( const ExType & x )

friend

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

Definition at line 389 of file generic_expression.hpp.

                                                {
       return ExType::tanh(x);
     }

◆ taylor [1/2]

template<typename Scalar >

Matrix<Scalar> taylor	(	const Matrix< Scalar > &	ex,
		const Matrix< Scalar > &	x
	)

friend

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

taylor(sin(x),x,x0) -> sin(x0)+cos(x0)*(x-x0)

casadi::GenericExpression< Matrix< Scalar > >::cos

static Matrix< Scalar > cos(const Matrix< Scalar > &x)

Cosine: x -> cos(x)

Definition: generic_expression.hpp:326

See also: linearize, mtaylor, linear_coeff

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

Definition at line 789 of file matrix_decl.hpp.

                                                                                            {
       return Matrix<Scalar>::taylor(ex, x, 0, 1);
     }

◆ taylor [2/2]

template<typename Scalar >

Matrix<Scalar> taylor	(	const Matrix< Scalar > &	ex,
		const Matrix< Scalar > &	x,
		const Matrix< Scalar > &	a,
		casadi_int	order = `1`
	)

friend

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

taylor(sin(x),x,x0) -> sin(x0)+cos(x0)*(x-x0)

See also: linearize, mtaylor, linear_coeff

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

Definition at line 785 of file matrix_decl.hpp.

                                                                                        {
       return Matrix<Scalar>::taylor(ex, x, a, order);
     }

◆ times

template<typename ExType >

ExType times	(	const ExType &	x,
		const ExType &	y
	)

friend

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

Definition at line 102 of file generic_expression.hpp.

                                                                {
     return ExType::times(x, y);
   }

◆ trace

template<typename MatType >

MatType trace ( const MatType & x )

friend

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

Definition at line 514 of file generic_matrix.hpp.

514 { return MatType::trace(x);}

◆ transpose

template<typename MatType >

MatType transpose ( const MatType & X )

friend

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

Definition at line 365 of file sparsity_interface.hpp.

                                                       {
       return X.T();
     }

◆ triangle

template<typename Scalar >

Matrix<Scalar> triangle ( const Matrix< Scalar > & x )

friend

$\begin {cases} \Lambda(x) = 0 & |x| >= 1 \\ \Lambda(x) = 1-|x| & |x| < 1 \end {cases}$

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

Definition at line 725 of file matrix_decl.hpp.

                                                                    {
       return Matrix<Scalar>::triangle(x);
     }

◆ tril

template<typename MatType >

MatType tril	(	const MatType &	x,
		bool	includeDiagonal = `true`
	)

friend

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

Definition at line 442 of file sparsity_interface.hpp.

                                                                             {
       return MatType::tril(x, includeDiagonal);
     }

◆ tril2symm

template<typename MatType >

MatType tril2symm ( const MatType & a )

friend

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

Definition at line 519 of file generic_matrix.hpp.

519 { return MatType::tril2symm(a);}

◆ triu

template<typename MatType >

MatType triu	(	const MatType &	x,
		bool	includeDiagonal = `true`
	)

friend

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

Definition at line 435 of file sparsity_interface.hpp.

                                                                             {
       return MatType::triu(x, includeDiagonal);
     }

◆ triu2symm

template<typename MatType >

MatType triu2symm ( const MatType & a )

friend

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

Definition at line 524 of file generic_matrix.hpp.

524 { return MatType::triu2symm(a);}

◆ unite

template<typename MatType >

MatType unite	(	const MatType &	A,
		const MatType &	B
	)

friend

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

Definition at line 603 of file generic_matrix.hpp.

                                                                     {
       return MatType::unite(A, B);
     }

◆ vec

template<typename MatType >

MatType vec ( const MatType & x )

friend

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
Extra doc: https://github.com/casadi/casadi/wiki/L_3z

Definition at line 386 of file sparsity_interface.hpp.

                                                 {
       return MatType::vec(x);
     }

◆ veccat

template<typename MatType >

MatType veccat ( const std::vector< MatType > & x )

friend

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

Definition at line 331 of file sparsity_interface.hpp.

                                                                 {
       return MatType::veccat(x);
     }

◆ vertcat [1/6]

template<typename MatType >

MatType vertcat	(	const MatType &	x,
		const MatType &	y
	)

friend

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

Definition at line 510 of file sparsity_interface.hpp.

                                                                       {
       return vertcat(std::vector<MatType>{x, y});
     }

◆ vertcat [2/6]

template<typename MatType >

MatType vertcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z
	)

friend

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

Definition at line 517 of file sparsity_interface.hpp.

                                                                                         {
       return vertcat(std::vector<MatType>{x, y, z});
     }

◆ vertcat [3/6]

template<typename MatType >

MatType vertcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w
	)

friend

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

Definition at line 524 of file sparsity_interface.hpp.

                                                     {
       return vertcat(std::vector<MatType>{x, y, z, w});
     }

◆ vertcat [4/6]

template<typename MatType >

MatType vertcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w,
		const MatType &	v
	)

friend

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

Definition at line 532 of file sparsity_interface.hpp.

                                                                       {
       return vertcat(std::vector<MatType>{x, y, z, w, v});
     }

◆ vertcat [5/6]

template<typename MatType >

MatType vertcat	(	const MatType &	x,
		const MatType &	y,
		const MatType &	z,
		const MatType &	w,
		const MatType &	v,
		const MatType &	u
	)

friend

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

Definition at line 540 of file sparsity_interface.hpp.

                                                                                         {
       return vertcat(std::vector<MatType>{x, y, z, w, v, u});
     }

◆ vertcat [6/6]

template<typename MatType >

MatType vertcat ( const std::vector< MatType > & v )

friend

Alternative terminology: vertical stack, vstack, vertical append, [a;b]

vertcat(vertsplit(x, ...)) = x

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

Definition at line 108 of file sparsity_interface.hpp.

                                                                {
       return MatType::vertcat(v);
     }

◆ vertsplit [1/2]

template<typename MatType >

std::vector<MatType > vertsplit	(	const MatType &	x,
		casadi_int	incr = `1`
	)

friend

Parameters

incr	Size of each group of rows

vertcat(vertsplit(x, ...)) = x

print vertsplit(SX.sym("a",4))

[SX(a_0), SX(a_1), SX(a_2), SX(a_3)]

print vertsplit(SX.sym("a",4),2)

[SX([a_0, a_1]), SX([a_2, a_3])]

If the number of rows is not a multiple of incr, the last entry returned will have a size smaller than incr.

print vertsplit(DM([0,1,2,3,4]),2)

[DM([0, 1]), DM([2, 3]), DM(4)]

\seealso vertsplit_n

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

Definition at line 204 of file sparsity_interface.hpp.

                                                                                      {
       return MatType::vertsplit(x, incr);
     }

◆ vertsplit [2/2]

template<typename MatType >

std::vector<MatType > vertsplit	(	const MatType &	x,
		const std::vector< casadi_int > &	offset
	)

friend

Parameters

output_offset List of all start rows for each group the last row group will run to the end.

vertcat(vertsplit(x, ...)) = x

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

Definition at line 162 of file sparsity_interface.hpp.

                                                                        {
       return MatType::vertsplit(x, offset);
     }

◆ vertsplit_n

template<typename MatType >

std::vector<MatType > vertsplit_n	(	const MatType &	x,
		casadi_int	n
	)

friend

Parameters

n	Number of groups of rows

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

vertcat(vertsplit(x, ...)) = x

\seealso vertsplit

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

Definition at line 219 of file sparsity_interface.hpp.

                                                                                   {
       return MatType::vertsplit_n(x, n);
     }

◆ which_depends

template<typename MatType >

std::vector<bool> which_depends	(	const MatType &	expr,
		const MatType &	var,
		casadi_int	order,
		bool	tr
	)

friend

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

Definition at line 930 of file generic_matrix.hpp.

                                    {
       return MatType::which_depends(expr, var, order, tr);
     }