#include <function.hpp>

Detailed Description

A Function instance is a general multiple-input, multiple-output function where each input and output can be a sparse matrix.
For an introduction to this class, see the CasADi user guide.
Function is a reference counted and immutable class; copying a class instance is very cheap and its behavior (with some exceptions) is not affected by calling its member functions.

Author: Joel Andersson

Date: 2010-2017

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

List of available options
Id	Type	Description	Used in
ad_weight	OT_DOUBLE	Weighting factor for derivative calculation.When there is an option of either using forward or reverse mode directional derivatives, the condition ad_weightnf<=(1-ad_weight)na is used where nf and na are estimates of the number of forward/reverse mode directional derivatives needed. By default, ad_weight is calculated automatically, but this can be overridden by setting this option. In particular, 0 means forcing forward mode and 1 forcing reverse mode. Leave unset for (class specific) heuristics.	casadi::FunctionInternal
ad_weight_sp	OT_DOUBLE	Weighting factor for sparsity pattern calculation calculation.Overrides default behavior. Set to 0 and 1 to force forward and reverse mode respectively. Cf. option "ad_weight". When set to -1, sparsity is completely ignored and dense matrices are used.	casadi::FunctionInternal
always_inline	OT_BOOL	Force inlining.	casadi::FunctionInternal
cache	OT_DICT	Prepopulate the function cache. Default: empty	casadi::FunctionInternal
compiler	OT_STRING	Just-in-time compiler plugin to be used.	casadi::FunctionInternal
custom_jacobian	OT_FUNCTION	Override CasADi's AD. Use together with 'jac_penalty': 0. Note: Highly experimental. Syntax may break often.	casadi::FunctionInternal
der_options	OT_DICT	Default options to be used to populate forward_options, reverse_options, and jacobian_options before those options are merged in.	casadi::FunctionInternal
derivative_of	OT_FUNCTION	The function is a derivative of another function. The type of derivative (directional derivative, Jacobian) is inferred from the function name.	casadi::FunctionInternal
dump	OT_BOOL	Dump function to file upon first evaluation. [false]	casadi::FunctionInternal
dump_dir	OT_STRING	Directory to dump inputs/outputs to. Make sure the directory exists [.]	casadi::FunctionInternal
dump_format	OT_STRING	Choose file format to dump matrices. See DM.from_file [mtx]	casadi::FunctionInternal
dump_in	OT_BOOL	Dump numerical values of inputs to file (readable with DM.from_file) [default: false] A counter is used to generate unique names. The counter may be reset using reset_dump_count.	casadi::FunctionInternal
dump_out	OT_BOOL	Dump numerical values of outputs to file (readable with DM.from_file) [default: false] A counter is used to generate unique names. The counter may be reset using reset_dump_count.	casadi::FunctionInternal
enable_fd	OT_BOOL	Enable derivative calculation by finite differencing. [default: false]]	casadi::FunctionInternal
enable_forward	OT_BOOL	Enable derivative calculation using generated functions for Jacobian-times-vector products - typically using forward mode AD - if available. [default: true]	casadi::FunctionInternal
enable_jacobian	OT_BOOL	Enable derivative calculation using generated functions for Jacobians of all differentiable outputs with respect to all differentiable inputs - if available. [default: true]	casadi::FunctionInternal
enable_reverse	OT_BOOL	Enable derivative calculation using generated functions for transposed Jacobian-times-vector products - typically using reverse mode AD - if available. [default: true]	casadi::FunctionInternal
error_on_fail	OT_BOOL	Throw exceptions when function evaluation fails (default true).	casadi::ProtoFunction
external_transform	OT_VECTORVECTOR	List of external_transform instruction arguments. Default: empty	casadi::FunctionInternal
fd_method	OT_STRING	Method for finite differencing [default 'central']	casadi::FunctionInternal
fd_options	OT_DICT	Options to be passed to the finite difference instance	casadi::FunctionInternal
forward_options	OT_DICT	Options to be passed to a forward mode constructor	casadi::FunctionInternal
gather_stats	OT_BOOL	Deprecated option (ignored): Statistics are now always collected.	casadi::FunctionInternal
inputs_check	OT_BOOL	Throw exceptions when the numerical values of the inputs don't make sense	casadi::FunctionInternal
is_diff_in	OT_BOOLVECTOR	Indicate for each input if it should be differentiable.	casadi::FunctionInternal
is_diff_out	OT_BOOLVECTOR	Indicate for each output if it should be differentiable.	casadi::FunctionInternal
jac_penalty	OT_DOUBLE	When requested for a number of forward/reverse directions, it may be cheaper to compute first the full jacobian and then multiply with seeds, rather than obtain the requested directions in a straightforward manner. Casadi uses a heuristic to decide which is cheaper. A high value of 'jac_penalty' makes it less likely for the heurstic to chose the full Jacobian strategy. The special value -1 indicates never to use the full Jacobian strategy	casadi::FunctionInternal
jacobian_options	OT_DICT	Options to be passed to a Jacobian constructor	casadi::FunctionInternal
jit	OT_BOOL	Use just-in-time compiler to speed up the evaluation	casadi::FunctionInternal
jit_cleanup	OT_BOOL	Cleanup up the temporary source file that jit creates. Default: true	casadi::FunctionInternal
jit_name	OT_STRING	The file name used to write out code. The actual file names used depend on 'jit_temp_suffix' and include extensions. Default: 'jit_tmp'	casadi::FunctionInternal
jit_options	OT_DICT	Options to be passed to the jit compiler.	casadi::FunctionInternal
jit_serialize	OT_STRING	Specify behaviour when serializing a jitted function: SOURCE\|link\|embed.	casadi::FunctionInternal
jit_temp_suffix	OT_BOOL	Use a temporary (seemingly random) filename suffix for generated code and libraries. This is desired for thread-safety. This behaviour may defeat caching compiler wrappers. Default: true	casadi::FunctionInternal
max_io	OT_INT	Acceptable number of inputs and outputs. Warn if exceeded.	casadi::FunctionInternal
max_num_dir	OT_INT	Specify the maximum number of directions for derivative functions. Overrules the builtin optimized_num_dir.	casadi::FunctionInternal
never_inline	OT_BOOL	Forbid inlining.	casadi::FunctionInternal
post_expand	OT_BOOL	After construction, expand this Function. Default: False	casadi::FunctionInternal
post_expand_options	OT_DICT	Options to be passed to post-construction expansion. Default: empty	casadi::FunctionInternal
print_canonical	OT_BOOL	When printing numerical matrices, use a format that is exact and reproducible in generated C code.	casadi::FunctionInternal
print_in	OT_BOOL	Print numerical values of inputs [default: false]	casadi::FunctionInternal
print_out	OT_BOOL	Print numerical values of outputs [default: false]	casadi::FunctionInternal
print_time	OT_BOOL	print information about execution time. Implies record_time.	casadi::ProtoFunction
record_time	OT_BOOL	record information about execution time, for retrieval with stats().	casadi::ProtoFunction
regularity_check	OT_BOOL	Throw exceptions when NaN or Inf appears during evaluation	casadi::ProtoFunction
reverse_options	OT_DICT	Options to be passed to a reverse mode constructor	casadi::FunctionInternal
user_data	OT_VOIDPTR	A user-defined field that can be used to identify the function or pass additional information	casadi::FunctionInternal
verbose	OT_BOOL	Verbose evaluation – for debugging	casadi::ProtoFunction

