#include <mx.hpp>

Detailed Description

The MX class is used to build up trees made up from MXNodes. It is a more general graph representation than the scalar expression, SX, and much less efficient for small objects. On the other hand, the class allows much more general operations than does SX, in particular matrix valued operations and calls to arbitrary differentiable functions.

The MX class is designed to have identical syntax with the Matrix<> template class, and uses DM (i.e. Matrix<double>) as its internal representation of the values at a node. By keeping the syntaxes identical, it is possible to switch from one class to the other, as well as inlining MX functions to SXElem functions.

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

Author: Joel Andersson

Date: 2010-2011

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

Definition at line 88 of file mx.hpp.

Inheritance diagram for casadi::MX:

[legend]

Collaboration diagram for casadi::MX:

[legend]

Public Types
typedef MX	ScalarType

typedef GenericMatrix< MX >	B
	Base class. More...

typedef std::map< std::string, MX >	MXDict
	Readability typedef. More...

using	internal_base_type = SharedObjectInternal

using	base_type = SharedObject

Public Member Functions
	MX ()
	Default constructor. More...

	MX (casadi_int nrow, casadi_int ncol)
	Create a sparse matrix with all structural zeros. More...

	MX (const std::pair< casadi_int, casadi_int > &rc)
	Create a sparse matrix with all structural zeros. More...

	MX (const Sparsity &sp)
	Create a sparse matrix from a sparsity pattern. More...

	MX (const Sparsity &sp, const MX &val)
	Construct matrix with a given sparsity and nonzeros. More...

	MX (const Sparsity &sp, const std::string &fname)
	Construct matrix with a given sparsity and a file with nonzeros. More...

	MX (const Matrix< double > &val, const std::string &name)
	Construct matrix with a given sparsity and nonzeros,. More...

	MX (double x)
	Create scalar constant (also implicit type conversion) More...

	MX (const std::vector< double > &x)
	Create vector constant (also implicit type conversion) More...

	MX (const Matrix< double > &x)
	Create sparse matrix constant (also implicit type conversion) More...

	~MX ()
	Destructor. More...

const Sparsity &	sparsity () const
	Get the sparsity pattern. More...

bool	__nonzero__ () const
	Returns the truth value of an MX expression. More...

Sparsity	get_sparsity () const
	Get an owning reference to the sparsity pattern. More...

std::vector< MX >	get_nonzeros () const
	Get nonzeros as list of scalar MXes. More...

void	erase (const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, bool ind1=false)
	Erase a submatrix (leaving structural zeros in its place) More...

void	erase (const std::vector< casadi_int > &rr, bool ind1=false)
	Erase a submatrix (leaving structural zeros in its place) More...

void	enlarge (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc, bool ind1=false)
	Enlarge matrix. More...

MX	operator- () const

MX	operator+ () const

MX	inv () const
	Element-wise inverse. More...

MX	dep (casadi_int ch=0) const
	Get the nth dependency as MX. More...

casadi_int	n_out () const
	Number of outputs. More...

MX	get_output (casadi_int oind) const
	Get an output. More...

casadi_int	n_dep () const
	Get the number of dependencies of a binary SXElem. More...

std::string	name () const
	Get the name. More...

	operator double () const
	Get the value (only for scalar constant nodes) More...

	operator Matrix< double > () const
	Get the value (only for constant nodes) More...

bool	is_symbolic () const
	Check if symbolic. More...

bool	is_constant () const
	Check if constant. More...

bool	is_integer () const
	Check if integer. More...

bool	is_doubled () const
	Check if the node is the sum of two equal expressions. More...

bool	is_call () const
	Check if evaluation. More...

Function	which_function () const
	Get function - only valid when is_call() is true. More...

bool	is_output () const
	Check if evaluation output. More...

bool	has_output () const
	Check if a multiple output node. More...

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

bool	is_op (casadi_int op) const
	Is it a certain operation. More...

bool	is_multiplication () const
	Check if multiplication. More...

bool	is_commutative () const
	Check if commutative operation. More...

bool	is_norm () const
	Check if norm. More...

bool	is_valid_input () const
	Check if matrix can be used to define function inputs. More...

casadi_int	n_primitives () const
	Get the number of primitives for MXFunction inputs/outputs. More...

std::vector< MX >	primitives () const
	Get primitives. More...

bool	has_duplicates () const
	Detect duplicate symbolic expressions. More...

void	reset_input () const
	Reset the marker for an input expression. More...

bool	is_eye () const
	check if identity More...

bool	is_zero () const
	check if zero (note that false negative answers are possible) More...

bool	is_one () const
	check if one (note that false negative answers are possible) More...

bool	is_minus_one () const
	check if minus one (note that false negative answers are possible) More...

bool	is_half () const
	check if 0.5 (note that false negative answers are possible) More...

bool	is_value (double val) const
	check if a certain value (note that false negative answers are possible) More...

bool	is_inf () const
	check if inf (note that false negative answers are possible) More...

bool	is_minus_inf () const
	check if -inf (note that false negative answers are possible) More...

bool	is_transpose () const
	Is the expression a transpose? More...

bool	is_regular () const
	Checks if expression does not contain NaN or Inf. More...

bool	is_binary () const
	Is binary operation. More...

bool	is_nonnegative () const
	Check if a value is always nonnegative (false negatives are allowed) More...

bool	is_unary () const
	Is unary operation. More...

casadi_int	op () const
	Get operation type. More...

Dict	info () const

void	serialize (SerializingStream &s) const
	Serialize an object. More...

casadi_int	get_temp () const

void	set_temp (casadi_int t) const
	Set the temporary variable. More...

MXNode *	get () const
	Get a const pointer to the node. More...

MX	nzref (const Sparsity &sp, const std::vector< casadi_int > &nz) const
	Low-level access to get_nzref. More...

MX	printme (const MX &b) const

MX	attachAssert (const MX &y, const std::string &fail_message="") const
	returns itself, but with an assertion attached More...

MX	monitor (const std::string &comment) const
	Monitor an expression. More...

MX	dump (const std::string &base_filename, const Dict &opts=Dict()) const
	Dump an expression. More...

void	reset_dump_count ()
	Reset the dump counter. More...

MX	T () const
	Transpose the matrix. More...

Matrix< casadi_int >	mapping () const
	Get an IM representation of a GetNonzeros or SetNonzeros node. More...

void	eval_mx (const std::vector< MX > &arg, std::vector< MX > &res, const std::vector< bool > &unique=std::vector< bool >()) const
	Evaluate the MX node with new symbolic dependencies. More...

	MX (const Sparsity &sp, double val, bool dummy)
	Construct constant matrix with a given sparsity and values. More...

casadi_int	nnz () const
	Get the number of (structural) non-zero elements. More...

casadi_int	nnz_lower () const
	Get the number of non-zeros in the lower triangular half. More...

casadi_int	nnz_upper () const
	Get the number of non-zeros in the upper triangular half. More...

casadi_int	nnz_diag () const
	Get get the number of non-zeros on the diagonal. More...

casadi_int	numel () const
	Get the number of elements. More...

casadi_int	size1 () const
	Get the first dimension (i.e. number of rows) More...

casadi_int	rows () const
	Get the number of rows, Octave-style syntax. More...

casadi_int	size2 () const
	Get the second dimension (i.e. number of columns) More...

casadi_int	columns () const
	Get the number of columns, Octave-style syntax. More...

std::string	dim (bool with_nz=false) const
	Get string representation of dimensions. More...

std::pair< casadi_int, casadi_int >	size () const
	Get the shape. More...

casadi_int	size (casadi_int axis) const
	Get the size along a particular dimensions. More...

bool	is_empty (bool both=false) const
	Check if the sparsity is empty, i.e. if one of the dimensions is zero. More...

bool	is_dense () const
	Check if the matrix expression is dense. More...

bool	is_scalar (bool scalar_and_dense=false) const
	Check if the matrix expression is scalar. More...

bool	is_square () const
	Check if the matrix expression is square. More...

bool	is_vector () const
	Check if the matrix is a row or column vector. More...

bool	is_row () const
	Check if the matrix is a row vector (i.e. size1()==1) More...

bool	is_column () const
	Check if the matrix is a column vector (i.e. size2()==1) More...

bool	is_triu () const
	Check if the matrix is upper triangular. More...

bool	is_tril () const
	Check if the matrix is lower triangular. More...

const MX	nz (const K &k) const
	Get vector nonzero or slice of nonzeros. More...

NonZeros< MX, K >	nz (const K &k)
	Access vector nonzero or slice of nonzeros. More...

const MX	operator() (const RR &rr) const
	Get vector element or slice. More...

const MX	operator() (const RR &rr, const CC &cc) const
	Get Matrix element or slice. More...

SubIndex< MX, RR >	operator() (const RR &rr)
	Access Matrix elements (one argument) More...

SubMatrix< MX, RR, CC >	operator() (const RR &rr, const CC &cc)
	Access Matrix elements (two arguments) More...

std::string	class_name () const
	Get class name. More...

void	disp (std::ostream &stream, bool more=false) const
	Print a description of the object. More...

std::string	get_str (bool more=false) const
	Get string representation. More...

void	print_ptr (std::ostream &stream=casadi::uout()) const

void	own (SharedObjectInternal *node)

void	assign (SharedObjectInternal *node)
	Assign the node to a node class pointer without reference counting. More...

casadi_int	getCount () const
	Get the reference count. More...

void	swap (GenericShared &other)
	Swap content with another instance. More...

std::string	debug_repr () const

bool	is_null () const
	Is a null pointer? More...

casadi_int	__hash__ () const
	Returns a number that is unique for a given Node. More...

GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...


MXNode *	operator-> ()
	Access a member of the node. More...

const MXNode *	operator-> () const
	Const access a member of the node. More...


std::vector< MX >	split_primitives (const MX &x) const
	Split up an expression along symbolic primitives. More...

std::vector< SX >	split_primitives (const SX &x) const
	Split up an expression along symbolic primitives. More...

std::vector< DM >	split_primitives (const DM &x) const
	Split up an expression along symbolic primitives. More...


MX	join_primitives (const std::vector< MX > &v) const
	Join an expression along symbolic primitives. More...

SX	join_primitives (const std::vector< SX > &v) const
	Join an expression along symbolic primitives. More...

DM	join_primitives (const std::vector< DM > &v) const
	Join an expression along symbolic primitives. More...


void	get (MX &m, bool ind1, const Slice &rr) const

void	get (MX &m, bool ind1, const Matrix< casadi_int > &rr) const

void	get (MX &m, bool ind1, const Sparsity &sp) const

void	get (MX &m, bool ind1, const MX &rr) const

void	get (MX &m, bool ind1, const casadi_int rr) const


void	get (MX &m, bool ind1, const Slice &rr, const Slice &cc) const

void	get (MX &m, bool ind1, const Slice &rr, const Matrix< casadi_int > &cc) const

void	get (MX &m, bool ind1, const Slice &rr, casadi_int cc) const

void	get (MX &m, bool ind1, const Matrix< casadi_int > &rr, const Slice &cc) const

void	get (MX &m, bool ind1, casadi_int rr, const Slice &cc) const

void	get (MX &m, bool ind1, const Matrix< casadi_int > &rr, const Matrix< casadi_int > &cc) const

void	get (MX &m, bool ind1, casadi_int rr, casadi_int cc) const

void	get (MX &m, bool ind1, const MX &rr, const Slice &cc) const

void	get (MX &m, bool ind1, const Slice &rr, const MX &cc) const

void	get (MX &m, bool ind1, const MX &rr, const MX &cc) const


void	set (const MX &m, bool ind1, const Slice &rr)

void	set (const MX &m, bool ind1, const Matrix< casadi_int > &rr)

void	set (const MX &m, bool ind1, const Sparsity &sp)


void	set (const MX &m, bool ind1, const Slice &rr, const Slice &cc)

void	set (const MX &m, bool ind1, const Slice &rr, const Matrix< casadi_int > &cc)

void	set (const MX &m, bool ind1, const Matrix< casadi_int > &rr, const Slice &cc)

void	set (const MX &m, bool ind1, const Matrix< casadi_int > &rr, const Matrix< casadi_int > &cc)


void	get_nz (MX &m, bool ind1, const Slice &kk) const

void	get_nz (MX &m, bool ind1, const Matrix< casadi_int > &kk) const

void	get_nz (MX &m, bool ind1, const MX &kk) const

void	get_nz (MX &m, bool ind1, casadi_int kk) const

void	get_nz (MX &m, bool ind1, const MX &inner, const Slice &outer) const

void	get_nz (MX &m, bool ind1, const Slice &inner, const MX &outer) const

void	get_nz (MX &m, bool ind1, const MX &inner, const MX &outer) const


void	set_nz (const MX &m, bool ind1, const Slice &kk)

void	set_nz (const MX &m, bool ind1, const Matrix< casadi_int > &kk)

void	set_nz (const MX &m, bool ind1, const MX &kk)

void	set_nz (const MX &m, bool ind1, casadi_int kk)


void	ad_forward (const std::vector< std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens) const
	Called from MXFunction. More...

void	ad_reverse (const std::vector< std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens) const
	Called from MXFunction. More...


std::vector< casadi_int >	get_row () const
	Get the sparsity pattern. See the Sparsity class for details. More...

std::vector< casadi_int >	get_colind () const
	Get the sparsity pattern. See the Sparsity class for details. More...

const casadi_int *	row () const
	Get the sparsity pattern. See the Sparsity class for details. More...

casadi_int	row (casadi_int el) const
	Get the sparsity pattern. See the Sparsity class for details. More...

const casadi_int *	colind () const
	Get the sparsity pattern. See the Sparsity class for details. More...

casadi_int	colind (casadi_int col) const
	Get the sparsity pattern. See the Sparsity class for details. More...

Static Public Member Functions
static std::string	type_name ()
	Get type name. More...

static MX	create (MXNode *node)
	Create from node. More...

static std::vector< MX >	createMultipleOutput (MXNode *node)
	Create from node (multiple-outputs) More...

static MX	deserialize (DeserializingStream &s)
	Deserialize with type disambiguation. More...

static MX	eye (casadi_int n)
	Identity matrix. More...

static bool	simplify_ref_count (std::vector< MX > &arg, std::vector< MX > &res, const Dict &opts=Dict())

static bool	simplify_const_folding (std::vector< MX > &arg, std::vector< MX > &res, const Dict &opts=Dict())

static bool	simplify_combine_terms (std::vector< MX > &arg, std::vector< MX > &res, const Dict &opts=Dict())

static 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())

static MX	interpn_linear (const std::vector< MX > &x, const MX &v, const std::vector< MX > &xq, const Dict &opts=Dict())
	Low-level access to inlined linear interpolation. More...

static void	set_max_depth (casadi_int eq_depth=1)
	Set or reset the depth to which equalities are being checked for simplifications. More...

static casadi_int	get_max_depth ()
	Get the depth to which equalities are being checked for simplifications. More...

static bool	test_cast (const SharedObjectInternal *ptr)
	Check if a particular cast is allowed. More...

static std::vector< MX >	get_input (const Function &f)
	Get function inputs. More...

static std::vector< MX >	get_free (const Function &f)
	Get free variables. More...

static MX	_sym (const std::string &name, const Sparsity &sp)

static MX	logsumexp (const MX &x)


static MX	binary (casadi_int op, const MX &x, const MX &y, bool unique_x=false, bool unique_y=false)
	Create nodes by their ID. More...

static MX	unary (casadi_int op, const MX &x, bool unique=false)
	Create nodes by their ID. More...


static MX	inf (const Sparsity &sp)
	create a matrix with all inf More...

static MX	inf (casadi_int nrow=1, casadi_int ncol=1)
	create a matrix with all inf More...

static MX	inf (const std::pair< casadi_int, casadi_int > &rc)
	create a matrix with all inf More...


static MX	nan (const Sparsity &sp)
	create a matrix with all nan More...

static MX	nan (casadi_int nrow=1, casadi_int ncol=1)
	create a matrix with all nan More...

static MX	nan (const std::pair< casadi_int, casadi_int > &rc)
	create a matrix with all nan More...


static MX	einstein (const MX &A, const MX &B, const MX &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)
	Computes an einstein dense tensor contraction. More...

static MX	einstein (const MX &A, const MX &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)
	Computes an einstein dense tensor contraction. More...


static bool	is_equal (const MX &x, const MX &y, casadi_int depth=0)

static MX	mmin (const MX &x)

static MX	mmax (const MX &x)


static MX	horzcat (const std::vector< MX > &x)

static MX	diagcat (const std::vector< MX > &x)

static MX	vertcat (const std::vector< MX > &x)

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

static std::vector< MX >	diagsplit (const MX &x, const std::vector< casadi_int > &offset1, const std::vector< casadi_int > &offset2)

static std::vector< MX >	vertsplit (const MX &x, const std::vector< casadi_int > &offset)

static MX	blockcat (const std::vector< std::vector< MX > > &v)

static MX	mtimes (const MX &x, const MX &y, const std::string &blas="reference")

static MX	mac (const MX &x, const MX &y, const MX &z, const std::string &blas="reference")

static MX	reshape (const MX &x, casadi_int nrow, casadi_int ncol)

static MX	reshape (const MX &x, const Sparsity &sp)

static MX	sparsity_cast (const MX &x, const Sparsity &sp)

static MX	kron (const MX &x, const MX &b)

static MX	kron_contract (const MX &m, const MX &x, bool inner)

static MX	repmat (const MX &x, casadi_int n, casadi_int m=1)


static MX	linspace (const MX &a, const MX &b, casadi_int nsteps)

static MX	jacobian (const MX &f, const MX &x, const Dict &opts=Dict())

static MX	hessian (const MX &f, const MX &x, const Dict &opts=Dict())

static MX	hessian (const MX &f, const MX &x, MX &g, const Dict &opts=Dict())

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

static std::vector< std::vector< MX > >	reverse (const std::vector< MX > &ex, const std::vector< MX > &arg, const std::vector< std::vector< MX > > &v, const Dict &opts=Dict())

static std::vector< bool >	which_depends (const MX &expr, const MX &var, casadi_int order=1, bool tr=false)

static Sparsity	jacobian_sparsity (const MX &f, const MX &x)

static MX	substitute (const MX &ex, const MX &v, const MX &vdef)

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

static void	substitute_inplace (const std::vector< MX > &v, std::vector< MX > &vdef, std::vector< MX > &ex, bool reverse)

static MX	solve (const MX &a, const MX &b)

static MX	solve (const MX &a, const MX &b, const std::string &lsolver, const Dict &dict=Dict())

static MX	inv_minor (const MX &A)

static MX	inv_node (const MX &A)

static MX	inv (const MX &A, const std::string &lsolver="qr", const Dict &dict=Dict())

static MX	pinv (const MX &A, const std::string &lsolver="qr", const Dict &dict=Dict())

static MX	expm_const (const MX &A, const MX &t)

static MX	expm (const MX &A)

static casadi_int	n_nodes (const MX &x)

static std::string	print_operator (const MX &x, const std::vector< std::string > &args)

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

static void	shared (std::vector< MX > &ex, std::vector< MX > &v, std::vector< MX > &vdef, const std::string &v_prefix, const std::string &v_suffix)

static MX	if_else (const MX &cond, const MX &if_true, const MX &if_false, bool short_circuit=false)

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

static bool	depends_on (const MX &x, const MX &arg)

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

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

static MX	simplify (const MX &x)

static MX	transform (const MX &x, const Dict &opts=Dict())

static MX	transform (const MX &x, const std::vector< std::vector< GenericType > > &passes, const Dict &opts=Dict())

static std::vector< MX >	transform (const std::vector< MX > &x, const Dict &opts=Dict())

static std::vector< MX >	transform (const std::vector< MX > &x, const std::vector< std::vector< GenericType > > &passes, const Dict &opts=Dict())

static MX	dot (const MX &x, const MX &y)

static MX	mrdivide (const MX &a, const MX &b)

static MX	mldivide (const MX &a, const MX &b)

static MX	norm_2 (const MX &x)

static MX	norm_fro (const MX &x)

static MX	norm_1 (const MX &x)

static MX	norm_inf (const MX &x)

static MX	unite (const MX &A, const MX &B)

static MX	trace (const MX &x)

static MX	diag (const MX &x)

static MX	sum2 (const MX &x)

static MX	sum1 (const MX &x)

static MX	polyval (const MX &p, const MX &x)

static MX	det (const MX &x)

static MX	det (const MX &x, const std::string &lsolver, const Dict &opts=Dict())

static std::vector< MX >	symvar (const MX &x)

static MX	nullspace (const MX &A)

static MX	repsum (const MX &x, casadi_int n, casadi_int m=1)

static MX	densify (const MX &x, const MX &val=0)

static MX	_bilin (const MX &A, const MX &x, const MX &y)

static MX	_rank1 (const MX &A, const MX &alpha, const MX &x, const MX &y)

static MX	project (const MX &x, const Sparsity &sp, bool intersect=false)

static MX	cumsum (const MX &x, casadi_int axis=-1)

static MX	_logsumexp (const MX &x)

static std::vector< MX >	cse (const std::vector< MX > &e)

static void	extract_parametric (const MX &expr, const MX &par, MX &expr_ret, std::vector< MX > &symbols, std::vector< MX > &parametric, const Dict &opts)

static void	separate_linear (const MX &expr, const MX &sym_lin, const MX &sym_const, MX &expr_const, MX &expr_lin, MX &expr_nonlin)


static MX	find (const MX &x)

static MX	low (const MX &v, const MX &p, const Dict &options=Dict())

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

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

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

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

static MX	matrix_expand (const MX &e, const std::vector< MX > &boundary, const Dict &options)

static std::vector< MX >	matrix_expand (const std::vector< MX > &e, const std::vector< MX > &boundary, const Dict &options)

static MX	lift (const MX &x, const MX &x_guess)

static DM	evalf (const MX &m)

static 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())

static 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())

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

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

static MX	stop_diff (const MX &expr, casadi_int order)

static MX	stop_diff (const MX &expr, const MX &var, casadi_int order)

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


static MX	interp1d (const std::vector< double > &x, const MX &v, const std::vector< double > &xq, const std::string &mode, bool equidistant)
	Functions called by friend functions defined here. More...

static casadi_int	sprank (const MX &x)
	Functions called by friend functions defined here. More...

static casadi_int	norm_0_mul (const MX &x, const MX &y)
	Functions called by friend functions defined here. More...

static MX	tril (const MX &x, bool includeDiagonal=true)
	Functions called by friend functions defined here. More...

static MX	triu (const MX &x, bool includeDiagonal=true)
	Functions called by friend functions defined here. More...

static MX	sumsqr (const MX &x)
	Functions called by friend functions defined here. More...

static MX	linspace (const MX &a, const MX &b, casadi_int nsteps)
	Functions called by friend functions defined here. More...

static MX	cross (const MX &a, const MX &b, casadi_int dim=-1)
	Functions called by friend functions defined here. More...

static MX	skew (const MX &a)
	Functions called by friend functions defined here. More...

static MX	inv_skew (const MX &a)
	Functions called by friend functions defined here. More...

static MX	tril2symm (const MX &x)
	Functions called by friend functions defined here. More...

static MX	triu2symm (const MX &x)
	Functions called by friend functions defined here. More...

static MX	repsum (const MX &x, casadi_int n, casadi_int m=1)
	Functions called by friend functions defined here. More...

static MX	diff (const MX &x, casadi_int n=1, casadi_int axis=-1)
	Functions called by friend functions defined here. More...

static bool	is_linear (const MX &expr, const MX &var)
	Functions called by friend functions defined here. More...

static bool	is_quadratic (const MX &expr, const MX &var)
	Functions called by friend functions defined here. More...

static void	quadratic_coeff (const MX &expr, const MX &var, MX &A, MX &b, MX &c, bool check)
	Functions called by friend functions defined here. More...

static void	linear_coeff (const MX &expr, const MX &var, MX &A, MX &b, bool check)
	Functions called by friend functions defined here. More...


static MX	mpower (const MX &x, const MX &y)

static MX	soc (const MX &x, const MX &y)

static MX	linearize (const MX &f, const MX &x, const MX &x0, const Dict &opts=Dict())

static MX	gradient (const MX &ex, const MX &arg, const Dict &opts=Dict())

static MX	tangent (const MX &ex, const MX &arg, const Dict &opts=Dict())

static MX	jtimes (const MX &ex, const MX &arg, const MX &v, bool tr=false, const Dict &opts=Dict())


static MX	bilin (const MX &A, const MX &x, const MX &y)
	Calculate bilinear/quadratic form x^T A y. More...


static MX	rank1 (const MX &A, const MX &alpha, const MX &x, const MX &y)
	Make a rank-1 update to a matrix A. More...

Construct symbolic primitives
The "sym" function is intended to work in a similar way as "sym" used in the Symbolic Toolbox for Matlab but instead creating a CasADi symbolic primitive.
static MX	sym (const std::string &name, casadi_int nrow=1, casadi_int ncol=1)
	Create an nrow-by-ncol symbolic primitive. More...

static MX	sym (const std::string &name, const std::pair< casadi_int, casadi_int > &rc)
	Construct a symbolic primitive with given dimensions. More...

static MX	sym (const std::string &name, const Sparsity &sp)
	Create symbolic primitive with a given sparsity pattern. More...

static std::vector< MX >	sym (const std::string &name, const Sparsity &sp, casadi_int p)
	Create a vector of length p with with matrices. More...

static std::vector< MX >	sym (const std::string &name, casadi_int nrow, casadi_int ncol, casadi_int p)
	Create a vector of length p with nrow-by-ncol symbolic primitives. More...

static std::vector< std::vector< MX > >	sym (const std::string &name, const Sparsity &sp, casadi_int p, casadi_int r)
	Create a vector of length r of vectors of length p with. More...

static std::vector< std::vector< MX > >	sym (const std::string &name, casadi_int nrow, casadi_int ncol, casadi_int p, casadi_int r)
	Create a vector of length r of vectors of length p. More...


static MX	zeros (casadi_int nrow=1, casadi_int ncol=1)
	Create a dense matrix or a matrix with specified sparsity with all entries zero. More...

static MX	zeros (const Sparsity &sp)
	Create a dense matrix or a matrix with specified sparsity with all entries zero. More...

static MX	zeros (const std::pair< casadi_int, casadi_int > &rc)
	Create a dense matrix or a matrix with specified sparsity with all entries zero. More...


static MX	ones (casadi_int nrow=1, casadi_int ncol=1)
	Create a dense matrix or a matrix with specified sparsity with all entries one. More...

static MX	ones (const Sparsity &sp)
	Create a dense matrix or a matrix with specified sparsity with all entries one. More...

static MX	ones (const std::pair< casadi_int, casadi_int > &rc)
	Create a dense matrix or a matrix with specified sparsity with all entries one. More...

Protected Member Functions
void	count_up ()

void	count_down ()

Static Private Member Functions

static MX	printme (const MX &x, const MX &y)

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

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

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

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

