casadi::Callback Class Reference

Callback function functionality. More...

#include <callback.hpp>

Detailed Description

This class provides a public API to the FunctionInternal class that can be subclassed by the user, who is then able to implement the different virtual method. Note that the Function class also provides a public API to FunctionInternal, but only allows calling, not being called.

The user is responsible for not deleting this class for the lifetime of the internal function object.

Author

Joris Gillis, Joel Andersson

Date

2015

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

Examples

Function/callback.py, and misc/assertion.py.

Definition at line 49 of file casadi/core/callback.hpp.

Inheritance diagram for casadi::Callback:

Collaboration diagram for casadi::Callback:

Public Types
typedef std::map< std::string, std::vector< std::string > >	AuxOut
using	internal_base_type = SharedObjectInternal
using	base_type = SharedObject

Public Member Functions
	Callback ()
	Default constructor. More...
	Callback (const Callback &obj)
	Copy constructor (throws an error) More...
virtual	~Callback ()
	Destructor. More...
void	construct (const std::string &name, const Dict &opts=Dict())
	Construct internal object. More...
virtual void	init ()
	Initialize the object. More...
virtual void	finalize ()
	Finalize the object. More...
virtual std::vector< DM >	eval (const std::vector< DM > &arg) const
	Evaluate numerically, using temporary matrices and work vectors. More...
virtual int	eval_buffer (const double **arg, const std::vector< casadi_int > &sizes_arg, double **res, const std::vector< casadi_int > &sizes_res) const
	A copy-free low level interface. More...
virtual bool	has_eval_buffer () const
	Does the Callback class support a copy-free low level interface ? More...
virtual casadi_int	get_n_in ()
	Get the number of inputs. More...
virtual casadi_int	get_n_out ()
	Get the number of outputs. More...
virtual Sparsity	get_sparsity_in (casadi_int i)
	Get the sparsity of an input. More...
virtual Sparsity	get_sparsity_out (casadi_int i)
	Get the sparsity of an output. More...
virtual std::string	get_name_in (casadi_int i)
	Get the name of an input. More...
virtual std::string	get_name_out (casadi_int i)
	Get the name of an output. More...
virtual bool	uses_output () const
	Do the derivative functions need nondifferentiated outputs? More...