Examples: SX/SXFunction_constr_oct.m, SX/SXFunction_constr_py.py, integrators/simulator.py, solvers/callback.py, solvers/exacthessian.py, and solvers/ipopt.py.

Definition at line 58 of file function.hpp.

Inheritance diagram for casadi::Function:

[legend]

Collaboration diagram for casadi::Function:

[legend]

Public Types
typedef std::map< std::string, std::vector< std::string > >	AuxOut

using	internal_base_type = SharedObjectInternal

using	base_type = SharedObject

Public Member Functions
	Function ()
	Default constructor, null pointer. More...

	Function (const std::string &fname)
	Construct from a file. More...

	~Function ()
	Destructor. 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::vector< std::string > &	name_out () const
	Get output scheme. More...

const std::string &	name_in (casadi_int ind) const
	Get input scheme name by index. 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...

bool	uses_output () const
	Do the derivative functions need nondifferentiated outputs? 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...

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

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

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

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

template<>
const SX CASADI_EXPORT	sym_in (casadi_int iind) const

template<>
const std::vector< SX > CASADI_EXPORT	sym_in () 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...


	Function (const std::string &name, const std::vector< SX > &ex_in, const std::vector< SX > &ex_out, const Dict &opts=Dict())
	Construct an SX function. More...

	Function (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=Dict())
	Construct an SX function. More...

	Function (const std::string &name, const std::map< std::string, SX > &dict, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const Dict &opts=Dict())
	Construct an SX function. More...


	Function (const std::string &name, const std::vector< MX > &ex_in, const std::vector< MX > &ex_out, const Dict &opts=Dict())
	Construct an MX function. More...

	Function (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=Dict())
	Construct an MX function. More...

	Function (const std::string &name, const std::map< std::string, MX > &dict, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out, const Dict &opts=Dict())
	Construct an MX function. More...


	Function (const std::string &name, SXIList ex_in, const SXVector &ex_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, const SXVector &ex_in, SXIList ex_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, SXIList ex_in, SXIList ex_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, SXIList ex_in, const SXVector &ex_out, const StringVector &name_in, const StringVector &name_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, const SXVector &ex_in, SXIList ex_out, const StringVector &name_in, const StringVector &name_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, SXIList ex_in, SXIList ex_out, const StringVector &name_in, const StringVector &name_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, MXIList ex_in, const MXVector &ex_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, const MXVector &ex_in, MXIList ex_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, MXIList ex_in, MXIList ex_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, MXIList ex_in, const MXVector &ex_out, const StringVector &name_in, const StringVector &name_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, const MXVector &ex_in, MXIList ex_out, const StringVector &name_in, const StringVector &name_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. More...

	Function (const std::string &name, MXIList ex_in, MXIList ex_out, const StringVector &name_in, const StringVector &name_out, const Dict &opts=Dict())
	To resolve ambiguity on some compilers. 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...

bool	is_diff_out (casadi_int ind) const
	Get differentiability of inputs/output. More...

std::vector< bool >	is_diff_in () 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...

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

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


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

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_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...

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_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...

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	load (const std::string &filename)
	Build function from serialization. More...

static Function	deserialize (DeserializingStream &s)
	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...

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

std::vector< const double * >	buf_in (VecArg 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< const double * >	buf_in (MapArg arg) 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...

Member Typedef Documentation

◆ AuxOut

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

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

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

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

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

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

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

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

Definition at line 623 of file function.hpp.

Constructor & Destructor Documentation

◆ Function() [1/20]

casadi::Function::Function ( )

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

Definition at line 58 of file function.cpp.

58 {

59 }

Referenced by bspline(), deserialize(), expand(), find_function(), fold(), map(), mapaccum(), and transform().

◆ Function() [2/20]

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

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

Definition at line 92 of file function.cpp.

                                            {
     casadi_error("Not implemented");
   }

◆ Function() [3/20]

casadi::Function::Function	(	const std::string &	name,
		const std::vector< SX > &	ex_in,
		const std::vector< SX > &	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 96 of file function.cpp.

                                        {
     construct(name, ex_in, ex_out, {}, {}, opts);
   }

References construct(), and name().

◆ Function() [4/20]

casadi::Function::Function	(	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 = `Dict()`
	)

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

Definition at line 102 of file function.cpp.

                                        {
     construct(name, ex_in, ex_out, name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [5/20]

casadi::Function::Function	(	const std::string &	name,
		const std::map< std::string, SX > &	dict,
		const std::vector< std::string > &	name_in,
		const std::vector< std::string > &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 183 of file function.cpp.

                         {
     construct(name, dict, name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [6/20]

casadi::Function::Function	(	const std::string &	name,
		const std::vector< MX > &	ex_in,
		const std::vector< MX > &	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 110 of file function.cpp.

                                        {
     construct(name, ex_in, ex_out, {}, {}, opts);
   }

References construct(), and name().

◆ Function() [7/20]

casadi::Function::Function	(	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 = `Dict()`
	)

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

Definition at line 116 of file function.cpp.

                                        {
     construct(name, ex_in, ex_out, name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [8/20]

casadi::Function::Function	(	const std::string &	name,
		const std::map< std::string, MX > &	dict,
		const std::vector< std::string > &	name_in,
		const std::vector< std::string > &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 189 of file function.cpp.

                         {
     construct(name, dict, name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [9/20]

casadi::Function::Function	(	const std::string &	name,
		SXIList	ex_in,
		const SXVector &	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 124 of file function.cpp.

                                                                {
     construct(name, SXVector(ex_in), ex_out, {}, {}, opts);
   }

References construct(), and name().

◆ Function() [10/20]

casadi::Function::Function	(	const std::string &	name,
		const SXVector &	ex_in,
		SXIList	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 129 of file function.cpp.

                                                                {
     construct(name, ex_in, SXVector(ex_out), {}, {}, opts);
   }

References construct(), and name().

◆ Function() [11/20]

casadi::Function::Function	(	const std::string &	name,
		SXIList	ex_in,
		SXIList	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 134 of file function.cpp.

                                                                                            {
     construct(name, SXVector(ex_in), SXVector(ex_out), {}, {}, opts);
   }

References construct(), and name().

◆ Function() [12/20]

casadi::Function::Function	(	const std::string &	name,
		SXIList	ex_in,
		const SXVector &	ex_out,
		const StringVector &	name_in,
		const StringVector &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 138 of file function.cpp.

                                                       {
     construct(name, SXVector(ex_in), ex_out, name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [13/20]

casadi::Function::Function	(	const std::string &	name,
		const SXVector &	ex_in,
		SXIList	ex_out,
		const StringVector &	name_in,
		const StringVector &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 144 of file function.cpp.

                                                                                    {
     construct(name, ex_in, SXVector(ex_out), name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [14/20]

casadi::Function::Function	(	const std::string &	name,
		SXIList	ex_in,
		SXIList	ex_out,
		const StringVector &	name_in,
		const StringVector &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 149 of file function.cpp.

                                                                                                   {
     construct(name, SXVector(ex_in), SXVector(ex_out), name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [15/20]

casadi::Function::Function	(	const std::string &	name,
		MXIList	ex_in,
		const MXVector &	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 154 of file function.cpp.

                                                                {
     construct(name, MXVector(ex_in), ex_out, {}, {}, opts);
   }

References construct(), and name().

◆ Function() [16/20]

casadi::Function::Function	(	const std::string &	name,
		const MXVector &	ex_in,
		MXIList	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 159 of file function.cpp.

                                                                {
     construct(name, ex_in, MXVector(ex_out), {}, {}, opts);
   }

References construct(), and name().

◆ Function() [17/20]

casadi::Function::Function	(	const std::string &	name,
		MXIList	ex_in,
		MXIList	ex_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 164 of file function.cpp.

                                                                                            {
     construct(name, MXVector(ex_in), MXVector(ex_out), {}, {}, opts);
   }

References construct(), and name().

◆ Function() [18/20]

casadi::Function::Function	(	const std::string &	name,
		MXIList	ex_in,
		const MXVector &	ex_out,
		const StringVector &	name_in,
		const StringVector &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 168 of file function.cpp.

                                                                                    {
     construct(name, MXVector(ex_in), ex_out, name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [19/20]

casadi::Function::Function	(	const std::string &	name,
		const MXVector &	ex_in,
		MXIList	ex_out,
		const StringVector &	name_in,
		const StringVector &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 173 of file function.cpp.

                                                                                    {
     construct(name, ex_in, MXVector(ex_out), name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ Function() [20/20]

casadi::Function::Function	(	const std::string &	name,
		MXIList	ex_in,
		MXIList	ex_out,
		const StringVector &	name_in,
		const StringVector &	name_out,
		const Dict &	opts = `Dict()`
	)

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

Definition at line 178 of file function.cpp.

                                                                                    {
     construct(name, MXVector(ex_in), MXVector(ex_out), name_in, name_out, opts);
   }

References construct(), name(), name_in(), and name_out().

◆ ~Function()

casadi::Function::~Function ( )

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

Definition at line 61 of file function.cpp.

61 {

62 }

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

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 eval_activity(), casadi::get_ptr(), n_in(), n_out(), nnz_in(), nnz_out(), casadi::str(), sz_arg(), sz_iw(), sz_res(), and 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

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 name_in(), size1_in(), 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

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 name_out(), size1_out(), size2_out(), and casadi::str().

Referenced by 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

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 assert_size_out(), name_out(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), sparsity_out(), and casadi::str().

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

◆ assign()

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

inherited

improper use will cause memory leaks!

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

Definition at line 96 of file generic_shared_impl.hpp.

                                                               {
     node = node_;
   }

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

static

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

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(), index_in(), nnz_in(), and sz_arg().

◆ buf_in() [2/2]

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

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(), n_in(), nnz_in(), and sz_arg().

◆ buf_out() [1/4]

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

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(), index_out(), nnz_out(), and sz_res().

◆ buf_out() [2/4]

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

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(), index_out(), nnz_out(), and sz_res().

◆ buf_out() [3/4]

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

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(), n_out(), nnz_out(), and sz_res().

◆ buf_out() [4/4]

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

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(), n_out(), nnz_out(), and sz_res().

◆ cache()

Dict casadi::Function::cache ( ) const

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

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

◆ call() [2/6]

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

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

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 call_gen(), casadi::construct_nlpsol(), casadi::detect_simple_bounds_gen(), casadi::FunctionInternal::eval_mx(), map(), casadi::MX::matrix_expand(), 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

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

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

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

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 call(), and name_out().

◆ call_gen() [2/2]

template<typename D >

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

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(), n_in(), n_out(), sz_arg(), sz_iw(), sz_res(), and sz_w().

Referenced by call(), and operator()().

◆ change_option()

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

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

◆ check_name()

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

static

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

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

◆ checkout()

casadi_int casadi::Function::checkout ( ) const

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

static

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 if_else(), mx_in(), n_out(), name(), name_in(), name_out(), 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()`
	)

static

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 create(), and name().

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

◆ construct() [1/3]

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
	)

protected

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 construct(), name(), name_in(), and name_out().

◆ construct() [2/3]

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
	)

protected

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(), name(), name_in(), name_out(), casadi::GenericShared< SharedObject, SharedObjectInternal >::operator=(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

◆ construct() [3/3]

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
	)

protected

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(), name(), name_in(), name_out(), casadi::GenericShared< SharedObject, SharedObjectInternal >::operator=(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::own().

Referenced by construct(), and Function().

◆ convert_in() [1/6]

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

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

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

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

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

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

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

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

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

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

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

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

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 )

static

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(), conditional(), casadi::conic(), casadi::Interpolant::construct(), casadi::MapSum::create(), casadi::Map::create(), casadi::OnnxFunction::create(), 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(), if_else(), jit(), casadi::nlpsol(), casadi::rootfinder(), and casadi::OptiNode::solver_construct().

◆ create() [2/2]

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

static

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

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 )

static

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

◆ deserialize() [2/3]

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

static

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(), Function(), casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null(), and casadi::DeserializingStream::unpack().

◆ deserialize() [3/3]

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

static

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

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

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

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

◆ expand() [1/2]

Function casadi::Function::expand ( ) const

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

◆ expand() [2/2]

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

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 Function(), get_free(), has_free(), casadi::join(), name(), name_in(), name_out(), 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

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

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

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

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(), name(), and casadi::str().

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

◆ find_function()

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

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 Function(), and name().

◆ find_functions()

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

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 )

static

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 check_name(), and name().

◆ fold()

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

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 Function(), mapaccum(), mx_in(), name(), name_in(), name_out(), casadi::range(), and size2_out().

◆ forward()

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

   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

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

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

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

Definition at line 1386 of file function.cpp.

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

References generate(), and name().

◆ generate() [2/2]

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

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

◆ generate_dependencies()

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

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 )

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(), nnz_in(), casadi::Matrix< Scalar >::nonzeros(), casadi::GenericMatrix< MatType >::numel(), nz_to_in(), and casadi::str().

◆ generate_in() [2/2]

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

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(), nz_from_in(), and casadi::Filesystem::ofstream_ptr().

◆ generate_lifted()

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

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 )

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(), nnz_out(), casadi::Matrix< Scalar >::nonzeros(), casadi::GenericMatrix< MatType >::numel(), nz_to_out(), and casadi::str().

◆ generate_out() [2/2]

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

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(), nz_from_out(), and casadi::Filesystem::ofstream_ptr().

◆ get() [1/2]

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

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

inline

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

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

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

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

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

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

bool casadi::Function::has_free ( ) const

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

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

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

◆ has_option()

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

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

◆ has_out()

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

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

◆ has_spfwd()

bool casadi::Function::has_spfwd ( ) const

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

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

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 factory(), name(), name_in(), and 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()`
	)

static

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 create(), and name().

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

◆ index_in()

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

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

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

◆ index_out()

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

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

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

◆ info()

Dict casadi::Function::info ( ) const

Obtain information about function

Definition at line 2138 of file function.cpp.

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

◆ instruction_constant()

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

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

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

(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

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

(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

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

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(), map(), and transform().

◆ is_diff_in() [1/2]

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

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

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

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

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

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 n_in(), and 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

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

◆ jacobian()

Function casadi::Function::jacobian ( ) const

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

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 factory(), name(), name_in(), and 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()`
	)

static

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 name(), name_in(), name_out(), sparsity_in(), and 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()`
	)

static

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 create(), name(), name_in(), name_out(), sparsity_in(), and sparsity_out().

◆ load()

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

static

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

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 Function(), map(), n_in(), n_out(), name_in(), name_out(), casadi::range(), size2_in(), size2_out(), sparsity_in(), and casadi::GenericMatrix< MX >::sym().

◆ map() [2/5]

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

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 call(), Function(), is_a(), n_in(), n_out(), name(), name_in(), name_out(), 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 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

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

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 Function(), map(), mx_in(), name(), name_in(), and 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

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 index_in(), index_out(), map(), and name().

◆ mapaccum() [1/6]

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

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 mapaccum(), and name().

◆ mapaccum() [2/6]

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

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 mapaccum(), name(), and casadi::str().

◆ mapaccum() [3/6]

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

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

Referenced by casadi::MX::cumsum(), fold(), and 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

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(), mapaccum(), n_in(), n_out(), name(), casadi::range(), and 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

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 index_in(), index_out(), mapaccum(), and 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

protected

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 Function(), mx_in(), n_in(), n_out(), name(), name_in(), name_out(), 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

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

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

Definition at line 1978 of file function.cpp.

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

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

◆ merge()

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

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

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

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 map(), and mapaccum().

◆ mx_in() [2/3]

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

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 conditional(), casadi::DaeBuilderInternal::create(), casadi::FixedStepIntegrator::create_advanced(), 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(), map(), transform(), and casadi::DaeBuilderInternal::transition().

◆ mx_in() [3/3]

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

inline

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

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

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

inline

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

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

Definition at line 971 of file function.cpp.

                                   {
     return (*this)->n_in_;
   }

◆ n_instructions()

casadi_int casadi::Function::n_instructions ( ) const

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

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

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

Definition at line 975 of file function.cpp.

                                    {
     return (*this)->n_out_;
   }

Referenced by activity(), casadi::CodeGenerator::add(), buf_out(), casadi::OracleFunction::calc_function(), casadi::DaeBuilderInternal::CallIO::calc_jac(), 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(), 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(), jac_sparsity(), casadi::FunctionInternal::jacobian(), casadi::Onnx::load(), map(), mapaccum(), casadi::MapSum::MapSum(), casadi::SymbolicQr::nfact(), casadi::Call::nout(), casadi::SXFunction::print(), casadi::qpsol_nlp(), 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

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

◆ name_in() [1/2]

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

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(), assert_size_in(), casadi::OracleFunction::calc_function(), conditional(), construct(), casadi::construct_nlpsol(), casadi::DaeBuilderInternal::create(), expand(), casadi::External::factory(), fold(), 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(), hessian_old(), casadi::Rootfinder::init(), jacobian_old(), jit(), casadi::DaeBuilderInternal::load_fmi_description(), map(), mapaccum(), casadi::onnx_input_name(), casadi::qpsol_nlp(), casadi::OptiNode::scale_helper(), and transform().

◆ name_in() [2/2]

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

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

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(), assert_size_out(), assert_sparsity_out(), casadi::blazing_spline(), casadi::OracleFunction::calc_function(), call_gen(), conditional(), construct(), casadi::construct_nlpsol(), casadi::DaeBuilderInternal::create(), expand(), casadi::External::factory(), fold(), 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(), hessian_old(), casadi::Rootfinder::init(), jacobian_old(), jit(), casadi::DaeBuilderInternal::load_fmi_description(), map(), mapaccum(), casadi::onnx_output_name(), casadi::qpsol_nlp(), casadi::OptiNode::scale_helper(), and transform().

◆ name_out() [2/2]

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

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

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(), activity(), casadi::SXFunction::ad_forward(), casadi::SXFunction::ad_reverse(), 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(), 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

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

inline

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.

302 {return nnz_in(index_in(iname));}

References nnz_in().

Referenced by nnz_in().

◆ nnz_out() [1/3]

casadi_int casadi::Function::nnz_out ( ) const

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(), activity(), casadi::SXFunction::ad_forward(), casadi::SXFunction::ad_reverse(), 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(), 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

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

inline

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.

313 {return nnz_out(index_out(oname));}

References nnz_out().

Referenced by nnz_out().

◆ nominal_in()

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

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

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

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

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

inline

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.

336 {return numel_in(index_in(iname));}

casadi::Function::numel_in

casadi_int numel_in() const

Get number of input elements.

Definition: function.cpp:1011

References numel_in().

Referenced by numel_in().

◆ numel_out() [1/3]

casadi_int casadi::Function::numel_out ( ) const

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

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

inline

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.

347 {return numel_out(index_out(oname));}

casadi::Function::numel_out

casadi_int numel_out() const

Get number of output elements.

Definition: function.cpp:1015

References numel_out().

Referenced by numel_out().

◆ nz_from_in()

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

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

◆ nz_from_out()

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

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

◆ nz_to_in()

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

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

◆ nz_to_out()

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

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

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

◆ operator()() [2/24]

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

inline

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

Functor shorthand for evaluation

Definition at line 1632 of file function.cpp.

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

References call().

◆ operator()() [4/24]

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

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

◆ operator()() [5/24]

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

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 memory(), casadi::uerr(), and casadi::CasadiException::what().

◆ operator()() [6/24]

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

inline

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

Functor shorthand for evaluation

Definition at line 1644 of file function.cpp.

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

References call().

◆ operator()() [8/24]

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

Functor shorthand for evaluation

Definition at line 1597 of file function.cpp.

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

References call().

Referenced by operator()().

◆ operator()() [9/24]

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

Functor shorthand for evaluation

Definition at line 1609 of file function.cpp.

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

References call().

◆ operator()() [10/24]

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

Functor shorthand for evaluation

Definition at line 1603 of file function.cpp.

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

References call().

◆ operator()() [11/24]

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

inline

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

Functor shorthand for evaluation

Definition at line 1638 of file function.cpp.

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

References call().

◆ operator()() [13/24]

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

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

◆ operator()() [14/24]

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

inline

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

Definition at line 644 of file function.hpp.

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

casadi::Function::buf_out

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

Supported arguments for numerical evaluation and converters.

Definition: function.cpp:547

casadi::Function::buf_in

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

Supported arguments for numerical evaluation and converters.

Definition: function.cpp:536

◆ operator()() [15/24]

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

inline

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

Definition at line 646 of file function.hpp.

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

◆ operator()() [16/24]

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

inline

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

Definition at line 643 of file function.hpp.

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

◆ operator()() [17/24]

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

inline

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

Definition at line 645 of file function.hpp.

645 { (*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

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

Definition at line 636 of file function.cpp.

                                                                                       {
     call_gen(arg, res);
   }

References call_gen().

◆ operator()() [19/24]

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

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

Definition at line 632 of file function.cpp.

                                                                                       {
     call_gen(arg, res);
   }

References call_gen().

◆ operator()() [20/24]

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

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

Definition at line 640 of file function.cpp.

                                                                                       {
     call_gen(arg, res);
   }

References call_gen().

◆ operator()() [21/24]

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

inline

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

Definition at line 639 of file function.hpp.

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

◆ operator()() [22/24]

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

inline

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

Definition at line 641 of file function.hpp.

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

◆ operator()() [23/24]

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

inline

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

Definition at line 638 of file function.hpp.

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

◆ operator()() [24/24]

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

inline

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

Definition at line 640 of file function.hpp.

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

◆ operator->()

FunctionInternal * casadi::Function::operator-> ( ) const

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 get(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null().

◆ operator==()

bool casadi::Function::operator== ( const Function & f ) const

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 get(), casadi::GenericShared< Shared, Internal >::is_null(), and casadi::GenericShared< SharedObject, SharedObjectInternal >::is_null().

◆ oracle()

Function casadi::Function::oracle ( ) const

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 )

static

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 )

static

Definition at line 2142 of file function.cpp.

                                                          {
     return SXFunction::order(expr);
   }

References casadi::SXFunction::order().

Referenced by casadi::SerializerBase::pack(), and which_depends().

◆ own()

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

inherited

Assign the node to a node class pointer (or null)

Definition at line 89 of file generic_shared_impl.hpp.

                                                            {
     count_down();
     node = node_;
     count_up();
   }

◆ print_dimensions()

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

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

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

Definition at line 1348 of file function.cpp.

                                                                              {
     (*this)->print_option(name, stream);
   }

References name().

◆ print_options()

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

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
	)

staticprotected

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

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

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

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

Referenced by casadi::_which_depends(), 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

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(), n_in(), n_out(), rev(), sz_arg(), sz_iw(), sz_res(), and sz_w().

◆ reverse()

Function casadi::Function::reverse ( casadi_int nadj ) const

   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

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

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

◆ serialize() [2/3]

void casadi::Function::serialize ( SerializingStream & s ) const

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

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

◆ set_temp()

void casadi::Function::set_temp	(	const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w,
		int	mem = `0`
	)		const

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

◆ set_work()

void casadi::Function::set_work	(	const double **&	arg,
		double **&	res,
		casadi_int *&	iw,
		double *&	w,
		int	mem = `0`
	)		const

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

◆ setup()

void casadi::Function::setup	(	const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w,
		int	mem = `0`
	)		const

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

◆ size1_in() [1/2]

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

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

inline

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

Definition at line 271 of file function.hpp.

271 {return size1_in(index_in(iname));}

References size1_in().

Referenced by size1_in().

◆ size1_out() [1/2]

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

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

inline

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

Definition at line 285 of file function.hpp.

285 {return size1_out(index_out(oname));}

References size1_out().

Referenced by size1_out().

◆ size2_in() [1/2]

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

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 assert_size_in(), casadi::FiniteDiff::get_sparsity_in(), map(), and mapaccum().

◆ size2_in() [2/2]

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

inline

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

Definition at line 273 of file function.hpp.

273 {return size2_in(index_in(iname));}

References size2_in().

Referenced by size2_in().

◆ size2_out() [1/2]

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

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 assert_size_out(), casadi::Call::create(), fold(), casadi::Onnx::load(), and map().

◆ size2_out() [2/2]

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

inline

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

Definition at line 287 of file function.hpp.

287 {return size2_out(index_out(oname));}

References size2_out().

Referenced by size2_out().

◆ size_in() [1/2]

std::pair< casadi_int, casadi_int > casadi::Function::size_in ( casadi_int ind ) const

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

inline

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

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

inline

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

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 name(), and casadi::FunctionInternal::slice().

Referenced by mapaccum(), and casadi::FunctionInternal::slice().

◆ sparsity_in() [1/2]

const Sparsity & casadi::Function::sparsity_in ( casadi_int ind ) const

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(), jit(), casadi::Onnx::load(), map(), casadi::Collocation::setup_step(), casadi::RungeKutta::setup_step(), casadi::simpleIntegrator(), casadi::simpleIRK(), casadi::simpleRK(), and sparsity_in().

◆ sparsity_in() [2/2]

const Sparsity & casadi::Function::sparsity_in ( const std::string & iname ) const

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 index_in(), and 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

[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

inline

[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

inline

[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

inline

[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

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 assert_sparsity_out(), casadi::OracleFunction::calc_function(), casadi::Switch::codegen_body(), 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(), jac_sparsity(), jit(), casadi::Onnx::load(), casadi::IdasInterface::psetupF(), casadi::Call::sparsity(), and sparsity_out().

◆ sparsity_out() [2/2]

const Sparsity & casadi::Function::sparsity_out ( const std::string & iname ) const

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 index_out(), and sparsity_out().

◆ stats()

Dict casadi::Function::stats ( int mem = 0 ) const

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

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 expand(), and sym_in().

◆ sx_in() [2/3]

const SX casadi::Function::sx_in ( casadi_int iind ) const

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

◆ sx_in() [3/3]

const SX casadi::Function::sx_in ( const std::string & iname ) const

inline

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

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

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

inline

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

Definition at line 2246 of file function.cpp.

                                                            {
       return sx_in();
   }

References sx_in().

◆ sym_in() [2/5]

template<typename T >

const std::vector<T> casadi::Function::sym_in ( ) const

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

Definition at line 2237 of file function.cpp.

                                                                {
       return sx_in(iind);
   }

References sx_in().

◆ sym_in() [4/5]

template<typename T >

const T casadi::Function::sym_in ( casadi_int iind ) const

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

inline

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

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

Definition at line 1235 of file function.cpp.

1235 { return (*this)->sz_arg();}

Referenced by activity(), casadi::SymbolicQrMemory::alloc(), buf_in(), 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(), rev(), casadi::MX::simplify_const_folding(), casadi::Call::sz_arg(), and sz_work().

◆ sz_iw()

size_t casadi::Function::sz_iw ( ) const

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

Definition at line 1239 of file function.cpp.

1239 { return (*this)->sz_iw();}

Referenced by activity(), casadi::SymbolicQrMemory::alloc(), 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(), rev(), casadi::MX::simplify_const_folding(), casadi::Call::sz_iw(), and sz_work().

◆ sz_res()

size_t casadi::Function::sz_res ( ) const

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

Definition at line 1237 of file function.cpp.

1237 { return (*this)->sz_res();}

Referenced by activity(), casadi::SymbolicQrMemory::alloc(), buf_out(), 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(), rev(), casadi::MX::simplify_const_folding(), casadi::Call::sz_res(), and sz_work().

◆ sz_w()

size_t casadi::Function::sz_w ( ) const

◆ sz_work()

void casadi::Function::sz_work	(	size_t &	sz_arg,
		size_t &	sz_res,
		size_t &	sz_iw,
		size_t &	sz_w
	)		const

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 sz_arg(), sz_iw(), sz_res(), and 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 )

static

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

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

Referenced by transform(), and casadi::MX::transform().

◆ transform() [2/4]

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

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

◆ transform() [3/4]

Function casadi::Function::transform	(	const std::string &	fname,
		const std::vector< std::vector< GenericType > > &	passes,
		const Dict &	opts = `Dict()`
	)		const

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 expand(), casadi::external_transform(), Function(), is_a(), mx_in(), name(), name_in(), name_out(), casadi::FunctionInternal::simplify_passes(), 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

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 name(), and transform().

◆ type_name()

static std::string casadi::Function::type_name ( )

inlinestatic

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

Definition at line 65 of file function.hpp.

65 {return "Function";}

◆ uses_output()

bool casadi::Function::uses_output ( ) const

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

Definition at line 1035 of file function.cpp.

                                    {
     return (*this)->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

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

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

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

Definition at line 2116 of file function.cpp.

                                                      {
     return (*this)->wrap(name);
   }

References name(), and casadi::FunctionInternal::wrap().

◆ wrap_as_needed() [1/2]

Function casadi::Function::wrap_as_needed ( const Dict & opts ) const

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

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 name(), and casadi::FunctionInternal::wrap_as_needed().

The documentation for this class was generated from the following files:

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Protected Member Functions

Member Typedef Documentation

◆ AuxOut

◆ base_type

◆ internal_base_type

◆ MapArg

◆ MapRes

◆ MPrRes

◆ VecArg

◆ VecRes

◆ VPrRes

Constructor & Destructor Documentation

◆ Function() [1/20]

◆ Function() [2/20]

◆ Function() [3/20]

◆ Function() [4/20]

◆ Function() [5/20]

◆ Function() [6/20]

◆ Function() [7/20]

◆ Function() [8/20]

◆ Function() [9/20]

◆ Function() [10/20]

◆ Function() [11/20]

◆ Function() [12/20]

◆ Function() [13/20]

◆ Function() [14/20]

◆ Function() [15/20]

◆ Function() [16/20]

◆ Function() [17/20]

◆ Function() [18/20]

◆ Function() [19/20]

◆ Function() [20/20]

◆ ~Function()

Member Function Documentation

◆ __hash__()

◆ activity()

◆ assert_size_in()

◆ assert_size_out()

◆ assert_sparsity_out()

◆ assign()

◆ bspline()

◆ buf_in() [1/2]

◆ buf_in() [2/2]

◆ buf_out() [1/4]

◆ buf_out() [2/4]

◆ buf_out() [3/4]

◆ buf_out() [4/4]

◆ cache()

◆ call() [1/6]

◆ call() [2/6]

◆ call() [3/6]

◆ call() [4/6]

◆ call() [5/6]

◆ call() [6/6]

◆ call_gen() [1/2]

◆ call_gen() [2/2]

◆ change_option()

◆ check_name()

◆ checkout()

◆ class_name()

◆ conditional() [1/2]

◆ conditional() [2/2]

◆ construct() [1/3]

◆ construct() [2/3]

◆ construct() [3/3]

◆ convert_in() [1/6]

◆ convert_in() [2/6]

◆ convert_in() [3/6]

◆ convert_in() [4/6]

◆ convert_in() [5/6]

◆ convert_in() [6/6]

◆ convert_out() [1/6]

◆ convert_out() [2/6]

◆ convert_out() [3/6]

◆ convert_out() [4/6]

◆ hash()