std::vector< 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 >	graph_substitute (const std::vector< MX > &ex, const std::vector< MX > &v, const std::vector< MX > &vdef, bool &updated)

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 >	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	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	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())

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

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())

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

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

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

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

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

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

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

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 >	difference (const std::vector< MX > &a, const std::vector< MX > &b)

Member Typedef Documentation

◆ B

typedef GenericMatrix<MX> casadi::MX::B

Definition at line 189 of file mx.hpp.

◆ base_type

using casadi::SharedObject::base_type = SharedObject

inherited

Definition at line 103 of file shared_object.hpp.

◆ internal_base_type

using casadi::SharedObject::internal_base_type = SharedObjectInternal

inherited

Definition at line 102 of file shared_object.hpp.

◆ MXDict

typedef std::map<std::string, MX> casadi::MX::MXDict

Definition at line 1064 of file mx.hpp.

◆ ScalarType

typedef MX casadi::MX::ScalarType

Scalar type

Definition at line 185 of file mx.hpp.

Constructor & Destructor Documentation

◆ MX() [1/11]

casadi::MX::MX ( )

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

Definition at line 61 of file mx.cpp.

          {
     own(ZeroByZero::getInstance());
   }

References casadi::ZeroByZero::getInstance(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

Referenced by binary(), blockcat(), create(), createMultipleOutput(), cse(), diagcat(), extract(), extract_parametric(), eye(), graph_substitute(), horzcat(), repmat(), separate_linear(), set(), set_nz(), simplify_const_folding(), simplify_ref_count(), solve(), and vertcat().

◆ MX() [2/11]

casadi::MX::MX	(	casadi_int	nrow,
		casadi_int	ncol
	)

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

Definition at line 110 of file mx.cpp.

                                          {
     own(ConstantMX::create(Sparsity(nrow, ncol), 0));
   }

References casadi::ConstantMX::create(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ MX() [3/11]

casadi::MX::MX ( const std::pair< casadi_int, casadi_int > & rc )

explicit

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

Definition at line 114 of file mx.cpp.

                                                   {
     own(ConstantMX::create(Sparsity(rc), 0));
   }

References casadi::ConstantMX::create(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ MX() [4/11]

casadi::MX::MX ( const Sparsity & sp )

explicit

Same as MX::ones(sparsity)

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

Definition at line 106 of file mx.cpp.

                            {
     own(ConstantMX::create(sp, 1));
   }

References casadi::ConstantMX::create(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ MX() [5/11]

casadi::MX::MX	(	const Sparsity &	sp,
		const MX &	val
	)

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

Definition at line 85 of file mx.cpp.

                                           {
     if (sp.is_reshape(val.sparsity())) {
       *this = reshape(val, sp);
     } else if (val.is_scalar()) {
       // Dense matrix if val dense
       if (val.is_dense()) {
         if (val.is_constant()) {
           own(ConstantMX::create(sp, static_cast<double>(val)));
         } else {
           *this = val->get_nzref(sp, std::vector<casadi_int>(sp.nnz(), 0));
         }
       } else {
         // Empty matrix
         own(ConstantMX::create(Sparsity(sp.size()), 0));
       }
     } else {
       casadi_assert_dev(val.is_column() && sp.nnz()==val.size1());
       *this = densify(val)->get_nzref(sp, range(sp.nnz()));
     }
   }

References casadi::ConstantMX::create(), densify(), casadi::MXNode::get_nzref(), casadi::GenericMatrix< MatType >::is_column(), is_constant(), casadi::GenericMatrix< MatType >::is_dense(), casadi::Sparsity::is_reshape(), casadi::GenericMatrix< MatType >::is_scalar(), casadi::Sparsity::nnz(), casadi::GenericShared< SharedObject, SharedObjectInternal >::own(), casadi::range(), reshape(), casadi::Sparsity::size(), casadi::GenericMatrix< MatType >::size1(), and sparsity().

◆ MX() [6/11]

casadi::MX::MX	(	const Sparsity &	sp,
		const std::string &	fname
	)

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

Definition at line 122 of file mx.cpp.

                                                    {
     own(ConstantMX::create(sp, fname));
   }

References casadi::ConstantMX::create(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ MX() [7/11]

casadi::MX::MX	(	const Matrix< double > &	val,
		const std::string &	name
	)

configurable in codegen via a pool

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

Definition at line 126 of file mx.cpp.

                                              {
     own(ConstantMX::create(val, name));
   }

References casadi::ConstantMX::create(), name(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ MX() [8/11]

casadi::MX::MX ( double x )

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

Definition at line 73 of file mx.cpp.

                  {
     own(ConstantMX::create(Sparsity::dense(1, 1), x));
   }

References casadi::ConstantMX::create(), casadi::Sparsity::dense(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ MX() [9/11]

casadi::MX::MX ( const std::vector< double > & x )

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

Definition at line 81 of file mx.cpp.

                                    {
     own(ConstantMX::create(DM(x)));
   }

References casadi::ConstantMX::create(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ MX() [10/11]

casadi::MX::MX ( const Matrix< double > & x )

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

Definition at line 77 of file mx.cpp.

                     {
     own(ConstantMX::create(x));
   }

References casadi::ConstantMX::create(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ ~MX()

casadi::MX::~MX ( )

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

Definition at line 58 of file mx.cpp.

58 {

59 }

◆ MX() [11/11]

casadi::MX::MX	(	const Sparsity &	sp,
		double	val,
		bool	dummy
	)

Definition at line 118 of file mx.cpp.

                                                    {
     own(ConstantMX::create(sp, val));
   }

References casadi::ConstantMX::create(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

Member Function Documentation

◆ hash()

casadi_int casadi::GenericShared< SharedObject , SharedObjectInternal >::__hash__

inherited

If the Object does not point to any node, "0" is returned.

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

Definition at line 123 of file generic_shared_impl.hpp.

                                                              {
     return reinterpret_cast<casadi_int>(get());
   }

◆ nonzero()

bool casadi::MX::__nonzero__ ( ) const

Definition at line 145 of file mx.cpp.

                              {
     return (*this)->__nonzero__();
   }

◆ _bilin()

MX casadi::MX::_bilin	(	const MX &	A,
		const MX &	x,
		const MX &	y
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 3209 of file mx.cpp.

                                                      {
    return A->get_bilin(x, y);
  }

References casadi::MXNode::get_bilin().

◆ _logsumexp()

MX casadi::MX::_logsumexp ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 3217 of file mx.cpp.

                               {
    return x->get_logsumexp();
  }

References casadi::MXNode::get_logsumexp().

◆ _rank1()

MX casadi::MX::_rank1	(	const MX &	A,
		const MX &	alpha,
		const MX &	x,
		const MX &	y
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 3213 of file mx.cpp.

                                                                      {
    return A->get_rank1(alpha, x, y);
  }

References casadi::MXNode::get_rank1().

◆ _sym()

MX casadi::MX::_sym	(	const std::string &	name,
		const Sparsity &	sp
	)

static

Definition at line 946 of file mx.cpp.

                                                        {
     if (sp.nnz()==0) {
       return MX::zeros(sp);
     } else {
       return MX::create(new SymbolicMX(name, sp));
     }
   }

References create(), name(), casadi::Sparsity::nnz(), and casadi::GenericMatrix< MX >::zeros().

◆ ad_forward()

void casadi::MX::ad_forward	(	const std::vector< std::vector< MX > > &	fseed,
		std::vector< std::vector< MX > > &	fsens
	)		const

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

Definition at line 3232 of file mx.cpp.

                                                          {
    try {
      (*this)->ad_forward(fseed, fsens);
    } catch (std::exception& e) {
      CASADI_THROW_ERROR_OBJ("ad_forward", e.what());
    }
  }

◆ ad_reverse()

void casadi::MX::ad_reverse	(	const std::vector< std::vector< MX > > &	aseed,
		std::vector< std::vector< MX > > &	asens
	)		const

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

Definition at line 3241 of file mx.cpp.

                                                          {
    try {
      (*this)->ad_reverse(aseed, asens);
    } catch (std::exception& e) {
      CASADI_THROW_ERROR_OBJ("ad_reverse", e.what());
    }
  }

◆ assign()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::assign ( Internal * node )

inherited

improper use will cause memory leaks!

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

Definition at line 96 of file generic_shared_impl.hpp.

                                                               {
     node = node_;
   }

◆ attachAssert()

MX casadi::MX::attachAssert	(	const MX &	y,
		const std::string &	fail_message = `""`
	)		const

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

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

Examples: misc/assertion.py.

Definition at line 743 of file mx.cpp.

                                                                       {
     casadi_assert(y.is_scalar(),
       "Error in attachAssert: assertion expression y must be scalar, "
       "but got " + y.dim());
     return(*this)->get_assert(y, fail_message);
   }

References casadi::GenericMatrix< MatType >::dim(), and casadi::GenericMatrix< MatType >::is_scalar().

◆ bilin()

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

staticinherited

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

◆ binary()

MX casadi::MX::binary	(	casadi_int	op,
		const MX &	x,
		const MX &	y,
		bool	unique_x = `false`,
		bool	unique_y = `false`
	)

static

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

Definition at line 533 of file mx.cpp.

                                                                                      {
     // Check, correct dimensions
     if (x.size()!=y.size() && !x.is_scalar() && !y.is_scalar()) {
       // x and y are horizontal multiples of each other?
       if (!x.is_empty() && !y.is_empty()) {
         if (x.size1() == y.size1() && x.size2() % y.size2() == 0) {
           return binary(op, x, repmat(y, 1, x.size2() / y.size2()), unique_x, false);
         } else if (y.size1() == x.size1() && y.size2() % x.size2() == 0) {
           return binary(op, repmat(x, 1, y.size2() / x.size2()), y, false, unique_y);
         }
       }
       // x and y are empty horizontal multiples of each other?
       if (x.size1()==0 && y.size1()==0 && x.size2()>0 && y.size2()>0) {
         if (x.size2() % y.size2() == 0) {
           return MX(0, x.size2());
         } else if (y.size2() % x.size2() == 0) {
           return MX(0, y.size2());
         }
       }
       // Dimension mismatch
       casadi_error("Dimension mismatch for " + casadi_math<double>::print(op, "x", "y") +
                    ", x is " + x.dim() + ", while y is " + y.dim());
     }
     // Call internal class
     return x->get_binary(op, y, unique_x, unique_y);
   }

References casadi::GenericMatrix< MatType >::dim(), casadi::MXNode::get_binary(), casadi::GenericMatrix< MatType >::is_empty(), casadi::GenericMatrix< MatType >::is_scalar(), MX(), op(), repmat(), casadi::GenericMatrix< MatType >::size(), casadi::GenericMatrix< MatType >::size1(), and casadi::GenericMatrix< MatType >::size2().

Referenced by casadi::BinaryMX< ScX, ScY >::eval_mx(), and printme().

◆ blockcat()

MX casadi::MX::blockcat ( const std::vector< std::vector< MX > > & v )

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1263 of file mx.cpp.

                                                       {
     // Quick return if no block rows
     if (v.empty()) return MX(0, 0);
  
     // Make sure same number of block columns
     casadi_int ncols = v.front().size();
     for (auto&& e : v) {
       casadi_assert(e.size()==ncols, "blockcat: Inconsistent number of block columns");
     }
  
     // Quick return if no block columns
     if (v.front().empty()) return MX(0, 0);
  
     // Horizontally concatenate all columns for each row, then vertically concatenate rows
     std::vector<MX> rows;
     for (auto&& e : v) {
       rows.push_back(horzcat(e));
     }
     return vertcat(rows);
   }

References horzcat(), MX(), casadi::GenericMatrix< MX >::rows(), and vertcat().

Referenced by casadi::Expm::get_forward(), casadi::Nlpsol::get_forward(), casadi::Expm::get_reverse(), and casadi::Nlpsol::get_reverse().

◆ bspline() [1/3]

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()`
	)

static

Functions called by friend functions defined for this class

Definition at line 2224 of file mx.cpp.

                               {
     return BSpline::create(x, knots, coeffs.nonzeros(), degree, m, opts);
   }

References casadi::BSpline::create(), and casadi::Matrix< Scalar >::nonzeros().

Referenced by casadi::Function::bspline(), casadi::BSplineInterpolant::construct_graph(), and casadi::BSplineCommon::jac().

◆ bspline() [2/3]

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

static

Functions called by friend functions defined for this class

Definition at line 2241 of file mx.cpp.

                               {
     return BSplineParametric::create(x, coeffs, knots, degree, m, opts);
   }

References casadi::BSplineParametric::create().

◆ bspline() [3/3]

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()`
	)

static

Functions called by friend functions defined for this class

Definition at line 2233 of file mx.cpp.

                               {
     return BSplineParametric::create(x, coeffs, knots, degree, m, opts);
   }

References casadi::BSplineParametric::create().

◆ bspline_dual()

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()`
	)

static

Definition at line 2249 of file mx.cpp.

                               {
     return BSpline::dual(x, knots, degree, opts);
   }

References casadi::BSpline::dual().

Referenced by casadi::BSplineInterpolant::construct_graph().

◆ class_name()

std::string casadi::SharedObject::class_name ( ) const

inherited

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

Definition at line 31 of file shared_object.cpp.

                                            {
     return (*this)->class_name();
   }

Referenced by casadi::FmuFunction::check_mem_count(), casadi::MXFunction::export_code_body(), and casadi::BlazingSplineFunction::merge().

◆ colind() [1/2]

const casadi_int* casadi::GenericMatrix< MX >::colind ( ) const

inlineinherited

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

Definition at line 198 of file generic_matrix.hpp.

198 { return sparsity().colind(); }

casadi::GenericMatrix< MX >::sparsity

Sparsity sparsity() const

Get the sparsity pattern.

Definition: generic_matrix.hpp:1320

casadi::Sparsity::colind

const casadi_int * colind() const

Get a reference to the colindex of all column element (see class description)

Definition: sparsity.cpp:168

◆ colind() [2/2]

casadi_int casadi::GenericMatrix< MX >::colind ( casadi_int col ) const

inlineinherited

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

Definition at line 201 of file generic_matrix.hpp.

201 { return sparsity().colind(col); }

◆ columns()

casadi_int casadi::GenericMatrix< MX >::columns ( ) const

inlineinherited

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

Definition at line 124 of file generic_matrix.hpp.

124 {return size2();}

casadi::GenericMatrix< MX >::size2

casadi_int size2() const

Get the second dimension (i.e. number of columns)

Definition: generic_matrix.hpp:1355

◆ conditional()

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

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1395 of file mx.cpp.

                                                               {
     if (short_circuit) {
       // Get symbolic primitives
       std::vector<MX> arg = x;
       arg.push_back(x_default);
       arg = symvar(veccat(arg));
  
       // Form functions for cases
       std::vector<Function> f(x.size());
       for (casadi_int k=0; k<x.size(); ++k) {
         std::stringstream ss;
         ss << "f_case" << k;
         f[k] = Function(ss.str(), arg, {x[k]});
       }
       Function f_default("f_default", arg, {x_default});
  
       // Form Switch
       Function sw = Function::conditional("switch", f, f_default);
  
       // Call the Switch
       std::vector<MX> sw_arg;
       sw_arg.push_back(ind);
       sw_arg.insert(sw_arg.end(), arg.begin(), arg.end());
       return sw(sw_arg).at(0);
     } else {
       MX ret = x_default;
       for (casadi_int k=0; k<x.size(); ++k) {
         ret = if_else(ind==static_cast<double>(k), x[k], ret);
       }
       return ret;
     }
   }

References casadi::Function::conditional(), if_else(), symvar(), and casadi::SparsityInterface< MatType >::veccat().

◆ contains_all()

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

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2184 of file mx.cpp.

                                                                       {
     if (n.empty()) return true;
  
     // Set to contain all nodes
     std::set<MXNode*> l;
     for (const MX& e : v) l.insert(e.get());
  
     size_t l_unique = l.size();
  
     for (const MX& e : n) l.insert(e.get());
  
     return l.size()==l_unique;
   }

◆ contains_any()

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

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2198 of file mx.cpp.

                                                                       {
     if (n.empty()) return true;
  
     // Set to contain all nodes
     std::set<MXNode*> l;
     for (const MX& e : v) l.insert(e.get());
  
     size_t l_unique = l.size();
  
     std::set<MXNode*> r;
     for (const MX& e : n) r.insert(e.get());
  
     size_t r_unique = r.size();
     for (const MX& e : n) l.insert(e.get());
  
     return l.size()<l_unique+r_unique;
   }

◆ convexify()

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

static

Functions called by friend functions defined for this class

Definition at line 2256 of file mx.cpp.

                               {
     return H->get_convexify(opts);
   }

References casadi::MXNode::get_convexify().

◆ count_down()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::count_down

protectedinherited

Definition at line 133 of file generic_shared_impl.hpp.

                                                    {
 #ifdef WITH_EXTRA_CHECKS
     casadi_assert_dev(Function::call_depth_==0);
 #endif // WITH_EXTRA_CHECKS
     if (!node) return;
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     GenericWeakRef<Shared, Internal>* weak_ref =
       node->weak_ref_.load(std::memory_order_acquire);
 #else
     GenericWeakRef<Shared, Internal>* weak_ref = node->weak_ref_;
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
     if (weak_ref) {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
       // get_mutex() returns a shared_ptr copy, so the mutex outlives this lock
       // even if delete node (below) destroys the WeakRefInternal holding it
       auto mutex = weak_ref->get_mutex();
       // Avoid triggering a delete while a weak_ref.shared_if_alive is being called
       std::lock_guard<std::mutex> lock(*mutex);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
       if (--static_cast<Internal*>(node)->count == 0) {
         delete node;
         node = nullptr;
       }
     } else {
       if (--static_cast<Internal*>(node)->count == 0) {
         delete node;
         node = nullptr;
       }
     }
   }

◆ count_up()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::count_up

protectedinherited

Definition at line 132 of file generic_shared_impl.hpp.

                                                  {
 #ifdef WITH_EXTRA_CHECKS
     casadi_assert_dev(Function::call_depth_==0);
 #endif // WITH_EXTRA_CHECKS
  
     if (node) static_cast<Internal*>(node)->count++;
  
   }

◆ create()

MX casadi::MX::create ( MXNode * node )

static

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

Definition at line 69 of file mx.cpp.

                             {
     return MX(node, false, false, false, false);
   }

References MX().

◆ createMultipleOutput()

std::vector< MX > casadi::MX::createMultipleOutput ( MXNode * node )

static

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

Definition at line 130 of file mx.cpp.

                                                      {
     casadi_assert_dev(dynamic_cast<MultipleOutput*>(node) != nullptr);
     MX x =  MX::create(node);
     std::vector<MX> ret(x->nout());
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = x.get_output(i);
       if (ret[i].is_empty(true)) {
         ret[i] = MX(0, 0);
       } else if (ret[i].nnz()==0) {
         ret[i] = MX(ret[i].size());
       }
     }
     return ret;
   }

References create(), get_output(), casadi::GenericMatrix< MX >::is_empty(), MX(), casadi::GenericMatrix< MX >::nnz(), casadi::MXNode::nout(), and casadi::GenericMatrix< MX >::size().

Referenced by casadi::Call::create(), casadi::MXNode::get_diagsplit(), casadi::MXNode::get_horzsplit(), and casadi::MXNode::get_vertsplit().

◆ cross()

MX casadi::GenericMatrix< MX >::cross	(	const MX &	a,
		const MX &	b,
		casadi_int	dim = `-1`
	)

staticinherited

Definition at line 227 of file generic_matrix.hpp.

                                                                                           {
     casadi_assert(a.size1()==b.size1() && a.size2()==b.size2(),
       "cross(a, b): Inconsistent dimensions. Dimension of a ("
       + a.dim() + " ) must equal that of b (" + b.dim() + ").");
  
     casadi_assert(a.size1()==3 || a.size2()==3,
       "cross(a, b): One of the dimensions of a should have length 3, but got "
         + a.dim() + ".");
     casadi_assert(dim==-1 || dim==1 || dim==2,
       "cross(a, b, dim): Dim must be 1, 2 or -1 (automatic).");
  
     std::vector<MatType> ret(3);
  
     bool t = a.size1()==3;
  
     if (dim==1) t = true;
     if (dim==2) t = false;
  
     MatType a1 = t ? a(0, Slice()) : a(Slice(), 0);
     MatType a2 = t ? a(1, Slice()) : a(Slice(), 1);
     MatType a3 = t ? a(2, Slice()) : a(Slice(), 2);
  
     MatType b1 = t ? b(0, Slice()) : b(Slice(), 0);
     MatType b2 = t ? b(1, Slice()) : b(Slice(), 1);
     MatType b3 = t ? b(2, Slice()) : b(Slice(), 2);
  
     ret[0] = a2*b3-a3*b2;
     ret[1] = a3*b1-a1*b3;
     ret[2] = a1*b2-a2*b1;
  
     return t ? vertcat(ret) : horzcat(ret);
   }

◆ cse()

std::vector< MX > casadi::MX::cse ( const std::vector< MX > & e )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2642 of file mx.cpp.

                                               {
     std::vector<MX> orig = e;
     bool updated = true;
     while (updated) {
       Function f("f", std::vector<MX>{}, orig,
         {{"live_variables", false}, {"max_io", 0}, {"cse", false}, {"allow_free", true}});
       MXFunction *ff = f.get<MXFunction>();
  
       // Symbolic work, non-differentiated
       std::vector<MX> swork(ff->workloc_.size()-1);
  
       // Allocate storage for split outputs
       std::vector<std::vector<MX> > res_split(orig.size());
       for (casadi_int i=0; i<orig.size(); ++i) res_split[i].resize(orig[i].n_primitives());
  
       std::vector<MX> arg1, res1;
       std::vector<MX> res(orig.size());
  
       std::unordered_map<std::string, MX > cache;
       IncrementalSerializerMX s;
  
       SimpleCache<FunctionInternal*, std::string> function_serialize_cache;
       SimpleCache<std::string, Function> function_cache;
  
       // Pre-cache the original nodes
       // This makes sure we recycle old nodes when possible
       for (auto it=ff->algorithm_.begin(); it!=ff->algorithm_.end(); ++it) {
         if (it->op == OP_INPUT || it->op==OP_OUTPUT || it->op==OP_PARAMETER) continue;
  
         std::string key = s.pack(it->data);
  
         auto itk = cache.find(key);
         if (itk==cache.end()) {
           cache[key] = it->data;
         }
       }
  
       // Loop over computational nodes in forward order
       casadi_int alg_counter = 0;
       for (auto it=ff->algorithm_.begin(); it!=ff->algorithm_.end(); ++it, ++alg_counter) {
         if (it->op == OP_INPUT) {
           // pass
         } else if (it->op==OP_OUTPUT) {
           // Collect the results
           res_split.at(it->data->ind()).at(it->data->segment()) = swork[it->arg.front()];
         } else if (it->op==OP_PARAMETER) {
           // Fetch parameter
           MX& target = swork[it->res.front()];
           target = it->data;
           cache[s.pack(target)] = target;
         } else {
  
           // Arguments of the operation
           arg1.resize(it->arg.size());
           for (casadi_int i=0; i<arg1.size(); ++i) {
             casadi_int el = it->arg[i]; // index of the argument
             arg1[i] = el<0 ? MX(it->data->dep(i).size()) : swork[el];
           }
  
           // Perform the operation
           res1.resize(it->res.size());
           it->data->eval_mx(arg1, res1);
  
           // Get the result
           for (casadi_int i=0; i<res1.size(); ++i) {
             casadi_int el = it->res[i]; // index of the output
  
             MX& out_i = res1[i];
  
             // Default assumption is that out_i is not an output node
             casadi_int output_node = -1;
  
             if (out_i.is_output()) {
               output_node = out_i.which_output();
               // First pack/cache the parent (MultipleOutput node e.g. Call, Horzsplit)
               out_i = out_i.dep(0);
  
               // If we are a call node,
               if (out_i.op()==OP_CALL) {
                 FunctionInternal* fptr = out_i.which_function().get();
  
                 // Get or compute serialization (cached)
                 std::string key_s;
                 if (!function_serialize_cache.incache(fptr, key_s)) {
                   key_s = out_i.which_function().serialize();
                   function_serialize_cache.tocache(fptr, key_s);
                 }
  
                 // Get or store canonical function (cached)
                 Function canonical;
                 if (!function_cache.incache(key_s, canonical)) {
                   function_cache.tocache(key_s, out_i.which_function());
                 } else {
                   out_i = Call::create_call(canonical, out_i->dep_);
                 }
               }
             }
  
             while (true) {
               // Replace out_i by a cached variant if possible
               std::string key = s.pack(out_i);
  
               auto itk = cache.find(key);
               if (itk==cache.end()) {
                 cache[key] = out_i;
               } else {
                 out_i = itk->second;
               }
  
               if (output_node==-1) {
                 break; // Job is done
               } else {
                 // Recreate the output node on top of the parent
                 out_i = out_i.get_output(output_node);
                 output_node = -1;
                 // Loop once more
               }
             }
  
             if (el>=0) swork[el] = out_i;
           }
         }
       }
  
       // Join split outputs
       for (casadi_int i=0; i<res.size(); ++i) res[i] = orig[i].join_primitives(res_split[i]);
  
       std::vector<MX> subs_from;
       std::vector<MX> subs_to;
       for (const auto& e : function_cache.cache_map()) {
         e.second->merge(res, subs_from, subs_to);
       }
       orig = graph_substitute(res, subs_from, subs_to, updated);
     }
  
     return orig;
   }

References casadi::SimpleCache< K, T >::cache_map(), casadi::Call::create_call(), dep(), casadi::MXNode::dep_, casadi::Function::get(), get_output(), graph_substitute(), casadi::SimpleCache< K, T >::incache(), is_output(), join_primitives(), MX(), n_primitives(), op(), casadi::OP_CALL, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::Function::serialize(), casadi::SimpleCache< K, T >::tocache(), which_function(), and which_output().

◆ cumsum()

MX casadi::MX::cumsum	(	const MX &	x,
		casadi_int	axis = `-1`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 698 of file mx.cpp.

                                             {
     if (axis==-1) axis = x.is_row();
     MX r = axis==0 ? x.T() : x;
     Sparsity sl = r(Slice(), 0).sparsity();
     MX acc = MX::sym("acc", sl);
     MX u = MX::sym("u", sl);
  
     Function f("f", {acc, u}, {acc+u});
     f = f.mapaccum(r.size2());
     MX ret = f(std::vector<MX>{0, r})[0];
  
     return axis==0 ? ret.T() : ret;
   }

References casadi::GenericMatrix< MatType >::is_row(), casadi::Function::mapaccum(), casadi::GenericMatrix< MatType >::size2(), sparsity(), casadi::GenericMatrix< MX >::sym(), and T().

◆ debug_repr()

std::string casadi::GenericShared< SharedObject , SharedObjectInternal >::debug_repr

inherited

Definition at line 112 of file generic_shared_impl.hpp.

                                                               {
     if (node) {
         return node->debug_repr(node);
     } else {
         return "NULL";
     }
   }

◆ densify()

MX casadi::MX::densify	(	const MX &	x,
		const MX &	val = `0`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 923 of file mx.cpp.

                                            {
     casadi_assert_dev(val.is_scalar());
     if (x.is_dense()) {
       return x; // Already ok
     } else if (val->is_zero()) {
       return project(x, Sparsity::dense(x.size()));
     } else {
       MX ret = MX::repmat(val, x.size());
       ret(x.sparsity()) = x;
       return ret;
     }
   }

References casadi::Sparsity::dense(), casadi::GenericMatrix< MatType >::is_dense(), casadi::GenericMatrix< MatType >::is_scalar(), casadi::MXNode::is_zero(), project(), repmat(), casadi::GenericMatrix< MatType >::size(), and sparsity().

Referenced by MX(), and set().

◆ dep()

MX casadi::MX::dep ( casadi_int ch = 0 ) const

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

Definition at line 783 of file mx.cpp.

                                 {
     return (*this)->dep(ch);
   }

References casadi::MXNode::dep().

Referenced by casadi::OptiNode::canon_expr(), casadi::Call::common_cond(), casadi::DaeBuilderInternal::create(), cse(), casadi::MXFunction::export_code_body(), casadi::MXNode::get_binary(), casadi::BinaryMX< ScX, ScY >::get_solve_tril(), casadi::BinaryMX< ScX, ScY >::get_solve_triu(), inv(), is_doubled(), casadi::DaeBuilderInternal::jac_vdef_v_from_calls(), casadi::Onnx::load(), casadi::DaeBuilderInternal::load_fmi_description(), and casadi::DaeBuilderInternal::when().

◆ depends_on()

bool casadi::MX::depends_on	(	const MX &	x,
		const MX &	arg
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2165 of file mx.cpp.

                                                 {
     if (x.nnz()==0) return false;
  
     // Construct a temporary algorithm
     Function temp("tmp_depends_on", {arg}, {x}, Dict{{"max_io", 0}, {"allow_free", true}});
  
     // Perform a single dependency sweep
     std::vector<bvec_t> t_in(arg.nnz(), 1), t_out(x.nnz());
     temp({get_ptr(t_in)}, {get_ptr(t_out)});
  
     // Loop over results
     for (casadi_int i=0; i<t_out.size(); ++i) {
       if (t_out[i]) return true;
     }
  
     return false;
   }

References casadi::get_ptr(), and casadi::GenericMatrix< MatType >::nnz().

◆ deserialize()

MX casadi::MX::deserialize ( DeserializingStream & s )

static

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

Definition at line 863 of file mx.cpp.

                                            {
     return MX::create(MXNode::deserialize(s));
   }

References create(), and casadi::MXNode::deserialize().

◆ det() [1/2]

MX casadi::MX::det ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2020 of file mx.cpp.

                         {
     return det(x, "qr");
   }

◆ det() [2/2]

MX casadi::MX::det	(	const MX &	x,
		const std::string &	lsolver,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2024 of file mx.cpp.

                                                                     {
     Linsol mysolver("det", lsolver, x.sparsity(), opts);
     return mysolver.det(x);
   }

References casadi::Linsol::det(), and sparsity().

◆ diag()

MX casadi::MX::diag ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1464 of file mx.cpp.

                          {
     // Nonzero mapping
     std::vector<casadi_int> mapping;
  
     // Get the sparsity
     Sparsity sp = x.sparsity().get_diag(mapping);
  
     // Create a reference to the nonzeros
     return x->get_nzref(sp, mapping);
   }

References casadi::Sparsity::get_diag(), casadi::MXNode::get_nzref(), mapping(), and sparsity().

◆ diagcat()

MX casadi::MX::diagcat ( const std::vector< MX > & x )

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1155 of file mx.cpp.

                                        {
     // Quick return if empty or single element
     if (x.empty()) return MX();
     if (x.size()==1) return x.front();
     // Call recursively if any 0-by-0 matrices
     if (has_empty(x, true)) return diagcat(trim_empty(x, true));
     // Create diagcat node
     return x.front()->get_diagcat(x);
   }

References casadi::has_empty(), MX(), and casadi::trim_empty().

◆ diagsplit()

std::vector< MX > casadi::MX::diagsplit	(	const MX &	x,
		const std::vector< casadi_int > &	offset1,
		const std::vector< casadi_int > &	offset2
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1223 of file mx.cpp.

                                                                       {
     // Consistency check
     casadi_assert_dev(!offset1.empty());
     casadi_assert_dev(offset1.front()==0);
     casadi_assert_dev(offset1.back()==x.size1());
     casadi_assert_dev(is_monotone(offset1));
  
     // Consistency check
     casadi_assert_dev(!offset2.empty());
     casadi_assert_dev(offset2.front()==0);
     casadi_assert_dev(offset2.back()==x.size2());
     casadi_assert_dev(is_monotone(offset2));
  
     return x->get_diagsplit(offset1, offset2);
   }

References casadi::MXNode::get_diagsplit(), casadi::is_monotone(), casadi::GenericMatrix< MatType >::size1(), and casadi::GenericMatrix< MatType >::size2().

◆ diff()

MX casadi::GenericMatrix< MX >::diff	(	const MX &	x,
		casadi_int	n = `1`,
		casadi_int	axis = `-1`
	)

staticinherited

Definition at line 233 of file generic_matrix.hpp.

                                                                                       {
     casadi_assert(axis==-1 || axis==0 || axis==1, "Axis argument invalid");
     casadi_assert(n>=1, "n argument invalid");
  
     MatType ret = x;
     for (casadi_int i=0;i<n;++i) {
       // Matlab's special case
       if (axis==-1 && ret.is_scalar()) return MatType();
  
       casadi_int local_axis = (axis==-1) ? ret.is_row() : axis;
       if (local_axis==0) {
         if (ret.size1()<=1) {
           ret = MatType::zeros(0, ret.size2());
         } else {
           ret = ret(Slice(1, ret.size1()), Slice())-ret(Slice(0, ret.size1()-1), Slice());
         }
       } else {
         if (ret.size2()<=1) {
           ret = MatType::zeros(ret.size1(), 0);
         } else {
           ret = ret(Slice(), Slice(1, ret.size2()))-ret(Slice(), Slice(0, ret.size2()-1));
         }
       }
     }
     return ret;
   }

◆ difference()

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

static

Functions called by friend functions defined for this class

Definition at line 3099 of file mx.cpp.

                                                                              {
     // Create a set of MXNodes from b
     std::set<MXNode*> bs;
     for (const auto& e : b) {
       if (!e.is_null()) bs.insert(e.get());
     }
     std::vector<MX> ret;
     for (auto&& e : a) {
       // If the element is not in the set, add it to the return vector
       if (bs.find(e.get())==bs.end()) {
         ret.push_back(e);
       }
     }
     return ret;
   }

Referenced by stop_diff().

◆ dim()

std::string casadi::GenericMatrix< MX >::dim ( bool with_nz = false ) const

inherited

The representation is e.g. "4x5" or "4x5,10nz"

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

Definition at line 131 of file generic_matrix.hpp.

                                                           {
     return sparsity().dim(with_nz);
   }

◆ disp()

void casadi::SharedObject::disp	(	std::ostream &	stream,
		bool	more = `false`
	)		const

inherited

Definition at line 35 of file shared_object.cpp.

                                                              {
     if (is_null()) {
       stream << "NULL";
     } else {
       (*this)->disp(stream, more);
     }
   }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null().

Referenced by casadi::Nlpsol::disp_more(), and casadi::CsparseInterface::nfact().

◆ dot()

MX casadi::MX::dot	(	const MX &	x,
		const MX &	y
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 735 of file mx.cpp.

                                      {
     return x->get_dot(y);
   }

References casadi::MXNode::get_dot().

◆ dump()

MX casadi::MX::dump	(	const std::string &	base_filename,
		const Dict &	opts = `Dict()`
	)		const

Returns itself, but with the side effect of dumping values to file Allowed options: "dir" (dump directory), "format" (file format, default "mtx"), "verbose" (print filename on each dump, default false)

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

Definition at line 754 of file mx.cpp.

                                                                     {
     return(*this)->get_dump(base_filename, opts);
   }

References casadi::MXNode::get_dump().

◆ einstein() [1/2]

MX casadi::MX::einstein	(	const MX &	A,
		const MX &	B,
		const MX &	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
	)

static

Computes the product: C_c = A_a + B_b where a b c are index/einstein notation in an encoded form

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

The encoded form uses strictly negative numbers to indicate labels. For the above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}

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

Definition at line 682 of file mx.cpp.

                                       {
     return C->get_einstein(A, B, dim_c, dim_a, dim_b, c, a, b);
   }

References casadi::C.

Referenced by casadi::Einstein::ad_forward(), casadi::Einstein::ad_reverse(), and casadi::derivative_coeff_mx().

◆ einstein() [2/2]

MX casadi::MX::einstein	(	const MX &	A,
		const MX &	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
	)

static

Computes the product: C_c = A_a + B_b where a b c are index/einstein notation in an encoded form

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

The encoded form uses strictly negative numbers to indicate labels. For the above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}

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

Definition at line 690 of file mx.cpp.

                                       {
     return MX::zeros(product(dim_c), 1)->get_einstein(A, B, dim_c, dim_a, dim_b, c, a, b);
   }

References casadi::MXNode::get_einstein(), casadi::product(), and casadi::GenericMatrix< MX >::zeros().

◆ enlarge()

void casadi::MX::enlarge	(	casadi_int	nrow,
		casadi_int	ncol,
		const std::vector< casadi_int > &	rr,
		const std::vector< casadi_int > &	cc,
		bool	ind1 = `false`
	)

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

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

Definition at line 662 of file mx.cpp.

                                                                 {
     Sparsity sp = sparsity();
     sp.enlarge(nrow, ncol, rr, cc, ind1);
  
     MX ret = (*this)->get_nzref(sp, range(nnz())); // FIXME?
     *this = ret;
   }

References casadi::Sparsity::enlarge(), casadi::MXNode::get_nzref(), casadi::GenericMatrix< MX >::nnz(), casadi::range(), and sparsity().

◆ erase() [1/2]

void casadi::MX::erase	(	const std::vector< casadi_int > &	rr,
		bool	ind1 = `false`
	)

Erase elements of a matrix

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

Definition at line 648 of file mx.cpp.

                                                            {
     // Get sparsity of the new matrix
     Sparsity sp = sparsity();
  
     // Erase from sparsity pattern
     std::vector<casadi_int> mapping = sp.erase(rr, ind1);
  
     // Create new matrix
     if (mapping.size()!=nnz()) {
       MX ret = (*this)->get_nzref(sp, mapping);
       *this = ret;
     }
   }

References casadi::Sparsity::erase(), casadi::MXNode::get_nzref(), mapping(), casadi::GenericMatrix< MX >::nnz(), casadi::GenericMatrix< MatType >::size(), and sparsity().

◆ erase() [2/2]

void casadi::MX::erase	(	const std::vector< casadi_int > &	rr,
		const std::vector< casadi_int > &	cc,
		bool	ind1 = `false`
	)

Erase rows and/or columns of a matrix

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

Definition at line 616 of file mx.cpp.

                                                                                             {
     // Get sparsity of the new matrix
     Sparsity sp = sparsity();
  
     // Erase from sparsity pattern
     std::vector<casadi_int> mapping = sp.erase(rr, cc, ind1);
  
     // Create new matrix
     if (mapping.size()!=nnz()) {
       MX ret = (*this)->get_nzref(sp, mapping);
       *this = ret;
     }
   }

References casadi::Sparsity::erase(), casadi::MXNode::get_nzref(), mapping(), casadi::GenericMatrix< MX >::nnz(), casadi::GenericMatrix< MatType >::size(), and sparsity().

Referenced by set().

◆ eval_mx()

void casadi::MX::eval_mx	(	const std::vector< MX > &	arg,
		std::vector< MX > &	res,
		const std::vector< bool > &	unique = `std::vector<bool>()`
	)		const

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

Definition at line 3222 of file mx.cpp.

                                          {
    try {
      res.resize((*this)->nout());
      (*this)->eval_mx(arg, res, unique);
    } catch (std::exception& e) {
      CASADI_THROW_ERROR_OBJ("eval_mx", e.what());
    }
  }

◆ evalf()

DM casadi::MX::evalf ( const MX & m )

static

Functions called by friend functions defined for this class

Definition at line 768 of file mx.cpp.

                           {
     Function f("f", std::vector<MX>{}, {m}, {{"allow_free", true}});
     return f(std::vector<DM>{})[0];
   }

◆ expm()

MX casadi::MX::expm ( const MX & A )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2154 of file mx.cpp.

                          {
     Function ret = expmsol("mysolver", "slicot", A.sparsity());
     return ret(std::vector<MX>{A, 1})[0];
   }

References casadi::expmsol(), and sparsity().

◆ expm_const()

MX casadi::MX::expm_const	(	const MX &	A,
		const MX &	t
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2147 of file mx.cpp.

                                             {
     Dict opts;
     opts["const_A"] = true;
     Function ret = expmsol("mysolver", "slicot", A.sparsity(), opts);
     return ret(std::vector<MX>{A, t})[0];
   }

References casadi::expmsol(), and sparsity().

◆ extract()

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

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1740 of file mx.cpp.

                                              {
     try {
       // Read options
       std::string v_prefix = "v_", v_suffix = "";
       bool lift_shared = true, lift_calls = false;
       casadi_int v_ind = 0;
       for (auto&& op : opts) {
         if (op.first == "prefix") {
           v_prefix = std::string(op.second);
         } else if (op.first == "suffix") {
           v_suffix = std::string(op.second);
         } else if (op.first == "lift_shared") {
           lift_shared = op.second;
         } else if (op.first == "lift_calls") {
           lift_calls = op.second;
         } else if (op.first == "offset") {
           v_ind = op.second;
         } else {
           casadi_error("No such option: " + std::string(op.first));
         }
       }
       // Sort the expression
       Function f("tmp_extract", std::vector<MX>{}, ex, Dict{{"max_io", 0}, {"allow_free", true}});
       auto *ff = f.get<MXFunction>();
       // Get references to the internal data structures
       const std::vector<MXAlgEl>& algorithm = ff->algorithm_;
       std::vector<MX> work(ff->workloc_.size()-1);
       // Count how many times an expression has been used
       std::vector<casadi_int> usecount(work.size(), 0);
       // Remember the origin of every calculation
       std::vector<std::pair<casadi_int, casadi_int> > origin(work.size(), std::make_pair(-1, -1));
       // Which evaluations to replace
       std::vector<std::pair<casadi_int, casadi_int> > replace;
       // Evaluate the algorithm to identify which evaluations to replace
       casadi_int k=0;
       for (auto it=algorithm.begin(); it<algorithm.end(); ++it, ++k) {
         // Increase usage counters
         switch (it->op) {
         case OP_CONST:
         case OP_PARAMETER:
           break;
         default: // Unary operation, binary operation or output
           for (casadi_int c=0; c<it->arg.size(); ++c) {
             // Identify nodes used more than once
             if (lift_calls && it->op == OP_CALL) {
               // If not already marked for replacing
               if (usecount.at(it->arg[c]) >= 0) {
                 replace.push_back(origin.at(it->arg[c]));
                 usecount.at(it->arg[c]) = -1;  // Do not replace again
               }
             } else if (lift_shared && work[it->arg[c]].op() != OP_PARAMETER
                 && work[it->arg[c]].op() != OP_CONST) {
               if (usecount.at(it->arg[c]) == 0) {
                 // First time node is used
                 usecount.at(it->arg[c]) = 1;
               } else if (usecount.at(it->arg[c]) == 1) {
                 // Second time node is used
                 replace.push_back(origin.at(it->arg[c]));
                 usecount.at(it->arg[c]) = -1; // Do not replace again
               }
             }
           }
         }
         // Perform the operation
         switch (it->op) {
         case OP_OUTPUT:
           break;
         case OP_CONST:
           usecount[it->res.front()] = -1; // Never extract constants
           break;
         default:
           for (casadi_int c=0; c<it->res.size(); ++c) {
             if (it->res[c]>=0) {
               work[it->res[c]] = it->data.get_output(c);
               origin[it->res[c]] = std::make_pair(k, c);
               if (lift_calls && it->op == OP_CALL) {
                 // If function call, replace right away
                 replace.push_back(origin.at(it->res[c]));
                 usecount.at(it->res[c]) = -1; // Do not replace again
               } else {
                 usecount.at(it->res[c]) = 0; // Not (yet) extracted
               }
             }
           }
           break;
         }
       }
       // New variables and definitions
       v.clear();
       v.reserve(replace.size());
       vdef.clear();
       vdef.reserve(replace.size());
       // Quick return
       if (replace.empty()) return;
       // Sort the elements to be replaced in the order of appearence in the algorithm
       sort(replace.begin(), replace.end());
       std::vector<std::pair<casadi_int, casadi_int> >::const_iterator replace_it=replace.begin();
       // Arguments for calling the atomic operations
       std::vector<MX> oarg, ores;
       // Evaluate the algorithm
       k = 0;
       for (auto it=algorithm.begin(); it<algorithm.end(); ++it, ++k) {
         switch (it->op) {
         case OP_OUTPUT:
           casadi_assert(it->data->segment()==0, "Not implemented");
           ex[it->data->ind()] = work[it->arg.front()];
           break;
         case OP_CONST:
           work[it->res.front()] = it->data;
           break;
         default:
           {
             if (it->op == OP_PARAMETER) {
               // Free parameter
               work[it->res.front()] = it->data;
             } else {
               // Arguments of the operation
               oarg.resize(it->arg.size());
               for (casadi_int i=0; i<oarg.size(); ++i) {
                 casadi_int el = it->arg[i];
                 oarg[i] = el<0 ? MX(it->data->dep(i).size()) : work.at(el);
               }
               // Perform the operation
               ores.resize(it->res.size());
               it->data->eval_mx(oarg, ores);
               // Get the result
               for (casadi_int i=0; i<ores.size(); ++i) {
                 casadi_int el = it->res[i];
                 if (el>=0) work.at(el) = ores[i];
               }
             }
             // Possibly replace results with new variables
             for (casadi_int c=0; c<it->res.size(); ++c) {
               // Output index
               casadi_int ind = it->res[c];
               // In the list of nodes for replacing?
               bool replace_node = replace_it != replace.end()
                 && replace_it->first==k && replace_it->second==c;
               // Call node (introduce variable for outputs, even if unused)
               bool output_node = lift_calls && it->op == OP_CALL;
               // Skip if no reason to replace
               if (!replace_node && !output_node) continue;
               // Create a new variable
               Sparsity v_sp = it->op == OP_PARAMETER ? it->data.sparsity() : ores.at(c).sparsity();
               v.push_back(MX::sym(v_prefix + std::to_string(v_ind++) + v_suffix, v_sp));
               // Add definition of new variable
               if (ind >= 0) {
                 // Replace existing call
                 casadi_assert(replace_node, "Consistency check");
                 // Store the result
                 vdef.push_back(work[ind]);
                 // Use in calculations
                 work[ind] = v.back();
                 // Go to the next element to be replaced
                 replace_it++;
               } else {
                 // New node corresponding to an output
                 casadi_assert(output_node, "Consistency check");
                 // Store the result
                 vdef.push_back(ores.at(c));
               }
             }
           }
         }
       }
       // Ensure all nodes have been replaced
       casadi_assert(replace_it == replace.end(), "Consistency check failed");
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("extract", e.what());
     }
   }

References casadi::MXFunction::algorithm_, casadi::Function::get(), MX(), op(), casadi::OP_CALL, casadi::OP_CONST, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::replace(), casadi::sort(), and casadi::GenericMatrix< MX >::sym().

Referenced by shared().

◆ extract_parametric()

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

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2810 of file mx.cpp.

                           {
     std::string v_prefix = "e_";
     std::string v_suffix = "";
     bool extract_trivial = false;
     casadi_int v_offset = 0;
     for (auto&& op : opts) {
       if (op.first == "prefix") {
         v_prefix = std::string(op.second);
       } else if (op.first == "suffix") {
         v_suffix = std::string(op.second);
       } else if (op.first == "offset") {
         v_offset = op.second;
       } else if (op.first == "extract_trivial") {
         extract_trivial = op.second;
       } else {
         casadi_error("No such option: " + std::string(op.first));
       }
     }
     Function f("f", {par}, {expr}, {{"live_variables", false},
       {"max_io", 0}, {"allow_free", true}});
     MXFunction *ff = f.get<MXFunction>();
  
     // Work vector
     std::vector< MX > w(ff->workloc_.size()-1);
  
     // Status of the expression:
     // 0: dependant on constants only
     // 1: dependant on parameters/constants only
     // 2: dependant on non-parameters
     std::vector< char > expr_status(ff->workloc_.size()-1, 0);
  
     // Split up inputs analogous to symbolic primitives
     std::vector<MX> arg_split = par.split_primitives(par);
  
     // Allocate storage for split outputs
     std::vector<MX> res_split;
     res_split.resize(expr.n_primitives());
  
     // Scratch space for node inputs/outputs
     std::vector<MX > arg1, res1;
  
     // Map of registered symbols
     std::map<MXNode*, MX> symbol_map;
  
     // Flat list of registerd symbols and parametric expressions
     std::vector<MX> symbol_v, parametric_v;
  
     // Loop over computational nodes in forward order
     casadi_int alg_counter = 0;
     for (auto it=ff->algorithm_.begin(); it!=ff->algorithm_.end(); ++it, ++alg_counter) {
       if (it->op == OP_INPUT) {
         w[it->res.front()] = arg_split.at(it->data->segment());
         expr_status[it->res.front()] = 1;
       } else if (it->op==OP_OUTPUT) {
         MX arg = w[it->arg.front()];
         if (expr_status[it->arg.front()]==1) {
           arg = register_symbol(arg, symbol_map, symbol_v, parametric_v,
                   extract_trivial, v_offset, v_prefix, v_suffix);
         }
         // Collect the results
         res_split.at(it->data->segment()) = arg;
       } else if (it->op==OP_CONST) {
         // Fetch constant
         w[it->res.front()] = it->data;
         expr_status[it->res.front()] = 0;
       } else if (it->op==OP_PARAMETER) {
         // Free variables
         w[it->res.front()] = it->data;
         expr_status[it->res.front()] = 2;
       } else {
         // Arguments of the operation
         arg1.resize(it->arg.size());
         for (casadi_int i=0; i<arg1.size(); ++i) {
           casadi_int el = it->arg[i]; // index of the argument
           arg1[i] = el<0 ? MX(it->data->dep(i).size()) : w[el];
         }
  
         // Check worst case status of inputs
         char max_status = 0;
         for (casadi_int i=0; i<arg1.size(); ++i) {
           casadi_int el = it->arg[i]; // index of the argument
           if (el>=0) {
             max_status = std::max(max_status, expr_status[it->arg[i]]);
           }
         }
         bool any_tainted = max_status==2;
  
         if (any_tainted) {
           // Loop over all inputs
           for (casadi_int i=0; i<arg1.size(); ++i) {
             casadi_int el = it->arg[i]; // index of the argument
  
             // For each parametric input being mixed into a non-parametric expression
             if (el>=0 && expr_status[el]==1) {
  
               arg1[i] = register_symbol(w[el], symbol_map, symbol_v, parametric_v,
                 extract_trivial, v_offset, v_prefix, v_suffix);
             }
           }
         }
  
         // Perform the operation
         res1.resize(it->res.size());
         it->data->eval_mx(arg1, res1);
  
         // Get the result
         for (casadi_int i=0; i<res1.size(); ++i) {
           casadi_int el = it->res[i]; // index of the output
           if (el>=0) {
             w[el] = res1[i];
             // Update expression status
             expr_status[el] = max_status;
           }
         }
       }
     }
  
     // Join split outputs
     expr_ret = expr.join_primitives(res_split);
  
     symbols = symbol_v;
     parametric = parametric_v;
   }

References join_primitives(), MX(), n_primitives(), op(), casadi::OP_CONST, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::register_symbol(), and split_primitives().

◆ eye()

MX casadi::MX::eye ( casadi_int n )

static

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

Definition at line 600 of file mx.cpp.

                          {
     return MX(DM::eye(n));
   }

References casadi::Matrix< double >::eye(), and MX().

Referenced by casadi::OptiNode::canon_expr(), and inv().

◆ find()

MX casadi::MX::find ( const MX & x )

static

Functions called by friend functions defined for this class

Definition at line 2216 of file mx.cpp.

                          {
     return x->get_find();
   }

References casadi::MXNode::get_find().

Referenced by casadi::DaeBuilderInternal::create(), graph_substitute(), casadi::DaeBuilderInternal::hess_v_v_from_calls(), casadi::DaeBuilderInternal::jac_vdef_v_from_calls(), and casadi::register_symbol().

◆ forward()

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

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1949 of file mx.cpp.

                                                                     {
     try {
       // Read options
       bool always_inline = true;
       bool never_inline = false;
  
       Dict h_opts;
       Dict opts_remainder = extract_from_dict(opts, "helper_options", h_opts);
       h_opts["allow_free"] = true;
       for (auto&& op : opts_remainder) {
         if (op.first=="always_inline") {
           always_inline = op.second;
         } else if (op.first=="never_inline") {
           never_inline = op.second;
         } else {
           casadi_error("No such option: " + std::string(op.first));
         }
       }
       // Call internal function on a temporary object
       Function temp("forward_temp", arg, ex, h_opts);
       std::vector<std::vector<MX> > ret;
       temp->call_forward(arg, ex, v, ret, always_inline, never_inline);
       return ret;
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("forward", e.what());
     }
   }

References casadi::FunctionInternal::call_forward(), casadi::extract_from_dict(), and op().

◆ get() [1/16]

MXNode * casadi::MX::get ( ) const

Definition at line 564 of file mx.cpp.

                         {
     return static_cast<MXNode*>(SharedObject::get());
   }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::get().

Referenced by casadi::MXNode::_get_binary(), casadi::Constant< Value >::_get_binary(), casadi::DaeBuilderInternal::create(), get(), is_equal(), is_norm(), casadi::DaeBuilderInternal::jac_vdef_v_from_calls(), casadi::register_symbol(), reset_dump_count(), casadi::OptiNode::set_meta(), and casadi::OptiNode::set_meta_con().

◆ get() [2/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		casadi_int	rr,
		casadi_int	cc
	)		const

inline

Get a submatrix, two arguments

Definition at line 547 of file mx.hpp.

                                                                  {
       get(m, ind1, Matrix<casadi_int>(rr), Matrix<casadi_int>(cc));
     }

◆ get() [3/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		casadi_int	rr,
		const Slice &	cc
	)		const

inline

Get a submatrix, two arguments

Definition at line 542 of file mx.hpp.

                                                                                   {
       get(m, ind1, Matrix<casadi_int>(rr), cc);
     }

◆ get() [4/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const casadi_int	rr
	)		const

inline

Get a submatrix, single argument

Definition at line 529 of file mx.hpp.

                                                                        {
       get(m, ind1, Matrix<casadi_int>(rr));
     }

◆ get() [5/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	rr
	)		const

Get a submatrix, single argument

Definition at line 188 of file mx.cpp.

                                                                    {
     // If the indexed matrix is dense, use nonzero indexing
     if (is_dense()) {
       get_nz(m, ind1, rr);
       return;
     }
  
     // If indexed matrix was a row/column vector, make sure that the result is too
     bool tr = (is_column() && rr.is_row()) || (is_row() && rr.is_column());
  
     // Get the sparsity pattern - does bounds checking
     std::vector<casadi_int> mapping;
     Sparsity sp = sparsity().sub(rr.nonzeros(), tr ? rr.sparsity().T() : rr.sparsity(),
                                  mapping, ind1);
  
     // Create return MX
     m = (*this)->get_nzref(sp, mapping);
   }

References get_nz(), casadi::MXNode::get_nzref(), casadi::GenericMatrix< MatType >::is_column(), casadi::GenericMatrix< MX >::is_column(), casadi::GenericMatrix< MX >::is_dense(), casadi::GenericMatrix< MX >::is_row(), casadi::GenericMatrix< MatType >::is_row(), mapping(), casadi::Matrix< Scalar >::nonzeros(), casadi::Matrix< Scalar >::sparsity(), sparsity(), casadi::Sparsity::sub(), and casadi::Sparsity::T().

◆ get() [6/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	rr,
		const Matrix< casadi_int > &	cc
	)		const

Get a submatrix, two arguments

Definition at line 168 of file mx.cpp.

                                                                                                  {
     // Make sure dense vectors
     casadi_assert(rr.is_dense() && rr.is_vector(),
                           "Marix::get: First index must be a dense vector");
     casadi_assert(cc.is_dense() && cc.is_vector(),
                           "Marix::get: Second index must be a dense vector");
  
     // Get the sparsity pattern - does bounds checking
     std::vector<casadi_int> mapping;
     Sparsity sp = sparsity().sub(rr.nonzeros(), cc.nonzeros(), mapping, ind1);
  
     // Create return MX
     m = (*this)->get_nzref(sp, mapping);
   }

References casadi::MXNode::get_nzref(), casadi::GenericMatrix< MatType >::is_dense(), casadi::GenericMatrix< MatType >::is_vector(), mapping(), casadi::Matrix< Scalar >::nonzeros(), sparsity(), and casadi::Sparsity::sub().

◆ get() [7/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	rr,
		const Slice &	cc
	)		const

Get a submatrix, two arguments

Definition at line 163 of file mx.cpp.

                                                                                     {
     // Fall back on (IM, IM)
     get(m, ind1, rr, cc.all(size2(), ind1));
   }

References casadi::Slice::all(), get(), and casadi::GenericMatrix< MX >::size2().

◆ get() [8/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const MX &	rr
	)		const

Get a submatrix, single argument

Definition at line 215 of file mx.cpp.

                                                    {
     casadi_assert(is_dense(), "Parametric slicing only supported for dense matrices."
                               "Got " + dim(true) + " instead.");
     get_nz(m, ind1, rr);
   }

References casadi::GenericMatrix< MX >::dim(), get_nz(), and casadi::GenericMatrix< MX >::is_dense().

◆ get() [9/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const MX &	rr,
		const MX &	cc
	)		const

Get a submatrix, two arguments

Definition at line 231 of file mx.cpp.

                                                                  {
     casadi_assert(is_dense(), "Parametric slicing only supported for dense matrices.");
     m = (*this)->get_nz_ref(ind1 ? rr-1 : rr, floor(ind1 ? cc-1 : cc)*size1());
   }

References casadi::GenericExpression< MX >::floor(), casadi::MXNode::get_nz_ref(), casadi::GenericMatrix< MX >::is_dense(), and casadi::GenericMatrix< MX >::size1().

◆ get() [10/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const MX &	rr,
		const Slice &	cc
	)		const

Get a submatrix, two arguments

Definition at line 226 of file mx.cpp.

                                                                     {
     casadi_assert(is_dense(), "Parametric slicing only supported for dense matrices.");
     m = (*this)->get_nz_ref(ind1 ? rr-1 : rr, cc.apply(size2())*size1());
   }

References casadi::Slice::apply(), casadi::MXNode::get_nz_ref(), casadi::GenericMatrix< MX >::is_dense(), casadi::GenericMatrix< MX >::size1(), and casadi::GenericMatrix< MX >::size2().

◆ get() [11/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Slice &	rr
	)		const

Get a submatrix, single argument

Definition at line 183 of file mx.cpp.

                                                       {
     // Fall back on IM
     get(m, ind1, rr.all(numel(), ind1));
   }

References casadi::Slice::all(), get(), and casadi::GenericMatrix< MX >::numel().

◆ get() [12/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Slice &	rr,
		casadi_int	cc
	)		const

inline

Get a submatrix, two arguments

Definition at line 538 of file mx.hpp.

                                                                                   {
       get(m, ind1, rr, Matrix<casadi_int>(cc));
     }

◆ get() [13/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Slice &	rr,
		const Matrix< casadi_int > &	cc
	)		const

Get a submatrix, two arguments

Definition at line 158 of file mx.cpp.

                                                                                     {
     // Fall back on (IM, IM)
     get(m, ind1, rr.all(size1(), ind1), cc);
   }

References casadi::Slice::all(), get(), and casadi::GenericMatrix< MX >::size1().

◆ get() [14/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Slice &	rr,
		const MX &	cc
	)		const

Get a submatrix, two arguments

Definition at line 221 of file mx.cpp.

                                                                     {
     casadi_assert(is_dense(), "Parametric slicing only supported for dense matrices. ");
     m = (*this)->get_nz_ref(rr.apply(size1()), floor(ind1 ? cc-1 : cc)*size1());
   }

References casadi::Slice::apply(), casadi::GenericExpression< MX >::floor(), casadi::MXNode::get_nz_ref(), casadi::GenericMatrix< MX >::is_dense(), and casadi::GenericMatrix< MX >::size1().

◆ get() [15/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Slice &	rr,
		const Slice &	cc
	)		const

Get a submatrix, two arguments

Definition at line 153 of file mx.cpp.

                                                                        {
     // Fall back on (IM, IM)
     get(m, ind1, rr.all(size1(), ind1), cc.all(size2(), ind1));
   }

References casadi::Slice::all(), get(), casadi::GenericMatrix< MX >::size1(), and casadi::GenericMatrix< MX >::size2().

◆ get() [16/16]

void casadi::MX::get	(	MX &	m,
		bool	ind1,
		const Sparsity &	sp
	)		const

Get a submatrix, single argument

Definition at line 207 of file mx.cpp.

                                                          {
     casadi_assert(size()==sp.size(),
       "get(Sparsity sp): shape mismatch. This matrix has shape "
       + str(size()) + ", but supplied sparsity index has shape "
       + str(sp.size()) + ".");
     m = project(*this, sp);
   }

References project(), casadi::GenericMatrix< MX >::size(), casadi::Sparsity::size(), and casadi::str().

◆ get_colind()

std::vector<casadi_int> casadi::GenericMatrix< MX >::get_colind ( ) const

inlineinherited

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

Definition at line 195 of file generic_matrix.hpp.

195 { return sparsity().get_colind(); }

casadi::Sparsity::get_colind

std::vector< casadi_int > get_colind() const

Get the column index for each column.

Definition: sparsity.cpp:364

◆ get_free()

std::vector< MX > casadi::MX::get_free ( const Function & f )

static

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

Definition at line 3205 of file mx.cpp.

                                               {
     return f.free_mx();
   }

References casadi::Function::free_mx().

◆ get_input()

std::vector< MX > casadi::MX::get_input ( const Function & f )

static

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

Definition at line 3201 of file mx.cpp.

                                                {
     return f.mx_in();
   }

References casadi::Function::mx_in().

◆ get_max_depth()

casadi_int casadi::MX::get_max_depth ( )

static

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

Definition at line 942 of file mx.cpp.

                                {
     return eq_depth_;
   }

Referenced by is_doubled(), and casadi::MXNode::maxDepth().

◆ get_nonzeros()

std::vector< MX > casadi::MX::get_nonzeros ( ) const

Since MX is not a containter, the scalar MXes may be complex When the expression satisfies is_valid_input, the results may be simple

For example: vertcat(x,y).nonzeros() will return {x,y}

See also: expr.nz[:]

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

Definition at line 630 of file mx.cpp.

                                        {
     std::vector<MX> ret;
     std::vector<MX> p = primitives();
     for (const MX& e : p) {
       if (e.is_scalar()) {
         ret.push_back(e);
       } else {
         // Get nonzeros sparsity cast
         MX nz;
         e.get_nz(nz, false, Slice());
         for (casadi_int i=0; i<nz.nnz(); ++i) {
           ret.push_back(nz(i));
         }
       }
     }
     return ret;
   }

References get_nz(), casadi::GenericMatrix< MatType >::nnz(), casadi::GenericMatrix< MX >::nz(), and primitives().

◆ get_nz() [1/7]

void casadi::MX::get_nz	(	MX &	m,
		bool	ind1,
		casadi_int	kk
	)		const

inline

Get a set of nonzeros

Definition at line 576 of file mx.hpp.

                                                                     {
       get_nz(m, ind1, Matrix<casadi_int>(kk));
     }

◆ get_nz() [2/7]

void casadi::MX::get_nz	(	MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	kk
	)		const

Get a set of nonzeros

Definition at line 410 of file mx.cpp.

                                                                       {
     // If indexed matrix was a row/column vector, make sure that the result is too
     bool tr = (is_column() && kk.is_row()) || (is_row() && kk.is_column());
  
     // Quick return if no entries
     if (kk.nnz()==0) {
       m = MX::zeros(tr ? kk.sparsity().T() : kk.sparsity());
       return;
     }
  
     // Check bounds
     casadi_int sz = nnz();
     casadi_assert_in_range(kk.nonzeros(), -sz+ind1, sz+ind1);
  
     // Handle index-1, negative indices
     if (ind1 || *std::min_element(kk->begin(), kk->end())<0) {
       Matrix<casadi_int> kk_mod = kk;
       for (auto&& i : kk_mod.nonzeros()) {
         casadi_assert(!(ind1 && i<=0),
           "Matlab is 1-based, but requested index " + str(i) + ". "
           "Note that negative slices are disabled in the Matlab interface. "
           "Possibly you may want to use 'end'.");
         if (ind1) i--;
         if (i<0) i += sz;
       }
       get_nz(m, false, kk_mod); // Call recursively
       return;
     }
  
     // Return reference to the nonzeros
     m = (*this)->get_nzref(tr ? kk.sparsity().T() : kk.sparsity(), kk.nonzeros());
   }

References get_nz(), casadi::MXNode::get_nzref(), casadi::GenericMatrix< MatType >::is_column(), casadi::GenericMatrix< MX >::is_column(), casadi::GenericMatrix< MX >::is_row(), casadi::GenericMatrix< MatType >::is_row(), casadi::GenericMatrix< MX >::nnz(), casadi::GenericMatrix< MatType >::nnz(), casadi::Matrix< Scalar >::nonzeros(), casadi::Matrix< Scalar >::sparsity(), casadi::str(), casadi::Sparsity::T(), and casadi::GenericMatrix< MX >::zeros().

◆ get_nz() [3/7]

void casadi::MX::get_nz	(	MX &	m,
		bool	ind1,
		const MX &	inner,
		const MX &	outer
	)		const

Get a set of nonzeros

Definition at line 448 of file mx.cpp.

                                                                           {
     // Create return MX
     m = (*this)->get_nz_ref(ind1 ? inner-1.0: inner, ind1 ? outer-1.0: outer);
   }

References casadi::MXNode::get_nz_ref().

◆ get_nz() [4/7]

void casadi::MX::get_nz	(	MX &	m,
		bool	ind1,
		const MX &	inner,
		const Slice &	outer
	)		const

Get a set of nonzeros

Definition at line 458 of file mx.cpp.

                                                                              {
     // Create return MX
     m = (*this)->get_nz_ref(ind1 ? inner-1.0: inner, ind1 ? outer-1: outer);
   }

References casadi::MXNode::get_nz_ref().

◆ get_nz() [5/7]

void casadi::MX::get_nz	(	MX &	m,
		bool	ind1,
		const MX &	kk
	)		const

Get a set of nonzeros

Definition at line 443 of file mx.cpp.

                                                       {
     // Create return MX
     m = (*this)->get_nz_ref(ind1 ? kk-1.0 : kk);
   }

References casadi::MXNode::get_nz_ref().

◆ get_nz() [6/7]

void casadi::MX::get_nz	(	MX &	m,
		bool	ind1,
		const Slice &	inner,
		const MX &	outer
	)		const

Get a set of nonzeros

Definition at line 453 of file mx.cpp.

                                                                              {
     // Create return MX
     m = (*this)->get_nz_ref(ind1 ? inner-1: inner, ind1 ? outer-1.0: outer);
   }

References casadi::MXNode::get_nz_ref().

◆ get_nz() [7/7]

void casadi::MX::get_nz	(	MX &	m,
		bool	ind1,
		const Slice &	kk
	)		const

Get a set of nonzeros

Definition at line 405 of file mx.cpp.

                                                          {
     // Fallback on IM
     get_nz(m, ind1, kk.all(nnz(), ind1));
   }

References casadi::Slice::all(), and casadi::GenericMatrix< MX >::nnz().

Referenced by get(), casadi::get_boor(), get_nonzeros(), get_nz(), casadi::interpn_G(), and interpn_linear().

◆ get_output()

MX casadi::MX::get_output ( casadi_int oind ) const

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

Definition at line 902 of file mx.cpp.

                                          {
     return (*this)->get_output(oind);
   }

References casadi::MXNode::get_output().

Referenced by createMultipleOutput(), cse(), and graph_substitute().

◆ get_row()

std::vector<casadi_int> casadi::GenericMatrix< MX >::get_row ( ) const

inlineinherited

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

Definition at line 194 of file generic_matrix.hpp.

194 { return sparsity().get_row(); }

casadi::Sparsity::get_row

std::vector< casadi_int > get_row() const

Get the row for each non-zero entry.

Definition: sparsity.cpp:372

◆ get_sparsity()

Sparsity casadi::MX::get_sparsity ( ) const

inline

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

Definition at line 205 of file mx.hpp.

205 { return sparsity();}

◆ get_str()

std::string casadi::SharedObject::get_str ( bool more = false ) const

inlineinherited

Definition at line 91 of file shared_object.hpp.

                                                {
         std::stringstream ss;
         disp(ss, more);
         return ss.str();
       }

◆ get_temp()

casadi_int casadi::MX::get_temp ( ) const

Get the temporary variable

Definition at line 890 of file mx.cpp.

                                 {
     return (*this)->temp;
   }

◆ getCount()

casadi_int casadi::GenericShared< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 102 of file generic_shared_impl.hpp.

                                                              {
     return (*this)->getCount();
   }

◆ gradient()

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

staticinherited

Functions called by friend functions defined here

◆ graph_substitute() [1/4]

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

static

Functions called by friend functions defined for this class

Definition at line 1551 of file mx.cpp.

                                                      {
     return graph_substitute(std::vector<MX>{x}, v, vdef).at(0);
   }

Referenced by cse(), graph_substitute(), and matrix_expand().

◆ graph_substitute() [2/4]

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

static

Functions called by friend functions defined for this class

Definition at line 1556 of file mx.cpp.

                                                                     {
     return graph_substitute(std::vector<MX>{x}, v, vdef, updated).at(0);
   }

References graph_substitute().

◆ graph_substitute() [3/4]

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

static

Functions called by friend functions defined for this class

Definition at line 1561 of file mx.cpp.

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

References graph_substitute().

◆ graph_substitute() [4/4]

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

static

Functions called by friend functions defined for this class

Definition at line 1567 of file mx.cpp.

                                                       {
     casadi_assert(v.size()==vdef.size(),
       "Mismatch in the number of expression to substitute: "
       + str(v.size()) + " <-> " + str(vdef.size()) + ".");
  
     updated = false;
  
     // Quick return if all equal
     bool all_equal = true;
     for (casadi_int k=0; k<v.size(); ++k) {
       if (v[k].size()!=vdef[k].size() || !is_equal(v[k], vdef[k])) {
         all_equal = false;
         break;
       }
     }
     if (all_equal) return ex;
  
     // Validate dimensions
     for (casadi_int i=0;i<v.size();++i) {
       casadi_assert(v[i].size()==vdef[i].size(),
         "Inconsistent shapes for i = " + str(i) + ": v[i] " + v[i].dim() +
         " <-> vdef[i] " + vdef[i].dim());
     }
  
     // Sort the expression
     Dict opts({{"max_io", 0}, {"allow_free", true}});
     Function f("tmp_graph_substitute", std::vector<MX>{}, ex, opts);
     MXFunction *ff = f.get<MXFunction>();
  
     // Get references to the internal data structures
     const std::vector<MXAlgEl>& algorithm = ff->algorithm_;
     std::vector<MX> swork(ff->workloc_.size()-1);
  
     // A boolean vector indicated whoch nodes are tainted by substitutions
     std::vector<bool> tainted(swork.size());
  
     // Construct lookup table for expressions,
     // giving priority to first occurances
     std::map<const MXNode*, casadi_int> expr_lookup;
     for (casadi_int i=0;i<v.size();++i) {
       auto it = expr_lookup.find(v[i].operator->());
       if (it==expr_lookup.end()) expr_lookup[v[i].operator->()] = i;
     }
  
     // Construct found map
     std::vector<bool> expr_found(v.size(), false);
  
     // Allocate output vector
     std::vector<MX> f_out(f.n_out());
     std::vector<MX> oarg, ores;
  
     // expr_lookup iterator
     std::map<const MXNode*, casadi_int>::const_iterator it_lookup;
  
     // Allocate storage for split outputs
     std::vector<std::vector<MX>> out_split(ex.size());
     for (casadi_int i = 0; i < out_split.size(); ++i) out_split[i].resize(ex[i].n_primitives());
  
     for (auto it=algorithm.begin(); it!=algorithm.end(); ++it) {
  
       if (it->op != OP_OUTPUT) {
         // Check if it->data points to a supplied expr
         it_lookup = expr_lookup.find((it->data).operator->());
  
         if (it_lookup!=expr_lookup.end()) {
           // Fill in that expression in-place
           MX e = vdef[it_lookup->second];
  
           // If node is of a MultipleOutput type
           if (e->has_output()) {
             for (casadi_int i=0;i<it->res.size();++i) {
               casadi_int k = it->res[i];
               if (k!=-1) {
                 swork[k] = e.get_output(i);
                 tainted[k] = true;
               }
             }
           } else {
             swork[it->res.front()] = e;
             tainted[it->res.front()] = true;
           }
           expr_found[it_lookup->second] = true;
           continue;
         } else if (it->data->has_output()) {
           bool any_tainted = false;
           // Loop over all oputputs of MultiOutput
           for (casadi_int i=0;i<it->res.size();++i) {
             // Create Output node (cached)
             casadi_int k = it->res[i];
             if (k!=-1) {
               MX out = it->data.get_output(i);
               // Check if out points to a supplied expr
               it_lookup = expr_lookup.find(out.operator->());
               if (it_lookup!=expr_lookup.end()) {
                 // Fill in that expression in-place
                 MX e = vdef[it_lookup->second];
                 swork[k] = e;
                 tainted[k] = true;
                 any_tainted = true;
                 expr_found[it_lookup->second] = true;
               }
             }
           }
           if (any_tainted) continue;
         }
       }
  
       switch (it->op) {
       case OP_INPUT:
         tainted[it->res.front()] = false;
         break;
       case OP_PARAMETER:
         swork[it->res.front()] = it->data;
         tainted[it->res.front()] = false;
         break;
       case OP_OUTPUT:
         out_split.at(it->data->ind()).at(it->data->segment()) = swork[it->arg.front()];
         break;
       default:
         {
           bool node_tainted = false;
  
           // Arguments of the operation
           oarg.resize(it->arg.size());
           for (casadi_int i=0; i<oarg.size(); ++i) {
             casadi_int el = it->arg[i];
             if (el>=0) node_tainted =  node_tainted || tainted[el];
             oarg[i] = el<0 ? MX(it->data->dep(i).size()) : swork.at(el);
           }
  
           // Perform the operation
           ores.resize(it->res.size());
           if (!node_tainted) {
             if (it->data.has_output()) {
               for (casadi_int i=0;i<it->res.size();++i) {
                 ores.at(i) = it->data.get_output(i);
               }
             } else {
               ores.at(0) = it->data;
             }
           } else {
             it->data->eval_mx(oarg, ores);
           }
  
           // Get the result
           for (casadi_int i=0; i<ores.size(); ++i) {
             casadi_int el = it->res[i];
             if (el>=0) swork.at(el) = ores[i];
             if (el>=0) tainted[el] = node_tainted;
           }
         }
       }
     }
  
     // Join primitives
     for (size_t k = 0; k < out_split.size(); ++k) {
       f_out[k] = ex[k].join_primitives(out_split.at(k));
     }
  
     bool all_found=true;
     for (casadi_int i=0;i<v.size();++i) {
       all_found = all_found && expr_found[i];
     }
  
     updated = any(expr_found);
  
     return f_out;
  
   }

References casadi::MXFunction::algorithm_, casadi::any(), casadi::GenericMatrix< MX >::dim(), find(), get_output(), casadi::MXNode::get_output(), casadi::MXNode::has_output(), is_equal(), MX(), n_primitives(), casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::GenericMatrix< MX >::size(), and casadi::str().

◆ has_duplicates()

bool casadi::MX::has_duplicates ( ) const

If there are symbolic primitives appearing more than once, the function will return true and the names of the duplicate expressions will be passed to casadi_warning. Note: Will mark the node using MX::set_temp. Make sure to call reset_input() after usage.

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

Definition at line 1018 of file mx.cpp.

                                 {
     return (*this)->has_duplicates();
   }

◆ has_output()

bool casadi::MX::has_output ( ) const

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

Definition at line 815 of file mx.cpp.

                             {
     return (*this)->has_output();
   }

◆ hessian() [1/2]

MX casadi::MX::hessian	(	const MX &	f,
		const MX &	x,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1932 of file mx.cpp.

                                                            {
     MX g;
     return hessian(f, x, g, opts);
   }

◆ hessian() [2/2]

MX casadi::MX::hessian	(	const MX &	f,
		const MX &	x,
		MX &	g,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1937 of file mx.cpp.

                                                                   {
     try {
       Dict all_opts = opts;
       g = gradient(f, x, opts);
       if (!opts.count("symmetric")) all_opts["symmetric"] = true;
       return jacobian(g, x, all_opts);
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("hessian", e.what());
     }
   }

References casadi::GenericMatrix< MX >::gradient, and jacobian().

◆ horzcat()

MX casadi::MX::horzcat ( const std::vector< MX > & x )

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1119 of file mx.cpp.

                                        {
     // Check dimensions
     if (x.size()>1) {
       std::vector<MX> ne = trim_empty(x, true);
       for (casadi_int i=0;i<ne.size();i++) {
         casadi_assert(ne[i].size1()==ne[0].size1(),
           "horzcat dimension mismatch  x[" + str(i) + "]:" + ne[i].dim() +
           " and x[0]: " + ne[0].dim() + ".");
       }
     }
  
     if (x.empty()) {
       return MX(1, 0);
     } else if (x.size()==1) {
       return x.front();
     } else if (has_empty(x)) {
       std::vector<MX> ret = trim_empty(x);
       if (ret.empty()) {
         // We still want horzcat(zeros(0,5),zeros(0,5)) -> zeros(0,10)
         ret = trim_empty(x, true);
         casadi_int s = 0;
         casadi_int nrow = 0;
         for (casadi_int i=0;i<ret.size();++i) {
           s+= ret[i].size2();
           casadi_assert_dev(nrow==0 || nrow==ret[i].size1());
           nrow = ret[i].size1();
         }
         return MX::zeros(nrow, s);
       } else {
         return horzcat(ret);
       }
     } else {
       return x.front()->get_horzcat(x);
     }
   }

References casadi::GenericMatrix< MX >::dim(), casadi::has_empty(), MX(), casadi::GenericExpression< MX >::ne(), casadi::GenericMatrix< MatType >::size(), casadi::GenericMatrix< MX >::size1(), casadi::str(), casadi::trim_empty(), and casadi::GenericMatrix< MX >::zeros().

Referenced by blockcat(), and vertcat().

◆ horzsplit()

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

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1206 of file mx.cpp.

                                                                               {
     // Consistency check
     casadi_assert_dev(!offset.empty());
     casadi_assert_dev(offset.front()==0);
     casadi_assert_dev(offset.back()==x.size2());
     casadi_assert_dev(is_monotone(offset));
  
     // Trivial return if possible
     if (offset.size()==1) {
       return std::vector<MX>(0);
     } else if (offset.size()==2) {
       return std::vector<MX>(1, x);
     } else {
       return x->get_horzsplit(offset);
     }
   }

References casadi::MXNode::get_horzsplit(), casadi::is_monotone(), casadi::SparsityInterface< MatType >::offset(), and casadi::GenericMatrix< MatType >::size2().

Referenced by vertsplit().

◆ if_else()

MX casadi::MX::if_else	(	const MX &	cond,
		const MX &	if_true,
		const MX &	if_false,
		bool	short_circuit = `false`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1373 of file mx.cpp.

                                                                                         {
     if (short_circuit) {
       // Get symbolic primitives
       std::vector<MX> arg = symvar(veccat(std::vector<MX>{x_true, x_false}));
  
       // Form functions for cases
       Function f_true("f_true", arg, {x_true});
       Function f_false("f_false", arg, {x_false});
  
       // Form Switch
       Function sw = Function::if_else("switch", f_true, f_false);
  
       // Call the Switch
       std::vector<MX> sw_arg;
       sw_arg.push_back(cond);
       sw_arg.insert(sw_arg.end(), arg.begin(), arg.end());
       return sw(sw_arg).at(0);
     } else {
       return if_else_zero(cond, x_true) + if_else_zero(!cond, x_false);
     }
   }

References casadi::Function::if_else(), casadi::GenericExpression< MX >::if_else_zero(), symvar(), and casadi::SparsityInterface< MatType >::veccat().

Referenced by conditional().

◆ inf() [1/3]

MX casadi::MX::inf	(	casadi_int	nrow = `1`,
		casadi_int	ncol = `1`
	)

static

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

Definition at line 576 of file mx.cpp.

                                              {
     return inf(Sparsity::dense(nrow, ncol));
   }

References casadi::Sparsity::dense(), and inf().

◆ inf() [2/3]

MX casadi::MX::inf ( const Sparsity & sp )

static

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

Definition at line 584 of file mx.cpp.

                                {
     return create(ConstantMX::create(sp, std::numeric_limits<double>::infinity()));
   }

References casadi::ConstantMX::create(), and create().

Referenced by inf(), and casadi::init_gen().

◆ inf() [3/3]

MX casadi::MX::inf ( const std::pair< casadi_int, casadi_int > & rc )

static

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

Definition at line 580 of file mx.cpp.

                                                       {
     return inf(rc.first, rc.second);
   }

References inf().

◆ info()

Dict casadi::MX::info ( ) const

Obtain information about node

Definition at line 855 of file mx.cpp.

                       {
     return (*this)->info();
   }

Referenced by casadi::MXFunction::export_code_body(), and casadi::Onnx::load().

◆ interp1d()

MX casadi::GenericMatrix< MX >::interp1d	(	const std::vector< double > &	x,
		const MX &	v,
		const std::vector< double > &	xq,
		const std::string &	mode,
		bool	equidistant
	)

staticinherited

Definition at line 213 of file generic_matrix.hpp.

                                                                             {
  
     bool mode_floor = false;
     bool mode_ceil = false;
     if (mode=="floor") {
       mode_floor = true;
     } else if (mode=="ceil") {
       mode_ceil = true;
     } else if (mode=="linear") {
       //
     } else {
       casadi_error("interp1d(x, v, xq, mode): "
         "Mode must be 'floor', 'ceil' or 'linear'. Got '" + mode + "' instead.");
     }
  
     casadi_assert(is_increasing(x), "interp1d(x, v, xq): x must be increasing.");
  
     casadi_assert(x.size()==v.size1(),
       "interp1d(x, v, xq): dimensions mismatch. v expected to have " + str(x.size()) + " rows,"
       " but got " + str(v.size1()) + " instead.");
  
     // Need at least two elements
     casadi_assert(x.size()>=2, "interp1d(x, v, xq): x must be at least length 2.");
  
     // Vectors to compose a sparse matrix
     std::vector<double> val;
     std::vector<casadi_int> colind(1, 0);
     std::vector<casadi_int> row;
  
     // Number of nonzeros in to-be composed matrix
     casadi_int nnz = 0;
     for (casadi_int i=0;i<xq.size();++i) {
       // Obtain index corresponding to xq[i]
       double ind = index_interp1d(x, xq[i], equidistant);
  
       if (mode_floor) ind = floor(ind);
       if (mode_ceil) ind = ceil(ind);
  
       // Split into integer and fractional part
       double int_partd;
       double frac_part = modf(ind, &int_partd);
       casadi_int int_part = static_cast<casadi_int>(int_partd);
  
       if (frac_part==0) {
          // Create a single entry
          val.push_back(1);
          row.push_back(int_part);
          nnz+=1;
          colind.push_back(nnz);
        } else {
          // Create a double entry
          val.push_back(1-frac_part);
          val.push_back(frac_part);
          row.push_back(int_part);
          row.push_back(int_part+1);
          nnz+=2;
          colind.push_back(nnz);
        }
      }
  
      // Construct sparsity for composed matrix
      Sparsity sp(x.size(), xq.size() , colind, row);
  
      return MatType::mtimes(MatType(sp, val).T(), v);
  
   }

◆ interpn_linear()

MX casadi::MX::interpn_linear	(	const std::vector< MX > &	x,
		const MX &	v,
		const std::vector< MX > &	xq,
		const Dict &	opts = `Dict()`
	)

static

Usually, you want to be using 'interpolant' instead.

Accepts lookup_mode option.

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

Definition at line 3145 of file mx.cpp.

                         {
  
     casadi_int n_dim = x.size();
     std::vector<std::string> lookup_mode(n_dim, "auto");
     for (auto&& op : opts) {
       if (op.first=="lookup_mode") {
         lookup_mode = op.second;
       } else {
         casadi_error("Unknown option '" + op.first + "'.");
       }
     }
  
     casadi_assert_dev(xq.size()==n_dim);
     casadi_assert_dev(v.is_vector());
  
     // Extract grid dimensions
     std::vector<casadi_int> x_dims;
     for (auto e : x) x_dims.push_back(e.numel());
  
     // Determine multipicity of output
     casadi_int n_out = v.numel()/product(x_dims);
     casadi_assert(n_out*product(x_dims)==v.numel(),
       "Dimension mismatch: coefficients (" + str(v.numel()) + ") should be "
       "an integer multiple of product-of-dimensions (" + str(product(x_dims)) + ").");
  
     // Dimension check xq
     casadi_int nq = xq[0].numel();
     for (auto e : xq) {
       casadi_assert_dev(e.is_vector() && e.numel()==nq);
     }
  
     // Compute stride vector
     std::vector<casadi_int> strides;
     strides.push_back(n_out);
     for (auto d : x_dims) strides.push_back(strides.back()*d);
  
     // Pre-compute lower index and normalized coordinate
     // (Allows for more sub-expression sharing)
     std::vector<MX> xis, Ls, Lps;
     for (casadi_int i=0;i<n_dim;++i) {
       MX L = low(x[i], xq[i], {{"lookup_mode", lookup_mode[i]}});
       MX Lp = L+1;
       MX xl, xu;
       x[i].get_nz(xl, false, L);
       x[i].get_nz(xu, false, Lp);
       xis.push_back((xq[i]-xl)/(xu-xl));
       Ls.push_back(L);
       Lps.push_back(Lp);
     }
  
     Slice I(0, n_out);
  
     return interpn_G(n_dim, v, xis, Ls, Lps, strides, I);
   }

References get_nz(), casadi::interpn_G(), casadi::GenericMatrix< MatType >::is_vector(), low(), n_out(), casadi::GenericMatrix< MatType >::numel(), op(), casadi::product(), casadi::GenericMatrix< MatType >::size(), and casadi::str().

Referenced by casadi::LinearInterpolant::do_inline().

◆ inv() [1/2]

MX casadi::MX::inv ( ) const

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

Definition at line 1087 of file mx.cpp.

                    {
     if (is_op(OP_INV)) {
       return dep(0);
     } else {
       return (*this)->get_unary(OP_INV);
     }
   }

References dep(), is_op(), and casadi::OP_INV.

◆ inv() [2/2]

MX casadi::MX::inv	(	const MX &	A,
		const std::string &	lsolver = `"qr"`,
		const Dict &	dict = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2037 of file mx.cpp.

                                                                     {
     return solve(x, MX::eye(x.size1()), lsolver, dict);
   }

References eye(), casadi::GenericMatrix< MatType >::size1(), and solve().

◆ inv_minor()

MX casadi::MX::inv_minor ( const MX & A )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2033 of file mx.cpp.

                               {
     casadi_error("Not implemented");
   }

◆ inv_node()

MX casadi::MX::inv_node ( const MX & A )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2029 of file mx.cpp.

                              {
     return x->get_inv();
   }

References casadi::MXNode::get_inv().

◆ inv_skew()

MX casadi::GenericMatrix< MX >::inv_skew ( const MX & a )

staticinherited

Definition at line 229 of file generic_matrix.hpp.

                                                            {
     casadi_assert(a.size1()==3 && a.size2()==3,
       "inv_skew(a): Expecting 3-by-3 matrix, got " + a.dim() + ".");
  
     return 0.5*vertcat(std::vector<MatType>({a(2, 1)-a(1, 2), a(0, 2)-a(2, 0), a(1, 0)-a(0, 1)}));
   }

◆ is_binary()

bool casadi::MX::is_binary ( ) const

Definition at line 843 of file mx.cpp.

                            {
     return (*this)->is_binary();
   }

Referenced by casadi::MXFunction::export_code_body(), and is_commutative().

◆ is_call()

bool casadi::MX::is_call ( ) const

Definition at line 803 of file mx.cpp.

                          {
     return (*this)->op()==OP_CALL;
   }

References casadi::OP_CALL.

Referenced by casadi::BlazingSplineFunction::merge().

◆ is_column()

bool casadi::GenericMatrix< MX >::is_column ( ) const

inlineinherited

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

Definition at line 178 of file generic_matrix.hpp.

178 { return sparsity().is_column();}

casadi::Sparsity::is_column

bool is_column() const

Check if the pattern is a column vector (i.e. size2()==1)

Definition: sparsity.cpp:285

◆ is_commutative()

bool casadi::MX::is_commutative ( ) const

Definition at line 879 of file mx.cpp.

                                 {
     if (is_unary()) return true;
     casadi_assert(is_binary() || is_unary(),
       "MX::is_commutative: must be binary or unary operation");
     return operation_checker<CommChecker>(op());
   }

References is_binary(), is_unary(), and op().

◆ is_constant()

bool casadi::MX::is_constant ( ) const

Definition at line 799 of file mx.cpp.

                              {
     return (*this)->op()==OP_CONST;
   }

References casadi::OP_CONST.

Referenced by casadi::MXNode::_get_binary(), casadi::constant_ints(), casadi::DaeBuilderInternal::create(), casadi::ConstantMX::get_dot(), casadi::MXNode::get_einstein(), casadi::Constant< Value >::get_nzassign(), is_regular(), casadi::DaeBuilderInternal::load_fmi_description(), MX(), casadi::OptiNode::subject_to(), and casadi::MXNode::~MXNode().

◆ is_dense()

bool casadi::GenericMatrix< MX >::is_dense ( ) const

inlineinherited

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

Definition at line 153 of file generic_matrix.hpp.

153 { return sparsity().is_dense();}

casadi::Sparsity::is_dense

bool is_dense() const

Is dense?

Definition: sparsity.cpp:273

◆ is_doubled()

bool casadi::MX::is_doubled ( ) const

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

Definition at line 1082 of file mx.cpp.

                             {
     return (op()==OP_ADD && is_equal(dep(0), dep(1), get_max_depth())) ||
            (op()==OP_TWICE);
   }

References dep(), get_max_depth(), is_equal(), op(), casadi::OP_ADD, and casadi::OP_TWICE.

◆ is_empty()

bool casadi::GenericMatrix< MX >::is_empty ( bool both = false ) const

inlineinherited

(or optionally both dimensions)

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

Definition at line 148 of file generic_matrix.hpp.

148 { return sparsity().is_empty(both);}

casadi::Sparsity::is_empty

bool is_empty(bool both=false) const

Check if the sparsity is empty.

Definition: sparsity.cpp:144

◆ is_equal()

bool casadi::MX::is_equal	(	const MX &	x,
		const MX &	y,
		casadi_int	depth = `0`
	)

static

Functions called by friend functions defined for GenericExpression

Definition at line 867 of file mx.cpp.

                                                               {
     return MXNode::is_equal(x.get(), y.get(), depth);
   }

References get(), and casadi::MXNode::is_equal().

Referenced by casadi::BinaryMX< ScX, ScY >::_get_binary(), casadi::UnaryMX::_get_binary(), casadi::Call::common_cond(), casadi::MXNode::get_binary(), graph_substitute(), is_doubled(), casadi::BinaryMX< ScX, ScY >::is_equal(), casadi::MXNode::sameOpAndDeps(), and substitute().

◆ is_eye()

bool casadi::MX::is_eye ( ) const

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

Definition at line 1026 of file mx.cpp.

                         {
     return (*this)->is_eye();
   }

Referenced by mac().

◆ is_half()

bool casadi::MX::is_half ( ) const

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

Definition at line 1046 of file mx.cpp.

                          {
     return (*this)->is_half();
   }

◆ is_inf()

bool casadi::MX::is_inf ( ) const

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

Definition at line 1070 of file mx.cpp.

                         {
     return (*this)->is_inf();
   }

◆ is_integer()

bool casadi::MX::is_integer ( ) const

Definition at line 1078 of file mx.cpp.

                             {
     return (*this)->is_integer();
   }

◆ is_linear()

bool casadi::GenericMatrix< MX >::is_linear	(	const MX &	expr,
		const MX &	var
	)

staticinherited

Definition at line 235 of file generic_matrix.hpp.

                                                                                 {
     return !any(MatType::which_depends(expr, var, 2, true));
   }

◆ is_minus_inf()

bool casadi::MX::is_minus_inf ( ) const

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

Definition at line 1074 of file mx.cpp.

                               {
     return (*this)->is_minus_inf();
   }

◆ is_minus_one()

bool casadi::MX::is_minus_one ( ) const

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

Definition at line 1042 of file mx.cpp.

                               {
     return (*this)->is_value(-1);
   }

◆ is_multiplication()

bool casadi::MX::is_multiplication ( ) const

Definition at line 827 of file mx.cpp.

                                    {
     return (*this)->op()==OP_MTIMES;
   }

References casadi::OP_MTIMES.

◆ is_nonnegative()

bool casadi::MX::is_nonnegative ( ) const

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

Definition at line 1054 of file mx.cpp.

                                 {
     return (*this)->is_nonnegative();
   }

◆ is_norm()

bool casadi::MX::is_norm ( ) const

Definition at line 831 of file mx.cpp.

                          {
     return dynamic_cast<const Norm*>(get())!=nullptr;
   }

References get().

◆ is_null()

bool casadi::GenericShared< SharedObject , SharedObjectInternal >::is_null

inherited

Definition at line 116 of file generic_shared_impl.hpp.

                                                       {
     return node==nullptr;
   }

◆ is_one()

bool casadi::MX::is_one ( ) const

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

Definition at line 1038 of file mx.cpp.

                         {
     return (*this)->is_one();
   }

◆ is_op()

bool casadi::MX::is_op ( casadi_int op ) const

Definition at line 823 of file mx.cpp.

                                     {
     return (*this)->op()==op;
   }

References op().

Referenced by casadi::OptiNode::canon_expr(), inv(), and casadi::DaeBuilderInternal::when().

◆ is_output()

bool casadi::MX::is_output ( ) const

Definition at line 811 of file mx.cpp.

                            {
     return (*this)->is_output();
   }

Referenced by casadi::DaeBuilderInternal::create(), cse(), and casadi::DaeBuilderInternal::jac_vdef_v_from_calls().

◆ is_quadratic()

bool casadi::GenericMatrix< MX >::is_quadratic	(	const MX &	expr,
		const MX &	var
	)

staticinherited

Definition at line 236 of file generic_matrix.hpp.

                                                                                    {
     return is_linear(gradient(expr, var), var);
   }

◆ is_regular()

bool casadi::MX::is_regular ( ) const

Definition at line 1062 of file mx.cpp.

                             {
     if (is_constant()) {
       return static_cast<DM>(*this).is_regular();
     } else {
       casadi_error("Cannot check regularity for symbolic MX");
     }
   }

References is_constant(), and casadi::Matrix< Scalar >::is_regular().

◆ is_row()

bool casadi::GenericMatrix< MX >::is_row ( ) const

inlineinherited

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

Definition at line 173 of file generic_matrix.hpp.

173 { return sparsity().is_row();}

casadi::Sparsity::is_row

bool is_row() const

Check if the pattern is a row vector (i.e. size1()==1)

Definition: sparsity.cpp:281

◆ is_scalar()

bool casadi::GenericMatrix< MX >::is_scalar ( bool scalar_and_dense = false ) const

inherited

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

Definition at line 158 of file generic_matrix.hpp.

                                                                     {
     return sparsity().is_scalar(scalar_and_dense);
   }

◆ is_square()

bool casadi::GenericMatrix< MX >::is_square ( ) const

inlineinherited

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

Definition at line 163 of file generic_matrix.hpp.

163 { return sparsity().is_square();}

casadi::Sparsity::is_square

bool is_square() const

Is square?

Definition: sparsity.cpp:293

◆ is_symbolic()

bool casadi::MX::is_symbolic ( ) const

Definition at line 795 of file mx.cpp.

                              {
     return (*this)->op()==OP_PARAMETER;
   }

References casadi::OP_PARAMETER.

Referenced by casadi::DaeBuilder::add(), casadi::DaeBuilderInternal::der(), casadi::OptiNode::describe(), casadi::DaeBuilderInternal::find(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::register_symbol(), and substitute_inplace().

◆ is_transpose()

bool casadi::MX::is_transpose ( ) const

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

Definition at line 1058 of file mx.cpp.

                               {
     return op()==OP_TRANSPOSE;
   }

References op(), and casadi::OP_TRANSPOSE.

◆ is_tril()

bool casadi::GenericMatrix< MX >::is_tril ( ) const

inlineinherited

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

Definition at line 188 of file generic_matrix.hpp.

188 { return sparsity().is_tril();}

casadi::Sparsity::is_tril

bool is_tril(bool strictly=false) const

Is lower triangular?

Definition: sparsity.cpp:321

◆ is_triu()

bool casadi::GenericMatrix< MX >::is_triu ( ) const

inlineinherited

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

Definition at line 183 of file generic_matrix.hpp.

183 { return sparsity().is_triu();}

casadi::Sparsity::is_triu

bool is_triu(bool strictly=false) const

Is upper triangular?

Definition: sparsity.cpp:325

◆ is_unary()

bool casadi::MX::is_unary ( ) const

Definition at line 847 of file mx.cpp.

                           {
     return (*this)->is_unary();
   }

Referenced by casadi::MXFunction::export_code_body(), and is_commutative().

◆ is_valid_input()

bool casadi::MX::is_valid_input ( ) const

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

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

Definition at line 954 of file mx.cpp.

                                 {
     return (*this)->is_valid_input();
   }

Referenced by casadi::DaeBuilderInternal::der(), casadi::OptiNode::set_domain(), and casadi::OptiNode::to_function().

◆ is_value()

bool casadi::MX::is_value ( double val ) const

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

Definition at line 1050 of file mx.cpp.

                                     {
     return (*this)->is_value(val);
   }

◆ is_vector()

bool casadi::GenericMatrix< MX >::is_vector ( ) const

inlineinherited

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

Definition at line 168 of file generic_matrix.hpp.

168 { return sparsity().is_vector();}

casadi::Sparsity::is_vector

bool is_vector() const

Check if the pattern is a row or column vector.

Definition: sparsity.cpp:289

◆ is_zero()

bool casadi::MX::is_zero ( ) const

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

Definition at line 1030 of file mx.cpp.

                          {
     if (nnz()==0) {
       return true;
     } else {
       return (*this)->is_zero();
     }
   }

References casadi::GenericMatrix< MX >::nnz().

Referenced by casadi::MXNode::_get_binary(), casadi::MXNode::get_dot(), casadi::MXNode::get_einstein(), casadi::MXNode::get_mac(), and mac().

◆ jacobian()

MX casadi::MX::jacobian	(	const MX &	f,
		const MX &	x,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1920 of file mx.cpp.

                                                             {
     try {
       Dict h_opts;
       Dict opts_remainder = extract_from_dict(opts, "helper_options", h_opts);
       h_opts["allow_free"] = true;
       Function h("helper_jacobian_MX", {x}, {f}, h_opts);
       return h.get<MXFunction>()->jac(opts_remainder).at(0);
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("jacobian", e.what());
     }
   }

References casadi::extract_from_dict(), and casadi::Function::get().

Referenced by hessian(), and casadi::Scpgen::init().

◆ jacobian_sparsity()

Sparsity casadi::MX::jacobian_sparsity	(	const MX &	f,
		const MX &	x
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2016 of file mx.cpp.

                                                          {
     return _jacobian_sparsity(f, x);
   }

References casadi::_jacobian_sparsity().

◆ join_primitives() [1/3]

DM casadi::MX::join_primitives ( const std::vector< DM > & v ) const

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

Definition at line 1010 of file mx.cpp.

                                                      {
     casadi_assert(v.size()==n_primitives(), "Wrong number of primitives supplied");
     std::vector<DM>::const_iterator it=v.begin();
     DM ret = (*this)->join_primitives(it);
     casadi_assert_dev(it==v.end());
     return ret;
   }

References n_primitives().

◆ join_primitives() [2/3]

MX casadi::MX::join_primitives ( const std::vector< MX > & v ) const

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

Definition at line 994 of file mx.cpp.

                                                      {
     casadi_assert(v.size()==n_primitives(), "Wrong number of primitives supplied");
     std::vector<MX>::const_iterator it=v.begin();
     MX ret = (*this)->join_primitives(it);
     casadi_assert_dev(it==v.end());
     return ret;
   }

References casadi::MXNode::join_primitives(), and n_primitives().

Referenced by cse(), casadi::DaeBuilderInternal::der(), extract_parametric(), separate_linear(), simplify_const_folding(), and simplify_ref_count().

◆ join_primitives() [3/3]

SX casadi::MX::join_primitives ( const std::vector< SX > & v ) const

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

Definition at line 1002 of file mx.cpp.

                                                      {
     casadi_assert(v.size()==n_primitives(), "Wrong number of primitives supplied");
     std::vector<SX>::const_iterator it=v.begin();
     SX ret = (*this)->join_primitives(it);
     casadi_assert_dev(it==v.end());
     return ret;
   }

References n_primitives().

◆ jtimes()

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

staticinherited

Functions called by friend functions defined here

◆ kron()

MX casadi::MX::kron	(	const MX &	x,
		const MX &	b
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 2077 of file mx.cpp.

                                       {
     return a->get_kron(b);
   }

References casadi::MXNode::get_kron().

◆ kron_contract()

MX casadi::MX::kron_contract	(	const MX &	m,
		const MX &	x,
		bool	inner
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 2081 of file mx.cpp.

                                                            {
     return m->get_kron_contract(x, inner);
   }

References casadi::MXNode::get_kron_contract().

Referenced by casadi::kron_contract().

◆ lift()

MX casadi::MX::lift	(	const MX &	x,
		const MX &	x_guess
	)

static

Functions called by friend functions defined for this class

Definition at line 763 of file mx.cpp.

                                             {
     casadi_assert_dev(x.sparsity()==x_guess.sparsity());
     return x->_get_binary(OP_LIFT, x_guess, false, false);
   }

References casadi::MXNode::_get_binary(), casadi::OP_LIFT, and sparsity().

◆ linear_coeff()

void casadi::GenericMatrix< MX >::linear_coeff	(	const MX &	expr,
		const MX &	var,
		MX &	A,
		MX &	b,
		bool	check
	)

staticinherited

Definition at line 239 of file generic_matrix.hpp.

                                               {
     casadi_assert(expr.is_vector(), "'linear_coeff' only defined for vector expressions.");
     if (check)
       casadi_assert(is_linear(expr, var), "'linear_coeff' called on non-linear expression.");
     A = substitute(jacobian(expr, var), var, 0);
     b = vec(substitute(expr, var, 0));
   }

◆ linearize()

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

staticinherited

Functions called by friend functions defined here

◆ linspace() [1/2]

MX casadi::GenericMatrix< MX >::linspace	(	const MX &	a,
		const MX &	b,
		casadi_int	nsteps
	)

staticinherited

Definition at line 226 of file generic_matrix.hpp.

                                                                                                 {
     std::vector<MatType> ret(nsteps);
     ret[0] = a;
     MatType step = (b-a)/static_cast<MatType>(nsteps-1);
  
     for (casadi_int i=1; i<nsteps-1; ++i)
       ret[i] = a + i * step;
  
     ret[nsteps-1] = b;
     return vertcat(ret);
   }

◆ linspace() [2/2]

MX casadi::MX::linspace	(	const MX &	a,
		const MX &	b,
		casadi_int	nsteps
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2103 of file mx.cpp.

                                                              {
     // Specialized over GenericMatrix<MX>::linspace to keep the MX graph
     // O(1) in nsteps. The FP recipe (a + i*step interior, literal b at
     // the endpoint) matches the generic implementation and numpy.linspace
     // bit-for-bit; see test_linspace in test/python/matrix.py.
     if (nsteps < 2) return b;
     MX step = (b - a) / static_cast<double>(nsteps - 1);
     std::vector<double> idx(nsteps - 1);
     for (casadi_int i = 0; i < nsteps - 1; ++i) idx[i] = static_cast<double>(i);
     return vertcat(std::vector<MX>{a + DM(idx) * step, b});
   }

References vertcat().

◆ logsumexp()

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

staticinherited

◆ low()

MX casadi::MX::low	(	const MX &	v,
		const MX &	p,
		const Dict &	options = `Dict()`
	)

static

Functions called by friend functions defined for this class

Definition at line 2220 of file mx.cpp.

                                                           {
     return p->get_low(v, options);
   }

References casadi::MXNode::get_low().

Referenced by interpn_linear().

◆ mac()

MX casadi::MX::mac	(	const MX &	x,
		const MX &	y,
		const MX &	z,
		const std::string &	blas = `"reference"`
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 712 of file mx.cpp.

                                                                          {
     if (x.is_scalar() || y.is_scalar()) {
       // Use element-wise multiplication if at least one factor scalar
       return z + x*y;
     }
  
     // Check matching dimensions
     casadi_assert(x.size2()==y.size1(),
       "Matrix product with incompatible dimensions. Lhs is "
       + x.dim() + " and rhs is " + y.dim() + ".");
  
     // Check if we can simplify the product
     if (x.is_eye()) {
       return y + z;
     } else if (y.is_eye()) {
       return x + z;
     } else if (x.is_zero() || y.is_zero()) {
       return z;
     } else {
       return x->get_mac(y, z, blas);
     }
   }

References casadi::GenericMatrix< MatType >::dim(), casadi::MXNode::get_mac(), is_eye(), casadi::GenericMatrix< MatType >::is_scalar(), is_zero(), casadi::GenericMatrix< MatType >::size1(), and casadi::GenericMatrix< MatType >::size2().

Referenced by mtimes().

◆ mapping()

Matrix< casadi_int > casadi::MX::mapping ( ) const

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

Definition at line 886 of file mx.cpp.

                                        {
     return (*this)->mapping();
   }

Referenced by diag(), erase(), get(), and unite().

◆ matrix_expand() [1/2]

MX casadi::MX::matrix_expand	(	const MX &	e,
		const std::vector< MX > &	boundary,
		const Dict &	options
	)

static

Functions called by friend functions defined for this class

Definition at line 2046 of file mx.cpp.

                                                                                       {
     return matrix_expand(std::vector<MX>{e}, boundary, options).at(0);
   }

◆ matrix_expand() [2/2]

std::vector< MX > casadi::MX::matrix_expand	(	const std::vector< MX > &	e,
		const std::vector< MX > &	boundary,
		const Dict &	options
	)

static

Functions called by friend functions defined for this class

Definition at line 2050 of file mx.cpp.

                                                          {
  
     // Create symbols for boundary nodes
     std::vector<MX> syms(boundary.size());
  
     for (casadi_int i=0;i<syms.size();++i) {
       syms[i] = MX::sym("x", boundary[i].sparsity());
     }
  
     // Substitute symbols for boundary nodes
     std::vector<MX> ret = graph_substitute(e, boundary, syms);
  
     // Obtain list of dependents
     std::vector<MX> v = symvar(veccat(ret));
  
     // Construct an MXFunction with it
     Function f("tmp_matrix_expand", v, ret, Dict{{"max_io", 0}, {"allow_free", true}});
  
     // Expand to SXFunction
     Function s = f.expand("expand_" + f.name(), options);
     std::vector<MX> r;
     s.call(graph_substitute(v, syms, boundary), r);
     return r;
   }

References casadi::Function::call(), casadi::Function::expand(), graph_substitute(), sparsity(), casadi::GenericMatrix< MX >::sym(), symvar(), and casadi::SparsityInterface< MatType >::veccat().

◆ mldivide()

MX casadi::MX::mldivide	(	const MX &	a,
		const MX &	b
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 778 of file mx.cpp.

                                           {
     if (a.is_scalar() || b.is_scalar()) return b/a;
     return solve(a, b);
   }

References casadi::GenericMatrix< MatType >::is_scalar(), and solve().

◆ mmax()

MX casadi::MX::mmax ( const MX & x )

static

Functions called by friend functions defined for GenericExpression

Definition at line 875 of file mx.cpp.

                          {
     return x->get_mmax();
   }

References casadi::MXNode::get_mmax().

◆ mmin()

MX casadi::MX::mmin ( const MX & x )

static

Functions called by friend functions defined for GenericExpression

Definition at line 871 of file mx.cpp.

                          {
     return x->get_mmin();
   }

References casadi::MXNode::get_mmin().

◆ monitor()

MX casadi::MX::monitor ( const std::string & comment ) const

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

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

Definition at line 750 of file mx.cpp.

                                                {
     return(*this)->get_monitor(comment);
   }

References casadi::MXNode::get_monitor().

◆ mpower()

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

staticinherited

Functions called by friend functions defined here

◆ mrdivide()

MX casadi::MX::mrdivide	(	const MX &	a,
		const MX &	b
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 773 of file mx.cpp.

                                           {
     if (a.is_scalar() || b.is_scalar()) return b/a;
     return solve(a.T(), b.T()).T();
   }

References casadi::GenericMatrix< MatType >::is_scalar(), solve(), and T().

◆ mtimes()

MX casadi::MX::mtimes	(	const MX &	x,
		const MX &	y,
		const std::string &	blas = `"reference"`
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 672 of file mx.cpp.

                                                                {
     if (x.is_scalar() || y.is_scalar()) {
       // Use element-wise multiplication if at least one factor scalar
       return x*y;
     } else {
       MX z = MX::zeros(Sparsity::mtimes(x.sparsity(), y.sparsity()));
       return mac(x, y, z, blas);
     }
   }

References casadi::GenericMatrix< MatType >::is_scalar(), mac(), casadi::Sparsity::mtimes(), sparsity(), and casadi::GenericMatrix< MX >::zeros().

Referenced by pinv(), solve(), sum1(), and sum2().

◆ n_dep()

casadi_int casadi::MX::n_dep ( ) const

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

Definition at line 787 of file mx.cpp.

                              {
     return (*this)->n_dep();
   }

Referenced by casadi::DaeBuilderInternal::create(), and casadi::DaeBuilderInternal::load_fmi_description().

◆ n_nodes()

casadi_int casadi::MX::n_nodes ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1475 of file mx.cpp.

                                     {
     Dict opts{{"max_io", 0}, {"cse", false}, {"allow_free", true}};
     Function f("tmp_n_nodes", std::vector<MX>{}, {x}, opts);
     return f.n_nodes();
   }

References casadi::Function::n_nodes().

◆ n_out()

casadi_int casadi::MX::n_out ( ) const

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

Definition at line 898 of file mx.cpp.

                              {
     return (*this)->nout();
   }

Referenced by casadi::DaeBuilderInternal::create(), and interpn_linear().

◆ n_primitives()

casadi_int casadi::MX::n_primitives ( ) const

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

Definition at line 958 of file mx.cpp.

                                     {
     return (*this)->n_primitives();
   }

Referenced by cse(), extract_parametric(), graph_substitute(), join_primitives(), primitives(), separate_linear(), simplify_const_folding(), simplify_ref_count(), and split_primitives().

◆ name()

std::string casadi::MX::name ( ) const

Definition at line 791 of file mx.cpp.

                            {
     return (*this)->name();
   }

Referenced by _sym(), casadi::DaeBuilder::add(), casadi::OptiNode::describe(), casadi::DaeBuilderInternal::find(), casadi::DaeBuilderInternal::import_binding_equations(), casadi::DaeBuilderInternal::import_dynamic_equations(), casadi::DaeBuilderInternal::import_model_variables(), casadi::DaeBuilderInternal::load_fmi_description(), and MX().

◆ nan() [1/3]

MX casadi::MX::nan	(	casadi_int	nrow = `1`,
		casadi_int	ncol = `1`
	)

static

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

Definition at line 588 of file mx.cpp.

                                              {
     return nan(Sparsity::dense(nrow, ncol));
   }

References casadi::Sparsity::dense(), and nan().

◆ nan() [2/3]

MX casadi::MX::nan ( const Sparsity & sp )

static

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

Definition at line 596 of file mx.cpp.

                                {
     return create(ConstantMX::create(sp, std::numeric_limits<double>::quiet_NaN()));
   }

References casadi::ConstantMX::create(), and create().

Referenced by casadi::MXNode::_get_binary(), nan(), and casadi::qpsol_nlp().

◆ nan() [3/3]

MX casadi::MX::nan ( const std::pair< casadi_int, casadi_int > & rc )

static

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

Definition at line 592 of file mx.cpp.

                                                       {
     return nan(rc.first, rc.second);
   }

References nan().

◆ nnz()

casadi_int casadi::GenericMatrix< MX >::nnz

inherited

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

Definition at line 84 of file generic_matrix.hpp.

                                                {
     return sparsity().nnz();
   }

◆ nnz_diag()

casadi_int casadi::GenericMatrix< MX >::nnz_diag

inherited

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

Definition at line 99 of file generic_matrix.hpp.

                                                     {
     return sparsity().nnz_diag();
   }

◆ nnz_lower()

casadi_int casadi::GenericMatrix< MX >::nnz_lower

inherited

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

Definition at line 89 of file generic_matrix.hpp.

                                                      {
     return sparsity().nnz_lower();
   }

◆ nnz_upper()

casadi_int casadi::GenericMatrix< MX >::nnz_upper

inherited

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

Definition at line 94 of file generic_matrix.hpp.

                                                      {
     return sparsity().nnz_upper();
   }

◆ norm_0_mul()

static casadi_int casadi::GenericMatrix< MX >::norm_0_mul	(	const MX &	x,
		const MX &	y
	)

inlinestaticinherited

Definition at line 216 of file generic_matrix.hpp.

                                                                      {
       return Sparsity::norm_0_mul(x.sparsity(), y.sparsity());
     }

◆ norm_1()

MX casadi::MX::norm_1 ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1296 of file mx.cpp.

                            {
     return x->get_norm_1();
   }

References casadi::MXNode::get_norm_1().

◆ norm_2()

MX casadi::MX::norm_2 ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1284 of file mx.cpp.

                            {
     if (x.is_vector()) {
       return norm_fro(x);
     } else {
       return x->get_norm_2();
     }
   }

References casadi::MXNode::get_norm_2(), casadi::GenericMatrix< MatType >::is_vector(), and norm_fro().

◆ norm_fro()

MX casadi::MX::norm_fro ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1292 of file mx.cpp.

                              {
     return x->get_norm_fro();
   }

References casadi::MXNode::get_norm_fro().

Referenced by norm_2().

◆ norm_inf()

MX casadi::MX::norm_inf ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1300 of file mx.cpp.

                              {
     return x->get_norm_inf();
   }

References casadi::MXNode::get_norm_inf().

◆ nullspace()

MX casadi::MX::nullspace ( const MX & A )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2159 of file mx.cpp.

                               {
     SX A_sx = SX::sym("A", A.sparsity());
     Function f("nullspace", {A_sx}, {SX::nullspace(A_sx)});
     return f(A).at(0);
   }

References casadi::Matrix< Scalar >::nullspace(), sparsity(), and casadi::GenericMatrix< Matrix< Scalar > >::sym().

◆ numel()

casadi_int casadi::GenericMatrix< MX >::numel

inherited

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

Definition at line 104 of file generic_matrix.hpp.

                                                  {
     return sparsity().numel();
   }

◆ nz() [1/2]

NonZeros<MX , K> casadi::GenericMatrix< MX >::nz ( const K & k )

inlineinherited

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

Definition at line 258 of file generic_matrix.hpp.

                                         {
       return NonZeros<MatType, K>(self(), k);
     }

◆ nz() [2/2]

const MX casadi::GenericMatrix< MX >::nz ( const K & k ) const

inlineinherited

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

Definition at line 248 of file generic_matrix.hpp.

                                        {
       MatType ret;
       self().get_nz(ret, false, k);
       return ret;
     }

◆ nzref()

MX casadi::MX::nzref	(	const Sparsity &	sp,
		const std::vector< casadi_int > &	nz
	)		const

Intended for writing unittests

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

Definition at line 149 of file mx.cpp.

                                                                         {
     return (*this)->get_nzref(sp, nz);
   }

References casadi::MXNode::get_nzref(), and casadi::GenericMatrix< MX >::nz().

◆ ones() [1/3]

static MX casadi::GenericMatrix< MX >::ones	(	casadi_int	nrow = `1`,
		casadi_int	ncol = `1`
	)

inlinestaticinherited

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

Definition at line 1302 of file generic_matrix.hpp.

                                                               {
       return ones(Sparsity::dense(nrow, ncol));
     }

◆ ones() [2/3]

static MX casadi::GenericMatrix< MX >::ones ( const Sparsity & sp )

inlinestaticinherited

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

Definition at line 1305 of file generic_matrix.hpp.

1305 { return MatType(sp, 1, false);}

◆ ones() [3/3]

static MX casadi::GenericMatrix< MX >::ones ( const std::pair< casadi_int, casadi_int > & rc )

inlinestaticinherited

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

Definition at line 1306 of file generic_matrix.hpp.

                                                                    {
       return ones(rc.first, rc.second);
     }

◆ op()

casadi_int casadi::MX::op ( ) const

Definition at line 851 of file mx.cpp.

                           {
     return (*this)->op();
   }

Referenced by casadi::UnaryMX::_get_binary(), binary(), cse(), extract(), extract_parametric(), forward(), casadi::MXNode::get_binary(), interpn_linear(), is_commutative(), is_doubled(), is_op(), is_transpose(), casadi::MXFunction::MXFunction(), reset_dump_count(), reverse(), and unary().

◆ operator double()

casadi::MX::operator double ( ) const

explicit

Definition at line 835 of file mx.cpp.

                             {
     return (*this)->to_double();
   }

References casadi::MXNode::to_double().

◆ operator Matrix< double >()

casadi::MX::operator Matrix< double > ( ) const

explicit

◆ operator()() [1/4]

SubIndex<MX , RR> casadi::GenericMatrix< MX >::operator() ( const RR & rr )

inlineinherited

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

Definition at line 286 of file generic_matrix.hpp.

                                                    {
       return SubIndex<MatType, RR>(self(), rr);
     }

◆ operator()() [2/4]

const MX casadi::GenericMatrix< MX >::operator() ( const RR & rr ) const

inlineinherited

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

Definition at line 266 of file generic_matrix.hpp.

                                                  {
       MatType ret;
       self().get(ret, false, rr);
       return ret;
     }

◆ operator()() [3/4]

SubMatrix<MX , RR, CC> casadi::GenericMatrix< MX >::operator()	(	const RR &	rr,
		const CC &	cc
	)

inlineinherited

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

Definition at line 294 of file generic_matrix.hpp.

                                                                       {
       return SubMatrix<MatType, RR, CC>(self(), rr, cc);
     }

◆ operator()() [4/4]

const MX casadi::GenericMatrix< MX >::operator()	(	const RR &	rr,
		const CC &	cc
	)		const

inlineinherited

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

Definition at line 276 of file generic_matrix.hpp.

                                                                {
       MatType ret;
       self().get(ret, false, rr, cc);
       return ret;
     }

◆ operator+()

MX casadi::MX::operator+ ( ) const

inline

Definition at line 247 of file mx.hpp.

247 { return *this; }

◆ operator-()

MX casadi::MX::operator- ( ) const

Definition at line 604 of file mx.cpp.

                          {
     if ((*this)->op()==OP_NEG) {
       return (*this)->dep(0);
     } else {
       return (*this)->get_unary(OP_NEG);
     }
   }

References casadi::MXNode::dep(), casadi::MXNode::get_unary(), and casadi::OP_NEG.

◆ operator->() [1/2]

MXNode * casadi::MX::operator-> ( )

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

Definition at line 568 of file mx.cpp.

                          {
     return static_cast<MXNode*>(SharedObject::operator->());
   }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::operator->().

◆ operator->() [2/2]

const MXNode * casadi::MX::operator-> ( ) const

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

Definition at line 572 of file mx.cpp.

                                      {
     return static_cast<const MXNode*>(SharedObject::operator->());
   }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::operator->().

◆ own()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::own ( Internal * node )

inherited

Assign the node to a node class pointer (or null)

Definition at line 89 of file generic_shared_impl.hpp.

                                                            {
     count_down();
     node = node_;
     count_up();
   }

◆ pinv()

MX casadi::MX::pinv	(	const MX &	A,
		const std::string &	lsolver = `"qr"`,
		const Dict &	dict = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2139 of file mx.cpp.

                                                                      {
     if (A.size1()>=A.size2()) {
       return solve(mtimes(A.T(), A), A.T(), lsolver, dict);
     } else {
       return solve(mtimes(A, A.T()), A, lsolver, dict).T();
     }
   }

References mtimes(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), solve(), and T().

◆ polyval()

MX casadi::MX::polyval	(	const MX &	p,
		const MX &	x
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1489 of file mx.cpp.

                                          {
     casadi_assert(p.is_dense(), "polynomial coefficients vector must be a vector");
     casadi_assert(p.is_column() && p.nnz()>0, "polynomial coefficients must be a vector");
     MX ret = p.nz(0);
     for (casadi_int i=1; i<p.nnz(); ++i) {
       ret = ret*x + p.nz(i);
     }
     return ret;
   }

References casadi::GenericMatrix< MatType >::is_column(), casadi::GenericMatrix< MatType >::is_dense(), casadi::GenericMatrix< MatType >::nnz(), and casadi::GenericMatrix< MatType >::nz().

◆ primitives()

std::vector< MX > casadi::MX::primitives ( ) const

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

Definition at line 962 of file mx.cpp.

                                      {
     std::vector<MX> ret(n_primitives());
     std::vector<MX>::iterator it=ret.begin();
     (*this)->primitives(it);
     casadi_assert_dev(it==ret.end());
     return ret;
   }

References n_primitives().

Referenced by casadi::DaeBuilderInternal::der(), get_nonzeros(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::OptiNode::set_domain(), and casadi::OptiNode::to_function().

◆ print_operator()

std::string casadi::MX::print_operator	(	const MX &	x,
		const std::vector< std::string > &	args
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1499 of file mx.cpp.

                                                                             {
     return x->disp(args);
   }

References casadi::MXNode::disp().

◆ print_ptr()

void casadi::SharedObject::print_ptr ( std::ostream & stream = casadi::uout() ) const

inherited

Print the pointer to the internal class

Definition at line 43 of file shared_object.cpp.

                                                        {
     stream << get();
   }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::get().

◆ printme()

MX casadi::MX::printme ( const MX & b ) const

Definition at line 739 of file mx.cpp.

                                   {
     return binary(OP_PRINTME, *this, b);
   }

References binary(), and casadi::OP_PRINTME.

◆ project()

MX casadi::MX::project	(	const MX &	x,
		const Sparsity &	sp,
		bool	intersect = `false`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 906 of file mx.cpp.

                                                                 {
     try {
       if (x.is_empty() || (sp==x.sparsity())) {
         return x;
       } else {
         casadi_assert(sp.size()==x.size(), "Cannot project " + x.dim() + " to " + sp.dim());
         if (intersect) {
           return x->get_project(sp.intersect(x.sparsity()));
         } else {
           return x->get_project(sp);
         }
       }
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("project", e.what());
     }
   }

References casadi::GenericMatrix< MatType >::dim(), casadi::Sparsity::dim(), casadi::MXNode::get_project(), casadi::Sparsity::intersect(), casadi::GenericMatrix< MatType >::is_empty(), casadi::GenericMatrix< MatType >::size(), casadi::Sparsity::size(), and sparsity().

Referenced by densify(), get(), set(), set_nz(), simplify_const_folding(), and simplify_ref_count().

◆ quadratic_coeff()

void casadi::GenericMatrix< MX >::quadratic_coeff	(	const MX &	expr,
		const MX &	var,
		MX &	A,
		MX &	b,
		MX &	c,
		bool	check
	)

staticinherited

Definition at line 237 of file generic_matrix.hpp.

                                                           {
     casadi_assert(expr.is_scalar(), "'quadratic_coeff' only defined for scalar expressions.");
     A = hessian(expr, var);
     b = substitute(jacobian(expr, var), var, 0).T();
     if (check)
       casadi_assert(!depends_on(A, var), "'quadratic_coeff' called on non-quadratic expression.");
     c = substitute(expr, var, 0);
   }

◆ rank1()

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

staticinherited

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

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

◆ repmat()

MX casadi::MX::repmat	(	const MX &	x,
		casadi_int	n,
		casadi_int	m = `1`
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 2085 of file mx.cpp.

                                                        {
     if (n==0 && m==0) {
       return MX();
     } else if (n==0) {
       return MX(0, x.size2()*m);
     } else if (m==0) {
       return MX(x.size1()*n, 0);
     } else if (n==1 && m==1) {
       return x;
     } else {
       return x->get_repmat(n, m);
     }
   }

References casadi::MXNode::get_repmat(), MX(), casadi::GenericMatrix< MatType >::size1(), and casadi::GenericMatrix< MatType >::size2().

Referenced by binary(), densify(), and set().

◆ repsum() [1/2]

MX casadi::GenericMatrix< MX >::repsum	(	const MX &	x,
		casadi_int	n,
		casadi_int	m = `1`
	)

staticinherited

Definition at line 232 of file generic_matrix.hpp.

                                                                                      {
     casadi_assert_dev(x.size1() % n==0);
     casadi_assert_dev(x.size2() % m==0);
     std::vector< std::vector< MatType> > s =
       blocksplit(x, x.size1()/n, x.size2()/m);
     MatType sum = 0;
     for (casadi_int i=0;i<s.size();++i) {
       for (casadi_int j=0;j<s[i].size();++j) {
         sum = sum + s[i][j];
       }
     }
     return sum;
   }

◆ repsum() [2/2]

MX casadi::MX::repsum	(	const MX &	x,
		casadi_int	n,
		casadi_int	m = `1`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2099 of file mx.cpp.

                                                        {
     return x->get_repsum(n, m);
   }

References casadi::MXNode::get_repsum().

◆ reset_dump_count()

void casadi::MX::reset_dump_count ( )

Definition at line 758 of file mx.cpp.

                             {
     casadi_assert(op()==OP_DUMP, "reset_dump_count: not a dump node");
     static_cast<Dump*>(get())->reset_dump_count();
   }

References get(), op(), and casadi::OP_DUMP.

◆ reset_input()

void casadi::MX::reset_input ( ) const

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

Definition at line 1022 of file mx.cpp.

                              {
     (*this)->reset_input();
   }

◆ reshape() [1/2]

MX casadi::MX::reshape	(	const MX &	x,
		casadi_int	nrow,
		casadi_int	ncol
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1343 of file mx.cpp.

                                                               {
     // Quick return if trivial
     if (nrow==x.size1() && ncol==x.size2()) return x;
  
     // Reshape the sparsity pattern
     return reshape(x, Sparsity::reshape(x.sparsity(), nrow, ncol));
   }

References casadi::Sparsity::reshape(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), and sparsity().

Referenced by MX().

◆ reshape() [2/2]

MX casadi::MX::reshape	(	const MX &	x,
		const Sparsity &	sp
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1351 of file mx.cpp.

                                                 {
     casadi_assert(sp.is_reshape(x.sparsity()), "Reshape mismatch");
  
     // Quick return if trivial
     if (sp==x.sparsity()) return x;
  
     // Call internal method
     return x->get_reshape(sp);
   }

References casadi::MXNode::get_reshape(), casadi::Sparsity::is_reshape(), and sparsity().

◆ reverse()

std::vector< std::vector< MX > > casadi::MX::reverse	(	const std::vector< MX > &	ex,
		const std::vector< MX > &	arg,
		const std::vector< std::vector< MX > > &	v,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1980 of file mx.cpp.

                                                                     {
     try {
       // Read options
       bool always_inline = true;
       bool never_inline = false;
  
  
       Dict h_opts;
       Dict opts_remainder = extract_from_dict(opts, "helper_options", h_opts);
       h_opts["allow_free"] = true;
  
       for (auto&& op : opts_remainder) {
         if (op.first=="always_inline") {
           always_inline = op.second;
         } else if (op.first=="never_inline") {
           never_inline = op.second;
         } else {
           casadi_error("No such option: " + std::string(op.first));
         }
       }
       // Call internal function on a temporary object
       Function temp("reverse_temp", arg, ex, h_opts);
       std::vector<std::vector<MX> > ret;
       temp->call_reverse(arg, ex, v, ret, always_inline, never_inline);
       return ret;
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("reverse", e.what());
     }
   }

References casadi::FunctionInternal::call_reverse(), casadi::extract_from_dict(), and op().

Referenced by substitute_inplace().

◆ row() [1/2]

const casadi_int* casadi::GenericMatrix< MX >::row ( ) const

inlineinherited

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

Definition at line 197 of file generic_matrix.hpp.

197 { return sparsity().row(); }

casadi::Sparsity::row

const casadi_int * row() const

Get a reference to row-vector,.

Definition: sparsity.cpp:164

◆ row() [2/2]

casadi_int casadi::GenericMatrix< MX >::row ( casadi_int el ) const

inlineinherited

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

Definition at line 200 of file generic_matrix.hpp.

200 { return sparsity().row(el); }

◆ rows()

casadi_int casadi::GenericMatrix< MX >::rows ( ) const

inlineinherited

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

Definition at line 114 of file generic_matrix.hpp.

114 {return size1();}

◆ separate_linear()

void casadi::MX::separate_linear	(	const MX &	expr,
		const MX &	sym_lin,
		const MX &	sym_const,
		MX &	expr_const,
		MX &	expr_lin,
		MX &	expr_nonlin
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2936 of file mx.cpp.

                                                      {
  
     std::vector<MX> in = {sym_const, sym_lin};
     std::vector<MX> out = {expr};
  
     Function f("f", in, out, {{"live_variables", false},
       {"max_io", 0}, {"allow_free", true}});
     MXFunction *ff = f.get<MXFunction>();
  
     // Each work vector element has (const, lin, nonlin) part
     std::vector< std::array<MX, 3> > w(ff->workloc_.size()-1);
  
   // Split up inputs analogous to symbolic primitives
     std::vector<std::vector<MX> > arg_split(in.size());
     for (casadi_int i=0; i<in.size(); ++i) arg_split[i] = in[i].split_primitives(in[i]);
  
     // Allocate storage for split outputs
     std::array<std::vector<MX>, 3> res_split;
     for (int k=0;k<3;++k) {
       res_split[k].resize(expr.n_primitives());
     }
  
     std::vector<std::array<MX, 3> > arg1, res1;
  
     std::array<MX, 3> res;
  
     // Loop over computational nodes in forward order
     casadi_int alg_counter = 0;
     for (auto it=ff->algorithm_.begin(); it!=ff->algorithm_.end(); ++it, ++alg_counter) {
       if (it->op == OP_INPUT) {
         MX null = MX::zeros(arg_split.at(it->data->ind()).at(it->data->segment()).sparsity());
         w[it->res.front()][0] = null;
         w[it->res.front()][1] = null;
         w[it->res.front()][2] = null;
         w[it->res.front()][it->data->ind()] = arg_split.at(it->data->ind()).at(it->data->segment());
       } else if (it->op==OP_OUTPUT) {
         // Collect the results
         for (int i=0;i<3;++i) {
           res_split.at(i).at(it->data->segment()) = w[it->arg.front()][i];
         }
       } else if (it->op==OP_CONST) {
         // Fetch constant
         w[it->res.front()][0] = it->data;
         w[it->res.front()][1] = MX::zeros(it->data->sparsity());
         w[it->res.front()][2] = MX::zeros(it->data->sparsity());
       } else if (it->op==OP_PARAMETER) {
         // Fetch parameter
         w[it->res.front()][0] = MX::zeros(it->data->sparsity());
         w[it->res.front()][1] = MX::zeros(it->data->sparsity());
         w[it->res.front()][2] = it->data;
       } else {
         // Arguments of the operation
         arg1.resize(it->arg.size());
         for (casadi_int i=0; i<arg1.size(); ++i) {
           casadi_int el = it->arg[i]; // index of the argument
           for (int k=0;k<3;++k) {
             arg1[i][k] = el<0 ? MX(it->data->dep(i).size()) : w[el][k];
           }
         }
  
         // Perform the operation
         res1.clear();
         res1.resize(it->res.size());
         for (casadi_int i=0;i<it->res.size();++i) {
           for (int k=0;k<3;++k) {
             res1[i][k] = MX::zeros(it->data->sparsity());
           }
         }
         it->data->eval_linear(arg1, res1);
  
         // Get the result
         for (casadi_int i=0; i<res1.size(); ++i) {
           casadi_int el = it->res[i]; // index of the output
           for (int k=0;k<3;++k) {
             if (el>=0) w[el][k] = res1[i][k];
           }
         }
       }
     }
  
     // Join split outputs
     for (int k=0;k<3;++k) {
       res[k] = expr.join_primitives(res_split[k]);
     }
     expr_const = res[0];
     expr_lin = res[1];
     expr_nonlin = res[2];
   }

References join_primitives(), MX(), n_primitives(), casadi::OP_CONST, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, split_primitives(), and casadi::GenericMatrix< MX >::zeros().

◆ serialize()

void casadi::MX::serialize ( SerializingStream & s ) const

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

Definition at line 859 of file mx.cpp.

                                                {
     (*this)->serialize(s);
   }

◆ set() [1/7]

void casadi::MX::set	(	const MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	rr
	)

Set a submatrix, single argument

Definition at line 320 of file mx.cpp.

                                                                    {
     // Assert dimensions of assigning matrix
     if (rr.sparsity() != m.sparsity()) {
       if (rr.size() == m.size()) {
         // Remove submatrix to be replaced
         erase(rr.nonzeros(), ind1);
  
         // Find the intersection between rr's and m's sparsity patterns
         Sparsity sp = rr.sparsity() * m.sparsity();
  
         // Project both matrices to this sparsity
         set(project(m, sp), ind1, Matrix<casadi_int>::project(rr, sp));
         return;
       } else if (m.is_scalar()) {
         // m scalar means "set all"
         if (m.is_dense()) {
           set(MX(rr.sparsity(), m), ind1, rr);
         } else {
           set(MX(rr.size()), ind1, rr);
         }
         return;
       } else if (rr.size1() == m.size2() && rr.size2() == m.size1()
                  && std::min(m.size1(), m.size2()) == 1) {
         // m is transposed if necessary
         set(m.T(), ind1, rr);
         return;
       } else {
         // Error otherwise
         casadi_error("Dimension mismatch. lhs is " + str(rr.size())
                      + ", while rhs is " + str(m.size()));
       }
     }
  
     // Dimensions of this
     casadi_int sz1 = size1(), sz2 = size2(), sz = nnz(), nel = numel(), rrsz = rr.nnz();
  
     // Quick return if nothing to set
     if (rrsz==0) return;
  
     // Check bounds
     casadi_assert_in_range(rr.nonzeros(), -nel+ind1, nel+ind1);
  
     // Dense mode
     if (is_dense() && m.is_dense()) {
       set_nz(m, ind1, rr);
       return;
     }
  
     // Construct new sparsity pattern
     std::vector<casadi_int> new_row=sparsity().get_row(), new_col=sparsity().get_col();
     std::vector<casadi_int> nz(rr.nonzeros());
     new_row.reserve(sz+rrsz);
     new_col.reserve(sz+rrsz);
     nz.reserve(rrsz);
     for (std::vector<casadi_int>::iterator i=nz.begin(); i!=nz.end(); ++i) {
       if (ind1) (*i)--;
       if (*i<0) *i += nel;
       new_row.push_back(*i % sz1);
       new_col.push_back(*i / sz1);
     }
     Sparsity sp = Sparsity::triplet(sz1, sz2, new_row, new_col);
  
     // If needed, update pattern
     if (sp != sparsity()) *this = project(*this, sp);
  
     // Find the nonzeros corresponding to rr
     sparsity().get_nz(nz);
  
     // Create a nonzero assignment node
     *this = m->get_nzassign(*this, nz);
   }

◆ set() [2/7]

void casadi::MX::set	(	const MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	rr,
		const Matrix< casadi_int > &	cc
	)

Set a submatrix, two arguments

Definition at line 251 of file mx.cpp.

                                                                                                  {
     // Row vector rr (e.g. in MATLAB) is transposed to column vector
     if (rr.size1()==1 && rr.size2()>1) {
       set(m, ind1, rr.T(), cc);
       return;
     }
  
     // Row vector cc (e.g. in MATLAB) is transposed to column vector
     if (cc.size1()==1 && cc.size2()>1) {
       set(m, ind1, rr, cc.T());
       return;
     }
  
     // Make sure rr and cc are dense vectors
     casadi_assert(rr.is_dense() && rr.is_column(),
       "MX::set: First index not dense vector");
     casadi_assert(cc.is_dense() && cc.is_column(),
       "MX::set: Second index not dense vector");
  
     // Assert dimensions of assigning matrix
     if (rr.size1() != m.size1() || cc.size1() != m.size2()) {
       if (m.is_scalar()) {
         // m scalar means "set all"
         set(repmat(m, rr.size1(), cc.size1()), ind1, rr, cc);
         return;
       } else if (rr.size1() == m.size2() && cc.size1() == m.size1()
                  && std::min(m.size1(), m.size2()) == 1) {
         // m is transposed if necessary
         set(m.T(), ind1, rr, cc);
         return;
       } else {
         // Error otherwise
         casadi_error("Dimension mismatch. lhs is " + str(rr.size1()) + "-by-"
                      + str(cc.size1()) + ", while rhs is " + str(m.size()));
       }
     }
  
     // Dimensions
     casadi_int sz1 = size1(), sz2 = size2();
  
     // Report out-of-bounds
     casadi_assert_in_range(rr.nonzeros(), -sz1+ind1, sz1+ind1);
     casadi_assert_in_range(cc.nonzeros(), -sz2+ind1, sz2+ind1);
  
     // If we are assigning with something sparse, first remove existing entries
     if (!m.is_dense()) {
       erase(rr.nonzeros(), cc.nonzeros(), ind1);
     }
  
     // Collect all assignments
     IM el = IM::zeros(m.sparsity());
     for (casadi_int j=0; j<el.size2(); ++j) { // Loop over columns of m
       casadi_int this_j = cc->at(j) - ind1; // Corresponding column in this
       if (this_j<0) this_j += sz2;
       for (casadi_int k=el.colind(j); k<el.colind(j+1); ++k) { // Loop over rows of m
         casadi_int i = m.row(k);
         casadi_int this_i = rr->at(i) - ind1; // Corresponding row in this
         if (this_i<0) this_i += sz1;
         el->at(k) = this_i + this_j*sz1;
       }
     }
     set(m, false, el);
   }

◆ set() [3/7]

void casadi::MX::set	(	const MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	rr,
		const Slice &	cc
	)

Set a submatrix, two arguments

Definition at line 246 of file mx.cpp.

                                                                                     {
     // Fall back on (IM, IM)
     set(m, ind1, rr, cc.all(size2(), ind1));
   }

References casadi::Slice::all(), set(), and casadi::GenericMatrix< MX >::size2().

◆ set() [4/7]

void casadi::MX::set	(	const MX &	m,
		bool	ind1,
		const Slice &	rr
	)

Set a submatrix, single argument

Definition at line 315 of file mx.cpp.

                                                       {
     // Fall back on IM
     set(m, ind1, rr.all(size1(), ind1));
   }

References casadi::Slice::all(), and casadi::GenericMatrix< MX >::size1().

Referenced by set().

◆ set() [5/7]

void casadi::MX::set	(	const MX &	m,
		bool	ind1,
		const Slice &	rr,
		const Matrix< casadi_int > &	cc
	)

Set a submatrix, two arguments

Definition at line 241 of file mx.cpp.

                                                                                     {
     // Fall back on (IM, IM)
     set(m, ind1, rr.all(size1(), ind1), cc);
   }

References casadi::Slice::all(), set(), and casadi::GenericMatrix< MX >::size1().

◆ set() [6/7]

void casadi::MX::set	(	const MX &	m,
		bool	ind1,
		const Slice &	rr,
		const Slice &	cc
	)

Set a submatrix, two arguments

Definition at line 236 of file mx.cpp.

                                                                        {
     // Fall back on (IM, IM)
     set(m, ind1, rr.all(size1(), ind1), cc.all(size2(), ind1));
   }

References casadi::Slice::all(), set(), casadi::GenericMatrix< MX >::size1(), and casadi::GenericMatrix< MX >::size2().

◆ set() [7/7]

void casadi::MX::set	(	const MX &	m,
		bool	ind1,
		const Sparsity &	sp
	)

Set a submatrix, single argument

Definition at line 392 of file mx.cpp.

                                                          {
     casadi_assert(size()==sp.size(),
       "set(Sparsity sp): shape mismatch. This matrix has shape "
       + str(size()) + ", but supplied sparsity index has shape "
       + str(sp.size()) + ".");
     std::vector<casadi_int> ii = sp.find();
     if (m.is_scalar()) {
       (*this)(ii) = densify(m);
     } else {
       (*this)(ii) = densify(m(ii));
     }
   }

References densify(), casadi::Sparsity::find(), casadi::GenericMatrix< MatType >::is_scalar(), casadi::GenericMatrix< MX >::size(), casadi::Sparsity::size(), and casadi::str().

◆ set_max_depth()

void casadi::MX::set_max_depth ( casadi_int eq_depth = 1 )

static

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

Definition at line 938 of file mx.cpp.

                                             {
     eq_depth_ = eq_depth;
   }

◆ set_nz() [1/4]

void casadi::MX::set_nz	(	const MX &	m,
		bool	ind1,
		casadi_int	kk
	)

inline

Set a set of nonzeros

Definition at line 589 of file mx.hpp.

589 { set_nz(m, ind1, Matrix<casadi_int>(kk)); }

References set_nz().

Referenced by set_nz().

◆ set_nz() [2/4]

void casadi::MX::set_nz	(	const MX &	m,
		bool	ind1,
		const Matrix< casadi_int > &	kk
	)

Set a set of nonzeros

Definition at line 468 of file mx.cpp.

                                                                       {
     casadi_assert(kk.nnz()==m.nnz() || m.nnz()==1,
       "MX::set_nz: length of non-zero indices (" + str(kk.nnz()) + ") " +
       "must match size of rhs (" + str(m.nnz()) + ").");
  
     // Assert dimensions of assigning matrix
     if (kk.sparsity() != m.sparsity()) {
       if (m.is_scalar()) {
         // m scalar means "set all"
         if (!m.is_dense()) return; // Nothing to set
         set_nz(MX(kk.sparsity(), m), ind1, kk);
         return;
       } else if (kk.size() == m.size()) {
         // Project sparsity if needed
         set_nz(project(m, kk.sparsity()), ind1, kk);
         return;
       } else if (kk.size1() == m.size2() && kk.size2() == m.size1()
                  && std::min(m.size1(), m.size2()) == 1) {
         // m is transposed if necessary
         set_nz(m.T(), ind1, kk);
         return;
       } else {
         // Error otherwise
         casadi_error("Dimension mismatch. lhs is " + str(kk.size())
                      + ", while rhs is " + str(m.size()));
       }
     }
  
     // Call recursively if points both objects point to the same node
     if (this==&m) {
       MX m_copy = m;
       set_nz(m_copy, ind1, kk);
       return;
     }
  
     // Check bounds
     casadi_int sz = nnz();
     casadi_assert_in_range(kk.nonzeros(), -sz+ind1, sz+ind1);
  
     // Quick return if no assignments to be made
     if (kk.nnz()==0) return;
  
     // Handle index-1, negative indices
     if (ind1 || *std::min_element(kk->begin(), kk->end())<0) {
       Matrix<casadi_int> kk_mod = kk;
       for (auto&& i : kk_mod.nonzeros()) {
         casadi_assert(!(ind1 && i<=0),
           "Matlab is 1-based, but requested index " + str(i) + ". "
           "Note that negative slices are disabled in the Matlab interface. "
           "Possibly you may want to use 'end'.");
         if (ind1) i--;
         if (i<0) i += sz;
       }
       set_nz(m, false, kk_mod); // Call recursively
       return;
     }
  
     // Create a nonzero assignment node
     *this = m->get_nzassign(*this, kk.nonzeros());
   }

References casadi::MXNode::get_nzassign(), casadi::GenericMatrix< MatType >::is_dense(), casadi::GenericMatrix< MatType >::is_scalar(), MX(), casadi::GenericMatrix< MX >::nnz(), casadi::GenericMatrix< MatType >::nnz(), casadi::Matrix< Scalar >::nonzeros(), project(), set_nz(), casadi::GenericMatrix< MatType >::size(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), casadi::Matrix< Scalar >::sparsity(), sparsity(), casadi::str(), and T().

◆ set_nz() [3/4]

void casadi::MX::set_nz	(	const MX &	m,
		bool	ind1,
		const MX &	kk
	)

Set a set of nonzeros

Definition at line 529 of file mx.cpp.

                                                       {
     *this = m->get_nzassign(*this, ind1 ? kk-1 : kk);
   }

References casadi::MXNode::get_nzassign().

◆ set_nz() [4/4]

void casadi::MX::set_nz	(	const MX &	m,
		bool	ind1,
		const Slice &	kk
	)

Set a set of nonzeros

Definition at line 463 of file mx.cpp.

                                                          {
     // Fallback on IM
     set_nz(m, ind1, kk.all(nnz(), ind1));
   }

References casadi::Slice::all(), and casadi::GenericMatrix< MX >::nnz().

Referenced by set(), and set_nz().

◆ set_temp()

void casadi::MX::set_temp ( casadi_int t ) const

Definition at line 894 of file mx.cpp.

                                       {
     (*this)->temp = t;
   }

◆ shared()

void casadi::MX::shared	(	std::vector< MX > &	ex,
		std::vector< MX > &	v,
		std::vector< MX > &	vdef,
		const std::string &	v_prefix,
		const std::string &	v_suffix
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1913 of file mx.cpp.

                                                             {
     // Call new, more generic function
     extract(ex, v, vdef, Dict{{"lift_shared", true}, {"lift_calls", false},
       {"prefix", v_prefix}, {"suffix", v_suffix}});
   }

References extract().

◆ simplify()

MX casadi::MX::simplify ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1311 of file mx.cpp.

                              {
     return x;
   }

◆ simplify_combine_terms()

bool casadi::MX::simplify_combine_terms	(	std::vector< MX > &	arg,
		std::vector< MX > &	res,
		const Dict &	opts = `Dict()`
	)

static

Definition at line 1304 of file mx.cpp.

                                                    {
     // No term-combining available for MX; leave the graph untouched
     return false;
   }

◆ simplify_const_folding()

bool casadi::MX::simplify_const_folding	(	std::vector< MX > &	arg,
		std::vector< MX > &	res,
		const Dict &	opts = `Dict()`
	)

static

Definition at line 2388 of file mx.cpp.

                                                 {
     simplify_const_folding_order(arg, res, opts);
     Dict temp_opts = {{"live_variables", false},
                       {"max_io", 0},
                       {"cse", false},
                       {"allow_free", true}};
     Function f("temp", arg, res, temp_opts);
     MXFunction *ff = f.get<MXFunction>();
     const std::vector<casadi_int>& workloc_ = ff->workloc_;
     const auto& algorithm_ = ff->algorithm_;
  
     // Data structures for numeric evaluation
     std::vector<double> w_vec(f.sz_w());
     double* w = get_ptr(w_vec);
     std::vector<casadi_int> iw_vec(f.sz_iw());
     casadi_int* iw = get_ptr(iw_vec);
     std::vector<const double*> arg_num_vec(f.sz_arg());
     const double** arg_num = get_ptr(arg_num_vec);
     std::vector<double*> res_num_vec(f.sz_res());
     double** res_num = get_ptr(res_num_vec);
  
     // Is the work vector entry numeric?
     std::vector<bool> is_numeric(workloc_.size()-1);
  
     // Data structures for symbolic evaluation
  
     // Symbolic work, non-differentiated
     std::vector<MX> swork(workloc_.size()-1);
  
     // Split up inputs analogous to symbolic primitives
     std::vector<std::vector<MX> > arg_split(arg.size());
     for (casadi_int i=0; i<arg.size(); ++i) arg_split[i] = arg[i].split_primitives(arg[i]);
  
     // Allocate storage for split outputs
     std::vector<std::vector<MX> > res_split(res.size());
     for (casadi_int i=0; i<res.size(); ++i) res_split[i].resize(res[i].n_primitives());
  
     std::vector<MX> arg1, res1;
  
     std::unordered_multimap< std::size_t, std::pair<MX, DM> > cache;
  
     bool performed_folding = false;
  
     // Loop over computational nodes in forward order
     for (auto it=algorithm_.begin(); it!=algorithm_.end(); ++it) {
       if (it->op == OP_INPUT) {
         swork[it->res.front()] = project(arg_split.at(it->data->ind()).at(it->data->segment()),
                                           it->data.sparsity(), true);
         is_numeric[it->res.front()] = false;
       } else if (it->op==OP_OUTPUT) {
         // Collect the results
         MX& target = res_split.at(it->data->ind()).at(it->data->segment());
         casadi_int el = it->arg.front();
         if (is_numeric[el] && !it->data->dep().is_constant()) {
           target = get_const(it->data->dep().sparsity(), w + workloc_[el], cache);
         } else {
           target = swork[el];
         }
       } else if (it->op==OP_PARAMETER) {
         // Fetch parameter
         swork[it->res.front()] = it->data;
         is_numeric[it->res.front()] = false;
       } else {
         // Arguments of the operation
         arg1.resize(it->arg.size());
  
         // Is current algel numeric?
         bool numeric = true;
  
         // Loop over algel inputs
         for (casadi_int i=0; i<arg1.size(); ++i) {
           casadi_int el = it->arg[i];
           if (el<0) {
             // Populate arg1 vector
             arg1[i] = MX(it->data->dep(i).size());
           } else {
             // Populate arg1 vector
             arg1[i] = swork[el];
             // Can only be numeric if arguments are
             numeric = numeric && is_numeric[el];
           }
         }
  
         if (numeric) {
           // Set up arg_num and res_num for numerical evaluation
           for (casadi_int i=0; i<it->arg.size(); ++i)
             arg_num[i] = it->arg[i]>=0 ? w+workloc_[it->arg[i]] : nullptr;
           for (casadi_int i=0; i<it->res.size(); ++i)
             res_num[i] = it->res[i]>=0 ? w+workloc_[it->res[i]] : nullptr;
  
           if (it->data->eval(arg_num, res_num, iw, w)) casadi_error("Evaluation error");
           performed_folding = true;
         } else {
           // Prepare for symbolic evaluation
           for (casadi_int i=0; i<arg1.size(); ++i) {
             casadi_int el = it->arg[i];
             if (el>=0) {
               MX& target = arg1[i];
               if (is_numeric[el] && !it->data->dep(i).is_constant()) {
                 target = get_const(it->data->dep(i).sparsity(), w + workloc_[el], cache);
               } else {
                 target = swork[el];
               }
             }
           }
         }
  
         // Perform the operation
         res1.resize(it->res.size());
         it->data->eval_mx(arg1, res1);
  
         // Process results
         for (casadi_int i=0; i<res1.size(); ++i) {
           casadi_int el = it->res[i]; // index of the output
           if (el>=0) {
             swork[el] = res1[i];      // store symbolic result
             is_numeric[el] = numeric; // store flag
           }
         }
       }
     }
  
     // Join split outputs
     for (casadi_int i=0; i<res.size(); ++i) res[i] = res[i].join_primitives(res_split[i]);
  
     return performed_folding;
   }

References casadi::MXFunction::algorithm_, casadi::MXNode::eval_mx(), casadi::Function::get(), casadi::get_const(), casadi::get_ptr(), join_primitives(), MX(), n_primitives(), casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, project(), casadi::simplify_const_folding_order(), split_primitives(), casadi::Function::sz_arg(), casadi::Function::sz_iw(), casadi::Function::sz_res(), casadi::Function::sz_w(), and casadi::MXFunction::workloc_.

◆ simplify_ref_count()

bool casadi::MX::simplify_ref_count	(	std::vector< MX > &	arg,
		std::vector< MX > &	res,
		const Dict &	opts = `Dict()`
	)

static

Definition at line 2518 of file mx.cpp.

                                                 {
     Dict temp_opts = {{"live_variables", false},
                       {"max_io", 0},
                       {"cse", false},
                       {"allow_free", true}};
     Function f("temp", arg, res, temp_opts);
     MXFunction *ff = f.get<MXFunction>();
     const std::vector<casadi_int>& workloc_ = ff->workloc_;
     const auto& algorithm_ = ff->algorithm_;
  
     std::vector<casadi_int> rwork(workloc_.size()-1);
     for (auto it=algorithm_.begin(); it!=algorithm_.end(); ++it) {
       if (it->op == OP_INPUT) {
       } else if (it->op==OP_OUTPUT) {
         rwork[it->arg.front()]++;
       } else if (it->op==OP_PARAMETER) {
         rwork[it->res.front()]++;
       } else {
         for (casadi_int i=0; i<it->arg.size(); ++i) {
           casadi_int el = it->arg[i];
           if (el>=0) {
             rwork[el]++;
           }
         }
       }
     }
  
     // Forward pass
     {
  
       // Symbolic work, non-differentiated
       std::vector<MX> swork(workloc_.size()-1);
  
       // Split up inputs analogous to symbolic primitives
       std::vector<std::vector<MX> > arg_split(arg.size());
       for (casadi_int i=0; i<arg.size(); ++i) arg_split[i] = arg[i].split_primitives(arg[i]);
  
       // Allocate storage for split outputs
       std::vector<std::vector<MX> > res_split(res.size());
       for (casadi_int i=0; i<res.size(); ++i) res_split[i].resize(res[i].n_primitives());
  
       std::vector<MX> arg1, res1;
  
       // Loop over computational nodes in forward order
       for (auto it=algorithm_.begin(); it!=algorithm_.end(); ++it) {
         if (it->op == OP_INPUT) {
           swork[it->res.front()] = project(arg_split.at(it->data->ind()).at(it->data->segment()),
                                             it->data.sparsity(), true);
         } else if (it->op==OP_OUTPUT) {
           // Collect the results
           res_split.at(it->data->ind()).at(it->data->segment()) = swork[it->arg.front()];
         } else if (it->op==OP_PARAMETER) {
           // Fetch parameter
           swork[it->res.front()] = it->data;
         } else {
           // Arguments of the operation
           arg1.resize(it->arg.size());
  
           std::vector<bool> unique(it->arg.size(), true);
           for (casadi_int i=0; i<arg1.size(); ++i) {
             casadi_int el = it->arg[i];
             if (el<0) {
               arg1[i] = MX(it->data->dep(i).size());
             } else {
               arg1[i] = swork[el];
               if (rwork[el]>1) unique[i] = false;
             }
           }
  
           // Perform the operation
           res1.resize(it->res.size());
           it->data->eval_mx(arg1, res1, unique);
  
           // Get the result
           for (casadi_int i=0; i<res1.size(); ++i) {
             casadi_int el = it->res[i]; // index of the output
             if (el>=0) {
               swork[el] = res1[i];
             }
           }
         }
       }
  
       // Join split outputs
       for (casadi_int i=0; i<res.size(); ++i) res[i] = res[i].join_primitives(res_split[i]);
     }
     return true;
   }

References casadi::MXFunction::algorithm_, casadi::Function::get(), join_primitives(), MX(), n_primitives(), casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, project(), split_primitives(), and casadi::MXFunction::workloc_.

◆ size() [1/2]

std::pair< casadi_int, casadi_int > casadi::GenericMatrix< MX >::size

inherited

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

Definition at line 136 of file generic_matrix.hpp.

                                                                      {
     return sparsity().size();
   }

◆ size() [2/2]

casadi_int casadi::GenericMatrix< MX >::size ( casadi_int axis ) const

inherited

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

Definition at line 141 of file generic_matrix.hpp.

                                                                {
     return sparsity().size(axis);
   }

◆ size1()

casadi_int casadi::GenericMatrix< MX >::size1

inherited

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

Definition at line 109 of file generic_matrix.hpp.

                                                  {
     return sparsity().size1();
   }

◆ size2()

casadi_int casadi::GenericMatrix< MX >::size2

inherited

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

Definition at line 119 of file generic_matrix.hpp.

                                                  {
     return sparsity().size2();
   }

◆ skew()

MX casadi::GenericMatrix< MX >::skew ( const MX & a )

staticinherited

Definition at line 228 of file generic_matrix.hpp.

                                                        {
     casadi_assert(a.is_vector() && (a.size1()==3 || a.size2()==3),
       "skew(a): Expecting 3-vector, got " + a.dim() + ".");
  
     MatType x = a(0);
     MatType y = a(1);
     MatType z = a(2);
     return blockcat(std::vector< std::vector<MatType> >({{0, -z, y}, {z, 0, -x}, {-y, x, 0}}));
   }

◆ soc()

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

staticinherited

Functions called by friend functions defined here

◆ solve() [1/2]

MX casadi::MX::solve	(	const MX &	a,
		const MX &	b
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2115 of file mx.cpp.

                                        {
     if (a.is_triu()) {
       // A is upper triangular
       return a->get_solve_triu(b, false);
     } else if (a.is_tril()) {
       // A is lower triangular
       return a->get_solve_tril(b, false);
     } else if (a.sparsity().is_orthonormal()) {
       // A is orthonormal -> inv(A)==A.T
       MX nz = sparsity_cast(a, Sparsity::dense(a.nnz()));
       const Sparsity& Q = a.sparsity();
       return mtimes(MX(Q, 1/nz).T(), b);
     } else {
       // Fall-back to QR factorization
       return solve(a, b, "qr");
     }
   }

References casadi::Sparsity::dense(), casadi::MXNode::get_solve_tril(), casadi::MXNode::get_solve_triu(), casadi::Sparsity::is_orthonormal(), casadi::GenericMatrix< MatType >::is_tril(), casadi::GenericMatrix< MatType >::is_triu(), mtimes(), MX(), casadi::GenericMatrix< MatType >::nnz(), casadi::GenericMatrix< MX >::nz(), casadi::Q, sparsity(), sparsity_cast(), and T().

Referenced by casadi::Nlpsol::get_forward(), casadi::Nlpsol::get_reverse(), inv(), mldivide(), mrdivide(), pinv(), and solve().

◆ solve() [2/2]

MX casadi::MX::solve	(	const MX &	a,
		const MX &	b,
		const std::string &	lsolver,
		const Dict &	dict = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2133 of file mx.cpp.

                                                                                    {
     if (a.sparsity().is_orthonormal()) return solve(a, b);
     Linsol mysolver("tmp_solve", lsolver, a.sparsity(), dict);
     return mysolver.solve(a, b, false);
   }

References casadi::Sparsity::is_orthonormal(), casadi::Linsol::solve(), solve(), and sparsity().

◆ sparsity()

const Sparsity & casadi::MX::sparsity ( ) const

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

Definition at line 612 of file mx.cpp.

                                      {
     return (*this)->sparsity();
   }

Referenced by casadi::MXNode::_get_binary(), casadi::Constant< Value >::_get_binary(), casadi::UnaryMX::_get_binary(), casadi::GetNonzeros::ad_forward(), casadi::SetNonzeros< Add >::ad_forward(), casadi::GetNonzeros::ad_reverse(), casadi::KronContract::ad_reverse(), casadi::Solve< Tr >::ad_reverse(), casadi::SparsityCast::ad_reverse(), casadi::DaeBuilderInternal::add(), casadi::Assertion::Assertion(), casadi::BinaryMX< ScX, ScY >::BinaryMX(), casadi::OptiNode::canon_expr(), casadi::Convexify::Convexify(), casadi::GetNonzerosParam::create(), casadi::SetNonzeros< Add >::create(), casadi::GetNonzeros::create(), cumsum(), densify(), det(), diag(), casadi::Diagsplit::Diagsplit(), casadi::Dot::Dot(), casadi::dplesol(), casadi::Dump::Dump(), enlarge(), erase(), casadi::GetNonzeros::eval_mx(), casadi::SetNonzeros< Add >::eval_mx(), expm(), expm_const(), casadi::MXFunction::export_code_body(), casadi::MXFunction::generate_lifted(), get(), casadi::MXNode::get_binary(), casadi::Variable::get_der(), casadi::MXNode::get_dot(), casadi::Nlpsol::get_forward(), casadi::MXNode::get_kron(), casadi::MXNode::get_kron_contract(), casadi::MXNode::get_mac(), casadi::Project::get_nzref(), casadi::Nlpsol::get_reverse(), casadi::HorzRepmat::HorzRepmat(), casadi::HorzRepsum::HorzRepsum(), casadi::Horzsplit::Horzsplit(), casadi::Scpgen::init(), casadi::Kron::Kron(), casadi::KronContract::KronContract(), lift(), casadi::Onnx::load(), casadi::Low::Low(), matrix_expand(), casadi::Monitor::Monitor(), mtimes(), casadi::Multiplication::Multiplication(), MX(), nullspace(), casadi::Horzcat::off(), casadi::Vertcat::off(), casadi::Diagcat::off(), casadi::DaeBuilderInternal::outputs(), casadi::OptiNode::parameter(), casadi::MXFunction::print_arg(), project(), casadi::Rank1::Rank1(), casadi::register_symbol(), reshape(), set(), set_nz(), casadi::SetNonzeros< Add >::SetNonzeros(), casadi::SetNonzerosParam< Add >::SetNonzerosParam(), casadi::simpleIRK(), solve(), casadi::Solve< Tr >::Solve(), casadi::Bilin::sp_forward(), casadi::KronContract::sp_forward(), casadi::Bilin::sp_reverse(), casadi::KronContract::sp_reverse(), casadi::Project::sp_reverse(), sparsity_cast(), casadi::Transpose::Transpose(), casadi::PseudoDenseMultiplication::try_create(), unite(), casadi::OptiNode::variable(), and casadi::Vertsplit::Vertsplit().

◆ sparsity_cast()

MX casadi::MX::sparsity_cast	(	const MX &	x,
		const Sparsity &	sp
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1361 of file mx.cpp.

                                                       {
     casadi_assert(x.nnz()==sp.nnz(),
       "Mismatching nonzero count: " + str(x.nnz()) + " versus " +
       str(sp.nnz()) + ".");
  
     // Quick return if trivial
     if (sp==x.sparsity()) return x;
  
     // Call internal method
     return x->get_sparsity_cast(sp);
   }

References casadi::MXNode::get_sparsity_cast(), casadi::GenericMatrix< MatType >::nnz(), casadi::Sparsity::nnz(), sparsity(), and casadi::str().

Referenced by solve().

◆ split_primitives() [1/3]

std::vector< DM > casadi::MX::split_primitives ( const DM & x ) const

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

Definition at line 986 of file mx.cpp.

                                                       {
     std::vector<DM> ret(n_primitives());
     std::vector<DM>::iterator it=ret.begin();
     (*this)->split_primitives(x, it);
     casadi_assert_dev(it==ret.end());
     return ret;
   }

References n_primitives().

◆ split_primitives() [2/3]

std::vector< MX > casadi::MX::split_primitives ( const MX & x ) const

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

Definition at line 970 of file mx.cpp.

                                                       {
     std::vector<MX> ret(n_primitives());
     std::vector<MX>::iterator it=ret.begin();
     (*this)->split_primitives(x, it);
     casadi_assert_dev(it==ret.end());
     return ret;
   }

References n_primitives().

Referenced by extract_parametric(), casadi::DaeBuilderInternal::load_fmi_description(), separate_linear(), simplify_const_folding(), and simplify_ref_count().

◆ split_primitives() [3/3]

std::vector< SX > casadi::MX::split_primitives ( const SX & x ) const

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

Definition at line 978 of file mx.cpp.

                                                       {
     std::vector<SX> ret(n_primitives());
     std::vector<SX>::iterator it=ret.begin();
     (*this)->split_primitives(x, it);
     casadi_assert_dev(it==ret.end());
     return ret;
   }

References n_primitives().

◆ sprank()

static casadi_int casadi::GenericMatrix< MX >::sprank ( const MX & x )

inlinestaticinherited

Definition at line 215 of file generic_matrix.hpp.

215 { return Sparsity::sprank(x.sparsity());}

◆ stop_diff() [1/2]

MX casadi::MX::stop_diff	(	const MX &	expr,
		casadi_int	order
	)

static

Functions called by friend functions defined for this class

Definition at line 3027 of file mx.cpp.

                                                    {
     std::vector<MX> s = symvar(expr);
     MX x = veccat(s);
     Dict options;
     options["never_inline"] = true;
  
     Dict inline_options;
     inline_options["never_inline"] = false;
     inline_options["always_inline"] = true;
     Dict der_options = Dict{{"forward_options", inline_options},
       {"reverse_options", inline_options},
       {"jacobian_options", inline_options}};
     if (order==1) {
       options["is_diff_in"] = std::vector<bool>{false};
       options["is_diff_out"] = std::vector<bool>{true};
       options = combine(options, der_options);
     } else if (order==2) {
       options["der_options"] = der_options;
       options["forward_options"] = Dict{{"is_diff_in", std::vector<bool>{false, true, true} },
         {"is_diff_out", std::vector<bool>{true}}};
       options["reverse_options"] = Dict{{"is_diff_in", std::vector<bool>{false, true, true} },
         {"is_diff_out", std::vector<bool>{true}}};
       options["jacobian_options"] = Dict{{"is_diff_in", std::vector<bool>{false, true} },
         {"is_diff_out", std::vector<bool>{false}}};
     } else {
       casadi_error("stop_diff: order must be 1 or 2, got " + str(order) + ".");
     }
  
     Function FS("FS", {x}, {expr}, {"x"}, {"z"}, options);
     return FS(std::vector<MX>{x})[0];
   }

References casadi::combine(), casadi::str(), symvar(), and casadi::SparsityInterface< MatType >::veccat().

◆ stop_diff() [2/2]

MX casadi::MX::stop_diff	(	const MX &	expr,
		const MX &	var,
		casadi_int	order
	)

static

Functions called by friend functions defined for this class

Definition at line 3059 of file mx.cpp.

                                                                   {
     casadi_warning("stop_diff(expr, var, order) is not well tested.");
     std::vector<MX> xv = symvar(var);
     std::vector<MX> s = symvar(expr);
     std::vector<MX> yv = difference(s, xv);
  
     MX x = veccat(xv);
     MX y = veccat(yv);
  
     Dict options;
     options["never_inline"] = true;
  
     Dict inline_options;
     inline_options["never_inline"] = false;
     inline_options["always_inline"] = true;
     Dict der_options = Dict{{"forward_options", inline_options},
       {"reverse_options", inline_options},
       {"jacobian_options", inline_options}};
     if (order==1) {
       options["is_diff_in"] = std::vector<bool>{false, true};
       options["is_diff_out"] = std::vector<bool>{true};
       options = combine(options, der_options);
     } else if (order==2) {
       options["der_options"] = der_options;
       options["forward_options"] = Dict{{"is_diff_in",
         std::vector<bool>{false, true, false, true, true} },
         {"is_diff_out", std::vector<bool>{true}}};
       options["reverse_options"] = Dict{{"is_diff_in",
         std::vector<bool>{false, true, false, true}},
         {"is_diff_out", std::vector<bool>{false, true}}};
       options["jacobian_options"] = Dict{{"is_diff_in", std::vector<bool>{false, true, true}},
         {"is_diff_out", std::vector<bool>{true}}};
     } else {
       casadi_error("stop_diff: order must be 1 or 2, got " + str(order) + ".");
     }
  
     Function FS("FS", {x, y}, {expr}, {"x", "y"}, {"z"}, options);
     return FS(std::vector<MX>{x, y})[0];
   }

References casadi::combine(), difference(), casadi::str(), symvar(), and casadi::SparsityInterface< MatType >::veccat().

◆ substitute() [1/2]

MX casadi::MX::substitute	(	const MX &	ex,
		const MX &	v,
		const MX &	vdef
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1525 of file mx.cpp.

                                                              {
     return substitute(std::vector<MX>{ex}, std::vector<MX>{v}, std::vector<MX>{vdef}).front();
   }

Referenced by casadi::DaeBuilderInternal::transition().

◆ substitute() [2/2]

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

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1529 of file mx.cpp.

                                                             {
     // Assert consistent dimensions
     casadi_assert_dev(v.size()==vdef.size());
  
     // Quick return if all equal
     bool all_equal = true;
     for (casadi_int k=0; k<v.size(); ++k) {
       if (v[k].size()!=vdef[k].size() || !is_equal(v[k], vdef[k])) {
         all_equal = false;
         break;
       }
     }
     if (all_equal) return ex;
  
     // Otherwise, evaluate symbolically
     Function F("tmp_substitute", v, ex, Dict{{"max_io", 0}, {"allow_free", true}});
     std::vector<MX> ret;
     F.call(vdef, ret, true);
     return ret;
   }

References casadi::Function::call(), is_equal(), and casadi::GenericMatrix< MX >::size().

◆ substitute_inplace()

void casadi::MX::substitute_inplace	(	const std::vector< MX > &	v,
		std::vector< MX > &	vdef,
		std::vector< MX > &	ex,
		bool	reverse
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1503 of file mx.cpp.

                                                               {
     casadi_assert(v.size()==vdef.size(),
                           "Mismatch in the number of expression to substitute.");
     for (casadi_int k=0; k<v.size(); ++k) {
       casadi_assert(v[k].is_symbolic(),
         "Variable " + str(k) + " is not symbolic");
       casadi_assert(v[k].size() == vdef[k].size(),
         "Inconsistent shape for variable " + str(k) + ".");
     }
     casadi_assert(reverse==false, "Not implemented");
  
     // quick return if nothing to replace
     if (v.empty()) return;
  
     // implemented in MXFunction
     std::vector<MX> f_out = vdef;
     f_out.insert(f_out.end(), ex.begin(), ex.end());
     Function temp("tmp_substitute_inplace", {v}, f_out, Dict{{"max_io", 0}, {"allow_free", true}});
     temp.get<MXFunction>()->substitute_inplace(vdef, ex);
   }

References casadi::Function::get(), is_symbolic(), reverse(), casadi::GenericMatrix< MX >::size(), and casadi::str().

◆ sum1()

MX casadi::MX::sum1 ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1485 of file mx.cpp.

                          {
     return mtimes(MX::ones(1, x.size1()), x);
   }

References mtimes(), casadi::GenericMatrix< MX >::ones(), and casadi::GenericMatrix< MatType >::size1().

◆ sum2()

MX casadi::MX::sum2 ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1481 of file mx.cpp.

                          {
     return mtimes(x, MX::ones(x.size2(), 1));
   }

References mtimes(), casadi::GenericMatrix< MX >::ones(), and casadi::GenericMatrix< MatType >::size2().

◆ sumsqr()

static MX casadi::GenericMatrix< MX >::sumsqr ( const MX & x )

inlinestaticinherited

Definition at line 225 of file generic_matrix.hpp.

225 { return dot(x, x);}

casadi::GenericMatrix< MX >::dot

friend MX dot(const MX &x, const MX &y)

Inner product of two matrices.

Definition: generic_matrix.hpp:573

◆ swap()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::swap ( GenericShared< SharedObject, SharedObjectInternal > & other )

inherited

Definition at line 105 of file generic_shared_impl.hpp.

                                                                  {
     GenericShared<Shared, Internal> temp = *this;
     *this = other;
     other = temp;
   }

◆ sym() [1/7]

static std::vector<MX > casadi::GenericMatrix< MX >::sym	(	const std::string &	name,
		casadi_int	nrow,
		casadi_int	ncol,
		casadi_int	p
	)

inlinestaticinherited

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

Definition at line 1261 of file generic_matrix.hpp.

                                        {
       return sym(name, Sparsity::dense(nrow, ncol), p);
     }

◆ sym() [2/7]

static std::vector<std::vector<MX > > casadi::GenericMatrix< MX >::sym	(	const std::string &	name,
		casadi_int	nrow,
		casadi_int	ncol,
		casadi_int	p,
		casadi_int	r
	)

inlinestaticinherited

with nrow-by-ncol symbolic primitives

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

Definition at line 1280 of file generic_matrix.hpp.

                                                                                                {
       return sym(name, Sparsity::dense(nrow, ncol), p, r);
     }

◆ sym() [3/7]

static MX casadi::GenericMatrix< MX >::sym	(	const std::string &	name,
		casadi_int	nrow = `1`,
		casadi_int	ncol = `1`
	)

inlinestaticinherited

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

Definition at line 1233 of file generic_matrix.hpp.

                                                                                     {
       return sym(name, Sparsity::dense(nrow, ncol));
     }

◆ sym() [4/7]

static MX casadi::GenericMatrix< MX >::sym	(	const std::string &	name,
		const Sparsity &	sp
	)

inlinestaticinherited

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

Definition at line 1247 of file generic_matrix.hpp.

                                                                   {
       return MatType::_sym(name, sp);
     }

◆ sym() [5/7]

std::vector< MX > casadi::GenericMatrix< MX >::sym	(	const std::string &	name,
		const Sparsity &	sp,
		casadi_int	p
	)

staticinherited

with symbolic primitives of given sparsity

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

Definition at line 1256 of file generic_matrix.hpp.

                                                                                      {
     std::vector<MatType> ret(p);
     std::stringstream ss;
     for (casadi_int k=0; k<p; ++k) {
       ss.str("");
       ss << name << k;
       ret[k] = sym(ss.str(), sp);
     }
     return ret;
   }

◆ sym() [6/7]

std::vector< std::vector< MX > > casadi::GenericMatrix< MX >::sym	(	const std::string &	name,
		const Sparsity &	sp,
		casadi_int	p,
		casadi_int	r
	)

staticinherited

symbolic primitives with given sparsity

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

Definition at line 1272 of file generic_matrix.hpp.

                                                                                 {
     std::vector<std::vector<MatType> > ret(r);
     for (casadi_int k=0; k<r; ++k) {
       std::stringstream ss;
       ss << name << "_" << k;
       ret[k] = sym(ss.str(), sp, p);
     }
     return ret;
   }

◆ sym() [7/7]

static MX casadi::GenericMatrix< MX >::sym	(	const std::string &	name,
		const std::pair< casadi_int, casadi_int > &	rc
	)

inlinestaticinherited

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

Definition at line 1240 of file generic_matrix.hpp.

                                                                                          {
       return sym(name, rc.first, rc.second);
     }

◆ symvar()

std::vector< MX > casadi::MX::symvar ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2041 of file mx.cpp.

                                       {
     Function f("f", std::vector<MX>{}, {x}, {{"allow_free", true}});
     return f.free_mx();
   }

References casadi::Function::free_mx().

Referenced by conditional(), if_else(), matrix_expand(), casadi::OptiNode::set_initial(), casadi::OptiNode::set_linear_scale(), casadi::OptiNode::set_value(), stop_diff(), casadi::OptiNode::symvar(), transform(), and casadi::OptiNode::update_user_dict().

◆ T()

MX casadi::MX::T ( ) const

Definition at line 1095 of file mx.cpp.

                  {
     return (*this)->get_transpose();
   }

References casadi::MXNode::get_transpose().

Referenced by casadi::Determinant::ad_forward(), casadi::Solve< Tr >::ad_forward(), casadi::BSplineCommon::ad_reverse(), casadi::Determinant::ad_reverse(), casadi::Inverse::ad_reverse(), casadi::BSplineInterpolant::construct_graph(), cumsum(), casadi::do_inline(), casadi::LinearInterpolant::do_inline(), casadi::get_boor(), casadi::MXNode::get_find(), casadi::Dple::get_forward(), casadi::Expm::get_reverse(), casadi::Nlpsol::get_reverse(), casadi::SqicInterface::init(), mrdivide(), pinv(), casadi::Call::projectArg(), set(), set_nz(), solve(), vertcat(), and vertsplit().

◆ tangent()

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

staticinherited

Functions called by friend functions defined here

◆ test_cast()

bool casadi::MX::test_cast ( const SharedObjectInternal * ptr )

static

Definition at line 1099 of file mx.cpp.

                                                     {
     return dynamic_cast<const MXNode*>(ptr)!=nullptr;
   }

◆ trace()

MX casadi::MX::trace ( const MX & x )

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1455 of file mx.cpp.

                           {
     casadi_assert(x.is_square(), "trace: must be square");
     MX res(0);
     for (casadi_int i=0; i < x.size2(); i ++) {
       res += x(i, i);
     }
     return res;
   }

References casadi::GenericMatrix< MatType >::is_square(), and casadi::GenericMatrix< MatType >::size2().

◆ transform() [1/4]

MX casadi::MX::transform	(	const MX &	x,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1315 of file mx.cpp.

                                                 {
     return transform(std::vector<MX>{x}, opts).at(0);
   }

Referenced by transform().

◆ transform() [2/4]

MX casadi::MX::transform	(	const MX &	x,
		const std::vector< std::vector< GenericType > > &	passes,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1319 of file mx.cpp.

                                                                           {
     return transform(std::vector<MX>{x}, passes, opts).at(0);
   }

References transform().

◆ transform() [3/4]

std::vector< MX > casadi::MX::transform	(	const std::vector< MX > &	x,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1324 of file mx.cpp.

                                                                       {
     // Route through Function::transform; inputs are the free variables across all of x
     std::vector<MX> arg = symvar(veccat(x));
     Function f("transform", arg, x,
                {{"allow_free", true}, {"allow_duplicate_io_names", true}});
     f = f.transform(opts);
     return f(arg);
   }

References symvar(), casadi::Function::transform(), and casadi::SparsityInterface< MatType >::veccat().

◆ transform() [4/4]

std::vector< MX > casadi::MX::transform	(	const std::vector< MX > &	x,
		const std::vector< std::vector< GenericType > > &	passes,
		const Dict &	opts = `Dict()`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1333 of file mx.cpp.

                                                                           {
     // Route through Function::transform; inputs are the free variables across all of x
     std::vector<MX> arg = symvar(veccat(x));
     Function f("transform", arg, x,
                {{"allow_free", true}, {"allow_duplicate_io_names", true}});
     f = f.transform(passes, opts);
     return f(arg);
   }

References symvar(), casadi::Function::transform(), and casadi::SparsityInterface< MatType >::veccat().

◆ tril()

static MX casadi::GenericMatrix< MX >::tril	(	const MX &	x,
		bool	includeDiagonal = `true`
	)

inlinestaticinherited

Definition at line 219 of file generic_matrix.hpp.

                                                                      {
       return project(x, Sparsity::tril(x.sparsity(), includeDiagonal));
     }

◆ tril2symm()

MX casadi::GenericMatrix< MX >::tril2symm ( const MX & x )

staticinherited

Definition at line 230 of file generic_matrix.hpp.

                                                             {
     casadi_assert(x.is_square(),
       "Shape error in tril2symm. Expecting square shape but got " + x.dim());
     casadi_assert(x.nnz_upper()-x.nnz_diag()==0,
       "Sparsity error in tril2symm. Found above-diagonal entries in argument: " + x.dim());
     return x +  x.T() - diag(diag(x));
   }

◆ triu()

static MX casadi::GenericMatrix< MX >::triu	(	const MX &	x,
		bool	includeDiagonal = `true`
	)

inlinestaticinherited

Definition at line 222 of file generic_matrix.hpp.

                                                                      {
       return project(x, Sparsity::triu(x.sparsity(), includeDiagonal));
     }

◆ triu2symm()

MX casadi::GenericMatrix< MX >::triu2symm ( const MX & x )

staticinherited

Definition at line 231 of file generic_matrix.hpp.

                                                             {
     casadi_assert(x.is_square(),
       "Shape error in triu2symm. Expecting square shape but got " + x.dim());
     casadi_assert(x.nnz_lower()-x.nnz_diag()==0,
       "Sparsity error in triu2symm. Found below-diagonal entries in argument: " + x.dim());
     return x + x.T() - diag(diag(x));
   }

◆ type_name()

static std::string casadi::MX::type_name ( )

inlinestatic

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

Definition at line 97 of file mx.hpp.

97 {return "MX";}

◆ unary()

MX casadi::MX::unary	(	casadi_int	op,
		const MX &	x,
		bool	unique = `false`
	)

static

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

Definition at line 560 of file mx.cpp.

                                                       {
     return x->get_unary(Operation(op), unique);
   }

References casadi::MXNode::get_unary(), and op().

Referenced by casadi::UnaryMX::eval_mx().

◆ unite()

MX casadi::MX::unite	(	const MX &	A,
		const MX &	B
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 1429 of file mx.cpp.

                                        {
     // Join the sparsity patterns
     std::vector<unsigned char> mapping;
     Sparsity sp = A.sparsity().unite(B.sparsity(), mapping);
  
     // Split up the mapping
     std::vector<casadi_int> nzA, nzB;
  
     // Copy sparsity
     for (casadi_int k=0; k<mapping.size(); ++k) {
       if (mapping[k]==1) {
         nzA.push_back(k);
       } else if (mapping[k]==2) {
         nzB.push_back(k);
       } else {
         throw CasadiException("Pattern intersection not empty");
       }
     }
  
     // Create mapping
     MX ret = MX::zeros(sp);
     ret = A->get_nzassign(ret, nzA);
     ret = B->get_nzassign(ret, nzB);
     return ret;
   }

References casadi::MXNode::get_nzassign(), mapping(), casadi::GenericMatrix< MatType >::size(), casadi::GenericMatrix< MatType >::sparsity(), sparsity(), casadi::Sparsity::unite(), and casadi::GenericMatrix< MX >::zeros().

◆ vertcat()

MX casadi::MX::vertcat ( const std::vector< MX > & x )

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1165 of file mx.cpp.

                                        {
     // Check dimensions
     if (x.size()>1) {
       std::vector<MX> ne = trim_empty(x, true);
       for (casadi_int i=0;i<ne.size();i++) {
         casadi_assert(ne[i].size2()==ne[0].size2(),
           "vertcat dimension mismatch  x[" + str(i) + "]:" + ne[i].dim() +
           " and x[0]: " + ne[0].dim() + ".");
       }
     }
  
     if (x.empty()) {
       return MX(0, 1);
     } else if (x.size()==1) {
       return x.front();
     } else if (has_empty(x)) {
       std::vector<MX> ret = trim_empty(x);
       if (ret.empty()) {
         // We still want vertcat(zeros(5,0),zeros(5,0)) -> zeros(10,0)
         ret = trim_empty(x, true);
         casadi_int s = 0;
         casadi_int ncol = 0;
         for (casadi_int i=0;i<ret.size();++i) {
           s+= ret[i].size1();
           casadi_assert_dev(ncol==0 || ret[i].size2()==ncol);
           ncol = ret[i].size2();
         }
         return MX::zeros(s, ncol);
       } else {
         return vertcat(ret);
       }
     } else if (!x.front().is_column()) {
       // Vertcat operation only supports vectors, rewrite using horzcat
       std::vector<MX> xT = x;
       for (std::vector<MX>::iterator i=xT.begin(); i!=xT.end(); ++i) *i = i->T();
       return horzcat(xT).T();
     } else {
       return x.front()->get_vertcat(x);
     }
   }

References casadi::GenericMatrix< MX >::dim(), casadi::MXNode::get_vertcat(), casadi::has_empty(), horzcat(), MX(), casadi::GenericExpression< MX >::ne(), casadi::GenericMatrix< MatType >::size(), casadi::GenericMatrix< MX >::size2(), casadi::str(), T(), casadi::trim_empty(), and casadi::GenericMatrix< MX >::zeros().

Referenced by blockcat(), casadi::Nlpsol::get_forward(), casadi::Nlpsol::get_reverse(), casadi::Blocksqp::init(), and linspace().

◆ vertsplit()

std::vector< MX > casadi::MX::vertsplit	(	const MX &	x,
		const std::vector< casadi_int > &	offset
	)

static

Functions called by friend functions defined for SparsityInterface

Definition at line 1240 of file mx.cpp.

                                                                               {
     if (x.is_column()) {
       // Consistency check
       casadi_assert_dev(!offset.empty());
       casadi_assert_dev(offset.front()==0);
       casadi_assert_dev(offset.back()==x.size1());
       casadi_assert_dev(is_monotone(offset));
  
       // Trivial return if possible
       if (offset.size()==1) {
         return std::vector<MX>();
       } else if (offset.size()==2) {
         return std::vector<MX>(1, x);
       } else {
         return x->get_vertsplit(offset);
       }
     } else {
       std::vector<MX> ret = horzsplit(x.T(), offset);
       for (auto&& e : ret) e = e.T();
       return ret;
     }
   }

References casadi::MXNode::get_vertsplit(), horzsplit(), casadi::GenericMatrix< MatType >::is_column(), casadi::is_monotone(), casadi::SparsityInterface< MatType >::offset(), casadi::GenericMatrix< MatType >::size1(), and T().

◆ weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericShared< SharedObject , SharedObjectInternal >::weak

inherited

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

Definition at line 130 of file generic_shared_impl.hpp.

                                                                           {
     return (*this)->weak();
   }

◆ which_depends()

std::vector< bool > casadi::MX::which_depends	(	const MX &	expr,
		const MX &	var,
		casadi_int	order = `1`,
		bool	tr = `false`
	)

static

Functions called by friend functions defined for GenericMatrix

Definition at line 2012 of file mx.cpp.

                                                                                             {
     return _which_depends(expr, var, order, tr);
   }

References casadi::_which_depends().

◆ which_function()

Function casadi::MX::which_function ( ) const

Definition at line 807 of file mx.cpp.

                                     {
     return (*this)->which_function();
   }

Referenced by casadi::DaeBuilderInternal::create(), cse(), casadi::Onnx::load(), and casadi::BlazingSplineFunction::merge().

◆ which_output()

casadi_int casadi::MX::which_output ( ) const

Definition at line 819 of file mx.cpp.

                                     {
     return (*this)->which_output();
   }

Referenced by casadi::DaeBuilderInternal::create(), cse(), and casadi::DaeBuilderInternal::jac_vdef_v_from_calls().

◆ zeros() [1/3]

static MX casadi::GenericMatrix< MX >::zeros	(	casadi_int	nrow = `1`,
		casadi_int	ncol = `1`
	)

inlinestaticinherited

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

Definition at line 1289 of file generic_matrix.hpp.

                                                                {
       return zeros(Sparsity::dense(nrow, ncol));
     }

◆ zeros() [2/3]

static MX casadi::GenericMatrix< MX >::zeros ( const Sparsity & sp )

inlinestaticinherited

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

Definition at line 1292 of file generic_matrix.hpp.

1292 { return MatType(sp, 0, false);}

◆ zeros() [3/3]

static MX casadi::GenericMatrix< MX >::zeros ( const std::pair< casadi_int, casadi_int > & rc )

inlinestaticinherited

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

Definition at line 1293 of file generic_matrix.hpp.

                                                                     {
       return zeros(rc.first, rc.second);
     }

The documentation for this class was generated from the following files:

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Private Member Functions

Friends

Member Typedef Documentation

◆ B

◆ base_type

◆ internal_base_type

◆ MXDict

◆ ScalarType

Constructor & Destructor Documentation

◆ MX() [1/11]

◆ MX() [2/11]

◆ MX() [3/11]

◆ MX() [4/11]

◆ MX() [5/11]

◆ MX() [6/11]

◆ MX() [7/11]

◆ MX() [8/11]

◆ MX() [9/11]

◆ MX() [10/11]

◆ ~MX()

◆ MX() [11/11]

Member Function Documentation

◆ __hash__()

◆ __nonzero__()

◆ _bilin()

◆ _logsumexp()

◆ _rank1()

◆ _sym()

◆ ad_forward()

◆ ad_reverse()

◆ assign()

◆ attachAssert()

◆ bilin()

◆ binary()

◆ blockcat()

◆ bspline() [1/3]

◆ bspline() [2/3]

◆ bspline() [3/3]

◆ bspline_dual()

◆ class_name()

◆ colind() [1/2]

◆ colind() [2/2]

◆ columns()

◆ conditional()

◆ contains_all()

◆ contains_any()

◆ convexify()

◆ count_down()

◆ count_up()

◆ create()

◆ createMultipleOutput()

◆ cross()

◆ cse()

◆ cumsum()

◆ debug_repr()

◆ densify()

◆ dep()

◆ depends_on()

◆ deserialize()

◆ det() [1/2]

◆ det() [2/2]

◆ diag()

◆ diagcat()

◆ diagsplit()

◆ diff()

◆ difference()

◆ dim()

◆ disp()

◆ dot()

◆ dump()

◆ einstein() [1/2]

◆ einstein() [2/2]

◆ enlarge()

◆ erase() [1/2]

◆ erase() [2/2]

◆ hash()

◆ nonzero()