virtual Function	get_factory (const std::string &name, const std::vector< std::string > &s_in, const std::vector< std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
	Customize calls to the function factory. More...
casadi_int	n_in () const
	Get the number of function inputs. More...
casadi_int	n_out () const
	Get the number of function outputs. More...
std::vector< bool >	activity (const std::vector< bool > &arg) const
	Output signal activity induced by a given input activity. More...
const std::vector< std::string > &	name_in () const
	Get input scheme. More...
const std::string &	name_in (casadi_int ind) const
	Get input scheme name by index. More...
const std::vector< std::string > &	name_out () const
	Get output scheme. More...
const std::string &	name_out (casadi_int ind) const
	Get output scheme name by index. More...
casadi_int	index_in (const std::string &name) const
	Find the index for a string describing a particular entry of an input scheme. More...
casadi_int	index_out (const std::string &name) const
	Find the index for a string describing a particular entry of an output scheme. More...
bool	has_in (const std::string &name) const
	Does the function have a particularly named input? More...
bool	has_out (const std::string &name) const
	Does the function have a particularly named output? More...
double	default_in (casadi_int ind) const
	Get default input value. More...
double	max_in (casadi_int ind) const
	Get largest input value. More...
double	min_in (casadi_int ind) const
	Get smallest input value. More...
std::vector< double >	nominal_in (casadi_int ind) const
	Get nominal input value. More...
std::vector< double >	nominal_out (casadi_int ind) const
	Get nominal output value. More...
Function	factory (const std::string &name, const std::vector< std::string > &s_in, const std::vector< std::string > &s_out, const AuxOut &aux=AuxOut(), const Dict &opts=Dict()) const
Function	oracle () const
	Get oracle. More...
std::vector< bool >	which_depends (const std::string &s_in, const std::vector< std::string > &s_out, casadi_int order=1, bool tr=false) const
	Which variables enter with some order. More...
void	print_dimensions (std::ostream &stream=casadi::uout()) const
	Print dimensions of inputs and outputs. More...
void	print_options (std::ostream &stream=casadi::uout()) const
	Print options to a stream. More...
void	print_option (const std::string &name, std::ostream &stream=casadi::uout()) const
	Print all information there is to know about a certain option. More...
bool	has_option (const std::string &option_name) const
	Does a particular option exist. More...
void	change_option (const std::string &option_name, const GenericType &option_value)
	Change option after object creation for debugging. More...
void	reset_dump_count ()
	Reset the counter used to name dump files. More...
Function	jacobian_old (casadi_int iind, casadi_int oind) const
	[DEPRECATED] Replaced by Function::factory. More...
Function	hessian_old (casadi_int iind, casadi_int oind) const
	[DEPRECATED] Replaced by Function::factory. More...
Function	jacobian () const
	Calculate all Jacobian blocks. More...
bool	operator== (const Function &f) const
	Check if same as another function. More...
int	operator() (const double **arg, double **res, casadi_int *iw, double *w, int mem) const
	Evaluate memory-less, numerically. More...
int	operator() (const double **arg, double **res, casadi_int *iw, double *w) const
	Evaluate numerically with checkout/release. More...
int	operator() (const SXElem **arg, SXElem **res, casadi_int *iw, SXElem *w, int mem=0) const
	Evaluate memory-less SXElem. More...
int	operator() (const bvec_t **arg, bvec_t **res, casadi_int *iw, bvec_t *w, int mem=0) const
	Propagate sparsity forward. More...
template<typename M >
void	call_gen (const std::map< std::string, M > &arg, std::map< std::string, M > &res, bool always_inline, bool never_inline) const
	Call using a map. More...
int	eval_activity (const bvec_t **arg, bvec_t **res, casadi_int *iw, bvec_t *w, int mem=0) const
	Propagate signal activity forward (bit set = active (possibly nonzero)) More...
int	rev (bvec_t **arg, bvec_t **res, casadi_int *iw, bvec_t *w, int mem=0) const
	Propagate sparsity backward. More...
int	rev (std::vector< bvec_t * > arg, std::vector< bvec_t * > res) const
	Propagate sparsity backward with temporary memory allocation. More...
std::vector< MX >	mapsum (const std::vector< MX > &x, const std::string &parallelization="serial") const
	Evaluate symbolically in parallel and sum (matrix graph) More...
Function	map (casadi_int n, const std::string &parallelization="serial") const
	Create a mapped version of this function. More...
Function	map (casadi_int n, const std::string &parallelization, casadi_int max_num_threads) const
Function	slice (const std::string &name, const std::vector< casadi_int > &order_in, const std::vector< casadi_int > &order_out, const Dict &opts=Dict()) const
	returns a new function with a selection of inputs/outputs of the original More...
Function	forward (casadi_int nfwd) const
	Get a function that calculates nfwd forward derivatives. More...
Function	reverse (casadi_int nadj) const
	Get a function that calculates nadj adjoint derivatives. More...
const std::vector< Sparsity > &	jac_sparsity (bool compact=false) const
	Get, if necessary generate, the sparsity of all Jacobian blocks. More...
Sparsity	jac_sparsity (casadi_int oind, casadi_int iind, bool compact=false) const
	Get, if necessary generate, the sparsity of a single Jacobian block. More...
std::string	generate (const std::string &fname, const Dict &opts=Dict()) const
	Export / Generate C code for the function. More...
std::string	generate (const Dict &opts=Dict()) const
	Export / Generate C code for the function. More...
std::string	generate_dependencies (const std::string &fname, const Dict &opts=Dict()) const
	Export / Generate C code for the dependency function. More...
FunctionInternal *	get () const
template<typename T >
T *	get () const
	Get a pointer and typecast. More...
FunctionInternal *	operator-> () const
	Const access functions of the node. More...
Dict	stats (int mem=0) const
	Get all statistics obtained at the end of the last evaluate call. More...
template<>
const SX CASADI_EXPORT	sym_in (casadi_int iind) const
template<>
const std::vector< SX > CASADI_EXPORT	sym_in () const
bool	has_free () const
	Does the function have free variables. More...
std::vector< std::string >	get_free () const
	Get free variables as a string. More...
std::vector< SX >	free_sx () const
	Get all the free variables of the function. More...
std::vector< MX >	free_mx () const
	Get all the free variables of the function. More...
void	generate_lifted (Function &vdef_fcn, Function &vinit_fcn) const
	Extract the functions needed for the Lifted Newton method. More...
casadi_int	n_nodes () const
	Number of nodes in the algorithm. More...
casadi_int	n_instructions () const
	Number of instruction in the algorithm (SXFunction/MXFunction) More...
casadi_int	instruction_id (casadi_int k) const
	Identifier index of the instruction (SXFunction/MXFunction) More...
std::vector< casadi_int >	instruction_input (casadi_int k) const
	Locations in the work vector for the inputs of the instruction. More...
double	instruction_constant (casadi_int k) const
	Get the floating point output argument of an instruction (SXFunction) More...
std::vector< casadi_int >	instruction_output (casadi_int k) const
	Location in the work vector for the output of the instruction. More...
MX	instruction_MX (casadi_int k) const
	Get the MX node corresponding to an instruction (MXFunction) More...
SX	instructions_sx () const
	Get the SX node corresponding to all instructions (SXFunction) More...
size_t	sz_arg () const
	Get required length of arg field. More...
size_t	sz_res () const
	Get required length of res field. More...
size_t	sz_iw () const
	Get required length of iw field. More...
size_t	sz_w () const
	Get required length of w field. More...
void	sz_work (size_t &sz_arg, size_t &sz_res, size_t &sz_iw, size_t &sz_w) const
	Get number of temporary variables needed. More...
void	set_work (const double **&arg, double **&res, casadi_int *&iw, double *&w, int mem=0) const
	Set the (persistent) work vectors. More...
void	set_temp (const double **arg, double **res, casadi_int *iw, double *w, int mem=0) const
	Set the (temporary) work vectors. More...
void	setup (const double **arg, double **res, casadi_int *iw, double *w, int mem=0) const
	Set the (persistent and temporary) work vectors. More...
void	merge (const std::vector< MX > &arg, std::vector< MX > &subs_from, std::vector< MX > &subs_to) const
	List merge opportunitities. More...
const std::string &	name () const
	Name of the function. More...
bool	is_a (const std::string &type, bool recursive=true) const
	Check if the function is of a particular type. More...
void	assert_size_in (casadi_int i, casadi_int nrow, casadi_int ncol) const
	Assert that an input dimension is equal so some given value. More...
void	assert_size_out (casadi_int i, casadi_int nrow, casadi_int ncol) const
	Assert that an output dimension is equal so some given value. More...
void	assert_sparsity_out (casadi_int i, const Sparsity &sp, casadi_int n=1, bool allow_all_zero_sparse=true) const
	Assert that an output sparsity is a multiple of some given sparsity. More...
casadi_int	checkout () const
	Checkout a memory object. More...
void	release (int mem) const
	Release a memory object. More...
void *	memory (int ind) const
	Get memory object. More...
Dict	cache () const
	Get all functions in the cache. More...
std::vector< std::string >	get_function () const
	Get a list of all functions. More...
Function	get_function (const std::string &name) const
	Get a dependency function. More...
bool	has_function (const std::string &fname) const
	Check if a particular dependency exists. More...
std::vector< Function >	find_functions (casadi_int max_depth=-1) const
	Get all functions embedded in the expression graphs. More...
Function	find_function (const std::string &name, casadi_int max_depth=-1) const
	Get a specific function embedded in the expression graphs. More...
Dict	info () const
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...
virtual bool	has_jacobian () const
	Return Jacobian of all input elements with respect to all output elements. More...
virtual Function	get_jacobian (const std::string &name, const std::vector< std::string > &inames, const std::vector< std::string > &onames, const Dict &opts) const
	Return Jacobian of all input elements with respect to all output elements. More...
virtual bool	has_forward (casadi_int nfwd) const
	Return function that calculates forward derivatives. More...
virtual Function	get_forward (casadi_int nfwd, const std::string &name, const std::vector< std::string > &inames, const std::vector< std::string > &onames, const Dict &opts) const
	Return function that calculates forward derivatives. More...
virtual bool	has_reverse (casadi_int nadj) const
	Return function that calculates adjoint derivatives. More...
virtual Function	get_reverse (casadi_int nadj, const std::string &name, const std::vector< std::string > &inames, const std::vector< std::string > &onames, const Dict &opts) const
	Return function that calculates adjoint derivatives. More...
virtual bool	has_jac_sparsity (casadi_int oind, casadi_int iind) const
	Return sparsity of Jacobian of all input elements. More...
virtual Sparsity	get_jac_sparsity (casadi_int oind, casadi_int iind, bool symmetric) const
	Return sparsity of Jacobian of all input elements. More...
Function	expand () const
	Expand a function to SX. More...
Function	expand (const std::string &name, const Dict &opts=Dict()) const
	Expand a function to SX. More...
Function	transform (const Dict &opts=Dict()) const
	Apply transformation passes. More...
Function	transform (const std::string &fname, const Dict &opts=Dict()) const
	Apply transformation passes. More...
Function	transform (const std::vector< std::vector< GenericType > > &passes, const Dict &opts=Dict()) const
	Apply transformation passes. More...
Function	transform (const std::string &fname, const std::vector< std::vector< GenericType > > &passes, const Dict &opts=Dict()) const
	Apply transformation passes. More...
casadi_int	size1_in (casadi_int ind) const
	Get input dimension. More...
casadi_int	size1_in (const std::string &iname) const
	Get input dimension. More...
casadi_int	size2_in (casadi_int ind) const
	Get input dimension. More...
casadi_int	size2_in (const std::string &iname) const
	Get input dimension. More...
std::pair< casadi_int, casadi_int >	size_in (casadi_int ind) const
	Get input dimension. More...
std::pair< casadi_int, casadi_int >	size_in (const std::string &iname) const
	Get input dimension. More...
casadi_int	size1_out (casadi_int ind) const
	Get output dimension. More...
casadi_int	size1_out (const std::string &oname) const
	Get output dimension. More...
casadi_int	size2_out (casadi_int ind) const
	Get output dimension. More...
casadi_int	size2_out (const std::string &oname) const
	Get output dimension. More...
std::pair< casadi_int, casadi_int >	size_out (casadi_int ind) const
	Get output dimension. More...
std::pair< casadi_int, casadi_int >	size_out (const std::string &oname) const
	Get output dimension. More...
casadi_int	nnz_in () const
	Get number of input nonzeros. More...
casadi_int	nnz_in (casadi_int ind) const
	Get number of input nonzeros. More...
casadi_int	nnz_in (const std::string &iname) const
	Get number of input nonzeros. More...
casadi_int	nnz_out () const
	Get number of output nonzeros. More...
casadi_int	nnz_out (casadi_int ind) const
	Get number of output nonzeros. More...
casadi_int	nnz_out (const std::string &oname) const
	Get number of output nonzeros. More...
casadi_int	numel_in () const
	Get number of input elements. More...
casadi_int	numel_in (casadi_int ind) const
	Get number of input elements. More...
casadi_int	numel_in (const std::string &iname) const
	Get number of input elements. More...
casadi_int	numel_out () const
	Get number of output elements. More...
casadi_int	numel_out (casadi_int ind) const
	Get number of output elements. More...
casadi_int	numel_out (const std::string &oname) const
	Get number of output elements. More...
const Sparsity &	sparsity_in (casadi_int ind) const
	Get sparsity of a given input. More...
const Sparsity &	sparsity_in (const std::string &iname) const
	Get sparsity of a given input. More...
const Sparsity &	sparsity_out (casadi_int ind) const
	Get sparsity of a given output. More...
const Sparsity &	sparsity_out (const std::string &iname) const
	Get sparsity of a given output. More...
bool	is_diff_in (casadi_int ind) const
	Get differentiability of inputs/output. More...
std::vector< bool >	is_diff_in () const
	Get differentiability of inputs/output. More...
bool	is_diff_out (casadi_int ind) const
	Get differentiability of inputs/output. More...
std::vector< bool >	is_diff_out () const
	Get differentiability of inputs/output. More...
Function	wrap () const
	Wrap in an Function instance consisting of only one MX call. More...
Function	wrap (const std::string &name) const
	Wrap in an Function instance consisting of only one MX call. More...
Function	wrap_as_needed (const Dict &opts) const
	Wrap in a Function with options. More...
Function	wrap_as_needed (const std::string &name, const Dict &opts) const
	Wrap in a Function with options. More...
const Sparsity	sparsity_jac (casadi_int iind, casadi_int oind, bool compact=false, bool symmetric=false) const
const Sparsity	sparsity_jac (const std::string &iind, casadi_int oind=0, bool compact=false, bool symmetric=false) const
const Sparsity	sparsity_jac (casadi_int iind, const std::string &oind, bool compact=false, bool symmetric=false) const
const Sparsity	sparsity_jac (const std::string &iind, const std::string &oind, bool compact=false, bool symmetric=false) const
void	call (const std::vector< DM > &arg, std::vector< DM > &res, bool always_inline=false, bool never_inline=false) const
	Evaluate the function symbolically or numerically. More...
void	call (const std::vector< SX > &arg, std::vector< SX > &res, bool always_inline=false, bool never_inline=false) const
	Evaluate the function symbolically or numerically. More...
void	call (const std::vector< MX > &arg, std::vector< MX > &res, bool always_inline=false, bool never_inline=false) const
	Evaluate the function symbolically or numerically. More...
void	call (const DMDict &arg, DMDict &res, bool always_inline=false, bool never_inline=false) const
	Evaluate the function symbolically or numerically. More...
void	call (const SXDict &arg, SXDict &res, bool always_inline=false, bool never_inline=false) const
	Evaluate the function symbolically or numerically. More...
void	call (const MXDict &arg, MXDict &res, bool always_inline=false, bool never_inline=false) const
	Evaluate the function symbolically or numerically. More...
std::vector< DM >	operator() (const std::vector< DM > &arg) const
std::vector< SX >	operator() (const std::vector< SX > &arg) const
std::vector< MX >	operator() (const std::vector< MX > &arg) const
const DMDict	operator() (const DMDict &arg) const
const SXDict	operator() (const SXDict &arg) const
const MXDict	operator() (const MXDict &arg) const
void	operator() (std::vector< const double * > arg, std::vector< double * > res) const
	Evaluate with temporary memory allocation. More...
void	operator() (std::vector< const bvec_t * > arg, std::vector< bvec_t * > res) const
	Evaluate with temporary memory allocation. More...
void	operator() (std::vector< const SXElem * > arg, std::vector< SXElem * > res) const
	Evaluate with temporary memory allocation. More...
template<typename D >
void	call_gen (std::vector< const D * > arg, std::vector< D * > res) const
	Evaluate with temporary memory allocation. More...
void	operator() (VecArg arg, VecRes res) const
	Numerical evaluation. More...
void	operator() (VecArg arg, MapRes res) const
	Numerical evaluation. More...
void	operator() (VecArg arg, VPrRes res) const
	Numerical evaluation. More...
void	operator() (VecArg arg, MPrRes res) const
	Numerical evaluation. More...
void	operator() (MapArg arg, VecRes res) const
	Numerical evaluation. More...
void	operator() (MapArg arg, MapRes res) const
	Numerical evaluation. More...
void	operator() (MapArg arg, VPrRes res) const
	Numerical evaluation. More...
void	operator() (MapArg arg, MPrRes res) const
	Numerical evaluation. More...
std::vector< DM >	operator() (const DM &arg0) const
std::vector< SX >	operator() (const SX &arg0) const
std::vector< MX >	operator() (const MX &arg0) const
Function	mapaccum (const std::string &name, casadi_int N, const Dict &opts=Dict()) const
	Create a mapaccumulated version of this function. More...
Function	mapaccum (const std::string &name, casadi_int N, casadi_int n_accum, const Dict &opts=Dict()) const
	Create a mapaccumulated version of this function. More...
Function	mapaccum (const std::string &name, casadi_int n, const std::vector< casadi_int > &accum_in, const std::vector< casadi_int > &accum_out, const Dict &opts=Dict()) const
	Create a mapaccumulated version of this function. More...
Function	mapaccum (const std::string &name, casadi_int n, const std::vector< std::string > &accum_in, const std::vector< std::string > &accum_out, const Dict &opts=Dict()) const
	Create a mapaccumulated version of this function. More...
Function	mapaccum (casadi_int N, const Dict &opts=Dict()) const
	Create a mapaccumulated version of this function. More...
Function	fold (casadi_int N, const Dict &opts=Dict()) const
	Create a mapaccumulated version of this function. More...
Function	map (const std::string &name, const std::string &parallelization, casadi_int n, const std::vector< casadi_int > &reduce_in, const std::vector< casadi_int > &reduce_out, const Dict &opts=Dict()) const
	Map with reduction. More...
Function	map (const std::string &name, const std::string &parallelization, casadi_int n, const std::vector< std::string > &reduce_in, const std::vector< std::string > &reduce_out, const Dict &opts=Dict()) const
	Map with reduction. More...
Function	map (casadi_int n, const std::vector< bool > &reduce_in, const std::vector< bool > &reduce_out=std::vector< bool >(), const Dict &opts=Dict()) const
	Map with reduction. More...
void	generate_in (const std::string &fname, const std::vector< DM > &arg)
	Export an input file that can be passed to generate C code with a main. More...
std::vector< DM >	generate_in (const std::string &fname)
	Export an input file that can be passed to generate C code with a main. More...
void	generate_out (const std::string &fname, const std::vector< DM > &arg)
	Export an output file that can be checked with generated C code output. More...
std::vector< DM >	generate_out (const std::string &fname)
	Export an output file that can be checked with generated C code output. More...
void	export_code (const std::string &lang, const std::string &fname, const Dict &options=Dict()) const
	Export function in specific language. More...
std::string	export_code (const std::string &lang, const Dict &options=Dict()) const
	Export function in specific language. More...
void	export_code (const std::string &lang, std::ostream &stream, const Dict &options=Dict()) const
	Export function in specific language. More...
void	serialize (std::ostream &stream, const Dict &opts=Dict()) const
	Serialize. More...
void	serialize (SerializingStream &s) const
	Serialize an object. More...
std::string	serialize (const Dict &opts=Dict()) const
	Serialize. More...
void	save (const std::string &fname, const Dict &opts=Dict()) const
	Save Function to a file. More...
const SX	sx_in (casadi_int iind) const
	Get symbolic primitives equivalent to the input expressions. More...
const SX	sx_in (const std::string &iname) const
	Get symbolic primitives equivalent to the input expressions. More...
const std::vector< SX >	sx_in () const
	Get symbolic primitives equivalent to the input expressions. More...
const MX	mx_in (casadi_int ind) const
	Get symbolic primitives equivalent to the input expressions. More...
const MX	mx_in (const std::string &iname) const
	Get symbolic primitives equivalent to the input expressions. More...
const std::vector< MX >	mx_in () const
	Get symbolic primitives equivalent to the input expressions. More...
template<typename T >
const T	sym_in (casadi_int iind) const
	Get symbolic primitives equivalent to the input expressions. More...
template<typename T >
const T	sym_in (const std::string &iname) const
	Get symbolic primitives equivalent to the input expressions. More...
template<typename T >
const std::vector< T >	sym_in () const
	Get symbolic primitives equivalent to the input expressions. More...
const SX	sx_out (casadi_int oind) const
	Get symbolic primitives equivalent to the output expressions. More...
const SX	sx_out (const std::string &oname) const
	Get symbolic primitives equivalent to the output expressions. More...
const std::vector< SX >	sx_out () const
	Get symbolic primitives equivalent to the output expressions. More...
const MX	mx_out (casadi_int ind) const
	Get symbolic primitives equivalent to the output expressions. More...
const MX	mx_out (const std::string &oname) const
	Get symbolic primitives equivalent to the output expressions. More...
const std::vector< MX >	mx_out () const
	Get symbolic primitives equivalent to the output expressions. More...
std::vector< double >	nz_from_in (const std::vector< DM > &arg) const
	Convert from/to flat vector of input/output nonzeros. More...
std::vector< double >	nz_from_out (const std::vector< DM > &arg) const
	Convert from/to flat vector of input/output nonzeros. More...
std::vector< DM >	nz_to_in (const std::vector< double > &arg) const
	Convert from/to flat vector of input/output nonzeros. More...
std::vector< DM >	nz_to_out (const std::vector< double > &arg) const
	Convert from/to flat vector of input/output nonzeros. More...
DMDict	convert_in (const std::vector< DM > &arg) const
	Convert from/to input/output lists/map. More...
std::vector< DM >	convert_in (const DMDict &arg) const
	Convert from/to input/output lists/map. More...
SXDict	convert_in (const std::vector< SX > &arg) const
	Convert from/to input/output lists/map. More...
std::vector< SX >	convert_in (const SXDict &arg) const
	Convert from/to input/output lists/map. More...
MXDict	convert_in (const std::vector< MX > &arg) const
	Convert from/to input/output lists/map. More...
std::vector< MX >	convert_in (const MXDict &arg) const
	Convert from/to input/output lists/map. More...
DMDict	convert_out (const std::vector< DM > &arg) const
	Convert from/to input/output lists/map. More...
std::vector< DM >	convert_out (const DMDict &arg) const
	Convert from/to input/output lists/map. More...
SXDict	convert_out (const std::vector< SX > &arg) const
	Convert from/to input/output lists/map. More...
std::vector< SX >	convert_out (const SXDict &arg) const
	Convert from/to input/output lists/map. More...
MXDict	convert_out (const std::vector< MX > &arg) const
	Convert from/to input/output lists/map. More...
std::vector< MX >	convert_out (const MXDict &arg) const
	Convert from/to input/output lists/map. More...
bool	has_spfwd () const
	Is the class able to propagate seeds through the algorithm? More...
bool	has_sprev () const
	Is the class able to propagate seeds through the algorithm? More...

Static Public Member Functions
static std::string	type_name ()
	Get type name. More...
static Function	create (FunctionInternal *node)
	Create from node. More...
static Function	create (FunctionInternal *node, const Dict &opts)
	Create from node and initialize. More...
static Function	conditional (const std::string &name, const std::vector< Function > &f, const Function &f_def, const Dict &opts=Dict())
	Constuct a switch function. More...
static Function	conditional (const std::string &name, const Function &f, const Dict &opts=Dict())
	Conditional call to a function. More...
static Function	bspline (const std::string &name, const std::vector< std::vector< double > > &knots, const std::vector< double > &coeffs, const std::vector< casadi_int > &degree, casadi_int m=1, const Dict &opts=Dict())
	BSpline evaluator function. More...
static Function	if_else (const std::string &name, const Function &f_true, const Function &f_false, const Dict &opts=Dict())
	Constructor (if-else) More...
static bool	test_cast (const SharedObjectInternal *ptr)
	Check if a particular cast is allowed. More...
static bool	check_name (const std::string &name)
	Check if a string is a valid function name. More...
static std::string	fix_name (const std::string &name)
	Turn a string into a valid function name as defined by "check_name". More...
static Function	deserialize (std::istream &stream)
	Build function from serialization. More...
static Function	deserialize (const std::string &s)
	Build function from serialization. More...
static Function	deserialize (DeserializingStream &s)
	Build function from serialization. More...
static Function	load (const std::string &filename)
	Build function from serialization. More...
static std::vector< SX >	order (const std::vector< SX > &expr)
static std::vector< MX >	order (const std::vector< MX > &expr)
static Function	jit (const std::string &name, const std::string &body, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const Dict &opts=Dict())
	Create a just-in-time compiled function from a C language string. More...
static Function	jit (const std::string &name, const std::string &body, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const std::vector< Sparsity > &sparsity_in, const std::vector< Sparsity > &sparsity_out, const Dict &opts=Dict())
	Create a just-in-time compiled function from a C language string. More...

Protected Member Functions
Function	mapaccum (const std::string &name, const std::vector< Function > &chain, casadi_int n_accum=1, const Dict &opts=Dict()) const
	Helper function for mapaccum. More...
void	count_up ()
void	count_down ()
void	construct (const std::string &name, const std::vector< SX > &ex_in, const std::vector< SX > &ex_out, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const Dict &opts)
	Called by constructors. More...
void	construct (const std::string &name, const std::vector< MX > &ex_in, const std::vector< MX > &ex_out, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const Dict &opts)
	Called by constructors. More...
template<typename M >
void	construct (const std::string &name, const std::map< std::string, M > &dict, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const Dict &opts)
	Called by constructors. More...

Static Protected Member Functions
static bool	proceed_to (std::istream &file, const std::string &str)
	Helper function for parsing .casadi files. More...
std::vector< const double * >	buf_in (VecArg arg) const
	Supported arguments for numerical evaluation and converters. More...
std::vector< const double * >	buf_in (MapArg arg) const
	Supported arguments for numerical evaluation and converters. More...
std::vector< double * >	buf_out (VecRes res) const
	Supported arguments for numerical evaluation and converters. More...
std::vector< double * >	buf_out (VPrRes res) const
	Supported arguments for numerical evaluation and converters. More...
std::vector< double * >	buf_out (MapRes res) const
	Supported arguments for numerical evaluation and converters. More...
std::vector< double * >	buf_out (MPrRes res) const
	Supported arguments for numerical evaluation and converters. More...
typedef const std::vector< std::vector< double > > &	VecArg
	Supported arguments for numerical evaluation and converters. More...
typedef std::vector< std::vector< double > > &	VecRes
	Supported arguments for numerical evaluation and converters. More...
typedef std::vector< std::vector< double > * >	VPrRes
	Supported arguments for numerical evaluation and converters. More...
typedef const std::map< std::string, std::vector< double > > &	MapArg
	Supported arguments for numerical evaluation and converters. More...
typedef std::map< std::string, std::vector< double > > &	MapRes
	Supported arguments for numerical evaluation and converters. More...
typedef std::map< std::string, std::vector< double > * >	MPrRes
	Supported arguments for numerical evaluation and converters. More...

Member Typedef Documentation

AuxOut

typedef std::map<std::string, std::vector<std::string> > casadi::Function::AuxOut

inherited

Definition at line 447 of file function.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.

MapArg

typedef const std::map<std::string, std::vector<double> >& casadi::Function::MapArg

inherited

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

Definition at line 626 of file function.hpp.

MapRes

typedef std::map<std::string, std::vector<double> >& casadi::Function::MapRes

inherited

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

Definition at line 628 of file function.hpp.

MPrRes

typedef std::map<std::string, std::vector<double>*> casadi::Function::MPrRes

inherited

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

Definition at line 630 of file function.hpp.

VecArg

typedef const std::vector<std::vector<double> >& casadi::Function::VecArg

inherited

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

Definition at line 619 of file function.hpp.

VecRes

typedef std::vector<std::vector<double> >& casadi::Function::VecRes

inherited

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

Definition at line 621 of file function.hpp.

VPrRes

typedef std::vector<std::vector<double>*> casadi::Function::VPrRes

inherited

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

Definition at line 623 of file function.hpp.

Constructor & Destructor Documentation

Callback() [1/2]

casadi::Callback::Callback

(

)

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

Definition at line 29 of file callback.cpp.

                     {
  }

Callback() [2/2]

casadi::Callback::Callback

(

const Callback &

obj

)

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

Definition at line 32 of file callback.cpp.

                                        : Function() { // NOLINT
    casadi_error("Callback objects cannot be copied");
  }

~Callback()

casadi::Callback::~Callback ( )

virtual

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

Definition at line 44 of file callback.cpp.

                      {
    try {
      // Make sure that this object isn't used after its deletion
    if (!is_null()) get<CallbackInternal>()->self_ = nullptr;
    } catch (...) {
      casadi_warning("Problem in Callback destructor");
    }
  }

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

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

activity()

std::vector< bool > casadi::Function::activity ( const std::vector< bool > &  arg ) const

inherited

arg is a flat activity mask over all input nonzeros (size nnz_in(), true = active = possibly nonzero); the result is the corresponding mask over all output nonzeros (size nnz_out()). An output that comes out inactive (false) is guaranteed zero for any value of the active inputs. Unlike sparsity propagation this exploits annihilation: an inactive operand of a multiply kills the product.

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

Definition at line 1269 of file function.cpp.

                                                                     {
    casadi_assert(arg.size()==static_cast<size_t>(nnz_in()),
      "activity: expected mask of size nnz_in()=" + str(nnz_in())
      + ", got " + str(arg.size()) + ".");
 
    // bvec buffers for the concatenated input/output nonzeros
    std::vector<bvec_t> in_buf(nnz_in()), out_buf(nnz_out(), 0);
    for (casadi_int k=0; k<nnz_in(); ++k) in_buf[k] = arg[k] ? ~static_cast<bvec_t>(0) : 0;
 
    // Per-input/output pointers into the buffers
    std::vector<const bvec_t*> argp(sz_arg(), nullptr);
    std::vector<bvec_t*> resp(sz_res(), nullptr);
    casadi_int off = 0;
    for (casadi_int i=0; i<n_in(); ++i) { argp[i] = get_ptr(in_buf)+off; off += nnz_in(i); }
    off = 0;
    for (casadi_int i=0; i<n_out(); ++i) { resp[i] = get_ptr(out_buf)+off; off += nnz_out(i); }
 
    // Work vectors
    std::vector<casadi_int> iw(sz_iw());
    std::vector<bvec_t> w(sz_w());
 
    eval_activity(get_ptr(argp), get_ptr(resp), get_ptr(iw), get_ptr(w));
 
    std::vector<bool> ret(nnz_out());
    for (casadi_int k=0; k<nnz_out(); ++k) ret[k] = out_buf[k]!=0;
    return ret;
  }

References casadi::Function::eval_activity(), casadi::get_ptr(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::nnz_in(), casadi::Function::nnz_out(), casadi::str(), casadi::Function::sz_arg(), casadi::Function::sz_iw(), casadi::Function::sz_res(), and casadi::Function::sz_w().

Referenced by casadi::Call::create().

assert_size_in()

void casadi::Function::assert_size_in ( casadi_int  i, casadi_int  nrow, casadi_int  ncol  ) const

inherited

Definition at line 1982 of file function.cpp.

                                                                                    {
    casadi_assert(size1_in(i)==nrow && size2_in(i)==ncol,
      "Incorrect shape for " + str(*this) + " input " + str(i) + " \""
      + name_in(i) + "\". Expected " + str(nrow) + "-by-" + str(ncol)
      + " but got " + str(size1_in(i)) +  "-by-" + str(size2_in(i)));
 
  }

References casadi::Function::name_in(), casadi::Function::size1_in(), casadi::Function::size2_in(), and casadi::str().

Referenced by casadi::FunctionInternal::forward(), and casadi::FunctionInternal::reverse().

assert_size_out()

void casadi::Function::assert_size_out ( casadi_int  i, casadi_int  nrow, casadi_int  ncol  ) const

inherited

Definition at line 1990 of file function.cpp.

                                                                                     {
    casadi_assert(size1_out(i)==nrow && size2_out(i)==ncol,
      "Incorrect shape for " + str(*this) + " output " + str(i) + " \""
      + name_out(i) + "\". Expected " + str(nrow) + "-by-" + str(ncol)
      + " but got " + str(size1_out(i)) +  "-by-" + str(size2_out(i)));
  }

References casadi::Function::name_out(), casadi::Function::size1_out(), casadi::Function::size2_out(), and casadi::str().

Referenced by casadi::Function::assert_sparsity_out().

assert_sparsity_out()

void casadi::Function::assert_sparsity_out ( casadi_int  i, const Sparsity &  sp, casadi_int  n = 1, bool  allow_all_zero_sparse = true  ) const

inherited

Definition at line 1997 of file function.cpp.

                                                      {
    // Assert shape
    assert_size_out(i, sp.size1(), sp.size2() * n);
    // Quick return if empty sparse
    if (allow_all_zero_sparse && sparsity_out(i).nnz() == 0) return;
    // Check sparsities
    casadi_assert(sparsity_out(i).is_stacked(sp, n), "Mismatching sparsity "
      "(but correct dimensions) for " + str(*this) + " output " + name_out(i));
  }

References casadi::Function::assert_size_out(), casadi::Function::name_out(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::Function::sparsity_out(), and casadi::str().

Referenced by casadi::FunctionInternal::forward(), and casadi::FunctionInternal::reverse().

assign()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::assign ( SharedObjectInternal *  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_;
  }

bspline()

Function casadi::Function::bspline ( const std::string &  name, const std::vector< std::vector< double > > &  knots, const std::vector< double > &  coeffs, const std::vector< casadi_int > &  degree, casadi_int  m = 1, const Dict &  opts = Dict()  )

staticinherited

Requires a known coefficient tensor

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

Definition at line 943 of file function.cpp.

                                        {
    try {
      casadi_assert(degree.size()==knots.size(), "Degree list length (" + str(degree.size()) + ") "
                  "must match knot list length (" + str(knots.size()) + ").");
      MX x = MX::sym("x", degree.size());
      std::vector<std::string> lookup_mode;
      Dict opts_remainder = extract_from_dict(opts, "lookup_mode", lookup_mode);
      Dict opts_bspline;
      opts_bspline["lookup_mode"] = lookup_mode;
      MX y = MX::bspline(x, DM(coeffs), knots, degree, m, opts_bspline);
      return Function(name, {x}, {y}, opts_remainder);
    } catch(std::exception& e) {
      THROW_ERROR_NOOBJ("bspline", e.what(), "BSpline");
    }
  }

References casadi::MX::bspline(), casadi::extract_from_dict(), casadi::Function::Function(), casadi::Function::name(), casadi::str(), and casadi::GenericMatrix< MX >::sym().

buf_in() [1/2]

std::vector< const double * > casadi::Function::buf_in ( Function::MapArg  arg ) const

inherited

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

Definition at line 570 of file function.cpp.

                                                                    {
    // Return value (RVO)
    std::vector<const double*> ret(sz_arg(), nullptr);
 
    // Read inputs
    for (auto i=arg.begin(); i!=arg.end(); ++i) {
      casadi_int ind = index_in(i->first);
      casadi_assert_dev(i->second.size()==nnz_in(ind));
      ret[ind] = get_ptr(i->second);
    }
 
    return ret;
  }

References casadi::get_ptr(), casadi::Function::index_in(), casadi::Function::nnz_in(), and casadi::Function::sz_arg().

buf_in() [2/2]

std::vector< const double * > casadi::Function::buf_in ( Function::VecArg  arg ) const

inherited

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

Definition at line 536 of file function.cpp.

                                                                    {
    casadi_assert_dev(arg.size()==n_in());
    auto arg_it=arg.begin();
    std::vector<const double*> buf_arg(sz_arg());
    for (casadi_uint i=0; i<arg.size(); ++i) {
      casadi_assert_dev(arg_it->size()==nnz_in(i));
      buf_arg[i] = get_ptr(*arg_it++);
    }
    return buf_arg;
  }

References casadi::get_ptr(), casadi::Function::n_in(), casadi::Function::nnz_in(), and casadi::Function::sz_arg().

buf_out() [1/4]

std::vector< double * > casadi::Function::buf_out ( Function::MapRes  res ) const

inherited

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

Definition at line 584 of file function.cpp.

                                                               {
    // Return value (RVO)
    std::vector<double*> ret(sz_res(), nullptr);
 
    // Read outputs
    for (auto i=res.begin(); i!=res.end(); ++i) {
      casadi_int ind = index_out(i->first);
      i->second.resize(nnz_out(ind));
      ret[ind] = get_ptr(i->second);
    }
 
    return ret;
  }

References casadi::get_ptr(), casadi::Function::index_out(), casadi::Function::nnz_out(), and casadi::Function::sz_res().

buf_out() [2/4]

std::vector< double * > casadi::Function::buf_out ( Function::MPrRes  res ) const

inherited

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

Definition at line 598 of file function.cpp.

                                                               {
    // Return value (RVO)
    std::vector<double*> ret(sz_res(), nullptr);
 
    // Read outputs
    for (auto i=res.begin(); i!=res.end(); ++i) {
      casadi_int ind = index_out(i->first);
      casadi_assert_dev(i->second!=0);
      i->second->resize(nnz_out(ind));
      ret[ind] = get_ptr(*i->second);
    }
 
    return ret;
  }

References casadi::get_ptr(), casadi::Function::index_out(), casadi::Function::nnz_out(), and casadi::Function::sz_res().

buf_out() [3/4]

std::vector< double * > casadi::Function::buf_out ( Function::VecRes  res ) const

inherited

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

Definition at line 547 of file function.cpp.

                                                               {
    res.resize(n_out());
    auto res_it=res.begin();
    std::vector<double*> buf_res(sz_res());
    for (casadi_uint i=0; i<res.size(); ++i) {
      res_it->resize(nnz_out(i));
      buf_res[i] = get_ptr(*res_it++);
    }
    return buf_res;
  }

References casadi::get_ptr(), casadi::Function::n_out(), casadi::Function::nnz_out(), and casadi::Function::sz_res().

buf_out() [4/4]

std::vector< double * > casadi::Function::buf_out ( Function::VPrRes  res ) const

inherited

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

Definition at line 558 of file function.cpp.

                                                               {
    casadi_assert_dev(res.size()==n_out());
    auto res_it=res.begin();
    std::vector<double*> buf_res(sz_res());
    for (casadi_uint i=0; i<res.size(); ++i) {
      casadi_assert_dev(*res_it!=0);
      (*res_it)->resize(nnz_out(i));
      buf_res[i] = get_ptr(**res_it++);
    }
    return buf_res;
  }

References casadi::get_ptr(), casadi::Function::n_out(), casadi::Function::nnz_out(), and casadi::Function::sz_res().

cache()

Dict casadi::Function::cache ( ) const

inherited

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

Definition at line 2032 of file function.cpp.

                             {
    try {
      return (*this)->cache();
    } catch(std::exception& e) {
      THROW_ERROR("cache", e.what());
      return {};
    }
  }

call() [1/6]

void casadi::Function::call ( const DMDict &  arg, DMDict &  res, bool  always_inline = false, bool  never_inline = false  ) const

inherited

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

Definition at line 1650 of file function.cpp.

                                                                   {
    try {
      call_gen(arg, res, always_inline, never_inline);
    } catch(std::exception& e) {
      THROW_ERROR("call", e.what());
    }
  }

References casadi::Function::call_gen().

call() [2/6]

void casadi::Function::call ( const MXDict &  arg, MXDict &  res, bool  always_inline = false, bool  never_inline = false  ) const

inherited

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

Definition at line 1668 of file function.cpp.

                                                                   {
    try {
      call_gen(arg, res, always_inline, never_inline);
    } catch(std::exception& e) {
      THROW_ERROR("call", e.what());
    }
  }

References casadi::Function::call_gen().

call() [3/6]

void casadi::Function::call ( const std::vector< DM > &  arg, std::vector< DM > &  res, bool  always_inline = false, bool  never_inline = false  ) const

inherited

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

Definition at line 509 of file function.cpp.

                                                                   {
    try {
      (*this)->call(arg, res, always_inline, never_inline);
    } catch(std::exception& e) {
      THROW_ERROR("call", e.what());
    }
  }

Referenced by casadi::Function::call_gen(), casadi::construct_nlpsol(), casadi::detect_simple_bounds_gen(), casadi::FunctionInternal::eval_mx(), casadi::Function::map(), casadi::MX::matrix_expand(), casadi::Function::operator()(), and casadi::MX::substitute().

call() [4/6]

void casadi::Function::call ( const std::vector< MX > &  arg, std::vector< MX > &  res, bool  always_inline = false, bool  never_inline = false  ) const

inherited

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

Definition at line 527 of file function.cpp.

                                                                   {
    try {
      (*this)->call(arg, res, always_inline, never_inline);
    } catch(std::exception& e) {
      THROW_ERROR("call", e.what());
    }
  }

call() [5/6]

void casadi::Function::call ( const std::vector< SX > &  arg, std::vector< SX > &  res, bool  always_inline = false, bool  never_inline = false  ) const

inherited

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

Definition at line 518 of file function.cpp.

                                                                   {
    try {
      (*this)->call(arg, res, always_inline, never_inline);
    } catch(std::exception& e) {
      THROW_ERROR("call", e.what());
    }
  }

call() [6/6]

void casadi::Function::call ( const SXDict &  arg, SXDict &  res, bool  always_inline = false, bool  never_inline = false  ) const

inherited

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

Definition at line 1659 of file function.cpp.

                                                                   {
    try {
      call_gen(arg, res, always_inline, never_inline);
    } catch(std::exception& e) {
      THROW_ERROR("call", e.what());
    }
  }

References casadi::Function::call_gen().

call_gen() [1/2]

template<typename M >

void casadi::Function::call_gen ( const std::map< std::string, M > &  arg, std::map< std::string, M > &  res, bool  always_inline, bool  never_inline  ) const

inherited

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

Definition at line 1616 of file function.cpp.

                                                                    {
    // Convert to vector arguments
    std::vector<M> arg_v = (*this)->convert_arg(arg);
 
    // Make call
    std::vector<M> res_v;
    call(arg_v, res_v, always_inline, never_inline);
 
    // Save to map
    res.clear();
    for (casadi_int i=0; i<res_v.size(); ++i) {
      res[name_out(i)] = res_v[i];
    }
  }

References casadi::Function::call(), and casadi::Function::name_out().

call_gen() [2/2]

template<typename D >

void casadi::Function::call_gen ( std::vector< const D * >  arg, std::vector< D * >  res  ) const

inherited

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

Definition at line 614 of file function.cpp.

                                                                          {
    // Input buffer
    casadi_assert_dev(arg.size()>=n_in());
    arg.resize(sz_arg());
 
    // Output buffer
    casadi_assert_dev(res.size()>=n_out());
    res.resize(sz_res());
 
    // Work vectors
    std::vector<casadi_int> iw(sz_iw());
    std::vector<D> w(sz_w());
 
    // Evaluate memoryless
    (*this)(get_ptr(arg), get_ptr(res), get_ptr(iw), get_ptr(w), 0);
  }

References casadi::get_ptr(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::sz_arg(), casadi::Function::sz_iw(), casadi::Function::sz_res(), and casadi::Function::sz_w().

Referenced by casadi::Function::call(), and casadi::Function::operator()().

change_option()

void casadi::Function::change_option ( const std::string &  option_name, const GenericType &  option_value  )

inherited

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

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

Definition at line 1361 of file function.cpp.

                                                                                            {
    try {
      // Assert existance
      if (!has_option(option_name))
        casadi_error("Option '" + option_name + "' does not exist");
      // Call internal class
      (*this)->change_option(option_name, option_value);
    } catch(std::exception& e) {
      THROW_ERROR("change_option", e.what());
    }
  }

References casadi::Function::has_option().

check_name()

bool casadi::Function::check_name ( const std::string &  name )

staticinherited

Valid function names consist of

• At least one character
• Upper and lower case letters: a-zA-Z
• Numbers 0-9, but never as first character
• Underscore, but never as first character and never next to another underscore

May not be one of the following keywords: "null", "jac", "hess"

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

Definition at line 1513 of file function.cpp.

                                                 {
    // Check if empty
    if (name.empty()) return false;
 
    // Check if keyword
    for (const char* kw : {"null", "jac", "hess"}) {
      if (name==kw) return false;
    }
 
    // Make sure that the first character is a letter
    auto it=name.begin();
    if (!std::isalpha(*it++)) return false;
 
    // Check remain_ing characters
    for (; it!=name.end(); ++it) {
      if (*it=='_') {
        // Make sure that the next character isn't also an underscore
        if (it+1!=name.end() && *(it+1)=='_') return false;
      } else {
        // Make sure alphanumeric
        if (!std::isalnum(*it)) return false;
      }
    }
 
    // Valid function name if reached this point
    return true;
  }

References casadi::Function::name().

Referenced by casadi::CodeGenerator::CodeGenerator(), casadi::Function::fix_name(), and casadi::FunctionInternal::FunctionInternal().

checkout()

casadi_int casadi::Function::checkout ( ) const

inherited

Definition at line 1970 of file function.cpp.

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

Referenced by casadi::QpToNlp::alloc_mem(), casadi::FunctionBuffer::FunctionBuffer(), and casadi::FunctionBuffer::operator=().

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

conditional() [1/2]

Function casadi::Function::conditional ( const std::string &  name, const Function &  f, const Dict &  opts = Dict()  )

staticinherited

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

Definition at line 926 of file function.cpp.

                                           {
    try {
      // Create a dummy function with the same signature as f
      std::vector<MX> dummy_in = f.mx_in();
      std::vector<MX> dummy_out(f.n_out());
      for (casadi_int i = 0; i < dummy_out.size(); ++i) {
        dummy_out.at(i) = MX::zeros(f.sparsity_out(i));
      }
      Function dummy("dummy_" + f.name(), dummy_in, dummy_out, f.name_in(), f.name_out());
      // Form a conditional call
      return if_else(name, f, dummy, opts);
    } catch(std::exception& e) {
      THROW_ERROR_NOOBJ("conditional", e.what(), "Switch");
    }
  }

References casadi::Function::if_else(), casadi::Function::mx_in(), casadi::Function::n_out(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::Function::sparsity_out(), and casadi::GenericMatrix< MX >::zeros().

conditional() [2/2]

Function casadi::Function::conditional ( const std::string &  name, const std::vector< Function > &  f, const Function &  f_def, const Dict &  opts = Dict()  )

staticinherited

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

Definition at line 917 of file function.cpp.

                                                                          {
    try {
      return create(new Switch(name, f, f_def), opts);
    } catch(std::exception& e) {
      THROW_ERROR_NOOBJ("conditional", e.what(), "Switch");
    }
  }

References casadi::Function::create(), and casadi::Function::name().

Referenced by casadi::MX::conditional(), casadi::Switch::get_forward(), casadi::Switch::get_reverse(), and casadi::DaeBuilderInternal::transition().

construct() [1/4]

void casadi::Callback::construct	(	const std::string &	name,
		const Dict &	opts = Dict()
	)

This is the step that actually construct the internal object, as the class constructor only creates a null pointer. It should be called from the user constructor.

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

Definition at line 36 of file callback.cpp.

                                                                  {
    if (!is_null()) {
      casadi_error("Cannot create '" + name + "': Internal class already created");
    }
    own(new CallbackInternal(name, this));
    (*this)->construct(opts);
  }

References casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null(), casadi::Function::name(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

construct() [2/4]

template<typename M >

void casadi::Function::construct ( const std::string &  name, const std::map< std::string, M > &  dict, const std::vector< std::string > &  name_in, const std::vector< std::string > &  name_out, const Dict &  opts  )

protectedinherited

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

Definition at line 196 of file function.cpp.

                                             {
    std::vector<M> ex_in(name_in.size()), ex_out(name_out.size());
    for (auto&& i : dict) {
      std::vector<std::string>::const_iterator it;
      it = std::find(name_in.begin(), name_in.end(), i.first);
      if (it!=name_in.end()) {
        // Input expression
        ex_in[it-name_in.begin()] = i.second;
      } else {
        it = std::find(name_out.begin(), name_out.end(), i.first);
        if (it!=name_out.end()) {
        // Output expression
          ex_out[it-name_out.begin()] = i.second;
        } else {
        // Neither
          casadi_error("Unknown dictionary entry: '" + i.first + "'");
        }
      }
    }
    construct(name, ex_in, ex_out, name_in, name_out, opts);
  }

References casadi::Function::construct(), casadi::Function::name(), casadi::Function::name_in(), and casadi::Function::name_out().

construct() [3/4]

void casadi::Function::construct ( const std::string &  name, const std::vector< MX > &  ex_in, const std::vector< MX > &  ex_out, const std::vector< std::string > &  name_in, const std::vector< std::string > &  name_out, const Dict &  opts  )

protectedinherited

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

Definition at line 249 of file function.cpp.

                                             {
    try {
      own(new MXFunction(name, ex_in, ex_out, name_in, name_out));
      (*this)->construct(opts);
 
      // Perform post-construction expand
      auto it = opts.find("post_expand");
      if (it!=opts.end()) {
        if (!it->second) return;
        auto it = opts.find("post_expand_options");
        if (it==opts.end()) {
          operator=((*this).expand());
        } else {
          operator=((*this).expand((*this).name(), it->second));
        }
      }
 
      // Perform external transformations
      it = opts.find("external_transform");
      if (it!=opts.end()) {
        auto v = it->second.to_vector_vector();
        for (const std::vector<GenericType>& vec : v) {
          casadi_assert(vec.size()>=2, "external_transform: inner list must be length >=2");
          casadi_assert(vec.size()<=3, "external_transform: inner list must be length <=3");
          std::string name = vec[0].to_string();
          std::string op = vec[1].to_string();
          Dict opts = vec.size()==3 ? vec[2].to_dict() : Dict();
          operator=(external_transform(name, op, (*this), opts));
        }
      }
 
    } catch(std::exception& e) {
      THROW_ERROR_NOOBJ("Function", e.what(), "MXFunction");
    }
  }

References casadi::external_transform(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::GenericShared< SharedObject, SharedObjectInternal >::operator=(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

construct() [4/4]

void casadi::Function::construct ( const std::string &  name, const std::vector< SX > &  ex_in, const std::vector< SX > &  ex_out, const std::vector< std::string > &  name_in, const std::vector< std::string > &  name_out, const Dict &  opts  )

protectedinherited

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

Definition at line 221 of file function.cpp.

                                             {
    try {
      own(new SXFunction(name, ex_in, ex_out, name_in, name_out));
      (*this)->construct(opts);
 
      // Perform external transformations
      auto it = opts.find("external_transform");
      if (it!=opts.end()) {
        auto v = it->second.to_vector_vector();
        for (const std::vector<GenericType>& vec : v) {
          casadi_assert(vec.size()>=2, "external_transform: inner list must be length >=2");
          casadi_assert(vec.size()<=3, "external_transform: inner list must be length <=3");
          std::string name = vec[0].to_string();
          std::string op = vec[1].to_string();
          Dict opts = vec.size()==3 ? vec[2].to_dict() : Dict();
          operator=(external_transform(name, op, (*this), opts));
        }
      }
 
    } catch(std::exception& e) {
      THROW_ERROR_NOOBJ("Function", e.what(), "SXFunction");
    }
  }

References casadi::external_transform(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::GenericShared< SharedObject, SharedObjectInternal >::operator=(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

Referenced by casadi::Function::construct(), and casadi::Function::Function().

convert_in() [1/6]

std::vector< DM > casadi::Function::convert_in ( const DMDict &  arg ) const

inherited

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

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

Definition at line 1817 of file function.cpp.

                                                            {
    return (*this)->convert_arg(arg);
  }

convert_in() [2/6]

std::vector< MX > casadi::Function::convert_in ( const MXDict &  arg ) const

inherited

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

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

Definition at line 1849 of file function.cpp.

                                                            {
    return (*this)->convert_arg(arg);
  }

convert_in() [3/6]

DMDict casadi::Function::convert_in ( const std::vector< DM > &  arg ) const

inherited

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

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

Definition at line 1813 of file function.cpp.

                                                            {
    return (*this)->convert_arg(arg);
  }

convert_in() [4/6]

MXDict casadi::Function::convert_in ( const std::vector< MX > &  arg ) const

inherited

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

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

Definition at line 1845 of file function.cpp.

                                                            {
    return (*this)->convert_arg(arg);
  }

convert_in() [5/6]

SXDict casadi::Function::convert_in ( const std::vector< SX > &  arg ) const

inherited

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

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

Definition at line 1829 of file function.cpp.

                                                            {
    return (*this)->convert_arg(arg);
  }

convert_in() [6/6]

std::vector< SX > casadi::Function::convert_in ( const SXDict &  arg ) const

inherited

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

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

Definition at line 1833 of file function.cpp.

                                                            {
    return (*this)->convert_arg(arg);
  }

convert_out() [1/6]

std::vector< DM > casadi::Function::convert_out ( const DMDict &  arg ) const

inherited

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

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

Definition at line 1825 of file function.cpp.

                                                             {
    return (*this)->convert_res(arg);
  }

convert_out() [2/6]

std::vector< MX > casadi::Function::convert_out ( const MXDict &  arg ) const

inherited

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

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

Definition at line 1857 of file function.cpp.

                                                             {
    return (*this)->convert_res(arg);
  }

convert_out() [3/6]

DMDict casadi::Function::convert_out ( const std::vector< DM > &  arg ) const

inherited

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

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

Definition at line 1821 of file function.cpp.

                                                             {
    return (*this)->convert_res(arg);
  }

convert_out() [4/6]

MXDict casadi::Function::convert_out ( const std::vector< MX > &  arg ) const

inherited

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

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

Definition at line 1853 of file function.cpp.

                                                             {
    return (*this)->convert_res(arg);
  }

convert_out() [5/6]

SXDict casadi::Function::convert_out ( const std::vector< SX > &  arg ) const

inherited

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

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

Definition at line 1837 of file function.cpp.

                                                             {
    return (*this)->convert_res(arg);
  }

convert_out() [6/6]

std::vector< SX > casadi::Function::convert_out ( const SXDict &  arg ) const

inherited

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

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

Definition at line 1841 of file function.cpp.

                                                             {
    return (*this)->convert_res(arg);
  }

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() [1/2]

Function casadi::Function::create ( FunctionInternal *  node )

staticinherited

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

Definition at line 488 of file function.cpp.

                                                  {
    Function ret;
    ret.own(node);
    return ret;
  }

References casadi::GenericShared< Shared, Internal >::own().

Referenced by casadi::blazing_spline(), casadi::Function::conditional(), casadi::conic(), casadi::Interpolant::construct(), casadi::MapSum::create(), casadi::Map::create(), casadi::OnnxFunction::create(), casadi::Function::create(), casadi::Integrator::create_advanced(), casadi::FixedStepIntegrator::create_advanced(), casadi::dplesol(), casadi::expmsol(), casadi::DaeBuilderInternal::export_fmu(), casadi::external(), casadi::DaeBuilderInternal::fmu_fun(), casadi::FunctionInternal::forward(), casadi::ForwardDiff::get_forward(), casadi::CentralDiff::get_forward(), casadi::Smoothing::get_forward(), casadi::BlazingSplineFunction::get_jacobian(), casadi::Function::if_else(), casadi::Function::jit(), casadi::nlpsol(), casadi::rootfinder(), and casadi::OptiNode::solver_construct().

create() [2/2]

Function casadi::Function::create ( FunctionInternal *  node, const Dict &  opts  )

staticinherited

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

Definition at line 494 of file function.cpp.

                                                                    {
    Function ret = create(node);
    ret->construct(opts);
    return ret;
  }

References casadi::ProtoFunction::construct(), and casadi::Function::create().

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";
    }
  }

default_in()

double casadi::Function::default_in ( casadi_int  ind ) const

inherited

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

Definition at line 1677 of file function.cpp.

                                                  {
    return (*this)->get_default_in(ind);
  }

Referenced by casadi::Blocksqp::feasibilityRestorationPhase(), and casadi::FiniteDiff::get_default_in().

deserialize() [1/3]

Function casadi::Function::deserialize ( const std::string &  s )

staticinherited

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

Definition at line 1556 of file function.cpp.

                                                   {
    std::stringstream ss;
    ss << s;
    return deserialize(ss);
  }

References casadi::Function::deserialize().

deserialize() [2/3]

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

staticinherited

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

Definition at line 1491 of file function.cpp.

                                                       {
    bool is_null;
    s.unpack("Function::null", is_null);
    if (is_null) return Function();
    return FunctionInternal::deserialize(s);
  }

References casadi::FunctionInternal::deserialize(), casadi::Function::Function(), casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null(), and casadi::DeserializingStream::unpack().

deserialize() [3/3]

Function casadi::Function::deserialize ( std::istream &  stream )

staticinherited

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

Definition at line 1541 of file function.cpp.

                                                   {
    DeserializingStream s(stream);
    return deserialize(s);
  }

Referenced by casadi::Function::deserialize().

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

eval()

std::vector< DM > casadi::Callback::eval ( const std::vector< DM > &  arg ) const

virtual

This signature is not thread-safe. For guaranteed thread-safety, use eval_buffer

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

Definition at line 60 of file callback.cpp.

                                                             {
    return (*this)->FunctionInternal::eval_dm(arg);
  }

eval_activity()

int casadi::Function::eval_activity ( const bvec_t **  arg, bvec_t **  res, casadi_int *  iw, bvec_t *  w, int  mem = 0  ) const

inherited

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

Definition at line 1260 of file function.cpp.

                                                                    {
    try {
      return (*this)->eval_activity(arg, res, iw, w, memory(mem));
    } catch(std::exception& e) {
      THROW_ERROR("eval_activity", e.what());
    }
  }

References casadi::Function::memory().

Referenced by casadi::Function::activity(), and casadi::Call::eval_activity().

eval_buffer()

int casadi::Callback::eval_buffer ( const double **  arg, const std::vector< casadi_int > &  sizes_arg, double **  res, const std::vector< casadi_int > &  sizes_res  ) const

virtual

In Python, you will be passed two tuples of memoryview objects Note that only the structural nonzeros are present in the memoryview objects/buffers.

Make sure to override has_eval_buffer() to indicate support for this method.

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

Definition at line 53 of file callback.cpp.

                                                                                          {
    casadi_error("eval_buffer not overloaded.");
  }

expand() [1/2]

Function casadi::Function::expand ( ) const

inherited

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

Examples

Function/expand.py, and MX/matrix_expand.py.

Definition at line 312 of file function.cpp.

                                  {
    Dict opts = (*this)->generate_options("clone");
    return expand(name(), opts);
  }

References casadi::FunctionInternal::generate_options(), and casadi::Function::name().

Referenced by casadi::OracleFunction::expand(), casadi::OracleFunction::finalize(), casadi::Nlpsol::init(), casadi::OracleFunction::init(), casadi::MX::matrix_expand(), casadi::DaeBuilderInternal::oracle(), casadi::qpsol_nlp(), and casadi::Function::transform().

expand() [2/2]

Function casadi::Function::expand ( const std::string &  name, const Dict &  opts = Dict()  ) const

inherited

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

Definition at line 317 of file function.cpp.

                                                                         {
    casadi_assert(!has_free(),
      "Function with free symbols cannot be expanded. "
      "List of free variables in your Function: " +
        join(get_free(), ","));
 
    Dict my_opts = (*this)->generate_options("clone");
    update_dict(my_opts, opts);
    std::vector<SX> ex_in = sx_in();
    std::vector<SX> ex_out = Function(*this)(ex_in);
    return Function(name, ex_in, ex_out, name_in(), name_out(), my_opts);
  }

References casadi::Function::Function(), casadi::Function::get_free(), casadi::Function::has_free(), casadi::join(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::Function::sx_in(), and casadi::update_dict().

export_code() [1/3]

std::string casadi::Function::export_code ( const std::string &  lang, const Dict &  options = Dict()  ) const

inherited

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

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

Definition at line 1498 of file function.cpp.

                                                                                  {
    std::stringstream ss;
    (*this)->export_code(lang, ss, options);
    return ss.str();
  }

export_code() [2/3]

void casadi::Function::export_code ( const std::string &  lang, const std::string &  fname, const Dict &  options = Dict()  ) const

inherited

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

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

Definition at line 1459 of file function.cpp.

                                                         {
    auto stream_ptr = Filesystem::ofstream_ptr(fname);
    (*this)->export_code(lang, *stream_ptr, options);
  }

References casadi::Filesystem::ofstream_ptr().

export_code() [3/3]

void casadi::Function::export_code ( const std::string &  lang, std::ostream &  stream, const Dict &  options = Dict()  ) const

inherited

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

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

Definition at line 1454 of file function.cpp.

                                                     {
    (*this)->export_code(lang, stream, options);
  }

factory()

Function casadi::Function::factory ( const std::string &  name, const std::vector< std::string > &  s_in, const std::vector< std::string > &  s_out, const AuxOut &  aux = AuxOut(), const Dict &  opts = Dict()  ) const

inherited

Definition at line 2008 of file function.cpp.

                                  {
     try {
       return (*this)->factory(name, s_in, s_out, aux, opts);
     } catch(std::exception& e) {
       THROW_ERROR("factory", "Failed to create " + name + ":" + str(s_in) + "->" + str(s_out)
        + " with " + str(aux) + ":\n" + str(e.what()));
     }
  }

References casadi::FunctionInternal::factory(), casadi::Function::name(), and casadi::str().

Referenced by casadi::DaeBuilderInternal::create(), casadi::OracleFunction::create_function(), casadi::FunctionInternal::factory(), casadi::KinsolInterface::get_jtimes(), casadi::Function::hessian_old(), casadi::Rootfinder::init(), casadi::Blocksqp::init(), casadi::Function::jacobian_old(), and casadi::Nlpsol::kkt().

finalize()

virtual void casadi::Callback::finalize ( )

inlinevirtual

This function is called after the construction and init steps are completed, but before user functions are called. It is called recursively for the whole class hierarchy, starting with the highest level.

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

Definition at line 98 of file casadi/core/callback.hpp.

{}

find_function()

Function casadi::Function::find_function ( const std::string &  name, casadi_int  max_depth = -1  ) const

inherited

Parameters

[in]	name	Name of function needed
[in]	max_depth	Maximum depth - a negative number indicates no maximum

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

Definition at line 2084 of file function.cpp.

                                                                                    {
    try {
      // If negative, make largest positive number
      if (max_depth < 0) max_depth = std::numeric_limits<casadi_int>::max();
      // The internal routine uses a map to avoid duplicate functions
      std::map<FunctionInternal*, std::pair<Function, size_t> > all_fun;
      (*this)->find(all_fun, max_depth);
      // Search this map
      for (auto&& e : all_fun) {
        if (e.second.first.name() == name) return e.second.first;
      }
      // Not found
      casadi_error("'" + name + "' not found");
    } catch(std::exception& e) {
      THROW_ERROR("find", e.what());
      return Function();
    }
  }

References casadi::Function::Function(), and casadi::Function::name().

find_functions()

std::vector< Function > casadi::Function::find_functions ( casadi_int  max_depth = -1 ) const

inherited

Parameters

[in]

max_depth

Maximum depth - a negative number indicates no maximum

Returns

depth-first ordered, unique, list of dependencies

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

Definition at line 2067 of file function.cpp.

                                                                         {
    try {
      // If negative, make largest positive number
      if (max_depth < 0) max_depth = std::numeric_limits<casadi_int>::max();
      // The internal routine uses a map to avoid duplicate functions
      std::map<FunctionInternal*, std::pair<Function, size_t> > all_fun;
      (*this)->find(all_fun, max_depth);
      // Create return object
      std::vector<Function> ret(all_fun.size());
      for (auto&& e : all_fun) ret[e.second.second] = e.second.first;
      return ret;
    } catch(std::exception& e) {
      THROW_ERROR("find", e.what());
      return {};
    }
  }

Referenced by casadi::FunctionInternal::codegen_decref(), casadi::FunctionInternal::codegen_incref(), and casadi::DaeBuilder::gather_fun().

fix_name()

std::string casadi::Function::fix_name ( const std::string &  name )

staticinherited

Non-alphanumeric characters are converted into underscores and multiple consecutive undercores are dropped

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

Definition at line 1562 of file function.cpp.

                                                    {
    // Quick return if already valid name
    if (check_name(name)) return name;
 
    // If empty, name it "unnamed"
    if (name.empty()) return "unnamed";
 
    // Construct a sane name
    std::stringstream ss;
 
    // If the first character isn't a character, prepend an "a"
    if (!std::isalpha(name.front())) ss << "a";
 
    // Treat other characters
    bool previous_is_underscore = false;
    for (char c : name) {
      if (std::isalnum(c)) {
        // Alphanumeric characters
        ss << c;
        previous_is_underscore = false;
      } else if (!previous_is_underscore) {
        // Everything else becomes an underscore
        ss << '_';
        previous_is_underscore = true;
      }
    }
 
    // If name became a keyword, append 1
    for (const char* kw : {"null", "jac", "hess"}) {
      if (ss.str()==kw) ss << "1";
    }
 
    return ss.str();
  }

References casadi::Function::check_name(), and casadi::Function::name().

fold()

Function casadi::Function::fold ( casadi_int  N, const Dict &  opts = Dict()  ) const

inherited

Suppose the function has a signature of:

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

The the mapaccumulated version has the signature:

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

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

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

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

• much faster at construction time
• potentially much faster compilation times (for codegen)
• offers a trade-off between memory and evaluation time

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

This technique is much more scalable in terms of memory-usage, but slightly slower at evaluation, than a plain for-loop. The effect is similar to that of a for-loop with a check-pointing instruction after each chunk of iterations with size base.

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

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

Definition at line 661 of file function.cpp.

                                                              {
    Function base = mapaccum(N, opts);
    std::vector<MX> base_in = base.mx_in();
    std::vector<MX> out = base(base_in);
    out[0] = out[0](Slice(), range((N-1)*size2_out(0), N*size2_out(0))); // NOLINT
    return Function("fold_"+name(), base_in, out, name_in(), name_out(), opts);
  }

References casadi::Function::Function(), casadi::Function::mapaccum(), casadi::Function::mx_in(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::range(), and casadi::Function::size2_out().

forward()

Function casadi::Function::forward ( casadi_int  nfwd ) const

inherited

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

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

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

Definition at line 1324 of file function.cpp.

                                                  {
    try {
      return (*this)->forward(nfwd);
    } catch(std::exception& e) {
      THROW_ERROR("forward", e.what());
    }
  }

References casadi::FunctionInternal::forward().

Referenced by casadi::SXFunction::ad_forward(), casadi::DaeBuilderInternal::export_fmu(), casadi::FunctionInternal::forward(), casadi::Map::get_forward(), casadi::MapSum::get_forward(), casadi::Nlpsol::get_forward(), casadi::Switch::get_forward(), and casadi::ImplicitFixedStepIntegrator::init().

free_mx()

std::vector< MX > casadi::Function::free_mx ( ) const

inherited

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

Definition at line 1878 of file function.cpp.

                                        {
    try {
      return (*this)->free_mx();
    } catch(std::exception& e) {
      THROW_ERROR("free_mx", e.what());
    }
  }

Referenced by casadi::MX::get_free(), and casadi::MX::symvar().

free_sx()

std::vector< SX > casadi::Function::free_sx ( ) const

inherited

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

Definition at line 1870 of file function.cpp.

                                        {
    try {
      return (*this)->free_sx();
    } catch(std::exception& e) {
      THROW_ERROR("free_sx", e.what());
    }
  }

Referenced by casadi::Matrix< Scalar >::get_free().

generate() [1/2]

std::string casadi::Function::generate ( const Dict &  opts = Dict() ) const

inherited

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

Definition at line 1386 of file function.cpp.

                                                     {
    return generate(name(), opts);
  }

References casadi::Function::generate(), and casadi::Function::name().

generate() [2/2]

std::string casadi::Function::generate ( const std::string &  fname, const Dict &  opts = Dict()  ) const

inherited

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

Examples

SX/generateCode.py.

Definition at line 1390 of file function.cpp.

                                                                             {
    CodeGenerator gen(fname, opts);
    gen.add(*this);
    return gen.generate();
  }

References casadi::CodeGenerator::add(), and casadi::CodeGenerator::generate().

Referenced by casadi::Function::generate().

generate_dependencies()

std::string casadi::Function::generate_dependencies ( const std::string &  fname, const Dict &  opts = Dict()  ) const

inherited

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

Definition at line 1396 of file function.cpp.

                                                                                          {
    return (*this)->generate_dependencies(fname, opts);
  }

generate_in() [1/2]

std::vector< DM > casadi::Function::generate_in ( const std::string &  fname )

inherited

See also

generate_out

convert_in to convert between dict/map and vector

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

Definition at line 1430 of file function.cpp.

                                                            {
    DM data = DM::from_file(fname, "txt");
    // Empty files are okay
    if (data.is_empty(true)) data = DM(0, 1);
    casadi_assert(data.is_vector() && data.is_dense(), "Expected dense vector");
    casadi_assert(data.numel()==nnz_in(),
      "Dimension mismatch: file contains a vector of size " + str(data.numel())
      + ", while size " + str(nnz_in()) + " was expected.");
 
    return nz_to_in(data.nonzeros());
  }

References casadi::Matrix< double >::from_file(), casadi::GenericMatrix< MatType >::is_dense(), casadi::GenericMatrix< MatType >::is_empty(), casadi::GenericMatrix< MatType >::is_vector(), casadi::Function::nnz_in(), casadi::Matrix< Scalar >::nonzeros(), casadi::GenericMatrix< MatType >::numel(), casadi::Function::nz_to_in(), and casadi::str().

generate_in() [2/2]

void casadi::Function::generate_in ( const std::string &  fname, const std::vector< DM > &  arg  )

inherited

See also

generate_out

convert_in to convert between dict/map and vector

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

Definition at line 1400 of file function.cpp.

                                                                             {
    std::vector<double> d = nz_from_in(arg);
 
    // Set up output stream
    auto of_ptr = Filesystem::ofstream_ptr(fname);
    std::ostream& of = *of_ptr;
    normalized_setup(of);
 
    // Encode each output
    for (casadi_int i=0; i<d.size(); ++i) {
      normalized_out(of, d[i]);
      of << std::endl;
    }
  }

References casadi::normalized_out(), casadi::normalized_setup(), casadi::Function::nz_from_in(), and casadi::Filesystem::ofstream_ptr().

generate_lifted()

void casadi::Function::generate_lifted ( Function &  vdef_fcn, Function &  vinit_fcn  ) const

inherited

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

Definition at line 1898 of file function.cpp.

                                                                              {
    try {
      (*this)->generate_lifted(vdef_fcn, vinit_fcn);
    } catch(std::exception& e) {
      THROW_ERROR("generate_lifted", e.what());
    }
  }

Referenced by casadi::Scpgen::init().

generate_out() [1/2]

std::vector< DM > casadi::Function::generate_out ( const std::string &  fname )

inherited

See also

generate_in

convert_out to convert between dict/map and vector

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

Definition at line 1442 of file function.cpp.

                                                             {
    DM data = DM::from_file(fname, "txt");
    // Empty files are okay
    if (data.is_empty(true)) data = DM(0, 1);
    casadi_assert(data.is_vector() && data.is_dense(), "Expected dense vector");
    casadi_assert(data.numel()==nnz_out(),
      "Dimension mismatch: file contains a vector of size " + str(data.numel())
      + ", while size " + str(nnz_out()) + " was expected.");
 
    return nz_to_out(data.nonzeros());
  }

References casadi::Matrix< double >::from_file(), casadi::GenericMatrix< MatType >::is_dense(), casadi::GenericMatrix< MatType >::is_empty(), casadi::GenericMatrix< MatType >::is_vector(), casadi::Function::nnz_out(), casadi::Matrix< Scalar >::nonzeros(), casadi::GenericMatrix< MatType >::numel(), casadi::Function::nz_to_out(), and casadi::str().

generate_out() [2/2]

void casadi::Function::generate_out ( const std::string &  fname, const std::vector< DM > &  arg  )

inherited

See also

generate_in

convert_out to convert between dict/map and vector

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

Definition at line 1415 of file function.cpp.

                                                                              {
    std::vector<double> d = nz_from_out(res);
 
    // Set up output stream
    auto of_ptr = Filesystem::ofstream_ptr(fname);
    std::ostream& of = *of_ptr;
    normalized_setup(of);
 
    // Encode each output
    for (casadi_int i=0; i<d.size(); ++i) {
      normalized_out(of, d[i]);
      of << std::endl;
    }
  }

References casadi::normalized_out(), casadi::normalized_setup(), casadi::Function::nz_from_out(), and casadi::Filesystem::ofstream_ptr().

get() [1/2]

FunctionInternal * casadi::Function::get ( ) const

inherited

Get a const pointer to the node

Definition at line 505 of file function.cpp.

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

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

Referenced by casadi::FunctionInternal::add_embedded(), casadi::XFunction< DerivedType, MatType, NodeType >::call_forward(), casadi::XFunction< DerivedType, MatType, NodeType >::call_reverse(), casadi::LinearInterpolantJac::codegen_body(), casadi::conic_debug(), casadi::MX::cse(), casadi::CodeGenerator::define_local_mutex(), casadi::LinearInterpolantJac::eval(), casadi::MX::extract(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::XFunction< DerivedType, MatType, NodeType >::get_jacobian(), casadi::LinearInterpolantJac::has_parametric_grid(), casadi::LinearInterpolantJac::has_parametric_values(), casadi::SundialsInterface::init(), casadi::LinearInterpolantJac::init(), casadi::MX::jacobian(), casadi::CodeGenerator::local_mutex(), casadi::CodeGenerator::local_mutexes(), casadi::Function::operator->(), casadi::Function::operator==(), casadi::LinearInterpolantJac::serialize_type(), casadi::MX::simplify_const_folding(), casadi::simplify_const_folding_order(), casadi::MX::simplify_ref_count(), casadi::OptiNode::solve_prepare(), casadi::MX::substitute_inplace(), and casadi::CodeGenerator::wrapper().

get() [2/2]

template<typename T >

T* casadi::Function::get ( ) const

inlineinherited

Definition at line 984 of file function.hpp.

                   {
      T* ret = dynamic_cast<T*>(get());
      casadi_assert_dev(ret!=nullptr);
      return ret;
    }

References casadi::T.

get_factory()

Function casadi::Callback::get_factory ( const std::string &  name, const std::vector< std::string > &  s_in, const std::vector< std::string > &  s_out, const Function::AuxOut &  aux, const Dict &  opts  ) const

virtual

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

Definition at line 92 of file callback.cpp.

                              {
    return (*this)->FunctionInternal::factory(name, s_in, s_out, aux, opts);
  }

References casadi::Function::name().

get_forward()

Function casadi::Callback::get_forward ( casadi_int  nfwd, const std::string &  name, const std::vector< std::string > &  inames, const std::vector< std::string > &  onames, const Dict &  opts  ) const

virtual

forward(nfwd) returns a cached instance if available, and calls Function get_forward(casadi_int nfwd) if no cached version is available.

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

Definition at line 112 of file callback.cpp.

                                      {
    return (*this)->FunctionInternal::get_forward(nfwd, name, inames, onames, opts);
  }

References casadi::Function::name().

get_free()

std::vector< std::string > casadi::Function::get_free ( ) const

inherited

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

Definition at line 1382 of file function.cpp.

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

Referenced by casadi::OracleFunction::create_function(), casadi::Function::expand(), casadi::integrator(), casadi::nlpsol(), casadi::DaeBuilderInternal::prune(), casadi::rootfinder(), and casadi::DaeBuilderInternal::tearing_variables().

get_function() [1/2]

std::vector< std::string > casadi::Function::get_function ( ) const

inherited

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

Definition at line 2041 of file function.cpp.

                                                    {
    try {
      return (*this)->get_function();
    } catch(std::exception& e) {
      THROW_ERROR("get_function", e.what());
      return {};
    }
  }

Referenced by casadi::IdasInterface::psetupF().

get_function() [2/2]

Function casadi::Function::get_function ( const std::string &  name ) const

inherited

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

Definition at line 2050 of file function.cpp.

                                                             {
    try {
      return (*this)->get_function(name);
    } catch(std::exception& e) {
      THROW_ERROR("get_function", e.what());
    }
  }

References casadi::Function::name().

get_jac_sparsity()

virtual Sparsity casadi::Callback::get_jac_sparsity ( casadi_int  oind, casadi_int  iind, bool  symmetric  ) const

inlinevirtual

with respect to all output elements

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

Definition at line 228 of file casadi/core/callback.hpp.

                                                                                              {
      return Sparsity(); }

get_jacobian()

Function casadi::Callback::get_jacobian ( const std::string &  name, const std::vector< std::string > &  inames, const std::vector< std::string > &  onames, const Dict &  opts  ) const

virtual

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

Definition at line 104 of file callback.cpp.

                                       {
    return (*this)->FunctionInternal::get_jacobian(name, inames, onames, opts);
  }

References casadi::Function::name().

get_n_in()

casadi_int casadi::Callback::get_n_in ( )

virtual

This function is called during construction.

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

Definition at line 64 of file callback.cpp.

                                {
    return (*this)->FunctionInternal::get_n_in();
  }

get_n_out()

casadi_int casadi::Callback::get_n_out ( )

virtual

This function is called during construction.

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

Definition at line 68 of file callback.cpp.

                                 {
    return (*this)->FunctionInternal::get_n_out();
  }

get_name_in()

std::string casadi::Callback::get_name_in ( casadi_int  i )

virtual

This function is called during construction.

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

Definition at line 80 of file callback.cpp.

                                              {
    return (*this)->FunctionInternal::get_name_in(i);
  }

get_name_out()

std::string casadi::Callback::get_name_out ( casadi_int  i )

virtual

This function is called during construction.

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

Definition at line 84 of file callback.cpp.

                                               {
    return (*this)->FunctionInternal::get_name_out(i);
  }

get_reverse()

Function casadi::Callback::get_reverse ( casadi_int  nadj, const std::string &  name, const std::vector< std::string > &  inames, const std::vector< std::string > &  onames, const Dict &  opts  ) const

virtual

reverse(nadj) returns a cached instance if available, and calls Function get_reverse(casadi_int nadj) if no cached version is available.

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

Definition at line 124 of file callback.cpp.

                                      {
    return (*this)->FunctionInternal::get_reverse(nadj, name, inames, onames, opts);
  }

References casadi::Function::name().

get_sparsity_in()

Sparsity casadi::Callback::get_sparsity_in ( casadi_int  i )

virtual

This function is called during construction.

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

Definition at line 72 of file callback.cpp.

                                                 {
    return (*this)->FunctionInternal::get_sparsity_in(i);
  }

get_sparsity_out()

Sparsity casadi::Callback::get_sparsity_out ( casadi_int  i )

virtual

This function is called during construction.

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

Definition at line 76 of file callback.cpp.

                                                  {
    return (*this)->FunctionInternal::get_sparsity_out(i);
  }

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

getCount()

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

inherited

Definition at line 102 of file generic_shared_impl.hpp.

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

has_eval_buffer()

bool casadi::Callback::has_eval_buffer ( ) const

virtual

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

Definition at line 57 of file callback.cpp.

                                       {
    return false;
  }

has_forward()

bool casadi::Callback::has_forward ( casadi_int  nfwd ) const

virtual

forward(nfwd) returns a cached instance if available, and calls Function get_forward(casadi_int nfwd) if no cached version is available.

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

Definition at line 120 of file callback.cpp.

                                                  {
    return (*this)->FunctionInternal::has_forward(nfwd);
  }

has_free()

bool casadi::Function::has_free ( ) const

inherited

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

Definition at line 1894 of file function.cpp.

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

Referenced by casadi::construct_nlpsol(), casadi::OracleFunction::create_function(), casadi::detect_simple_bounds_gen(), casadi::Function::expand(), casadi::XFunction< DerivedType, MatType, NodeType >::factory(), casadi::integrator(), casadi::nlpsol(), casadi::rootfinder(), and casadi::DaeBuilderInternal::tearing_variables().

has_function()

bool casadi::Function::has_function ( const std::string &  fname ) const

inherited

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

Definition at line 2058 of file function.cpp.

                                                          {
    try {
      return (*this)->has_function(fname);
    } catch(std::exception& e) {
      THROW_ERROR("has_function", e.what());
      return false;
    }
  }

has_in()

bool casadi::Function::has_in ( const std::string &  name ) const

inherited

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

Definition at line 1137 of file function.cpp.

                                                   {
    for (const std::string& s : (*this)->name_in_) {
      if (s==name) return true;
    }
    return false;
  }

References casadi::Function::name().

has_jac_sparsity()

virtual bool casadi::Callback::has_jac_sparsity ( casadi_int  oind, casadi_int  iind  ) const

inlinevirtual

with respect to all output elements

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

Definition at line 227 of file casadi/core/callback.hpp.

{ return false; }

has_jacobian()

bool casadi::Callback::has_jacobian ( ) const

virtual

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

Definition at line 100 of file callback.cpp.

                                    {
    return (*this)->FunctionInternal::has_jacobian();
  }

has_option()

bool casadi::Function::has_option ( const std::string &  option_name ) const

inherited

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

Definition at line 1352 of file function.cpp.

                                                              {
    try {
      return (*this)->has_option(option_name);
    } catch(std::exception& e) {
      THROW_ERROR("has_option", e.what());
      return false;  // never reached
    }
  }

Referenced by casadi::Function::change_option().

has_out()

bool casadi::Function::has_out ( const std::string &  name ) const

inherited

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

Definition at line 1144 of file function.cpp.

                                                    {
    for (const std::string& s : (*this)->name_out_) {
      if (s==name) return true;
    }
    return false;
  }

References casadi::Function::name().

has_reverse()

bool casadi::Callback::has_reverse ( casadi_int  nadj ) const

virtual

reverse(nadj) returns a cached instance if available, and calls Function get_reverse(casadi_int nadj) if no cached version is available.

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

Definition at line 132 of file callback.cpp.

                                                  {
    return (*this)->FunctionInternal::has_reverse(nadj);
  }

has_spfwd()

bool casadi::Function::has_spfwd ( ) const

inherited

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

Definition at line 1886 of file function.cpp.

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

has_sprev()

bool casadi::Function::has_sprev ( ) const

inherited

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

Definition at line 1890 of file function.cpp.

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

hessian_old()

Function casadi::Function::hessian_old ( casadi_int  iind, casadi_int  oind  ) const

inherited

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

Definition at line 1048 of file function.cpp.

                                                                       {
    // Redirect to factory class
    std::vector<std::string> s_in = name_in();
    std::vector<std::string> s_out = name_out();
    s_out.insert(s_out.begin(), "grad:" + name_out(oind) + ":" + name_in(iind));
    s_out.insert(s_out.begin(),
                 "hess:" + name_out(oind) + ":" + name_in(iind) + ":" + name_in(iind));
    return factory(name() + "_hess", s_in, s_out);
  }

References casadi::Function::factory(), casadi::Function::name(), casadi::Function::name_in(), and casadi::Function::name_out().

if_else()

Function casadi::Function::if_else ( const std::string &  name, const Function &  f_true, const Function &  f_false, const Dict &  opts = Dict()  )

staticinherited

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

Definition at line 962 of file function.cpp.

                                                                        {
    try {
      return create(new Switch(name, std::vector<Function>(1, f_false), f_true), opts);
    } catch(std::exception& e) {
      THROW_ERROR_NOOBJ("if_else", e.what(), "Switch");
    }
  }

References casadi::Function::create(), and casadi::Function::name().

Referenced by casadi::Function::conditional(), and casadi::MX::if_else().

index_in()

casadi_int casadi::Function::index_in ( const std::string &  name ) const

inherited

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

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

Definition at line 1121 of file function.cpp.

                                                           {
    try {
      return (*this)->index_in(name);
    } catch(std::exception& e) {
      THROW_ERROR("index_in", e.what());
    }
  }

References casadi::Function::name().

Referenced by casadi::Function::buf_in(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::Function::sparsity_in(), casadi::DaeBuilderInternal::transition(), and casadi::DaeBuilderInternal::update_dependencies().

index_out()

casadi_int casadi::Function::index_out ( const std::string &  name ) const

inherited

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

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

Definition at line 1129 of file function.cpp.

                                                            {
    try {
      return (*this)->index_out(name);
    } catch(std::exception& e) {
      THROW_ERROR("index_out", e.what());
    }
  }

References casadi::Function::name().

Referenced by casadi::Function::buf_out(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::Function::sparsity_out(), and casadi::DaeBuilderInternal::update_dependencies().

info()

Dict casadi::Function::info ( ) const

inherited

Obtain information about function

Definition at line 2138 of file function.cpp.

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

init()

virtual void casadi::Callback::init ( )

inlinevirtual

This function is called after the object construction (for the whole class hierarchy) is complete, but before the finalization step. It is called recursively for the whole class hierarchy, starting with the lowest level.

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

Definition at line 88 of file casadi/core/callback.hpp.

{}

instruction_constant()

double casadi::Function::instruction_constant ( casadi_int  k ) const

inherited

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

Definition at line 1946 of file function.cpp.

                                                          {
    try {
      return (*this)->instruction_constant(k);
    } catch(std::exception& e) {
      THROW_ERROR("instruction_constant", e.what());
    }
  }

Referenced by casadi::SXFunction::export_code_body().

instruction_id()

casadi_int casadi::Function::instruction_id ( casadi_int  k ) const

inherited

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

Definition at line 1930 of file function.cpp.

                                                        {
    try {
      return (*this)->instruction_id(k);
    } catch(std::exception& e) {
      THROW_ERROR("instruction_id", e.what());
    }
  }

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

instruction_input()

std::vector< casadi_int > casadi::Function::instruction_input ( casadi_int  k ) const

inherited

(SXFunction/MXFunction)

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

Definition at line 1938 of file function.cpp.

                                                                      {
    try {
      return (*this)->instruction_input(k);
    } catch(std::exception& e) {
      THROW_ERROR("instruction_input", e.what());
    }
  }

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

instruction_MX()

MX casadi::Function::instruction_MX ( casadi_int  k ) const

inherited

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

Definition at line 1914 of file function.cpp.

                                                {
    try {
      return (*this)->instruction_MX(k);
    } catch(std::exception& e) {
      THROW_ERROR("instruction_MX", e.what());
    }
  }

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

instruction_output()

std::vector< casadi_int > casadi::Function::instruction_output ( casadi_int  k ) const

inherited

(SXFunction/MXFunction)

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

Definition at line 1954 of file function.cpp.

                                                                       {
    try {
      return (*this)->instruction_output(k);
    } catch(std::exception& e) {
      THROW_ERROR("instruction_output", e.what());
    }
  }

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

instructions_sx()

SX casadi::Function::instructions_sx ( ) const

inherited

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

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

Definition at line 1922 of file function.cpp.

                                     {
    try {
      return (*this)->instructions_sx();
    } catch(std::exception& e) {
      THROW_ERROR("instructions_sx", e.what());
    }
  }

is_a()

bool casadi::Function::is_a ( const std::string &  type, bool  recursive = true  ) const

inherited

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

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

Definition at line 1861 of file function.cpp.

                                                                 {
    return (*this)->is_a(type, recursive);
  }

Referenced by casadi::Integrator::augmented_dae(), casadi::Integrator::get_forward_dae(), casadi::MXFunction::get_stats(), casadi::Function::map(), and casadi::Function::transform().

is_diff_in() [1/2]

std::vector< bool > casadi::Function::is_diff_in ( ) const

inherited

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

Definition at line 1215 of file function.cpp.

                                             {
    try {
      return (*this)->is_diff_in_;
    } catch(std::exception& e) {
      THROW_ERROR("is_diff_in", e.what());
    }
  }

is_diff_in() [2/2]

bool casadi::Function::is_diff_in ( casadi_int  ind ) const

inherited

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

Definition at line 1199 of file function.cpp.

                                                {
    try {
      return (*this)->is_diff_in_.at(ind);
    } catch(std::exception& e) {
      THROW_ERROR("is_diff_in", e.what());
    }
  }

Referenced by casadi::FunctionInternal::get_sparsity_out(), casadi::Map::init(), and casadi::MapSum::init().

is_diff_out() [1/2]

std::vector< bool > casadi::Function::is_diff_out ( ) const

inherited

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

Definition at line 1223 of file function.cpp.

                                              {
    try {
      return (*this)->is_diff_out_;
    } catch(std::exception& e) {
      THROW_ERROR("is_diff_out", e.what());
    }
  }

is_diff_out() [2/2]

bool casadi::Function::is_diff_out ( casadi_int  ind ) const

inherited

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

Definition at line 1207 of file function.cpp.

                                                 {
    try {
      return (*this)->is_diff_out_.at(ind);
    } catch(std::exception& e) {
      THROW_ERROR("is_diff_out", e.what());
    }
  }

Referenced by casadi::FunctionInternal::get_sparsity_out(), casadi::Map::init(), and casadi::MapSum::init().

is_null()

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

inherited

Definition at line 116 of file generic_shared_impl.hpp.

                                                      {
    return node==nullptr;
  }

jac_sparsity() [1/2]

const std::vector< Sparsity > & casadi::Function::jac_sparsity ( bool  compact = false ) const

inherited

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

Definition at line 1092 of file function.cpp.

                                                                      {
    // Make sure all are calculated
    for (casadi_int oind = 0; oind < n_out(); ++oind) {
      for (casadi_int iind = 0; iind < n_in(); ++iind) {
        (void)jac_sparsity(oind, iind, compact);
      }
    }
    // Return reference to internal cache
    return (*this)->jac_sparsity_[compact];
  }

References casadi::Function::n_in(), and casadi::Function::n_out().

Referenced by casadi::_jacobian_sparsity(), casadi::CodeGenerator::add(), casadi::FunctionInternal::get_sparsity_out(), casadi::Integrator::sp_jac_dae(), casadi::Integrator::sp_jac_rdae(), and casadi::DaeBuilderInternal::update_dependencies().

jac_sparsity() [2/2]

Sparsity casadi::Function::jac_sparsity ( casadi_int  oind, casadi_int  iind, bool  compact = false  ) const

inherited

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

Definition at line 1103 of file function.cpp.

                                                                                      {
    try {
      bool symm = (*this)->jac_is_symm(oind, iind);
      symm = symm && sparsity_out(oind).is_dense();
      return (*this)->jac_sparsity(oind, iind, compact, symm);
    } catch(std::exception& e) {
      THROW_ERROR("jac_sparsity", e.what());
    }
  }

References casadi::Sparsity::is_dense(), and casadi::Function::sparsity_out().

jacobian()

Function casadi::Function::jacobian ( ) const

inherited

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

This function is cached.

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

Definition at line 1068 of file function.cpp.

                                    {
    try {
      return (*this)->jacobian();
    } catch(std::exception& e) {
      THROW_ERROR("jacobian", e.what());
    }
  }

References casadi::FunctionInternal::jacobian().

Referenced by casadi::DaeBuilderInternal::CallIO::calc_jac(), and casadi::FunctionInternal::jacobian().

jacobian_old()

Function casadi::Function::jacobian_old ( casadi_int  iind, casadi_int  oind  ) const

inherited

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

Definition at line 1040 of file function.cpp.

                                                                        {
    // Redirect to factory class
    std::vector<std::string> s_in = name_in();
    std::vector<std::string> s_out = name_out();
    s_out.insert(s_out.begin(), "jac:" + name_out(oind) + ":" + name_in(iind));
    return factory(name() + "_jac", s_in, s_out);
  }

References casadi::Function::factory(), casadi::Function::name(), casadi::Function::name_in(), and casadi::Function::name_out().

jit() [1/2]

Function casadi::Function::jit ( const std::string &  name, const std::string &  body, const std::vector< std::string > &  name_in, const std::vector< std::string > &  name_out, const Dict &  opts = Dict()  )

staticinherited

The names and sparsity patterns of all the inputs and outputs must be provided. If sparsities are not provided, all inputs and outputs are assumed to be scalar. Only specify the function body, assuming that input and output nonzeros are stored in arrays with the specified naming convension. The data type used is 'casadi_real', which is typically equal to 'double‘ or another data type with the same API as 'double’.

Inputs may be null pointers. This means that the all entries are zero. Outputs may be null points. This means that the corresponding result can be ignored.

If an error occurs in the evaluation, issue "return 1;";

The final generated function will have a structure similar to:

casadi_int fname(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem) { const casadi_real *x1, *x2; casadi_real *r1, *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 = *res++; <FUNCTION_BODY> return 0; }

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

Definition at line 289 of file function.cpp.

                                       {
    // Pass empty vectors -> default values
    std::vector<Sparsity> sparsity_in, sparsity_out;
    return jit(name, body, name_in, name_out, sparsity_in, sparsity_out, opts);
  }

References casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::Function::sparsity_in(), and casadi::Function::sparsity_out().

Referenced by casadi::JitFunction::get_jacobian().

jit() [2/2]

Function casadi::Function::jit ( const std::string &  name, const std::string &  body, const std::vector< std::string > &  name_in, const std::vector< std::string > &  name_out, const std::vector< Sparsity > &  sparsity_in, const std::vector< Sparsity > &  sparsity_out, const Dict &  opts = Dict()  )

staticinherited

The names and sparsity patterns of all the inputs and outputs must be provided. If sparsities are not provided, all inputs and outputs are assumed to be scalar. Only specify the function body, assuming that input and output nonzeros are stored in arrays with the specified naming convension. The data type used is 'casadi_real', which is typically equal to 'double‘ or another data type with the same API as 'double’.

Inputs may be null pointers. This means that the all entries are zero. Outputs may be null points. This means that the corresponding result can be ignored.

If an error occurs in the evaluation, issue "return 1;";

The final generated function will have a structure similar to:

casadi_int fname(const casadi_real** arg, casadi_real** res, casadi_int* iw, casadi_real* w, void* mem) { const casadi_real *x1, *x2; casadi_real *r1, *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 = *res++; <FUNCTION_BODY> return 0; }

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

Definition at line 298 of file function.cpp.

                                       {
    try {
      return create(new JitFunction(name, body, name_in, name_out,
                                    sparsity_in, sparsity_out), opts);
    } catch(std::exception& e) {
      THROW_ERROR_NOOBJ("jit", e.what(), "JitFunction");
    }
  }

References casadi::Function::create(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::Function::sparsity_in(), and casadi::Function::sparsity_out().

load()

Function casadi::Function::load ( const std::string &  filename )

staticinherited

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

Definition at line 1546 of file function.cpp.

                                                   {
    FileDeserializer fs(filename);
    auto t = fs.pop_type();
    if (t==SerializerBase::SerializationType::SERIALIZED_FUNCTION) {
      return fs.blind_unpack_function();
    } else {
      casadi_error("File is not loadable with 'load'. Use 'FileDeserializer' instead.");
    }
  }

References casadi::DeserializerBase::blind_unpack_function(), casadi::filename(), and casadi::DeserializerBase::pop_type().

Referenced by casadi::DaeBuilderInternal::load_fmi_description().

map() [1/5]

Function casadi::Function::map ( casadi_int  n, const std::string &  parallelization, casadi_int  max_num_threads  ) const

inherited

Definition at line 830 of file function.cpp.

                                        {
    casadi_assert(max_num_threads>=1, "max_num_threads invalid.");
    // No need for logic when we are not saturating the limit
    if (n<=max_num_threads) return map(n, parallelization);
 
    // Floored division
    casadi_int d = n/max_num_threads;
    if (d*max_num_threads==n) {
      // Easy when n is divisable by max_num_threads
      return map(d, "serial").map(max_num_threads, parallelization);
    } else {
      // Create a base map that computes a bit too much
      Function base = map(d+1, "serial").map(max_num_threads, parallelization);
      std::vector<MX> ret_in, base_in;
      casadi_int rem = (d+1)*max_num_threads-n;
      for (casadi_int i=0;i<n_in();++i) {
        MX arg = MX::sym("arg", repmat(sparsity_in(i), 1, n));
        ret_in.push_back(arg);
        MX last_arg = arg(Slice(), range((n-1)*size2_in(i), n*size2_in(i))); // NOLINT
        base_in.push_back(horzcat(arg, repmat(last_arg, 1, rem)));
      }
      std::vector<MX> ret_out = base(base_in);
      for (casadi_int i=0;i<n_out();++i) {
        ret_out[i] = horzsplit(ret_out[i], {0, n*size2_out(i), ret_out[i].size2()})[0];
      }
      return Function("helper", ret_in, ret_out, name_in(), name_out());
    }
  }

References casadi::Function::Function(), casadi::Function::map(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::range(), casadi::Function::size2_in(), casadi::Function::size2_out(), casadi::Function::sparsity_in(), and casadi::GenericMatrix< MX >::sym().

map() [2/5]

Function casadi::Function::map ( casadi_int  n, const std::string &  parallelization = "serial"  ) const

inherited

Suppose the function has a signature of:

   f: (a, p) -> ( s )

The the mapped version has the signature:

   F: (A, P) -> (S )

    with
        A: horzcat([a0, a1, ..., a_(N-1)])
        P: horzcat([p0, p1, ..., p_(N-1)])
        S: horzcat([s0, s1, ..., s_(N-1)])
    and
        s0 <- f(a0, p0)
        s1 <- f(a1, p1)
        ...
        s_(N-1) <- f(a_(N-1), p_(N-1))

Parameters

parallelization

Type of parallelization used: unroll|serial|openmp

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

Definition at line 861 of file function.cpp.

                                                                    {
    // Make sure not degenerate
    casadi_assert(n>0, "Degenerate map operation");
    // Quick return if possible
    if (n==1) return *this;
    // Unroll?
    if (parallelization=="unroll" || parallelization=="inline") {
      // Construct symbolic inputs
      std::vector<MX> arg(n_in());
      std::vector<std::vector<MX>> v(n, arg);
      std::vector<MX> tmp(n);
      for (casadi_int i=0; i<arg.size(); ++i) {
        for (casadi_int k=0; k<n; ++k) {
          tmp[k] = v[k][i] = MX::sym(name_in(i)+"_"+str(k), sparsity_in(i));
        }
        arg[i] = horzcat(tmp);
      }
      // Evaluate
      if (parallelization=="unroll") {
        for (auto&& w : v) w = (*this)(w);
      } else {
        for (auto&& w : v) call(std::vector<MX>(w), w, !is_a("SXFunction"), false);
      }
      // Gather outputs
      std::vector<MX> res(n_out());
      for (casadi_int i=0; i<res.size(); ++i) {
        for (casadi_int k=0; k<n; ++k) tmp[k] = v[k][i];
        res[i] = horzcat(tmp);
      }
      // Construct function
      return Function(name() + "_" + str(n), arg, res, name_in(), name_out());
    } else {
      // Generate/retrieve potentially cached map
      return (*this)->map(n, parallelization);
    }
  }

References casadi::Function::call(), casadi::Function::Function(), casadi::Function::is_a(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::Function::sparsity_in(), casadi::str(), and casadi::GenericMatrix< MX >::sym().

Referenced by casadi::Dple::get_forward(), casadi::Expm::get_forward(), casadi::External::get_forward(), casadi::Map::get_forward(), casadi::Dple::get_reverse(), casadi::Expm::get_reverse(), casadi::External::get_reverse(), casadi::Map::get_reverse(), and casadi::Function::map().

map() [3/5]

Function casadi::Function::map ( casadi_int  n, const std::vector< bool > &  reduce_in, const std::vector< bool > &  reduce_out = std::vector<bool>(), const Dict &  opts = Dict()  ) const

inherited

A subset of the inputs are non-repeated and a subset of the outputs summed up.

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

Definition at line 789 of file function.cpp.

                            {
    return MapSum::create("mapsum_" + str(n) + "_" + name(), "serial",
      *this, n, reduce_in, reduce_out, opts);
  }

References casadi::MapSum::create(), casadi::Function::name(), and casadi::str().

map() [4/5]

Function casadi::Function::map ( const std::string &  name, const std::string &  parallelization, casadi_int  n, const std::vector< casadi_int > &  reduce_in, const std::vector< casadi_int > &  reduce_out, const Dict &  opts = Dict()  ) const

inherited

A subset of the inputs are non-repeated and a subset of the outputs summed up.

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

Definition at line 797 of file function.cpp.

                                {
    // Wrap in an MXFunction
    Function f = map(n, parallelization);
    // Start with the fully mapped inputs
    std::vector<MX> arg = f.mx_in();
    std::vector<MX> f_arg = arg;
    // Replace reduced inputs
    for (casadi_int i : reduce_in) {
      arg[i] = mx_in(i);
      f_arg[i] = repmat(arg[i], 1, n);
    }
    // Get fully mapped outputs
    std::vector<MX> res = f(f_arg);
    // Replace reduced outputs
    for (casadi_int i : reduce_out) {
      res[i] = repsum(res[i], 1, n);
    }
    // Construct return
    return Function(name, arg, res, name_in(), name_out());
  }

References casadi::Function::Function(), casadi::Function::map(), casadi::Function::mx_in(), casadi::Function::name(), casadi::Function::name_in(), and casadi::Function::name_out().

map() [5/5]

Function casadi::Function::map ( const std::string &  name, const std::string &  parallelization, casadi_int  n, const std::vector< std::string > &  reduce_in, const std::vector< std::string > &  reduce_out, const Dict &  opts = Dict()  ) const

inherited

A subset of the inputs are non-repeated and a subset of the outputs summed up.

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

Definition at line 820 of file function.cpp.

                              {
    std::vector<casadi_int> reduce_in_num, reduce_out_num;
    for (const std::string& s : reduce_in) reduce_in_num.push_back(index_in(s));
    for (const std::string& s : reduce_out) reduce_out_num.push_back(index_out(s));
    return map(name, parallelization, n, reduce_in_num, reduce_out_num, opts);
  }

References casadi::Function::index_in(), casadi::Function::index_out(), casadi::Function::map(), and casadi::Function::name().

mapaccum() [1/6]

Function casadi::Function::mapaccum ( casadi_int  N, const Dict &  opts = Dict()  ) const

inherited

Suppose the function has a signature of:

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

The the mapaccumulated version has the signature:

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

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

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

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

• much faster at construction time
• potentially much faster compilation times (for codegen)
• offers a trade-off between memory and evaluation time

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

This technique is much more scalable in terms of memory-usage, but slightly slower at evaluation, than a plain for-loop. The effect is similar to that of a for-loop with a check-pointing instruction after each chunk of iterations with size base.

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

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

Definition at line 668 of file function.cpp.

                                                                  {
    return mapaccum("mapaccum_"+name(), N, opts);
  }

References casadi::Function::mapaccum(), and casadi::Function::name().

mapaccum() [2/6]

Function casadi::Function::mapaccum ( const std::string &  name, casadi_int  N, casadi_int  n_accum, const Dict &  opts = Dict()  ) const

inherited

Suppose the function has a signature of:

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

The the mapaccumulated version has the signature:

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

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

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

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

• much faster at construction time
• potentially much faster compilation times (for codegen)
• offers a trade-off between memory and evaluation time

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

This technique is much more scalable in terms of memory-usage, but slightly slower at evaluation, than a plain for-loop. The effect is similar to that of a for-loop with a check-pointing instruction after each chunk of iterations with size base.

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

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

Definition at line 674 of file function.cpp.

                                                      {
    Dict options = opts;
 
    // Default base
    casadi_int base = 10;
    auto it = options.find("base");
    if (it!=options.end()) {
      base = it->second;
      options.erase(it);
    }
 
    casadi_assert(N>0, "mapaccum: N must be positive");
 
    if (base==-1)
      return mapaccum(name, std::vector<Function>(N, *this), n_accum, options);
    casadi_assert(base>=2, "mapaccum: base must be positive");
 
    // Decompose N into
    std::vector<Function> chain;
    Function c = *this;
    while (N!=0) {
      casadi_int r = N % base;
      chain.insert(chain.end(), r, c);
      N = (N-r)/base;
      c = c.mapaccum(c.name()+"_acc"+str(base), std::vector<Function>(base, c), n_accum, options);
    }
    return mapaccum(name, chain, n_accum, options);
  }

References casadi::Function::mapaccum(), casadi::Function::name(), and casadi::str().

mapaccum() [3/6]

Function casadi::Function::mapaccum ( const std::string &  name, casadi_int  N, const Dict &  opts = Dict()  ) const

inherited

Suppose the function has a signature of:

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

The the mapaccumulated version has the signature:

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

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

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

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

• much faster at construction time
• potentially much faster compilation times (for codegen)
• offers a trade-off between memory and evaluation time

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

This technique is much more scalable in terms of memory-usage, but slightly slower at evaluation, than a plain for-loop. The effect is similar to that of a for-loop with a check-pointing instruction after each chunk of iterations with size base.

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

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

Definition at line 671 of file function.cpp.

                                                                                         {
    return mapaccum(name, N, 1, opts);
  }

References casadi::Function::name().

Referenced by casadi::MX::cumsum(), casadi::Function::fold(), and casadi::Function::mapaccum().

mapaccum() [4/6]

Function casadi::Function::mapaccum ( const std::string &  name, casadi_int  n, const std::vector< casadi_int > &  accum_in, const std::vector< casadi_int > &  accum_out, const Dict &  opts = Dict()  ) const

inherited

Suppose the function has a signature of:

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

The the mapaccumulated version has the signature:

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

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

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

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

• much faster at construction time
• potentially much faster compilation times (for codegen)
• offers a trade-off between memory and evaluation time

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

This technique is much more scalable in terms of memory-usage, but slightly slower at evaluation, than a plain for-loop. The effect is similar to that of a for-loop with a check-pointing instruction after each chunk of iterations with size base.

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

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

Definition at line 749 of file function.cpp.

                                                      {
    // Shorthands
    casadi_int n_in = this->n_in(), n_out = this->n_out();
    // Consistency checks
    casadi_assert_dev(in_range(accum_in, n_in) && isUnique(accum_in));
    casadi_assert_dev(in_range(accum_out, n_out) && isUnique(accum_out));
    casadi_assert_dev(accum_in.size()==accum_out.size());
    casadi_int n_accum=accum_in.size();
 
    // Quick return if no need to reorder
    if (accum_in==range(n_accum) && accum_out==range(n_accum)) {
      return mapaccum(name, n, n_accum, opts);
    }
 
    // Need to do some reordering
    std::vector<casadi_int> temp_in = complement(accum_in, n_in);
    std::vector<casadi_int> order_in = accum_in;
    order_in.insert(order_in.end(), temp_in.begin(), temp_in.end());
    std::vector<casadi_int> temp_out = complement(accum_out, n_out);
    std::vector<casadi_int> order_out = accum_out;
    order_out.insert(order_out.end(), temp_out.begin(), temp_out.end());
    Function ret = slice("slice_" + name, order_in, order_out);
    ret = ret.mapaccum("mapacc_" + name, n, n_accum, opts);
    return ret.slice(name, lookupvector(order_in, n_in),
                     lookupvector(order_out, n_out), opts);
  }

References casadi::complement(), casadi::in_range(), casadi::isUnique(), casadi::lookupvector(), casadi::Function::mapaccum(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name(), casadi::range(), and casadi::Function::slice().

mapaccum() [5/6]

Function casadi::Function::mapaccum ( const std::string &  name, casadi_int  n, const std::vector< std::string > &  accum_in, const std::vector< std::string > &  accum_out, const Dict &  opts = Dict()  ) const

inherited

Suppose the function has a signature of:

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

The the mapaccumulated version has the signature:

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

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

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

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

• much faster at construction time
• potentially much faster compilation times (for codegen)
• offers a trade-off between memory and evaluation time

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

This technique is much more scalable in terms of memory-usage, but slightly slower at evaluation, than a plain for-loop. The effect is similar to that of a for-loop with a check-pointing instruction after each chunk of iterations with size base.

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

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

Definition at line 779 of file function.cpp.

                                                      {
    std::vector<casadi_int> accum_in_num, accum_out_num;
    for (const std::string& s : accum_in) accum_in_num.push_back(index_in(s));
    for (const std::string& s : accum_out) accum_out_num.push_back(index_out(s));
    return mapaccum(name, n, accum_in_num, accum_out_num, opts);
  }

References casadi::Function::index_in(), casadi::Function::index_out(), casadi::Function::mapaccum(), and casadi::Function::name().

mapaccum() [6/6]

Function casadi::Function::mapaccum ( const std::string &  name, const std::vector< Function > &  chain, casadi_int  n_accum = 1, const Dict &  opts = Dict()  ) const

protectedinherited

Definition at line 704 of file function.cpp.

                                              {
    // Shorthands
    casadi_int n_in = this->n_in(), n_out = this->n_out();
    // Consistency checks
    casadi_assert(!chain.empty(), "mapaccum: chain must be non-empty");
    casadi_assert(n_accum<=std::min(n_in, n_out), "mapaccum: too many accumulators");
    // Quick return?
    if (chain.size()==1) return chain[0];
    // Get symbolic expressions for inputs and outputs
    std::vector<MX> arg = mx_in();
    std::vector<MX> res;
    // Vectorized inputs and outputs
    std::vector<std::vector<MX>> varg(n_in), vres(n_out);
    for (casadi_int i=0; i<n_accum; ++i) varg[i].push_back(arg[i]);
    // For each function call
    for (const auto& f : chain) {
 
      // Stacked input expressions
      for (casadi_int i=n_accum; i<n_in; ++i) {
        arg[i] = MX::sym(name_in(i) + "_" + str(i), f.sparsity_in(i));
        varg[i].push_back(arg[i]);
      }
 
      // Call f
      res = f(arg);
      // Save output expressions
      for (casadi_int i=0; i<n_out; ++i) vres[i].push_back(res[i]);
      // Copy function output to input
      std::copy_n(res.begin(), n_accum, arg.begin());
      for (casadi_int i=0; i<n_accum; ++i) {
        // Ony get last component (allows nested calls)
        casadi_int ncol_out=f.size2_out(i), ncol_in=size2_in(i);
        if (ncol_out>ncol_in) {
          arg[i] = horzsplit(arg[i], {0, ncol_out-ncol_in, ncol_out}).back();
        }
      }
    }
    // Construct return
    for (casadi_int i=0; i<n_in; ++i) arg[i] = horzcat(varg[i]);
    for (casadi_int i=0; i<n_out; ++i) res[i] = horzcat(vres[i]);
    return Function(name, arg, res, name_in(), name_out(), opts);
  }

References casadi::Function::Function(), casadi::Function::mx_in(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::Function::size2_in(), casadi::str(), and casadi::GenericMatrix< MX >::sym().

mapsum()

std::vector< MX > casadi::Function::mapsum ( const std::vector< MX > &  x, const std::string &  parallelization = "serial"  ) const

inherited

Parameters

parallelization

Type of parallelization used: unroll|serial|openmp

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

Definition at line 908 of file function.cpp.

                                                                      {
    try {
      return (*this)->mapsum_mx(x, parallelization);
    } catch(std::exception& e) {
      THROW_ERROR("mapsum", e.what());
    }
  }

max_in()

double casadi::Function::max_in ( casadi_int  ind ) const

inherited

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

Definition at line 1681 of file function.cpp.

                                              {
    return (*this)->get_max_in(ind);
  }

memory()

void * casadi::Function::memory ( int  ind ) const

inherited

Definition at line 1978 of file function.cpp.

                                      {
    return (*this)->memory(ind);
  }

Referenced by casadi::Function::eval_activity(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionBuffer::FunctionBuffer(), casadi::QpToNlp::get_stats(), casadi::Function::operator()(), casadi::FunctionBuffer::operator=(), casadi::Function::rev(), casadi::Function::set_temp(), casadi::Function::set_work(), casadi::Function::setup(), casadi::QpToNlp::solve(), casadi::ImplicitToNlp::solve(), and casadi::Function::stats().

merge()

void casadi::Function::merge ( const std::vector< MX > &  arg, std::vector< MX > &  subs_from, std::vector< MX > &  subs_to  ) const

inherited

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

Definition at line 1865 of file function.cpp.

                                                              {
    (*this)->merge(arg, subs_from, subs_to);
  }

min_in()

double casadi::Function::min_in ( casadi_int  ind ) const

inherited

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

Definition at line 1685 of file function.cpp.

                                              {
    return (*this)->get_min_in(ind);
  }

mx_in() [1/3]

const std::vector< MX > casadi::Function::mx_in ( ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1789 of file function.cpp.

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

Referenced by casadi::Function::map(), and casadi::Function::mapaccum().

mx_in() [2/3]

const MX casadi::Function::mx_in ( casadi_int  ind ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1781 of file function.cpp.

                                               {
    return (*this)->mx_in(ind);
  }

Referenced by casadi::Function::conditional(), casadi::DaeBuilderInternal::create(), casadi::FixedStepIntegrator::create_advanced(), casadi::Function::fold(), casadi::Map::get_forward(), casadi::MapSum::get_forward(), casadi::Switch::get_forward(), casadi::MX::get_input(), casadi::Map::get_reverse(), casadi::MapSum::get_reverse(), casadi::Switch::get_reverse(), casadi::Blocksqp::init(), casadi::Scpgen::init(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::Function::map(), casadi::Function::transform(), and casadi::DaeBuilderInternal::transition().

mx_in() [3/3]

const MX casadi::Function::mx_in ( const std::string &  iname ) const

inlineinherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1015 of file function.hpp.

                                                  {
      return mx_in(index_in(iname));
    }

mx_out() [1/3]

const std::vector< MX > casadi::Function::mx_out ( ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1793 of file function.cpp.

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

mx_out() [2/3]

const MX casadi::Function::mx_out ( casadi_int  ind ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1785 of file function.cpp.

                                                {
    return (*this)->mx_out(ind);
  }

mx_out() [3/3]

const MX casadi::Function::mx_out ( const std::string &  oname ) const

inlineinherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1043 of file function.hpp.

                                                  {
      return mx_out(index_out(oname));
    }

n_in()

casadi_int casadi::Function::n_in ( ) const

inherited

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

Definition at line 971 of file function.cpp.

                                  {
    return (*this)->n_in_;
  }

Referenced by casadi::Function::activity(), casadi::CodeGenerator::add(), casadi::Function::buf_in(), casadi::OracleFunction::calc_function(), casadi::DaeBuilderInternal::CallIO::calc_jac(), casadi::Call::Call(), casadi::Function::call_gen(), casadi::Nlpsol::callback(), casadi::FiniteDiff::codegen_body(), casadi::Sqpmethod::codegen_qp_ela_solve(), casadi::Feasiblesqpmethod::codegen_qp_solve(), casadi::Sqpmethod::codegen_qp_solve(), casadi::construct_nlpsol(), casadi::Call::create(), casadi::MapSum::create(), casadi::OracleFunction::create_function(), casadi::FiniteDiff::eval(), casadi::Scpgen::eval_exp(), casadi::Scpgen::eval_mat(), casadi::Scpgen::eval_res(), casadi::CallSX::eval_sx(), casadi::Scpgen::eval_vec(), casadi::SXFunction::ExtendedAlgEl::ExtendedAlgEl(), casadi::External::factory(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionInternal::forward(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), casadi::FiniteDiff::get_default_in(), casadi::FunctionInternal::get_n_in(), casadi::FiniteDiff::get_n_in(), casadi::Switch::get_n_in(), casadi::FunctionInternal::get_n_out(), casadi::FunctionInternal::get_name_in(), casadi::FiniteDiff::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::FunctionInternal::get_sparsity_in(), casadi::FiniteDiff::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::BonminInterface::init(), casadi::GurobiInterface::init(), casadi::IpoptInterface::init(), casadi::FastNewton::init(), casadi::Feasiblesqpmethod::init(), casadi::Newton::init(), casadi::Sqpmethod::init(), casadi::BonminInterface::intermediate_callback(), casadi::IpoptInterface::intermediate_callback(), casadi::Function::jac_sparsity(), casadi::FunctionInternal::jacobian(), casadi::Onnx::load(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::MapSum::MapSum(), casadi::SymbolicQr::nfact(), casadi::SXFunction::print(), casadi::SXNode::print_compact(), casadi::qpsol_nlp(), casadi::Function::rev(), casadi::FunctionInternal::reverse(), casadi::simpleIntegrator(), casadi::simpleIRK(), casadi::simpleRK(), casadi::WorhpInterface::solve(), casadi::Scpgen::solve(), casadi::SymbolicQr::solve(), casadi::Sqpmethod::solve_ela_QP(), casadi::Feasiblesqpmethod::solve_LP(), casadi::Feasiblesqpmethod::solve_QP(), casadi::Qrsqp::solve_QP(), casadi::Scpgen::solve_qp(), casadi::Sqpmethod::solve_QP(), and casadi::ThreadsWork().

n_instructions()

casadi_int casadi::Function::n_instructions ( ) const

inherited

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

Definition at line 1906 of file function.cpp.

                                            {
    try {
      return (*this)->n_instructions();
    } catch(std::exception& e) {
      THROW_ERROR("n_instructions", e.what());
    }
  }

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

n_nodes()

casadi_int casadi::Function::n_nodes ( ) const

inherited

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

Definition at line 1962 of file function.cpp.

                                     {
    try {
      return (*this)->n_nodes();
    } catch(std::exception& e) {
      THROW_ERROR("n_nodes", e.what());
    }
  }

Referenced by casadi::Scpgen::init(), casadi::MX::n_nodes(), and casadi::transform_stats().

n_out()

casadi_int casadi::Function::n_out ( ) const

inherited

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

Definition at line 975 of file function.cpp.

                                   {
    return (*this)->n_out_;
  }

Referenced by casadi::Function::activity(), casadi::CodeGenerator::add(), casadi::Function::buf_out(), casadi::OracleFunction::calc_function(), casadi::DaeBuilderInternal::CallIO::calc_jac(), casadi::Function::call_gen(), casadi::Nlpsol::callback(), casadi::FiniteDiff::codegen_body(), casadi::Sqpmethod::codegen_qp_ela_solve(), casadi::Feasiblesqpmethod::codegen_qp_solve(), casadi::Sqpmethod::codegen_qp_solve(), casadi::Function::conditional(), casadi::construct_nlpsol(), casadi::Call::create(), casadi::MapSum::create(), casadi::OracleFunction::create_function(), casadi::FiniteDiff::eval(), casadi::Scpgen::eval_exp(), casadi::Scpgen::eval_mat(), casadi::Scpgen::eval_res(), casadi::CallSX::eval_sx(), casadi::Scpgen::eval_vec(), casadi::MXFunction::export_code_body(), casadi::SXFunction::ExtendedAlgEl::ExtendedAlgEl(), casadi::External::factory(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionInternal::forward(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), casadi::FunctionInternal::get_n_in(), casadi::FiniteDiff::get_n_in(), casadi::FunctionInternal::get_n_out(), casadi::FiniteDiff::get_n_out(), casadi::Switch::get_n_out(), casadi::FunctionInternal::get_name_in(), casadi::FiniteDiff::get_name_in(), casadi::FunctionInternal::get_sparsity_in(), casadi::FiniteDiff::get_sparsity_in(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::BonminInterface::init(), casadi::GurobiInterface::init(), casadi::IpoptInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Sqpmethod::init(), casadi::BonminInterface::intermediate_callback(), casadi::IpoptInterface::intermediate_callback(), casadi::Function::jac_sparsity(), casadi::FunctionInternal::jacobian(), casadi::Onnx::load(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::MapSum::MapSum(), casadi::SymbolicQr::nfact(), casadi::Call::nout(), casadi::SXFunction::print(), casadi::qpsol_nlp(), casadi::Function::rev(), casadi::FunctionInternal::reverse(), casadi::simpleIntegrator(), casadi::simpleIRK(), casadi::simpleRK(), casadi::WorhpInterface::solve(), casadi::Scpgen::solve(), casadi::SymbolicQr::solve(), casadi::Sqpmethod::solve_ela_QP(), casadi::Feasiblesqpmethod::solve_LP(), casadi::Feasiblesqpmethod::solve_QP(), casadi::Qrsqp::solve_QP(), casadi::Scpgen::solve_qp(), casadi::Sqpmethod::solve_QP(), and casadi::ThreadsWork().

name()

const std::string & casadi::Function::name ( ) const

inherited

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

Definition at line 1504 of file function.cpp.

                                        {
    if (is_null()) {
      static std::string null = "null";
      return null;
    } else {
      return (*this)->name_;
    }
  }

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

Referenced by casadi::CodeGenerator::add(), casadi::DaeBuilderInternal::add_fun(), casadi::Integrator::augmented_dae(), casadi::Function::bspline(), casadi::Call::Call(), casadi::Function::check_name(), casadi::Function::conditional(), construct(), casadi::Function::construct(), casadi::construct_nlpsol(), casadi::MapSum::create(), casadi::Map::create(), casadi::FixedStepIntegrator::create_advanced(), casadi::Call::disp(), casadi::Switch::disp_more(), casadi::Function::expand(), casadi::Function::factory(), casadi::Function::find_function(), casadi::Function::fix_name(), casadi::Function::fold(), casadi::Function::Function(), casadi::FunctionInternal::FunctionInternal(), casadi::Function::generate(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), get_factory(), get_forward(), casadi::MapSum::get_forward(), casadi::MXFunction::get_function(), casadi::SXFunction::get_function(), casadi::Function::get_function(), get_jacobian(), casadi::FunctionInternal::get_n_in(), casadi::FunctionInternal::get_n_out(), casadi::FunctionInternal::get_name_in(), casadi::FunctionInternal::get_name_out(), get_reverse(), casadi::MapSum::get_reverse(), casadi::FunctionInternal::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::GraphBuilder::GraphBuilder(), casadi::Function::has_in(), casadi::Function::has_out(), casadi::Function::hessian_old(), casadi::Function::if_else(), casadi::Function::index_in(), casadi::Function::index_out(), casadi::FunctionInternal::init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::Rootfinder::init(), casadi::SundialsInterface::init(), casadi::FunctionInternal::jac_is_symm(), casadi::Function::jacobian_old(), casadi::Function::jit(), casadi::Onnx::load(), casadi::FunctionInternal::map(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::SXFunction::print(), casadi::SXNode::print_compact(), casadi::Function::print_option(), casadi::OptiNode::scale_helper(), casadi::OracleFunction::set_function(), casadi::RungeKutta::setup_step(), casadi::Function::slice(), casadi::FunctionInternal::tocache(), casadi::FunctionInternal::tocache_if_missing(), casadi::Function::transform(), casadi::Function::wrap(), and casadi::Function::wrap_as_needed().

name_in() [1/2]

const std::vector< std::string > & casadi::Function::name_in ( ) const

inherited

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

Definition at line 1113 of file function.cpp.

                                                      {
    return (*this)->name_in_;
  }

Referenced by casadi::CodeGenerator::add(), casadi::Function::assert_size_in(), casadi::OracleFunction::calc_function(), casadi::Function::conditional(), casadi::Function::construct(), casadi::construct_nlpsol(), casadi::DaeBuilderInternal::create(), casadi::Function::expand(), casadi::External::factory(), casadi::Function::fold(), casadi::Function::Function(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), casadi::KinsolInterface::get_jtimes(), casadi::FunctionInternal::get_name_in(), casadi::FiniteDiff::get_name_in(), casadi::Rootfinder::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::Rootfinder::get_name_out(), casadi::Function::hessian_old(), casadi::Rootfinder::init(), casadi::Function::jacobian_old(), casadi::Function::jit(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::onnx_input_name(), casadi::qpsol_nlp(), casadi::OptiNode::scale_helper(), and casadi::Function::transform().

name_in() [2/2]

const std::string & casadi::Function::name_in ( casadi_int  ind ) const

inherited

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

Definition at line 1151 of file function.cpp.

                                                         {
    try {
      return (*this)->name_in_.at(ind);
    } catch(std::exception& e) {
      THROW_ERROR("name_in", e.what());
    }
  }

name_out() [1/2]

const std::vector< std::string > & casadi::Function::name_out ( ) const

inherited

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

Definition at line 1117 of file function.cpp.

                                                       {
    return (*this)->name_out_;
  }

Referenced by casadi::CodeGenerator::add(), casadi::Function::assert_size_out(), casadi::Function::assert_sparsity_out(), casadi::blazing_spline(), casadi::OracleFunction::calc_function(), casadi::Function::call_gen(), casadi::Function::conditional(), casadi::Function::construct(), casadi::construct_nlpsol(), casadi::DaeBuilderInternal::create(), casadi::Function::expand(), casadi::External::factory(), casadi::Function::fold(), casadi::Function::Function(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), casadi::KinsolInterface::get_jtimes(), casadi::FunctionInternal::get_name_in(), casadi::FiniteDiff::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::FiniteDiff::get_name_out(), casadi::Rootfinder::get_name_out(), casadi::Function::hessian_old(), casadi::Rootfinder::init(), casadi::Function::jacobian_old(), casadi::Function::jit(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::onnx_output_name(), casadi::qpsol_nlp(), casadi::OptiNode::scale_helper(), and casadi::Function::transform().

name_out() [2/2]

const std::string & casadi::Function::name_out ( casadi_int  ind ) const

inherited

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

Definition at line 1159 of file function.cpp.

                                                          {
    try {
      return (*this)->name_out_.at(ind);
    } catch(std::exception& e) {
      THROW_ERROR("name_out", e.what());
    }
  }

nnz_in() [1/3]

casadi_int casadi::Function::nnz_in ( ) const

inherited

For a particular input or for all of the inputs

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

Definition at line 1003 of file function.cpp.

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

Referenced by casadi::_which_depends(), casadi::Function::activity(), casadi::SXFunction::ad_forward(), casadi::SXFunction::ad_reverse(), casadi::Function::buf_in(), casadi::OracleFunction::calc_function(), casadi::FiniteDiff::codegen_body(), casadi::Map::codegen_body(), casadi::OmpMap::codegen_body(), casadi::ThreadMap::codegen_body(), casadi::MapSum::codegen_body(), casadi::CallSX::create(), casadi::Call::create(), casadi::FiniteDiff::eval(), casadi::OmpMap::eval(), casadi::Map::eval_gen(), casadi::MapSum::eval_gen(), casadi::CallSX::eval_sx(), casadi::SXFunction::ExtendedAlgEl::ExtendedAlgEl(), casadi::Call::generate(), casadi::Function::generate_in(), casadi::MapSum::get_forward(), casadi::MapSum::get_reverse(), casadi::FiniteDiff::init(), casadi::Rootfinder::init(), casadi::SXFunction::init(), casadi::ImplicitToNlp::init(), casadi::QpToNlp::init(), casadi::SXFunction::print(), casadi::SXFunction::print_arg(), casadi::SXNode::print_compact(), casadi::SXFunction::print_res(), casadi::FunctionBuffer::set_arg(), casadi::ImplicitToNlp::set_work(), casadi::ImplicitToNlp::solve(), casadi::Map::sp_reverse(), casadi::MapSum::sp_reverse(), and casadi::ThreadsWork().

nnz_in() [2/3]

casadi_int casadi::Function::nnz_in ( casadi_int  ind ) const

inherited

For a particular input or for all of the inputs

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

Definition at line 1019 of file function.cpp.

                                                  {
    return (*this)->nnz_in(ind);
  }

nnz_in() [3/3]

casadi_int casadi::Function::nnz_in ( const std::string &  iname ) const

inlineinherited

For a particular input or for all of the inputs

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

Definition at line 302 of file function.hpp.

{return nnz_in(index_in(iname));}

References casadi::Function::nnz_in().

Referenced by casadi::Function::nnz_in().

nnz_out() [1/3]

casadi_int casadi::Function::nnz_out ( ) const

inherited

For a particular output or for all of the outputs

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

Definition at line 1007 of file function.cpp.

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

Referenced by casadi::_which_depends(), casadi::Function::activity(), casadi::SXFunction::ad_forward(), casadi::SXFunction::ad_reverse(), casadi::Function::buf_out(), casadi::SundialsInterface::calc_daeB(), casadi::OracleFunction::calc_function(), casadi::SundialsInterface::calc_quadB(), casadi::SXElem::call(), casadi::FiniteDiff::codegen_body(), casadi::Map::codegen_body(), casadi::OmpMap::codegen_body(), casadi::ThreadMap::codegen_body(), casadi::MapSum::codegen_body(), casadi::FiniteDiff::eval(), casadi::OmpMap::eval(), casadi::Map::eval_gen(), casadi::MapSum::eval_gen(), casadi::CallSX::eval_sx(), casadi::SXFunction::ExtendedAlgEl::ExtendedAlgEl(), casadi::Call::generate(), casadi::Function::generate_out(), casadi::FiniteDiff::init(), casadi::FixedStepIntegrator::init(), casadi::MapSum::init(), casadi::Rootfinder::init(), casadi::SXFunction::init(), casadi::SundialsInterface::init(), casadi::SuperscsInterface::init(), casadi::SymbolicQr::init_mem(), casadi::SXFunction::print(), casadi::SXFunction::print_res(), casadi::FunctionBuffer::set_res(), casadi::SundialsInterface::set_work(), casadi::SuperscsInterface::solve(), casadi::Map::sp_reverse(), casadi::MapSum::sp_reverse(), casadi::FixedStepIntegrator::stepB(), and casadi::ThreadsWork().

nnz_out() [2/3]

casadi_int casadi::Function::nnz_out ( casadi_int  ind ) const

inherited

For a particular output or for all of the outputs

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

Definition at line 1023 of file function.cpp.

                                                   {
    return (*this)->nnz_out(ind);
  }

nnz_out() [3/3]

casadi_int casadi::Function::nnz_out ( const std::string &  oname ) const

inlineinherited

For a particular output or for all of the outputs

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

Definition at line 313 of file function.hpp.

{return nnz_out(index_out(oname));}

References casadi::Function::nnz_out().

Referenced by casadi::Function::nnz_out().

nominal_in()

std::vector< double > casadi::Function::nominal_in ( casadi_int  ind ) const

inherited

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

Definition at line 1689 of file function.cpp.

                                                             {
    return (*this)->get_nominal_in(ind);
  }

Referenced by casadi::Integrator::init().

nominal_out()

std::vector< double > casadi::Function::nominal_out ( casadi_int  ind ) const

inherited

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

Definition at line 1693 of file function.cpp.

                                                              {
    return (*this)->get_nominal_out(ind);
  }

numel_in() [1/3]

casadi_int casadi::Function::numel_in ( ) const

inherited

For a particular input or for all of the inputs

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

Definition at line 1011 of file function.cpp.

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

Referenced by casadi::Integrator::init().

numel_in() [2/3]

casadi_int casadi::Function::numel_in ( casadi_int  ind ) const

inherited

For a particular input or for all of the inputs

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

Definition at line 1027 of file function.cpp.

                                                    {
    return (*this)->numel_in(ind);
  }

numel_in() [3/3]

casadi_int casadi::Function::numel_in ( const std::string &  iname ) const

inlineinherited

For a particular input or for all of the inputs

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

Definition at line 336 of file function.hpp.

{return numel_in(index_in(iname));}

References casadi::Function::numel_in().

Referenced by casadi::Function::numel_in().

numel_out() [1/3]

casadi_int casadi::Function::numel_out ( ) const

inherited

For a particular output or for all of the outputs

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

Definition at line 1015 of file function.cpp.

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

Referenced by casadi::Integrator::init(), and casadi::Nlpsol::init().

numel_out() [2/3]

casadi_int casadi::Function::numel_out ( casadi_int  ind ) const

inherited

For a particular output or for all of the outputs

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

Definition at line 1031 of file function.cpp.

                                                     {
    return (*this)->numel_out(ind);
  }

numel_out() [3/3]

casadi_int casadi::Function::numel_out ( const std::string &  oname ) const

inlineinherited

For a particular output or for all of the outputs

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

Definition at line 347 of file function.hpp.

{return numel_out(index_out(oname));}

References casadi::Function::numel_out().

Referenced by casadi::Function::numel_out().

nz_from_in()

std::vector< double > casadi::Function::nz_from_in ( const std::vector< DM > &  arg ) const

inherited

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

Definition at line 1797 of file function.cpp.

                                                                       {
    return (*this)->nz_in(arg);
  }

Referenced by casadi::Function::generate_in().

nz_from_out()

std::vector< double > casadi::Function::nz_from_out ( const std::vector< DM > &  arg ) const

inherited

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

Definition at line 1801 of file function.cpp.

                                                                        {
    return (*this)->nz_out(res);
  }

Referenced by casadi::Function::generate_out().

nz_to_in()

std::vector< DM > casadi::Function::nz_to_in ( const std::vector< double > &  arg ) const

inherited

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

Definition at line 1805 of file function.cpp.

                                                                     {
    return (*this)->nz_in(arg);
  }

Referenced by casadi::Function::generate_in().

nz_to_out()

std::vector< DM > casadi::Function::nz_to_out ( const std::vector< double > &  arg ) const

inherited

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

Definition at line 1809 of file function.cpp.

                                                                      {
    return (*this)->nz_out(res);
  }

Referenced by casadi::Function::generate_out().

operator()() [1/24]

int casadi::Function::operator() ( const bvec_t **  arg, bvec_t **  res, casadi_int *  iw, bvec_t *  w, int  mem = 0  ) const

inherited

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

Definition at line 1243 of file function.cpp.

                                                                      {
    try {
      return (*this)->sp_forward(arg, res, iw, w, memory(mem));
    } catch(std::exception& e) {
      THROW_ERROR("operator()", e.what());
    }
  }

References casadi::Function::memory().

operator()() [2/24]

std::vector<DM> casadi::Function::operator() ( const DM &  arg0 ) const

inlineinherited

Functor shorthand for evaluation, single argument (only C++)

Definition at line 651 of file function.hpp.

                                                   {
      return operator()(std::vector<DM>{arg0});
    }

operator()() [3/24]

const DMDict casadi::Function::operator() ( const DMDict &  arg ) const

inherited

Functor shorthand for evaluation

Definition at line 1632 of file function.cpp.

                                                           {
    DMDict res;
    call(arg, res);
    return res;
  }

References casadi::Function::call().

operator()() [4/24]

int casadi::Function::operator() ( const double **  arg, double **  res, casadi_int *  iw, double *  w  ) const

inherited

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

Definition at line 1702 of file function.cpp.

                                       {
    scoped_checkout<Function> mem(*this);
    return operator()(arg, res, iw, w, mem);
  }

References casadi::Function::operator()().

operator()() [5/24]

int casadi::Function::operator() ( const double **  arg, double **  res, casadi_int *  iw, double *  w, int  mem  ) const

inherited

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

Definition at line 1708 of file function.cpp.

                                                {
    try {
#ifdef WITH_EXTRA_CHECKS
      // Should never happen
      casadi_assert_dev(call_depth_>=0);
      call_depth_++;
      // For consistency check
      casadi_int depth = call_depth_;
#endif // WITH_EXTRA_CHECKS
      int ret = (*this)->eval_gen(arg, res, iw, w, memory(mem), false, false);
#ifdef WITH_EXTRA_CHECKS
      // Consitency check
      casadi_assert_dev(call_depth_==depth);
      call_depth_--;
#endif // WITH_EXTRA_CHECKS
      return ret;
    } catch (KeyboardInterruptException& e) {
      (void)e;  // unused
#ifdef WITH_EXTRA_CHECKS
      call_depth_--;
#endif // WITH_EXTRA_CHECKS
      throw;
    } catch(std::exception& e) {
#ifdef WITH_EXTRA_CHECKS
      call_depth_--;
#endif // WITH_EXTRA_CHECKS
      (*this)->print_in(uerr(), arg, true);
      THROW_ERROR("operator()", e.what());
    }
  }

References casadi::Function::memory(), casadi::uerr(), and casadi::CasadiException::what().

operator()() [6/24]

std::vector<MX> casadi::Function::operator() ( const MX &  arg0 ) const

inlineinherited

Functor shorthand for evaluation, single argument (only C++)

Definition at line 657 of file function.hpp.

                                                   {
      return operator()(std::vector<MX>{arg0});
    }

operator()() [7/24]

const MXDict casadi::Function::operator() ( const MXDict &  arg ) const

inherited

Functor shorthand for evaluation

Definition at line 1644 of file function.cpp.

                                                           {
    MXDict res;
    call(arg, res);
    return res;
  }

References casadi::Function::call().

operator()() [8/24]

std::vector< DM > casadi::Function::operator() ( const std::vector< DM > &  arg ) const

inherited

Functor shorthand for evaluation

Definition at line 1597 of file function.cpp.

                                                                   {
    std::vector<DM> res;
    call(arg, res);
    return res;
  }

References casadi::Function::call().

Referenced by casadi::Function::operator()().

operator()() [9/24]

std::vector< MX > casadi::Function::operator() ( const std::vector< MX > &  arg ) const

inherited

Functor shorthand for evaluation

Definition at line 1609 of file function.cpp.

                                                                   {
    std::vector<MX> res;
    call(arg, res);
    return res;
  }

References casadi::Function::call().

operator()() [10/24]

std::vector< SX > casadi::Function::operator() ( const std::vector< SX > &  arg ) const

inherited

Functor shorthand for evaluation

Definition at line 1603 of file function.cpp.

                                                                   {
    std::vector<SX> res;
    call(arg, res);
    return res;
  }

References casadi::Function::call().

operator()() [11/24]

std::vector<SX> casadi::Function::operator() ( const SX &  arg0 ) const

inlineinherited

Functor shorthand for evaluation, single argument (only C++)

Definition at line 654 of file function.hpp.

                                                   {
      return operator()(std::vector<SX>{arg0});
    }

operator()() [12/24]

const SXDict casadi::Function::operator() ( const SXDict &  arg ) const

inherited

Functor shorthand for evaluation

Definition at line 1638 of file function.cpp.

                                                           {
    SXDict res;
    call(arg, res);
    return res;
  }

References casadi::Function::call().

operator()() [13/24]

int casadi::Function::operator() ( const SXElem **  arg, SXElem **  res, casadi_int *  iw, SXElem *  w, int  mem = 0  ) const

inherited

Same syntax as the double version, allowing use in templated code

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

Definition at line 1740 of file function.cpp.

                                                {
    try {
      return (*this)->eval_sx(arg, res, iw, w, memory(mem), false, false);
    } catch(std::exception& e) {
      THROW_ERROR("operator()", e.what());
    }
  }

References casadi::Function::memory().

operator()() [14/24]

void casadi::Function::operator() ( MapArg  arg, MapRes  res  ) const

inlineinherited

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

Definition at line 644 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator()() [15/24]

void casadi::Function::operator() ( MapArg  arg, MPrRes  res  ) const

inlineinherited

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

Definition at line 646 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator()() [16/24]

void casadi::Function::operator() ( MapArg  arg, VecRes  res  ) const

inlineinherited

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

Definition at line 643 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator()() [17/24]

void casadi::Function::operator() ( MapArg  arg, VPrRes  res  ) const

inlineinherited

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

Definition at line 645 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator()() [18/24]

void casadi::Function::operator() ( std::vector< const bvec_t * >  arg, std::vector< bvec_t * >  res  ) const

inherited

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

Definition at line 636 of file function.cpp.

                                                                                      {
    call_gen(arg, res);
  }

References casadi::Function::call_gen().

operator()() [19/24]

void casadi::Function::operator() ( std::vector< const double * >  arg, std::vector< double * >  res  ) const

inherited

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

Definition at line 632 of file function.cpp.

                                                                                      {
    call_gen(arg, res);
  }

References casadi::Function::call_gen().

operator()() [20/24]

void casadi::Function::operator() ( std::vector< const SXElem * >  arg, std::vector< SXElem * >  res  ) const

inherited

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

Definition at line 640 of file function.cpp.

                                                                                      {
    call_gen(arg, res);
  }

References casadi::Function::call_gen().

operator()() [21/24]

void casadi::Function::operator() ( VecArg  arg, MapRes  res  ) const

inlineinherited

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

Definition at line 639 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator()() [22/24]

void casadi::Function::operator() ( VecArg  arg, MPrRes  res  ) const

inlineinherited

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

Definition at line 641 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator()() [23/24]

void casadi::Function::operator() ( VecArg  arg, VecRes  res  ) const

inlineinherited

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

Definition at line 638 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator()() [24/24]

void casadi::Function::operator() ( VecArg  arg, VPrRes  res  ) const

inlineinherited

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

Definition at line 640 of file function.hpp.

{ (*this)(buf_in(arg), buf_out(res)); }

operator->()

FunctionInternal * casadi::Function::operator-> ( ) const

inherited

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

Definition at line 500 of file function.cpp.

                                               {
    casadi_assert_dev(!is_null());
    return get();
  }

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

operator==()

bool casadi::Function::operator== ( const Function &  f ) const

inherited

Definition at line 2128 of file function.cpp.

                                                   {
    try {
      casadi_assert(!is_null(), "lhs is null");
      casadi_assert(!f.is_null(), "rhs is null");
      return get()==f.get();
    } catch(std::exception& e) {
      THROW_ERROR("operator==", e.what());
    }
  }

References casadi::Function::get(), casadi::GenericShared< Shared, Internal >::is_null(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null().

oracle()

Function casadi::Function::oracle ( ) const

inherited

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

Definition at line 2104 of file function.cpp.

                                  {
    try {
      return (*this)->oracle();
    } catch(std::exception& e) {
      THROW_ERROR("oracle", e.what());
    }
  }

References casadi::FunctionInternal::oracle().

order() [1/2]

std::vector< MX > casadi::Function::order ( const std::vector< MX > &  expr )

staticinherited

Definition at line 2146 of file function.cpp.

                                                         {
    return MXFunction::order(expr);
  }

References casadi::MXFunction::order().

order() [2/2]

std::vector< SX > casadi::Function::order ( const std::vector< SX > &  expr )

staticinherited

Definition at line 2142 of file function.cpp.

                                                         {
    return SXFunction::order(expr);
  }

References casadi::SXFunction::order().

Referenced by casadi::SerializerBase::pack(), and casadi::Function::which_depends().

own()

void casadi::GenericShared< SharedObject , SharedObjectInternal >::own ( SharedObjectInternal *  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();
  }

print_dimensions()

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

inherited

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

Definition at line 1340 of file function.cpp.

                                                          {
    (*this)->print_dimensions(stream);
  }

print_option()

void casadi::Function::print_option ( const std::string &  name, std::ostream &  stream = casadi::uout()  ) const

inherited

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

Definition at line 1348 of file function.cpp.

                                                                             {
    (*this)->print_option(name, stream);
  }

References casadi::Function::name().

print_options()

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

inherited

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

Definition at line 1344 of file function.cpp.

                                                       {
    (*this)->print_options(stream);
  }

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

proceed_to()

bool casadi::Function::proceed_to ( std::istream &  file, const std::string &  str  )

staticprotectedinherited

Definition at line 64 of file function.cpp.

                                                                  {
    // Make sure that the file is ready for reading
    if (!file.good()) return false;
    // Have we already wrapped around once?
    //bool wrapped_around = false;
    // Read line-by-line
    std::string tmp;
    while (true) {
      // Read a word
      std::streampos cur_pos = file.tellg();
      file >> tmp;
      if (!file.good()) return false;
 
      // Check if match
      if (str==tmp) return true;
 
      // If comment, continue to the end of the line
      if (tmp.at(0)=='#') {
        file.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
        continue;
      }
 
      // If mismatching name, rewind and break
      file.seekg(cur_pos);
      return false;
    }
  }

References casadi::str().

release()

void casadi::Function::release ( int  mem ) const

inherited

Definition at line 1974 of file function.cpp.

                                      {
    (*this)->release(mem);
  }

Referenced by casadi::QpToNlp::free_mem(), casadi::Sqpmethod::free_mem(), casadi::FunctionBuffer::operator=(), and casadi::FunctionBuffer::~FunctionBuffer().

reset_dump_count()

void casadi::Function::reset_dump_count ( )

inherited

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

Definition at line 1373 of file function.cpp.

                                  {
    try {
      (*this)->reset_dump_count();
    } catch(std::exception& e) {
      THROW_ERROR("reset_dump_count", e.what());
    }
  }

rev() [1/2]

int casadi::Function::rev ( bvec_t **  arg, bvec_t **  res, casadi_int *  iw, bvec_t *  w, int  mem = 0  ) const

inherited

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

Definition at line 1252 of file function.cpp.

                                                                                        {
    try {
      return (*this)->sp_reverse(arg, res, iw, w, memory(mem));
    } catch(std::exception& e) {
      THROW_ERROR("rev", e.what());
    }
  }

References casadi::Function::memory().

Referenced by casadi::_which_depends(), casadi::Function::rev(), casadi::Call::sp_reverse(), casadi::Map::sp_reverse(), casadi::MapSum::sp_reverse(), and casadi::Rootfinder::sp_reverse().

rev() [2/2]

int casadi::Function::rev ( std::vector< bvec_t * >  arg, std::vector< bvec_t * >  res  ) const

inherited

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

Definition at line 644 of file function.cpp.

                                                                        {
    // Input buffer
    casadi_assert_dev(arg.size()>=n_in());
    arg.resize(sz_arg());
 
    // Output buffer
    casadi_assert_dev(res.size()>=n_out());
    res.resize(sz_res());
 
    // Work vectors
    std::vector<casadi_int> iw(sz_iw());
    std::vector<bvec_t> w(sz_w());
 
    // Evaluate memoryless
    return rev(get_ptr(arg), get_ptr(res), get_ptr(iw), get_ptr(w), 0);
  }

References casadi::get_ptr(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::rev(), casadi::Function::sz_arg(), casadi::Function::sz_iw(), casadi::Function::sz_res(), and casadi::Function::sz_w().

reverse()

Function casadi::Function::reverse ( casadi_int  nadj ) const

inherited

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

   <tt>(n_in = n_in(), n_out = n_out())</tt>

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

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

Definition at line 1332 of file function.cpp.

                                                  {
    try {
      return (*this)->reverse(nadj);
    } catch(std::exception& e) {
      THROW_ERROR("reverse", e.what());
    }
  }

References casadi::FunctionInternal::reverse().

Referenced by casadi::SXFunction::ad_reverse(), casadi::DaeBuilderInternal::export_fmu(), casadi::Map::get_reverse(), casadi::MapSum::get_reverse(), casadi::Nlpsol::get_reverse(), casadi::Switch::get_reverse(), casadi::Integrator::init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::FunctionInternal::reverse(), and casadi::RungeKutta::setup_step().

save()

void casadi::Function::save ( const std::string &  fname, const Dict &  opts = Dict()  ) const

inherited

See also

load

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

Definition at line 1466 of file function.cpp.

                                                                    {
    FileSerializer fs(fname, opts);
    fs.pack(*this);
  }

References casadi::SerializerBase::pack().

serialize() [1/3]

std::string casadi::Function::serialize ( const Dict &  opts = Dict() ) const

inherited

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

Definition at line 1471 of file function.cpp.

                                                      {
    std::stringstream ss;
    serialize(ss, opts);
    return ss.str();
  }

References casadi::Function::serialize().

serialize() [2/3]

void casadi::Function::serialize ( SerializingStream &  s ) const

inherited

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

Definition at line 1482 of file function.cpp.

                                                     {
    if (is_null()) {
      s.pack("Function::null", true);
    } else {
      s.pack("Function::null", false);
      (*this)->serialize(s);
    }
  }

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

serialize() [3/3]

void casadi::Function::serialize ( std::ostream &  stream, const Dict &  opts = Dict()  ) const

inherited

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

Definition at line 1477 of file function.cpp.

                                                                     {
    SerializingStream s(stream, opts);
    serialize(s);
  }

Referenced by casadi::MX::cse(), and casadi::Function::serialize().

set_temp()

void casadi::Function::set_temp ( const double **  arg, double **  res, casadi_int *  iw, double *  w, int  mem = 0  ) const

inherited

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

Definition at line 1306 of file function.cpp.

                                         {
    try {
      (*this)->set_temp(memory(mem), arg, res, iw, w);
    } catch(std::exception& e) {
      THROW_ERROR("set_temp", e.what());
    }
  }

References casadi::Function::memory().

set_work()

void casadi::Function::set_work ( const double **&  arg, double **&  res, casadi_int *&  iw, double *&  w, int  mem = 0  ) const

inherited

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

Definition at line 1297 of file function.cpp.

                                         {
    try {
      (*this)->set_work(memory(mem), arg, res, iw, w);
    } catch(std::exception& e) {
      THROW_ERROR("set_work", e.what());
    }
  }

References casadi::Function::memory().

setup()

void casadi::Function::setup ( const double **  arg, double **  res, casadi_int *  iw, double *  w, int  mem = 0  ) const

inherited

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

Definition at line 1315 of file function.cpp.

                                         {
    try {
      (*this)->setup(memory(mem), arg, res, iw, w);
    } catch(std::exception& e) {
      THROW_ERROR("setup", e.what());
    }
  }

References casadi::Function::memory().

size1_in() [1/2]

casadi_int casadi::Function::size1_in ( casadi_int  ind ) const

inherited

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

Definition at line 979 of file function.cpp.

                                                    {
    return (*this)->size1_in(ind);
  }

Referenced by casadi::Function::assert_size_in(), casadi::construct_nlpsol(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FiniteDiff::get_sparsity_in(), and casadi::Blocksqp::init().

size1_in() [2/2]

casadi_int casadi::Function::size1_in ( const std::string &  iname ) const

inlineinherited

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

Definition at line 271 of file function.hpp.

{return size1_in(index_in(iname));}

References casadi::Function::size1_in().

Referenced by casadi::Function::size1_in().

size1_out() [1/2]

casadi_int casadi::Function::size1_out ( casadi_int  ind ) const

inherited

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

Definition at line 987 of file function.cpp.

                                                     {
    return (*this)->size1_out(ind);
  }

Referenced by casadi::Function::assert_size_out(), casadi::construct_nlpsol(), casadi::Call::create(), casadi::Blocksqp::init(), and casadi::Onnx::load().

size1_out() [2/2]

casadi_int casadi::Function::size1_out ( const std::string &  oname ) const

inlineinherited

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

Definition at line 285 of file function.hpp.

{return size1_out(index_out(oname));}

References casadi::Function::size1_out().

Referenced by casadi::Function::size1_out().

size2_in() [1/2]

casadi_int casadi::Function::size2_in ( casadi_int  ind ) const

inherited

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

Definition at line 983 of file function.cpp.

                                                    {
    return (*this)->size2_in(ind);
  }

Referenced by casadi::Function::assert_size_in(), casadi::FiniteDiff::get_sparsity_in(), casadi::Function::map(), and casadi::Function::mapaccum().

size2_in() [2/2]

casadi_int casadi::Function::size2_in ( const std::string &  iname ) const

inlineinherited

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

Definition at line 273 of file function.hpp.

{return size2_in(index_in(iname));}

References casadi::Function::size2_in().

Referenced by casadi::Function::size2_in().

size2_out() [1/2]

casadi_int casadi::Function::size2_out ( casadi_int  ind ) const

inherited

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

Definition at line 991 of file function.cpp.

                                                     {
    return (*this)->size2_out(ind);
  }

Referenced by casadi::Function::assert_size_out(), casadi::Call::create(), casadi::Function::fold(), casadi::Onnx::load(), and casadi::Function::map().

size2_out() [2/2]

casadi_int casadi::Function::size2_out ( const std::string &  oname ) const

inlineinherited

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

Definition at line 287 of file function.hpp.

{return size2_out(index_out(oname));}

References casadi::Function::size2_out().

Referenced by casadi::Function::size2_out().

size_in() [1/2]

std::pair< casadi_int, casadi_int > casadi::Function::size_in ( casadi_int  ind ) const

inherited

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

Definition at line 995 of file function.cpp.

                                                                        {
    return (*this)->size_in(ind);
  }

Referenced by casadi::blazing_spline(), casadi::DaeBuilderInternal::CallIO::calc_jac(), casadi::Integrator::get_reverse(), and casadi::Nlpsol::init().

size_in() [2/2]

std::pair<casadi_int, casadi_int> casadi::Function::size_in ( const std::string &  iname ) const

inlineinherited

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

Definition at line 275 of file function.hpp.

                                                                          {
      return size_in(index_in(iname));
    }

size_out() [1/2]

std::pair< casadi_int, casadi_int > casadi::Function::size_out ( casadi_int  ind ) const

inherited

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

Definition at line 999 of file function.cpp.

                                                                         {
    return (*this)->size_out(ind);
  }

Referenced by casadi::DaeBuilderInternal::CallIO::calc_jac(), casadi::SqicInterface::generateNativeCode(), casadi::FunctionInternal::get_sparsity_in(), and casadi::SqicInterface::init().

size_out() [2/2]

std::pair<casadi_int, casadi_int> casadi::Function::size_out ( const std::string &  oname ) const

inlineinherited

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

Definition at line 289 of file function.hpp.

                                                                           {
      return size_out(index_out(oname));
    }

slice()

Function casadi::Function::slice ( const std::string &  name, const std::vector< casadi_int > &  order_in, const std::vector< casadi_int > &  order_out, const Dict &  opts = Dict()  ) const

inherited

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

Definition at line 898 of file function.cpp.

                                                                        {
    try {
      return (*this)->slice(name, order_in, order_out, opts);
    } catch(std::exception& e) {
      THROW_ERROR("slice", e.what());
    }
  }

References casadi::Function::name(), and casadi::FunctionInternal::slice().

Referenced by casadi::Function::mapaccum(), and casadi::FunctionInternal::slice().

sparsity_in() [1/2]

const Sparsity & casadi::Function::sparsity_in ( casadi_int  ind ) const

inherited

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

Definition at line 1167 of file function.cpp.

                                                            {
    try {
      return (*this)->sparsity_in_.at(ind);
    } catch(std::exception& e) {
      THROW_ERROR("sparsity_in", e.what());
    }
  }

Referenced by casadi::Call::Call(), casadi::Switch::codegen_body(), casadi::SXFunction::eval_mx(), casadi::Switch::eval_sx(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), casadi::Integrator::get_forward_dae(), casadi::FunctionInternal::get_sparsity_in(), casadi::FiniteDiff::get_sparsity_in(), casadi::Nlpsol::get_sparsity_in(), casadi::Switch::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::Nlpsol::get_sparsity_out(), casadi::Rootfinder::get_sparsity_out(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::Switch::init(), casadi::Function::jit(), casadi::Onnx::load(), casadi::Function::map(), casadi::Collocation::setup_step(), casadi::RungeKutta::setup_step(), casadi::simpleIntegrator(), casadi::simpleIRK(), casadi::simpleRK(), and casadi::Function::sparsity_in().

sparsity_in() [2/2]

const Sparsity & casadi::Function::sparsity_in ( const std::string &  iname ) const

inherited

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

Definition at line 1175 of file function.cpp.

                                                                    {
    try {
      return sparsity_in(index_in(iname));
    } catch(std::exception& e) {
      THROW_ERROR("sparsity_in", e.what());
    }
  }

References casadi::Function::index_in(), and casadi::Function::sparsity_in().

sparsity_jac() [1/4]

const Sparsity casadi::Function::sparsity_jac ( casadi_int  iind, casadi_int  oind, bool  compact = false, bool  symmetric = false  ) const

inherited

[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian block

Definition at line 1058 of file function.cpp.

                                                                                     {
    try {
      return (*this)->jac_sparsity(oind, iind, compact, symmetric);
    } catch(std::exception& e) {
      THROW_ERROR("sparsity_jac", e.what());
    }
  }

Referenced by casadi::Blocksqp::init().

sparsity_jac() [2/4]

const Sparsity casadi::Function::sparsity_jac ( casadi_int  iind, const std::string &  oind, bool  compact = false, bool  symmetric = false  ) const

inlineinherited

[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian block

Definition at line 544 of file function.hpp.

                                                                                {
      return sparsity_jac(iind, index_out(oind), compact, symmetric);
    }

sparsity_jac() [3/4]

const Sparsity casadi::Function::sparsity_jac ( const std::string &  iind, casadi_int  oind = 0, bool  compact = false, bool  symmetric = false  ) const

inlineinherited

[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian block

Definition at line 540 of file function.hpp.

                                                                                {
      return sparsity_jac(index_in(iind), oind, compact, symmetric);
    }

sparsity_jac() [4/4]

const Sparsity casadi::Function::sparsity_jac ( const std::string &  iind, const std::string &  oind, bool  compact = false, bool  symmetric = false  ) const

inlineinherited

[DEPRECATED] Get, if necessary generate, the sparsity of a Jacobian block

Definition at line 548 of file function.hpp.

                                                                                {
      return sparsity_jac(index_in(iind), index_out(oind), compact, symmetric);
    }

sparsity_out() [1/2]

const Sparsity & casadi::Function::sparsity_out ( casadi_int  ind ) const

inherited

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

Definition at line 1183 of file function.cpp.

                                                             {
    try {
      return (*this)->sparsity_out_.at(ind);
    } catch(std::exception& e) {
      THROW_ERROR("sparsity_out", e.what());
    }
  }

Referenced by casadi::Function::assert_sparsity_out(), casadi::OracleFunction::calc_function(), casadi::Switch::codegen_body(), casadi::Function::conditional(), casadi::Switch::eval_sx(), casadi::MXFunction::export_code_body(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), casadi::Integrator::get_forward_dae(), casadi::FunctionInternal::get_sparsity_in(), casadi::FiniteDiff::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::FiniteDiff::get_sparsity_out(), casadi::Nlpsol::get_sparsity_out(), casadi::Rootfinder::get_sparsity_out(), casadi::Switch::get_sparsity_out(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::Switch::init(), casadi::KnitroInterface::init(), casadi::SnoptInterface::init(), casadi::SundialsInterface::init(), casadi::SuperscsInterface::init(), casadi::UnoInterface::init(), casadi::Qrsqp::init(), casadi::Scpgen::init(), casadi::SuperscsInterface::init_mem(), casadi::Function::jac_sparsity(), casadi::Function::jit(), casadi::Onnx::load(), casadi::IdasInterface::psetupF(), casadi::Call::sparsity(), and casadi::Function::sparsity_out().

sparsity_out() [2/2]

const Sparsity & casadi::Function::sparsity_out ( const std::string &  iname ) const

inherited

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

Definition at line 1191 of file function.cpp.

                                                                     {
    try {
      return sparsity_out(index_out(iname));
    } catch(std::exception& e) {
      THROW_ERROR("sparsity_out", e.what());
    }
  }

References casadi::Function::index_out(), and casadi::Function::sparsity_out().

stats()

Dict casadi::Function::stats ( int  mem = 0 ) const

inherited

Definition at line 1080 of file function.cpp.

                                    {
    if (!(*this)->has_memory(mem)) {
      THROW_ERROR("stats",
        "No stats available: Function/solver was not yet numerically evaluated.");
    }
    try {
      return (*this)->get_stats(memory(mem));
    } catch(std::exception& e) {
      THROW_ERROR("stats", e.what());
    }
  }

References casadi::Function::memory().

Referenced by casadi::DaeBuilder::get(), casadi::MXFunction::get_stats(), casadi::ImplicitToNlp::get_stats(), casadi::FunctionBuffer::stats(), and casadi::OptiNode::stats().

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;
  }

sx_in() [1/3]

const std::vector< SX > casadi::Function::sx_in ( ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1765 of file function.cpp.

                                            {
    try {
      return (*this)->sx_in();
    } catch(std::exception& e) {
      THROW_ERROR("sx_in", e.what());
    }
  }

Referenced by casadi::Function::expand(), and casadi::Function::sym_in().

sx_in() [2/3]

const SX casadi::Function::sx_in ( casadi_int  iind ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1749 of file function.cpp.

                                                {
    try {
      return (*this)->sx_in(iind);
    } catch(std::exception& e) {
      THROW_ERROR("sx_in", e.what());
    }
  }

Referenced by casadi::Matrix< Scalar >::get_input(), casadi::AmplInterface::init(), casadi::qpsol_nlp(), and casadi::Function::transform().

sx_in() [3/3]

const SX casadi::Function::sx_in ( const std::string &  iname ) const

inlineinherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1010 of file function.hpp.

                                                 {
      return sx_in(index_in(iname));
    }

sx_out() [1/3]

const std::vector< SX > casadi::Function::sx_out ( ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1773 of file function.cpp.

                                             {
    try {
      return (*this)->sx_out();
    } catch(std::exception& e) {
      THROW_ERROR("sx_out", e.what());
    }
  }

sx_out() [2/3]

const SX casadi::Function::sx_out ( casadi_int  oind ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1757 of file function.cpp.

                                                 {
    try {
      return (*this)->sx_out(oind);
    } catch(std::exception& e) {
      THROW_ERROR("sx_out", e.what());
    }
  }

sx_out() [3/3]

const SX casadi::Function::sx_out ( const std::string &  oname ) const

inlineinherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1038 of file function.hpp.

                                                  {
      return sx_out(index_out(oname));
    }

sym_in() [1/5]

template<>

const std::vector< MX > CASADI_EXPORT casadi::Function::sym_in ( ) const

inherited

Definition at line 2246 of file function.cpp.

                                                           {
      return sx_in();
  }

References casadi::Function::sx_in().

sym_in() [2/5]

template<typename T >

const std::vector<T> casadi::Function::sym_in ( ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

sym_in() [3/5]

template<>

const MX CASADI_EXPORT casadi::Function::sym_in ( casadi_int  iind ) const

inherited

Definition at line 2237 of file function.cpp.

                                                               {
      return sx_in(iind);
  }

References casadi::Function::sx_in().

sym_in() [4/5]

template<typename T >

const T casadi::Function::sym_in ( casadi_int  iind ) const

inherited

There is no guarantee that subsequent calls return unique answers

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

References casadi::T.

Referenced by casadi::construct_nlpsol().

sym_in() [5/5]

template<typename T >

const T casadi::Function::sym_in ( const std::string &  iname ) const

inlineinherited

There is no guarantee that subsequent calls return unique answers

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

Definition at line 1023 of file function.hpp.

                                                 {
      return sym_in<T>(index_in(iname));
    }

References casadi::T.

sz_arg()

size_t casadi::Function::sz_arg ( ) const

inherited

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

Definition at line 1235 of file function.cpp.

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

Referenced by casadi::Function::activity(), casadi::SymbolicQrMemory::alloc(), casadi::Function::buf_in(), casadi::Function::call_gen(), casadi::Nlpsol::codegen_setup_constants(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionBuffer::FunctionBuffer(), casadi::Map::init(), casadi::OmpMap::init(), casadi::ThreadMap::init(), casadi::MapSum::init(), casadi::SXFunction::init(), casadi::BSplineInterpolant::init(), casadi::GurobiInterface::init_mem(), casadi::Function::rev(), casadi::MX::simplify_const_folding(), casadi::Call::sz_arg(), and casadi::Function::sz_work().

sz_iw()

size_t casadi::Function::sz_iw ( ) const

inherited

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

Definition at line 1239 of file function.cpp.

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

Referenced by casadi::Function::activity(), casadi::SymbolicQrMemory::alloc(), casadi::Function::call_gen(), casadi::Nlpsol::codegen_setup_constants(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionBuffer::FunctionBuffer(), casadi::Map::init(), casadi::OmpMap::init(), casadi::ThreadMap::init(), casadi::MapSum::init(), casadi::SXFunction::init(), casadi::BSplineInterpolant::init(), casadi::GurobiInterface::init_mem(), casadi::Function::rev(), casadi::MX::simplify_const_folding(), casadi::Call::sz_iw(), and casadi::Function::sz_work().

sz_res()

size_t casadi::Function::sz_res ( ) const

inherited

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

Definition at line 1237 of file function.cpp.

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

Referenced by casadi::Function::activity(), casadi::SymbolicQrMemory::alloc(), casadi::Function::buf_out(), casadi::Function::call_gen(), casadi::Nlpsol::codegen_setup_constants(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionBuffer::FunctionBuffer(), casadi::Map::init(), casadi::OmpMap::init(), casadi::ThreadMap::init(), casadi::MapSum::init(), casadi::SXFunction::init(), casadi::BSplineInterpolant::init(), casadi::GurobiInterface::init_mem(), casadi::Function::rev(), casadi::MX::simplify_const_folding(), casadi::Call::sz_res(), and casadi::Function::sz_work().

sz_w()

size_t casadi::Function::sz_w ( ) const

inherited

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

Definition at line 1241 of file function.cpp.

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

Referenced by casadi::Function::activity(), casadi::SymbolicQrMemory::alloc(), casadi::Function::call_gen(), casadi::MapSum::codegen_body(), casadi::Nlpsol::codegen_setup_constants(), casadi::MapSum::eval_gen(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionBuffer::FunctionBuffer(), casadi::Map::init(), casadi::OmpMap::init(), casadi::ThreadMap::init(), casadi::MapSum::init(), casadi::Rootfinder::init(), casadi::SXFunction::init(), casadi::BSplineInterpolant::init(), casadi::GurobiInterface::init_mem(), casadi::Function::rev(), casadi::MX::simplify_const_folding(), casadi::MapSum::sp_reverse(), casadi::Call::sz_w(), and casadi::Function::sz_work().

sz_work()

void casadi::Function::sz_work ( size_t &  sz_arg, size_t &  sz_res, size_t &  sz_iw, size_t &  sz_w  ) const

inherited

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

Definition at line 1231 of file function.cpp.

                                                                                          {
    (*this)->sz_work(sz_arg, sz_res, sz_iw, sz_w);
  }

References casadi::Function::sz_arg(), casadi::Function::sz_iw(), casadi::Function::sz_res(), and casadi::Function::sz_w().

Referenced by casadi::FunctionInternal::alloc(), casadi::OmpMap::codegen_body(), casadi::ThreadMap::codegen_body(), casadi::ThreadMap::codegen_declarations(), casadi::OmpMap::eval(), casadi::OracleFunction::finalize(), and casadi::ThreadsWork().

test_cast()

bool casadi::Function::test_cast ( const SharedObjectInternal *  ptr )

staticinherited

Definition at line 1076 of file function.cpp.

                                                          {
    return dynamic_cast<const FunctionInternal*>(ptr)!=nullptr;
  }

transform() [1/4]

Function casadi::Function::transform ( const Dict &  opts = Dict() ) const

inherited

Options:

• passes (OT_VECTORVECTOR): an ordered list of passes. Each pass is a list whose first entry is the verb:
  • {"simplify", task, ...}: graph simplification passes applied in order (cse, ref_count, const_folding, combine_terms, empty_inputs). An integer before a task sets its run count (N>0: N times, 0: until a fixed point); the default is 1.
  • {"expand"}: expand to an SXFunction
  • {"external", library, operation, opts}: apply an externally defined transform (opts is an optional dict)
• boolean shorthands (used only when "passes" is absent): empty_inputs, combine_terms, cse, ref_count, const_folding. These build a single "simplify" pass.

The dict-only form applies a default simplification flow when empty. The (passes, opts) form runs an explicit pipeline; its opts accepts only "verbose" (the boolean simplify options are rejected there).

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

Definition at line 359 of file function.cpp.

                                                     {
    return transform(name(), opts);
  }

References casadi::Function::name().

Referenced by casadi::Function::transform(), and casadi::MX::transform().

transform() [2/4]

Function casadi::Function::transform ( const std::string &  fname, const Dict &  opts = Dict()  ) const

inherited

Options:

• passes (OT_VECTORVECTOR): an ordered list of passes. Each pass is a list whose first entry is the verb:
  • {"simplify", task, ...}: graph simplification passes applied in order (cse, ref_count, const_folding, combine_terms, empty_inputs). An integer before a task sets its run count (N>0: N times, 0: until a fixed point); the default is 1.
  • {"expand"}: expand to an SXFunction
  • {"external", library, operation, opts}: apply an externally defined transform (opts is an optional dict)
• boolean shorthands (used only when "passes" is absent): empty_inputs, combine_terms, cse, ref_count, const_folding. These build a single "simplify" pass.

The dict-only form applies a default simplification flow when empty. The (passes, opts) form runs an explicit pipeline; its opts accepts only "verbose" (the boolean simplify options are rejected there).

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

Definition at line 363 of file function.cpp.

                                                                             {
    try {
      // Boolean shorthands (defaults reproduce the meaningful default flow)
      bool empty_inputs = true;
      bool combine_terms = false;
      bool cse = true;
      bool ref_count = true;
      bool const_folding = true;
      bool verbose = false;
      for (auto&& op : opts) {
        if (op.first=="empty_inputs") {
          empty_inputs = op.second;
        } else if (op.first=="combine_terms") {
          combine_terms = op.second;
        } else if (op.first=="cse") {
          cse = op.second;
        } else if (op.first=="ref_count") {
          ref_count = op.second;
        } else if (op.first=="const_folding") {
          const_folding = op.second;
        } else if (op.first=="verbose") {
          verbose = op.second;
        } else {
          casadi_error("transform: no such option: " + std::string(op.first) + ".\n");
        }
      }
      std::vector<GenericType> simp = {std::string("simplify")};
      if (empty_inputs) simp.push_back("empty_inputs");
      if (combine_terms) simp.push_back("combine_terms");
      if (cse) simp.push_back("cse");
      if (ref_count) { simp.push_back(0); simp.push_back("ref_count"); }  // 0 = fixed point
      if (const_folding) simp.push_back("const_folding");
      return transform(fname, std::vector<std::vector<GenericType> >{simp}, {{"verbose", verbose}});
    } catch(std::exception& e) {
      THROW_ERROR("transform", e.what());
    }
  }

References casadi::Function::transform().

transform() [3/4]

Function casadi::Function::transform ( const std::string &  fname, const std::vector< std::vector< GenericType > > &  passes, const Dict &  opts = Dict()  ) const

inherited

Options:

• passes (OT_VECTORVECTOR): an ordered list of passes. Each pass is a list whose first entry is the verb:
  • {"simplify", task, ...}: graph simplification passes applied in order (cse, ref_count, const_folding, combine_terms, empty_inputs). An integer before a task sets its run count (N>0: N times, 0: until a fixed point); the default is 1.
  • {"expand"}: expand to an SXFunction
  • {"external", library, operation, opts}: apply an externally defined transform (opts is an optional dict)
• boolean shorthands (used only when "passes" is absent): empty_inputs, combine_terms, cse, ref_count, const_folding. These build a single "simplify" pass.

The dict-only form applies a default simplification flow when empty. The (passes, opts) form runs an explicit pipeline; its opts accepts only "verbose" (the boolean simplify options are rejected there).

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

Definition at line 406 of file function.cpp.

                                                       {
    try {
      // Only 'verbose' is accepted here; boolean simplify options belong to the
      // dict-only overload
      bool verbose = false;
      for (auto&& op : opts) {
        if (op.first=="verbose") {
          verbose = op.second;
        } else {
          casadi_error("transform(passes, opts): unsupported option '" + std::string(op.first)
            + "' (boolean simplify options are only allowed in the dict-only form).\n");
        }
      }
 
      if (verbose) {
        uout() << "transform(" << transform_passes_str(passes) << ")" << std::endl;
        uout() << "  start: " << transform_stats(*this) << std::endl;
      }
 
      // Run the pipeline
      Function f = *this;
      for (const auto& pass : passes) {
        casadi_assert(!pass.empty(), "transform: each pass must be a non-empty list");
        std::string verb = pass.front().to_string();
        if (verb=="simplify") {
          // Tasks are strings; an optional integer before a task sets its run
          // count (N>0: run N times, 0: run until a fixed point). Default: 1.
          std::vector<std::pair<std::string, casadi_int> > tasks;
          casadi_int count = 1;
          bool have_count = false;
          for (size_t i=1; i<pass.size(); ++i) {
            if (pass[i].is_int()) {
              count = pass[i].to_int();
              have_count = true;
            } else {
              tasks.push_back({pass[i].to_string(), count});
              count = 1;
              have_count = false;
            }
          }
          casadi_assert(!have_count,
            "transform 'simplify': trailing run count with no following task");
          f = f->simplify_passes(tasks);
        } else if (verb=="expand") {
          casadi_assert(pass.size()==1, "transform: 'expand' pass takes no arguments");
          f = f.expand();
        } else if (verb=="external") {
          casadi_assert(pass.size()>=3 && pass.size()<=4,
            "transform: 'external' pass must be {\"external\", library, operation[, opts]}");
          std::string lib = pass[1].to_string();
          std::string op = pass[2].to_string();
          Dict eopts = pass.size()==4 ? pass[3].to_dict() : Dict();
          f = external_transform(lib, op, f, eopts);
        } else {
          casadi_error("transform: unknown pass verb '" + verb + "'");
        }
        if (verbose) {
          uout() << "  after " << transform_passes_str({pass}) << ": "
                 << transform_stats(f) << std::endl;
        }
      }
 
      // Optionally rename the result (type-preserving for SX/MX functions)
      if (!fname.empty() && fname!=f.name()) {
        Dict ropts{{"allow_free", true}, {"allow_duplicate_io_names", true}};
        std::vector<std::string> ni = f.name_in(), no = f.name_out();
        if (f.is_a("SXFunction", true)) {
          std::vector<SX> arg = f.sx_in();
          f = Function(fname, arg, f(arg), ni, no, ropts);
        } else {
          std::vector<MX> arg = f.mx_in();
          f = Function(fname, arg, f(arg), ni, no, ropts);
        }
      }
      return f;
    } catch(std::exception& e) {
      THROW_ERROR("transform", e.what());
    }
  }

References casadi::Function::expand(), casadi::external_transform(), casadi::Function::Function(), casadi::Function::is_a(), casadi::Function::mx_in(), casadi::Function::name(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::FunctionInternal::simplify_passes(), casadi::Function::sx_in(), casadi::transform_passes_str(), casadi::transform_stats(), and casadi::uout().

transform() [4/4]

Function casadi::Function::transform ( const std::vector< std::vector< GenericType > > &  passes, const Dict &  opts = Dict()  ) const

inherited

Options:

• passes (OT_VECTORVECTOR): an ordered list of passes. Each pass is a list whose first entry is the verb:
  • {"simplify", task, ...}: graph simplification passes applied in order (cse, ref_count, const_folding, combine_terms, empty_inputs). An integer before a task sets its run count (N>0: N times, 0: until a fixed point); the default is 1.
  • {"expand"}: expand to an SXFunction
  • {"external", library, operation, opts}: apply an externally defined transform (opts is an optional dict)
• boolean shorthands (used only when "passes" is absent): empty_inputs, combine_terms, cse, ref_count, const_folding. These build a single "simplify" pass.

The dict-only form applies a default simplification flow when empty. The (passes, opts) form runs an explicit pipeline; its opts accepts only "verbose" (the boolean simplify options are rejected there).

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

Definition at line 401 of file function.cpp.

                                                       {
    return transform(name(), passes, opts);
  }

References casadi::Function::name(), and casadi::Function::transform().

type_name()

static std::string casadi::Callback::type_name ( )

inlinestatic

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

Definition at line 54 of file casadi/core/callback.hpp.

{return "Callback";}

uses_output()

bool casadi::Callback::uses_output ( ) const

virtual

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

Definition at line 88 of file callback.cpp.

                                   {
    return (*this)->FunctionInternal::uses_output();
  }

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::Function::which_depends ( const std::string &  s_in, const std::vector< std::string > &  s_out, casadi_int  order = 1, bool  tr = false  ) const

inherited

Parameters

[in]	order	Only 1 (linear) and 2 (nonlinear) allowed
[in]	tr	Flip the relationship. Return which expressions contain the variables

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

Definition at line 2022 of file function.cpp.

                                       {
    try {
      return (*this)->which_depends(s_in, s_out, order, tr);
    } catch(std::exception& e) {
      THROW_ERROR("which_depends", e.what());
    }
  }

References casadi::Function::order().

Referenced by casadi::BonminInterface::init(), casadi::IpoptInterface::init(), casadi::KnitroInterface::init(), and casadi::FunctionInternal::which_depends().

wrap() [1/2]

Function casadi::Function::wrap ( ) const

inherited

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

Definition at line 2112 of file function.cpp.

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

References casadi::FunctionInternal::wrap().

Referenced by casadi::FunctionInternal::which_depends().

wrap() [2/2]

Function casadi::Function::wrap ( const std::string &  name ) const

inherited

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

Definition at line 2116 of file function.cpp.

                                                     {
    return (*this)->wrap(name);
  }

References casadi::Function::name(), and casadi::FunctionInternal::wrap().

wrap_as_needed() [1/2]

Function casadi::Function::wrap_as_needed ( const Dict &  opts ) const

inherited

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

Definition at line 2120 of file function.cpp.

                                                          {
    return (*this)->wrap_as_needed(opts);
  }

References casadi::FunctionInternal::wrap_as_needed().

Referenced by casadi::MapSum::create().

wrap_as_needed() [2/2]

Function casadi::Function::wrap_as_needed ( const std::string &  name, const Dict &  opts  ) const

inherited

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

Definition at line 2124 of file function.cpp.

                                                                                 {
    return (*this)->wrap_as_needed(name, opts);
  }

References casadi::Function::name(), and casadi::FunctionInternal::wrap_as_needed().

---

The documentation for this class was generated from the following files:

• casadi/core/callback.hpp
• callback.cpp