Internal node class for MXFunction. More...

#include <mx_function.hpp>

Detailed Description

Author: Joel Andersson

Date: 2010-2015

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

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
allow_duplicate_io_names	OT_BOOL	Allow construction with duplicate io names (Default: false)	casadi::MXFunction
allow_free	OT_BOOL	Allow construction with free variables (Default: false)	casadi::MXFunction
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
cse	OT_BOOL	Perform common subexpression elimination (complexity is N*log(N) in graph size)	casadi::MXFunction
custom_jacobian	OT_FUNCTION	Override CasADi's AD. Use together with 'jac_penalty': 0. Note: Highly experimental. Syntax may break often.	casadi::FunctionInternal
default_in	OT_DOUBLEVECTOR	Default input values	casadi::MXFunction
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 and traces 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
dump_trace	OT_BOOL	Dump interpreted instruction values to name.NNNNNN.trace.jsonl in dump_dir, using the dump_in/dump_out counter. [false]	casadi::MXFunction
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
live_variables	OT_BOOL	Reuse variables in the work vector	casadi::MXFunction
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_instructions	OT_BOOL	Print each operation during evaluation. Influenced by print_canonical.	casadi::MXFunction
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

Definition at line 66 of file mx_function.hpp.

Inheritance diagram for casadi::MXFunction:

[legend]

Collaboration diagram for casadi::MXFunction:

[legend]

Public Types
typedef MXAlgEl	AlgEl
	An element of the algorithm, namely an MX node. More...

using	weak_ref_type = WeakRefInternal

Public Member Functions
	MXFunction (const std::string &name, const std::vector< MX > &input, const std::vector< MX > &output, const std::vector< std::string > &name_in, const std::vector< std::string > &name_out)
	Constructor. More...

	~MXFunction () override
	Destructor. More...

int	eval (const double arg, double res, casadi_int iw, double w, void *mem) const override
	Evaluate numerically, work vectors given. More...

void	trace_instruction (std::ostream &trace, casadi_int k, const double *w, bool output) const

void	disp_more (std::ostream &stream) const override
	Print description. More...

std::string	class_name () const override
	Get type name. More...

bool	is_a (const std::string &type, bool recursive) const override
	Check if the function is of a particular type. More...

Dict	get_stats (void *mem) const override
	Get all statistics. More...

Dict	generate_options (const std::string &target="clone") const override
	Reconstruct options dict. More...

void	init (const Dict &opts) override
	Initialize. More...

void	codegen_declarations (CodeGenerator &g) const override
	Generate code for the declarations of the C function. More...

void	codegen_incref (CodeGenerator &g) const override
	Codegen incref for dependencies. More...

void	codegen_decref (CodeGenerator &g) const override
	Codegen decref for dependencies. More...

void	codegen_body (CodeGenerator &g) const override
	Generate code for the body of the C function. More...

size_t	codegen_sz_w (const CodeGenerator &g) const override
	Work vector size of the generated code. More...

void	serialize_body (SerializingStream &s) const override
	Serialize an object without type information. More...

void	generate_lifted (Function &vdef_fcn, Function &vinit_fcn) const override
	Extract the residual function G and the modified function Z out of an expression. More...

bool	should_inline (bool with_sx, bool always_inline, bool never_inline) const override

int	eval_sx (const SXElem arg, SXElem res, casadi_int iw, SXElem w, void *mem, bool always_inline, bool never_inline) const override
	Evaluate symbolically, SX type. More...

void	eval_mx (const MXVector &arg, MXVector &res, bool always_inline, bool never_inline) const override
	Evaluate symbolically, MX type. More...

void	ad_forward (const std::vector< std::vector< MX > > &fwdSeed, std::vector< std::vector< MX > > &fwdSens) const
	Calculate forward mode directional derivatives. More...

void	ad_reverse (const std::vector< std::vector< MX > > &adjSeed, std::vector< std::vector< MX > > &adjSens) const
	Calculate reverse mode directional derivatives. More...

std::vector< MX >	symbolic_output (const std::vector< MX > &arg) const override
	Get a vector of symbolic variables corresponding to the outputs. More...

int	sp_forward (const bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem) const override
	Propagate sparsity forward. More...

int	eval_activity (const bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem) const override
	Propagate signal activity forward. More...

int	sp_reverse (bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem) const override
	Propagate sparsity backwards. More...

std::string	print (const AlgEl &el) const

void	print_arg (std::ostream &stream, casadi_int k, const AlgEl &el, const double **arg) const

void	print_arg (CodeGenerator &g, casadi_int k, const AlgEl &el, const std::vector< casadi_int > &arg, const std::vector< bool > &arg_is_ref) const

void	print_res (std::ostream &stream, casadi_int k, const AlgEl &el, double **res) const

void	print_res (CodeGenerator &g, casadi_int k, const AlgEl &el, const std::vector< casadi_int > &res, const std::vector< bool > &res_is_ref) const

std::vector< MX >	free_mx () const override
	Get free variables (MX) More...

bool	has_free () const override
	Does the function have free variables. More...

std::vector< std::string >	get_free () const override
	Print free variables. More...

std::vector< std::string >	get_function () const override
	Get list of dependency functions. More...

const Function &	get_function (const std::string &name) const override
	Get a dependency function. More...

casadi_int	n_nodes () const override
	Number of nodes in the algorithm. More...

casadi_int	n_instructions () const override
	Get the number of atomic operations. More...

MX	instruction_MX (casadi_int k) const override
	get MX expression associated with instruction More...

casadi_int	instruction_id (casadi_int k) const override
	Get an atomic operation operator index. More...

double	get_default_in (casadi_int ind) const override
	Get default input value. More...

std::vector< casadi_int >	instruction_input (casadi_int k) const override
	Get the (integer) input arguments of an atomic operation. More...

std::vector< casadi_int >	instruction_output (casadi_int k) const override
	Get the (integer) output argument of an atomic operation. More...

void	export_code_body (const std::string &lang, std::ostream &stream, const Dict &options) const override
	Export function in a specific language. More...

void	substitute_inplace (std::vector< MX > &vdef, std::vector< MX > &ex) const
	Substitute inplace, internal implementation. More...

void	find (std::map< FunctionInternal *, std::pair< Function, size_t > > &all_fun, casadi_int max_depth) const override

void	change_option (const std::string &option_name, const GenericType &option_value) override
	Change option after object creation for debugging. More...

std::vector< MX >	jac (const Dict &opts) const
	Construct a complete Jacobian by compression. More...

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

std::vector< bool >	which_depends (const std::string &s_in, const std::vector< std::string > &s_out, casadi_int order, bool tr=false) const override
	Which variables enter with some order. More...

Function	slice (const std::string &name, const std::vector< casadi_int > &order_in, const std::vector< casadi_int > &order_out, const Dict &opts) const override
	returns a new function with a selection of inputs/outputs of the original More...

Function	simplify_passes (const std::vector< std::pair< std::string, casadi_int > > &tasks) const override
	Apply an ordered list of simplify passes. More...

void	apply_simplify_passes (const std::vector< std::pair< std::string, casadi_int > > &tasks, std::vector< MX > &new_in, std::vector< MX > &new_out) const
	Apply simplify passes in-place on a set of inputs/outputs. More...

void	export_code (const std::string &lang, std::ostream &stream, const Dict &options) const override
	Export function in a specific language. More...

bool	has_codegen () const override
	Is codegen supported? More...

virtual bool	isInput (const std::vector< MX > &arg) const
	Helper function: Check if a vector equals ex_in. More...

void	call_forward (const std::vector< MX > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool always_inline, bool never_inline) const override
	Create call to (cached) derivative function, forward mode. More...

void	call_reverse (const std::vector< MX > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool always_inline, bool never_inline) const override
	Create call to (cached) derivative function, reverse mode. More...

void	delayed_serialize_members (SerializingStream &s) const
	Helper functions to avoid recursion limit. More...

void	delayed_deserialize_members (DeserializingStream &s)

virtual std::string	getAdaptorSolverName () const
	Obtain solver name from Adaptor. More...

void	reset_dump_count ()
	Reset the counter used to name dump files. More...

void	finalize () override
	Finalize the object creation. More...

void *	alloc_mem () const override
	Create memory block. More...

void	free_mem (void *mem) const override
	Free memory block. More...

Function	self () const
	Get a public class instance. More...

virtual bool	has_function (const std::string &fname) const

void	add_embedded (std::map< FunctionInternal *, std::pair< Function, size_t > > &all_fun, const Function &dep, casadi_int max_depth) const

template<typename M >
void	call (const std::vector< M > &arg, std::vector< M > &res, bool always_inline, bool never_inline) const
	Call a function, templated. More...

template<typename M >
bool	matching_arg (const std::vector< M > &arg, casadi_int &npar) const
	Check if input arguments that needs to be replaced. More...

template<typename M >
bool	matching_res (const std::vector< M > &arg, casadi_int &npar) const
	Check if output arguments that needs to be replaced. More...

template<typename M >
std::vector< M >	replace_arg (const std::vector< M > &arg, casadi_int npar) const
	Replace 0-by-0 inputs. More...

template<typename M >
std::vector< M >	project_arg (const std::vector< M > &arg, casadi_int npar) const
	Project sparsities. More...

template<typename M >
std::vector< M >	project_res (const std::vector< M > &arg, casadi_int npar) const
	Project sparsities. More...

template<typename M >
std::vector< M >	replace_res (const std::vector< M > &res, casadi_int npar) const
	Replace 0-by-0 outputs. More...

template<typename M >
std::vector< std::vector< M > >	replace_fseed (const std::vector< std::vector< M >> &fseed, casadi_int npar) const
	Replace 0-by-0 forward seeds. More...

template<typename M >
std::vector< std::vector< M > >	replace_fseed (const std::vector< std::vector< M > > &fseed, casadi_int npar) const

template<typename M >
std::vector< std::vector< M > >	replace_aseed (const std::vector< std::vector< M >> &aseed, casadi_int npar) const
	Replace 0-by-0 reverse seeds. More...

template<typename M >
std::vector< std::vector< M > >	replace_aseed (const std::vector< std::vector< M > > &aseed, casadi_int npar) const

std::vector< MX >	mapsum_mx (const std::vector< MX > &arg, const std::string &parallelization)
	Parallel evaluation. More...

virtual bool	uses_output () const
	Do the derivative functions need nondifferentiated outputs? More...

std::string	diff_prefix (const std::string &prefix) const
	Determine prefix for differentiated functions. More...

virtual const Function &	oracle () const
	Get oracle. More...

bool	has_derivative () const
	Can derivatives be calculated in any way? More...

virtual double	ad_weight () const
	Weighting factor for chosing forward/reverse mode. More...

virtual double	sp_weight () const
	Weighting factor for chosing forward/reverse mode,. More...

virtual std::vector< SX >	free_sx () const
	Get free variables (SX) More...

virtual double	instruction_constant (casadi_int k) const
	Get the floating point output argument of an atomic operation. More...

virtual SX	instructions_sx () const
	get SX expression associated with instructions More...

Dict	cache () const
	Get all functions in the cache. More...

bool	incache (const std::string &fname, Function &f, const std::string &suffix="") const
	Get function in cache. More...

void	tocache (const Function &f, const std::string &suffix="") const
	Save function to cache. More...

void	tocache_if_missing (Function &f, const std::string &suffix="") const
	Save function to cache, only if missing. More...

void	codegen (CodeGenerator &g, const std::string &fname) const
	Generate code the function. More...

void	codegen_meta (CodeGenerator &g) const
	Generate meta-information allowing a user to evaluate a generated function. More...

void	codegen_sparsities (CodeGenerator &g) const
	Codegen sparsities. More...

virtual std::string	codegen_name (const CodeGenerator &g, bool ns=true) const
	Get name in codegen. More...

std::string	codegen_mem (CodeGenerator &g, const std::string &index="mem") const
	Get thread-local memory object. More...

virtual void	codegen_alloc_mem (CodeGenerator &g) const
	Codegen decref for alloc_mem. More...

virtual void	codegen_init_mem (CodeGenerator &g) const
	Codegen decref for init_mem. More...

virtual void	codegen_free_mem (CodeGenerator &g) const
	Codegen for free_mem. More...

virtual void	codegen_checkout (CodeGenerator &g) const
	Codegen for checkout. More...

virtual void	codegen_release (CodeGenerator &g) const
	Codegen for release. More...

std::string	signature (const std::string &fname) const
	Code generate the function. More...

std::string	signature_unrolled (const std::string &fname) const
	Code generate the function. More...

virtual std::string	codegen_mem_type () const
	Thread-local memory object type. More...

virtual bool	codegen_needs_mem () const
	Is thread-local memory object needed? More...

virtual bool	codegen_mem_is_opaque () const
	Is thread-local memory object managed by checkout/release. More...

virtual std::string	generate_dependencies (const std::string &fname, const Dict &opts) const
	Export / Generate C code for the dependency function. More...

virtual void	jit_dependencies (const std::string &fname)
	Jit dependencies. More...

void	serialize_type (SerializingStream &s) const override
	Serialize type information. More...

void	disp (std::ostream &stream, bool more) const override
	Display object. More...

std::string	definition () const
	Get function signature: name:(inputs)->(outputs) More...

void	print_dimensions (std::ostream &stream) const
	Print dimensions of inputs and outputs. More...

void	get_partition (casadi_int iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool symmetric, bool allow_forward, bool allow_reverse) const
	Get the unidirectional or bidirectional partition. More...

virtual double	get_max_in (casadi_int ind) const
	Get largest input value. More...

virtual double	get_min_in (casadi_int ind) const
	Get smallest input value. More...

virtual std::vector< double >	get_nominal_in (casadi_int ind) const

virtual std::vector< double >	get_nominal_out (casadi_int ind) const

virtual double	get_reltol () const
	Get relative tolerance. More...

virtual double	get_abstol () const
	Get absolute tolerance. More...

virtual bool	get_diff_in (casadi_int i)
	Which inputs are differentiable. More...

virtual bool	get_diff_out (casadi_int i)
	Which outputs are differentiable. More...

casadi_int	index_in (const std::string &name) const
	Get input scheme index by name. More...

casadi_int	index_out (const std::string &name) const
	Get output scheme index by name. More...

virtual int	sp_forward_block (const bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem, casadi_int oind, casadi_int iind) const
	Propagate sparsity forward, specific block. 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...

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	alloc_arg (size_t sz_arg, bool persistent=false)
	Ensure required length of arg field. More...

void	alloc_res (size_t sz_res, bool persistent=false)
	Ensure required length of res field. More...

void	alloc_iw (size_t sz_iw, bool persistent=false)
	Ensure required length of iw field. More...

void	alloc_w (size_t sz_w, bool persistent=false)
	Ensure required length of w field. More...

void	alloc (const Function &f, bool persistent=false, int num_threads=1)
	Ensure work vectors long enough to evaluate function. More...

virtual void	set_work (void mem, const double &arg, double &res, casadi_int &iw, double *&w) const
	Set the (persistent) work vectors. More...

virtual void	set_temp (void mem, const double arg, double res, casadi_int iw, double *w) const
	Set the (temporary) work vectors. More...

void	setup (void mem, const double arg, double res, casadi_int iw, double *w) const
	Set the (persistent and temporary) work vectors. More...

virtual Dict	info () const

Function	map (casadi_int n, const std::string &parallelization) const
	Generate/retrieve cached serial map. More...

void	generate_in (const std::string &fname, const double **arg) const
	Export an input file that can be passed to generate C code with a main. More...

void	generate_out (const std::string &fname, double **res) const

virtual void	merge (const std::vector< MX > &arg, std::vector< MX > &subs_from, std::vector< MX > &subs_to) const
	List merge opportunitities. More...

template<typename MatType >
std::vector< std::vector< MatType > >	fwd_seed (casadi_int nfwd) const
	Symbolic expressions for the forward seeds. More...

template<typename MatType >
std::vector< std::vector< MatType > >	symbolicAdjSeed (casadi_int nadj, const std::vector< MatType > &v) const
	Symbolic expressions for the adjoint seeds. More...

void	print_in (std::ostream &stream, const double **arg, bool truncate) const
	Print inputs. More...

void	print_out (std::ostream &stream, double **res, bool truncate) const
	Print outputs. More...

void	construct (const Dict &opts)
	Construct. More...

void	print_options (std::ostream &stream) const
	Print list of options. More...

void	print_option (const std::string &name, std::ostream &stream) 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...

int	checkout () const
	Checkout a memory object. More...

void	release (int mem) const
	Release a memory object. More...

void *	memory (int ind) const
	Memory objects. More...

bool	has_memory (int ind) const
	Check for existance of memory object. More...

virtual void	check_mem_count (casadi_int n) const
	Check for validatity of memory object count. More...

virtual int	init_mem (void *mem) const
	Initalize memory block. More...

void	clear_mem ()
	Clear all memory (called from destructor) More...

void	print (const char *fmt,...) const
	C-style formatted printing during evaluation. More...

void	sprint (char buf, size_t buf_sz, const char fmt,...) const
	C-style formatted printing to string. More...

void	format_time (char *buffer, double time) const
	Format time in a fixed width 8 format. More...

void	print_time (const std::map< std::string, FStats > &fstats) const
	Print timing statistics. More...

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

virtual std::string	serialize_base_function () const
	String used to identify the immediate FunctionInternal subclass. More...

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

std::string	debug_repr (const SharedObjectInternal *) const

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


const MX	mx_in (casadi_int ind) const override
	Get function input(s) and output(s) More...

const std::vector< MX >	mx_in () const override
	Get function input(s) and output(s) More...


bool	has_spfwd () const override

bool	has_sprev () const override


bool	has_forward (casadi_int nfwd) const override
	Generate a function that calculates nfwd forward derivatives. More...

Function	get_forward (casadi_int nfwd, const std::string &name, const std::vector< std::string > &inames, const std::vector< std::string > &onames, const Dict &opts) const override
	Generate a function that calculates nfwd forward derivatives. More...


bool	has_reverse (casadi_int nadj) const override
	Generate a function that calculates nadj adjoint derivatives. More...

Function	get_reverse (casadi_int nadj, const std::string &name, const std::vector< std::string > &inames, const std::vector< std::string > &onames, const Dict &opts) const override
	Generate a function that calculates nadj adjoint derivatives. More...


bool	has_jacobian () const override
	Return Jacobian of all input elements with respect to all output elements. More...

Function	get_jacobian (const std::string &name, const std::vector< std::string > &inames, const std::vector< std::string > &onames, const Dict &opts) const override
	Return Jacobian of all input elements with respect to all output elements. More...


virtual void	call_forward (const std::vector< MX > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool always_inline, bool never_inline) const
	Forward mode AD, virtual functions overloaded in derived classes. More...

virtual void	call_forward (const std::vector< SX > &arg, const std::vector< SX > &res, const std::vector< std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool always_inline, bool never_inline) const
	Forward mode AD, virtual functions overloaded in derived classes. More...


virtual void	call_reverse (const std::vector< MX > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool always_inline, bool never_inline) const
	Reverse mode, virtual functions overloaded in derived classes. More...

virtual void	call_reverse (const std::vector< SX > &arg, const std::vector< SX > &res, const std::vector< std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool always_inline, bool never_inline) const
	Reverse mode, virtual functions overloaded in derived classes. More...


size_t	get_n_in () override
	Number of function inputs and outputs. More...

size_t	get_n_out () override
	Number of function inputs and outputs. More...


Sparsity	get_sparsity_in (casadi_int i) override
	Sparsities of function inputs and outputs. More...

Sparsity	get_sparsity_out (casadi_int i) override
	Sparsities of function inputs and outputs. More...


int	eval_gen (const double arg, double res, casadi_int iw, double w, void *mem, bool always_inline, bool never_inline) const
	Evaluate numerically. More...


int	eval_gen (const SXElem arg, SXElem res, casadi_int iw, SXElem w, void *mem, bool always_inline, bool never_inline) const
	Evaluate a function, overloaded. More...

int	eval_gen (const bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem, bool always_inline, bool never_inline) const
	Evaluate a function, overloaded. More...


virtual std::vector< DM >	eval_dm (const std::vector< DM > &arg) const
	Evaluate with DM matrices. More...

virtual bool	has_eval_dm () const
	Evaluate with DM matrices. More...


void	call_gen (const MXVector &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline) const
	Call a function, overloaded. More...

template<typename D >
void	call_gen (const std::vector< Matrix< D > > &arg, std::vector< Matrix< D > > &res, casadi_int npar, bool always_inline, bool never_inline) const
	Call a function, overloaded. More...


template<typename M >
void	check_arg (const std::vector< M > &arg, casadi_int &npar) const
	Check if input arguments have correct length and dimensions. More...


template<typename M >
void	check_res (const std::vector< M > &res, casadi_int &npar) const
	Check if output arguments have correct length and dimensions. More...


template<typename M >
std::map< std::string, M >	convert_arg (const std::vector< M > &arg) const
	Convert from/to input/output lists/map. More...

template<typename M >
std::vector< M >	convert_arg (const std::map< std::string, M > &arg) const
	Convert from/to input/output lists/map. More...

template<typename M >
std::map< std::string, M >	convert_res (const std::vector< M > &res) const
	Convert from/to input/output lists/map. More...

template<typename M >
std::vector< M >	convert_res (const std::map< std::string, M > &res) const
	Convert from/to input/output lists/map. More...


std::vector< double >	nz_in (const std::vector< DM > &arg) const
	Convert from/to flat vector of input/output nonzeros. More...

std::vector< DM >	nz_in (const std::vector< double > &arg) const
	Convert from/to flat vector of input/output nonzeros. More...

std::vector< double >	nz_out (const std::vector< DM > &res) const
	Convert from/to flat vector of input/output nonzeros. More...

std::vector< DM >	nz_out (const std::vector< double > &res) const
	Convert from/to flat vector of input/output nonzeros. More...


Function	jacobian () const
	Return Jacobian of all input elements with respect to all output elements. More...


Sparsity &	jac_sparsity (casadi_int oind, casadi_int iind, bool compact, bool symmetric) const
	Get Jacobian sparsity. More...

virtual bool	has_jac_sparsity (casadi_int oind, casadi_int iind) const
	Get Jacobian sparsity. More...

virtual Sparsity	get_jac_sparsity (casadi_int oind, casadi_int iind, bool symmetric) const
	Get Jacobian sparsity. More...


Function	forward (casadi_int nfwd) const
	Return function that calculates forward derivatives. More...


Function	reverse (casadi_int nadj) const
	Return function that calculates adjoint derivatives. More...


virtual const SX	sx_in (casadi_int ind) const
	Get function input(s) and output(s) More...

virtual const std::vector< SX >	sx_in () const
	Get function input(s) and output(s) More...

virtual const SX	sx_out (casadi_int ind) const
	Get function input(s) and output(s) More...

virtual const std::vector< SX >	sx_out () const
	Get function input(s) and output(s) More...

virtual const MX	mx_out (casadi_int ind) const
	Get function input(s) and output(s) More...

virtual const std::vector< MX >	mx_out () const
	Get function input(s) and output(s) More...

const DM	dm_in (casadi_int ind) const
	Get function input(s) and output(s) More...

const std::vector< DM >	dm_in () const
	Get function input(s) and output(s) More...

const DM	dm_out (casadi_int ind) const
	Get function input(s) and output(s) More...

const std::vector< DM >	dm_out () const
	Get function input(s) and output(s) More...


Function	wrap (const std::string &name) const
	Wrap in an Function instance consisting of only one MX call. More...

Function	wrap () const
	Wrap in an Function instance consisting of only one MX call. More...


Function	wrap_as_needed (const std::string &name, const Dict &opts) const
	Wrap in an Function instance consisting of only one MX call. More...

Function	wrap_as_needed (const Dict &opts) const
	Wrap in an Function instance consisting of only one MX call. More...


casadi_int	nnz_in () const
	Number of input/output nonzeros. More...

casadi_int	nnz_in (casadi_int ind) const
	Number of input/output nonzeros. More...

casadi_int	nnz_out () const
	Number of input/output nonzeros. More...

casadi_int	nnz_out (casadi_int ind) const
	Number of input/output nonzeros. More...


casadi_int	numel_in () const
	Number of input/output elements. More...

casadi_int	numel_in (casadi_int ind) const
	Number of input/output elements. More...

casadi_int	numel_out (casadi_int ind) const
	Number of input/output elements. More...

casadi_int	numel_out () const
	Number of input/output elements. More...


casadi_int	size1_in (casadi_int ind) const
	Input/output dimensions. More...

casadi_int	size2_in (casadi_int ind) const
	Input/output dimensions. More...

casadi_int	size1_out (casadi_int ind) const
	Input/output dimensions. More...

casadi_int	size2_out (casadi_int ind) const
	Input/output dimensions. More...

std::pair< casadi_int, casadi_int >	size_in (casadi_int ind) const
	Input/output dimensions. More...

std::pair< casadi_int, casadi_int >	size_out (casadi_int ind) const
	Input/output dimensions. More...


const Sparsity &	sparsity_in (casadi_int ind) const
	Input/output sparsity. More...

const Sparsity &	sparsity_out (casadi_int ind) const
	Input/output sparsity. More...


bool	all_scalar () const
	Are all inputs and outputs scalar. More...

virtual bool	jac_is_symm (casadi_int oind, casadi_int iind) const
	Is a Jacobian block known to be symmetric a priori? More...

Sparsity	to_compact (casadi_int oind, casadi_int iind, const Sparsity &sp) const
	Convert to compact Jacobian sparsity pattern. More...

Sparsity	from_compact (casadi_int oind, casadi_int iind, const Sparsity &sp) const
	Convert from compact Jacobian sparsity pattern. More...

template<bool fwd>
Sparsity	get_jac_sparsity_gen (casadi_int oind, casadi_int iind) const
	Get the sparsity pattern via sparsity seed propagation. More...

Sparsity	get_jac_sparsity_hierarchical (casadi_int oind, casadi_int iind) const
	A flavor of get_jac_sparsity_gen that does hierarchical block structure recognition. More...

Sparsity	get_jac_sparsity_hierarchical_symm (casadi_int oind, casadi_int iind) const


virtual std::string	get_name_in (casadi_int i)
	Names of function input and outputs. More...

virtual std::string	get_name_out (casadi_int i)
	Names of function input and outputs. More...


virtual size_t	codegen_sz_arg (const CodeGenerator &g) const
	Get required lengths, for codegen. More...

virtual size_t	codegen_sz_res (const CodeGenerator &g) const
	Get required lengths, for codegen. More...

virtual size_t	codegen_sz_iw (const CodeGenerator &g) const
	Get required lengths, for codegen. More...


virtual bool	fwdViaJac (casadi_int nfwd) const
	Calculate derivatives by multiplying the full Jacobian and multiplying. More...

virtual bool	adjViaJac (casadi_int nadj) const
	Calculate derivatives by multiplying the full Jacobian and multiplying. More...

Static Public Member Functions
static ProtoFunction *	deserialize (DeserializingStream &s)
	Deserialize with type disambiguation. More...

static std::vector< MX >	order (const std::vector< MX > &expr)

static void	sort_depth_first (std::stack< MXNode * > &s, std::vector< MXNode * > &nodes)
	Topological sorting of the nodes based on Depth-First Search (DFS) More...

static std::string	forward_name (const std::string &fcn, casadi_int nfwd)
	Helper function: Get name of forward derivative function. More...

static std::string	reverse_name (const std::string &fcn, casadi_int nadj)
	Helper function: Get name of adjoint derivative function. More...

template<typename MatType >
static MatType	ensure_stacked (const MatType &v, const Sparsity &sp, casadi_int n)
	Ensure that a matrix's sparsity is a horizontal multiple of another, or empty. More...

static std::string	get_jit_directory (const Dict &jit_options)
	Get JIT directory from options. More...

template<typename MatType >
static bool	purgable (const std::vector< MatType > &seed)
	Can a derivative direction be skipped. More...

static std::string	string_from_UnifiedReturnStatus (UnifiedReturnStatus status)

static void	print_canonical (std::ostream &stream, const Sparsity &sp, const double *nz)
	Print canonical representation of a numeric matrix. More...

static void	print_canonical (std::ostream &stream, casadi_int sz, const double *nz)
	Print canonical representation of a numeric vector. More...

static void	print_canonical (std::ostream &stream, double a)
	Print canonical representation of a number. More...


static bool	check_mat (const Sparsity &arg, const Sparsity &inp, casadi_int &npar)

Public Attributes
std::vector< AlgEl >	algorithm_
	All the runtime elements in the order of evaluation. More...

std::vector< casadi_int >	workloc_
	Offsets for elements in the w_ vector. More...

std::vector< bool >	workstate_

std::vector< MX >	free_vars_
	Free variables. More...

std::vector< double >	default_in_
	Default input values. More...

bool	live_variables_
	Live variables? More...

bool	print_instructions_
	Print instructions during evaluation. More...

bool	dump_trace_ = false

std::vector< MX >	in_
	Inputs of the function (needed for symbolic calculations) More...

std::vector< MX >	out_
	Outputs of the function (needed for symbolic calculations) More...

bool	always_inline_

bool	never_inline_

size_t	n_in_
	Number of inputs and outputs. More...

size_t	n_out_

std::vector< bool >	is_diff_in_
	Are inputs and outputs differentiable? More...

std::vector< bool >	is_diff_out_

std::vector< Sparsity >	sparsity_in_
	Input and output sparsity. More...

std::vector< Sparsity >	sparsity_out_

std::vector< std::string >	name_in_
	Input and output scheme. More...

std::vector< std::string >	name_out_

bool	jit_
	Use just-in-time compiler. More...

bool	jit_cleanup_
	Cleanup jit source file. More...

std::string	jit_serialize_
	Serialize behaviour. More...

std::string	jit_name_
	Name if jit source file. More...

std::string	jit_directory_

std::string	jit_base_name_

bool	jit_temp_suffix_
	Use a temporary name. More...

eval_t	eval_
	Numerical evaluation redirected to a C function. More...

casadi_checkout_t	checkout_
	Checkout redirected to a C function. More...

casadi_release_t	release_
	Release redirected to a C function. More...

signal_t	incref_
	Incref/decref redirected to C functions. More...

signal_t	decref_

Dict	stats_
	Dict of statistics (resulting from evaluate) More...

bool	has_refcount_
	Reference counting in codegen? More...

bool	has_refcount_in_deps_
	Reference counting in dependent functions. More...

Dict	cache_init_
	Values to prepopulate the function cache with. More...

WeakCache< std::string, Function >	cache_
	Function cache. More...

std::vector< Sparsity >	jac_sparsity_ [2]
	Cache for sparsities of the Jacobian blocks. More...

Function	derivative_of_
	If the function is the derivative of another function. More...

void *	user_data_
	User-set field. More...

std::string	compiler_plugin_
	Just-in-time compiler. More...

Importer	compiler_

Dict	jit_options_

double	jac_penalty_
	Penalty factor for using a complete Jacobian to calculate directional derivatives. More...

bool	enable_forward_

bool	enable_reverse_

bool	enable_jacobian_

bool	enable_fd_

bool	enable_forward_op_

bool	enable_reverse_op_

bool	enable_jacobian_op_

bool	enable_fd_op_

double	ad_weight_
	Weighting factor for derivative calculation and sparsity pattern calculation. More...

double	ad_weight_sp_

casadi_int	max_num_dir_
	Maximum number of sensitivity directions. More...

bool	inputs_check_
	Errors are thrown if numerical values of inputs look bad. More...

Dict	fd_options_

double	fd_step_

std::string	fd_method_

bool	print_in_

bool	print_out_

bool	print_canonical_

casadi_int	max_io_

bool	dump_in_

bool	dump_out_

bool	dump_

std::string	dump_dir_

std::string	dump_format_

Dict	forward_options_

Dict	reverse_options_

Dict	jacobian_options_

Dict	der_options_

Function	custom_jacobian_

std::vector< Function >	registered_functions_

casadi_int	dump_count_

std::string	name_
	Name. More...

bool	verbose_
	Verbose printout. More...

bool	print_time_

bool	record_time_

bool	regularity_check_
	Errors are thrown when NaN is produced. More...

bool	error_on_fail_
	Throw an exception on failure? More...

Static Public Attributes
static std::map< std::string, ProtoFunction ()(DeserializingStream &)>	deserialize_map

Protected Member Functions
	MXFunction (DeserializingStream &s)
	Deserializing constructor. More...

void	set_jac_sparsity (casadi_int oind, casadi_int iind, const Sparsity &sp)
	Populate jac_sparsity_ and jac_sparsity_compact_ during initialization. More...

std::unique_ptr< std::ostream >	open_trace (const double **arg, casadi_int dump_id) const

void	finish_trace (std::ostream &trace, double **res, int ret) const

void	initSingleton ()

void	destroySingleton ()

B	shared_from_this ()
	Get a shared object from the current internal object. More...

const B	shared_from_this () const
	Get a shared object from the current internal object. More...

Static Protected Member Functions
static void	trace_values (std::ostream &trace, const double *values, casadi_int nnz)

static const Options	options_
	Options. More...

const Options &	get_options () const override
	Options. More...

Member Typedef Documentation

◆ AlgEl

typedef MXAlgEl casadi::MXFunction::AlgEl

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

Definition at line 72 of file mx_function.hpp.

◆ weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

◆ MXFunction() [1/2]

casadi::MXFunction::MXFunction	(	const std::string &	name,
		const std::vector< MX > &	input,
		const std::vector< MX > &	output,
		const std::vector< std::string > &	name_in,
		const std::vector< std::string > &	name_out
	)

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

Definition at line 43 of file mx_function.cpp.

                                                                :
     XFunction<MXFunction, MX, MXNode>(name, inputv, outputv, name_in, name_out) {
   }

Referenced by deserialize(), and is_a().

◆ ~MXFunction()

casadi::MXFunction::~MXFunction ( )

override

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

Definition at line 51 of file mx_function.cpp.

                           {
     clear_mem();
   }

References casadi::ProtoFunction::clear_mem().

◆ MXFunction() [2/2]

casadi::MXFunction::MXFunction ( DeserializingStream & s )

explicitprotected

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

Definition at line 2008 of file mx_function.cpp.

                                                : XFunction<MXFunction, MX, MXNode>(s) {
     int version = s.version("MXFunction", 1, 3);
     size_t n_instructions;
     s.unpack("MXFunction::n_instr", n_instructions);
     algorithm_.resize(n_instructions);
     for (casadi_int k=0;k<n_instructions;++k) {
       AlgEl& e = algorithm_[k];
       s.unpack("MXFunction::alg::data", e.data);
       e.op = e.data.op();
       s.unpack("MXFunction::alg::arg", e.arg);
       s.unpack("MXFunction::alg::res", e.res);
     }
  
     s.unpack("MXFunction::workloc", workloc_);
     s.unpack("MXFunction::free_vars", free_vars_);
     s.unpack("MXFunction::default_in", default_in_);
     s.unpack("MXFunction::live_variables", live_variables_);
     print_instructions_ = false;
     if (version >= 2) s.unpack("MXFunction::print_instructions", print_instructions_);
  
     if (version >= 3) s.unpack("MXFunction::dump_trace", dump_trace_);
  
     XFunction<MXFunction, MX, MXNode>::delayed_deserialize_members(s);
   }

References algorithm_, casadi::MXAlgEl::arg, casadi::MXAlgEl::data, default_in_, casadi::XFunction< DerivedType, MatType, NodeType >::delayed_deserialize_members(), dump_trace_, free_vars_, live_variables_, n_instructions(), casadi::MX::op(), casadi::MXAlgEl::op, print_instructions_, casadi::MXAlgEl::res, casadi::DeserializingStream::unpack(), casadi::DeserializingStream::version(), and workloc_.

Member Function Documentation

◆ ad_forward()

void casadi::MXFunction::ad_forward	(	const std::vector< std::vector< MX > > &	fwdSeed,
		std::vector< std::vector< MX > > &	fwdSens
	)		const

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

Definition at line 897 of file mx_function.cpp.

                                                                         {
     if (verbose_) casadi_message(name_ + "::ad_forward(" + str(fseed.size())+ ")");
     try {
       // Allocate results
       casadi_int nfwd = fseed.size();
       fsens.resize(nfwd);
       for (casadi_int d=0; d<nfwd; ++d) {
         fsens[d].resize(n_out_);
       }
  
       // Quick return if no directions
       if (nfwd==0) return;
  
       // Check if seeds need to have dimensions corrected
       casadi_int npar = 1;
       for (auto&& r : fseed) {
         if (!matching_arg(r, npar)) {
           casadi_assert_dev(npar==1);
           ad_forward(replace_fseed(fseed, npar), fsens);
           return;
         }
       }
  
       // Check if there are any zero seeds
       for (auto&& r : fseed) {
         if (purgable(r)) {
           // New argument without all-zero directions
           std::vector<std::vector<MX> > fseed_purged, fsens_purged;
           fseed_purged.reserve(nfwd);
           std::vector<casadi_int> index_purged;
           for (casadi_int d=0; d<nfwd; ++d) {
             if (purgable(fseed[d])) {
               for (casadi_int i=0; i<fsens[d].size(); ++i) {
                 fsens[d][i] = MX(size_out(i));
               }
             } else {
               fseed_purged.push_back(fsens[d]);
               index_purged.push_back(d);
             }
           }
  
           // Call recursively
           ad_forward(fseed_purged, fsens_purged);
  
           // Fetch result
           for (casadi_int d=0; d<fseed_purged.size(); ++d) {
             fsens[index_purged[d]] = fsens_purged[d];
           }
           return;
         }
       }
  
       if (!enable_forward_) {
         // Do the non-inlining call from FunctionInternal
         // NOLINTNEXTLINE(bugprone-parent-virtual-call)
         FunctionInternal::call_forward(in_, out_, fseed, fsens, false, false);
         return;
       }
  
       // Work vector, forward derivatives
       std::vector<std::vector<MX> > dwork(workloc_.size()-1);
       fill(dwork.begin(), dwork.end(), std::vector<MX>(nfwd));
       if (verbose_) casadi_message("Allocated derivative work vector (forward mode)");
  
       // Split up fseed analogous to symbolic primitives
       std::vector<std::vector<std::vector<MX>>> fseed_split(nfwd);
       for (casadi_int d=0; d<nfwd; ++d) {
         fseed_split[d].resize(fseed[d].size());
         for (casadi_int i=0; i<fseed[d].size(); ++i) {
           fseed_split[d][i] = in_[i].split_primitives(fseed[d][i]);
         }
       }
  
       // Allocate splited forward sensitivities
       std::vector<std::vector<std::vector<MX>>> fsens_split(nfwd);
       for (casadi_int d=0; d<nfwd; ++d) {
         fsens_split[d].resize(out_.size());
         for (casadi_int i=0; i<out_.size(); ++i) {
           fsens_split[d][i].resize(out_[i].n_primitives());
         }
       }
  
       // Pointers to the arguments of the current operation
       std::vector<std::vector<MX> > oseed, osens;
       oseed.reserve(nfwd);
       osens.reserve(nfwd);
       std::vector<bool> skip(nfwd, false);
  
       // Loop over computational nodes in forward order
       for (auto&& e : algorithm_) {
         if (e.op == OP_INPUT) {
           // Fetch forward seed
           for (casadi_int d=0; d<nfwd; ++d) {
             dwork[e.res.front()][d] =
               project(fseed_split[d].at(e.data->ind()).at(e.data->segment()),
                                         e.data.sparsity(), true);
           }
         } else if (e.op==OP_OUTPUT) {
           // Collect forward sensitivity
           for (casadi_int d=0; d<nfwd; ++d) {
             fsens_split[d][e.data->ind()][e.data->segment()] = dwork[e.arg.front()][d];
           }
         } else if (e.op==OP_PARAMETER) {
           // Fetch parameter
           for (casadi_int d=0; d<nfwd; ++d) {
             dwork[e.res.front()][d] = MX();
           }
         } else {
           // Get seeds, ignoring all-zero directions
           oseed.clear();
           for (casadi_int d=0; d<nfwd; ++d) {
             // Collect seeds, skipping directions with only zeros
             std::vector<MX> seed(e.arg.size());
             skip[d] = true; // All seeds are zero?
             for (casadi_int i=0; i<e.arg.size(); ++i) {
               casadi_int el = e.arg[i];
               if (el<0 || dwork[el][d].is_empty(true)) {
                 seed[i] = MX(e.data->dep(i).size());
               } else {
                 seed[i] = dwork[el][d];
               }
               if (skip[d] && !seed[i].is_zero()) skip[d] = false;
             }
             if (!skip[d]) oseed.push_back(seed);
           }
  
           // Perform the operation
           osens.resize(oseed.size());
           if (!osens.empty()) {
             fill(osens.begin(), osens.end(), std::vector<MX>(e.res.size()));
             e.data.ad_forward(oseed, osens);
           }
  
           // Store sensitivities
           casadi_int d1=0;
           for (casadi_int d=0; d<nfwd; ++d) {
             for (casadi_int i=0; i<e.res.size(); ++i) {
               casadi_int el = e.res[i];
               if (el>=0) {
                 dwork[el][d] = skip[d] ? MX(e.data->sparsity(i).size()) : osens[d1][i];
               }
             }
             if (!skip[d]) d1++;
           }
         }
       }
  
       // Get forward sensitivities
       for (casadi_int d=0; d<nfwd; ++d) {
         for (casadi_int i=0; i<out_.size(); ++i) {
           fsens[d][i] = out_[i].join_primitives(fsens_split[d][i]);
         }
       }
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("ad_forward", e.what());
     }
   }

References algorithm_, casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::enable_forward_, casadi::XFunction< MXFunction, MX, MXNode >::in_, casadi::is_zero(), casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::XFunction< MXFunction, MX, MXNode >::out_, casadi::FunctionInternal::purgable(), casadi::FunctionInternal::replace_fseed(), casadi::FunctionInternal::size_out(), casadi::str(), casadi::ProtoFunction::verbose_, and workloc_.

◆ ad_reverse()

void casadi::MXFunction::ad_reverse	(	const std::vector< std::vector< MX > > &	adjSeed,
		std::vector< std::vector< MX > > &	adjSens
	)		const

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

Definition at line 1056 of file mx_function.cpp.

                                                                         {
     if (verbose_) casadi_message(name_ + "::ad_reverse(" + str(aseed.size())+ ")");
     try {
  
       // Allocate results
       casadi_int nadj = aseed.size();
       asens.resize(nadj);
       for (casadi_int d=0; d<nadj; ++d) {
         asens[d].resize(n_in_);
       }
  
       // Quick return if no directions
       if (nadj==0) return;
  
       // Check if seeds need to have dimensions corrected
       casadi_int npar = 1;
       for (auto&& r : aseed) {
         if (!matching_res(r, npar)) {
           casadi_assert_dev(npar==1);
           ad_reverse(replace_aseed(aseed, npar), asens);
           return;
         }
       }
  
       // Check if there are any zero seeds
       for (auto&& r : aseed) {
         // If any direction can be skipped
         if (purgable(r)) {
           // New argument without all-zero directions
           std::vector<std::vector<MX> > aseed_purged, asens_purged;
           aseed_purged.reserve(nadj);
           std::vector<casadi_int> index_purged;
           for (casadi_int d=0; d<nadj; ++d) {
             if (purgable(aseed[d])) {
               for (casadi_int i=0; i<asens[d].size(); ++i) {
                 asens[d][i] = MX(size_in(i));
               }
             } else {
               aseed_purged.push_back(asens[d]);
               index_purged.push_back(d);
             }
           }
  
           // Call recursively
           ad_reverse(aseed_purged, asens_purged);
  
           // Fetch result
           for (casadi_int d=0; d<aseed_purged.size(); ++d) {
             asens[index_purged[d]] = asens_purged[d];
           }
           return;
         }
       }
  
       if (!enable_reverse_) {
         std::vector<std::vector<MX> > v;
         // Do the non-inlining call from FunctionInternal
         // NOLINTNEXTLINE(bugprone-parent-virtual-call)
         FunctionInternal::call_reverse(in_, out_, aseed, v, false, false);
         for (casadi_int i=0; i<v.size(); ++i) {
           for (casadi_int j=0; j<v[i].size(); ++j) {
             if (!v[i][j].is_empty()) { // TODO(@jaeandersson): Hack
               if (asens[i][j].is_empty()) {
                 asens[i][j] = v[i][j];
               } else {
                 asens[i][j] += v[i][j];
               }
             }
           }
         }
         return;
       }
  
       // Split up aseed analogous to symbolic primitives
       std::vector<std::vector<std::vector<MX>>> aseed_split(nadj);
       for (casadi_int d=0; d<nadj; ++d) {
         aseed_split[d].resize(out_.size());
         for (casadi_int i=0; i<out_.size(); ++i) {
           aseed_split[d][i] = out_[i].split_primitives(aseed[d][i]);
         }
       }
  
       // Allocate splited adjoint sensitivities
       std::vector<std::vector<std::vector<MX>>> asens_split(nadj);
       for (casadi_int d=0; d<nadj; ++d) {
         asens_split[d].resize(in_.size());
         for (casadi_int i=0; i<in_.size(); ++i) {
           asens_split[d][i].resize(in_[i].n_primitives());
         }
       }
  
       // Pointers to the arguments of the current operation
       std::vector<std::vector<MX>> oseed, osens;
       oseed.reserve(nadj);
       osens.reserve(nadj);
       std::vector<bool> skip(nadj, false);
  
       // Work vector, adjoint derivatives
       std::vector<std::vector<MX> > dwork(workloc_.size()-1);
       fill(dwork.begin(), dwork.end(), std::vector<MX>(nadj));
  
       // Loop over computational nodes in reverse order
       for (auto it=algorithm_.rbegin(); it!=algorithm_.rend(); ++it) {
         if (it->op == OP_INPUT) {
           // Get the adjoint sensitivities
           for (casadi_int d=0; d<nadj; ++d) {
             asens_split[d].at(it->data->ind()).at(it->data->segment()) = dwork[it->res.front()][d];
             dwork[it->res.front()][d] = MX();
           }
         } else if (it->op==OP_OUTPUT) {
           // Pass the adjoint seeds
           for (casadi_int d=0; d<nadj; ++d) {
             MX a = project(aseed_split[d].at(it->data->ind()).at(it->data->segment()),
                            it->data.dep().sparsity(), true);
             if (dwork[it->arg.front()][d].is_empty(true)) {
               dwork[it->arg.front()][d] = a;
             } else {
               dwork[it->arg.front()][d] += a;
             }
           }
         } else if (it->op==OP_PARAMETER) {
           // Clear adjoint seeds
           for (casadi_int d=0; d<nadj; ++d) {
             dwork[it->res.front()][d] = MX();
           }
         } else {
           // Collect and reset seeds
           oseed.clear();
           for (casadi_int d=0; d<nadj; ++d) {
             // Can the direction be skipped completely?
             skip[d] = true;
  
             // Seeds for direction d
             std::vector<MX> seed(it->res.size());
             for (casadi_int i=0; i<it->res.size(); ++i) {
               // Get and clear seed
               casadi_int el = it->res[i];
               if (el>=0) {
                 seed[i] = dwork[el][d];
                 dwork[el][d] = MX();
               } else {
                 seed[i] = MX();
               }
  
               // If first time encountered, reset to zero of right dimension
               if (seed[i].is_empty(true)) seed[i] = MX(it->data->sparsity(i).size());
  
               // If nonzero seeds, keep direction
               if (skip[d] && !seed[i].is_zero()) skip[d] = false;
             }
             // Add to list of derivatives
             if (!skip[d]) oseed.push_back(seed);
           }
  
           // Get values of sensitivities before addition
           osens.resize(oseed.size());
           casadi_int d1=0;
           for (casadi_int d=0; d<nadj; ++d) {
             if (skip[d]) continue;
             osens[d1].resize(it->arg.size());
             for (casadi_int i=0; i<it->arg.size(); ++i) {
               // Pass seed and reset to avoid counting twice
               casadi_int el = it->arg[i];
               if (el>=0) {
                 osens[d1][i] = dwork[el][d];
                 dwork[el][d] = MX();
               } else {
                 osens[d1][i] = MX();
               }
  
               // If first time encountered, reset to zero of right dimension
               if (osens[d1][i].is_empty(true)) osens[d1][i] = MX(it->data->dep(i).size());
             }
             d1++;
           }
  
           // Perform the operation
           if (!osens.empty()) {
             it->data.ad_reverse(oseed, osens);
           }
  
           // Store sensitivities
           d1=0;
           for (casadi_int d=0; d<nadj; ++d) {
             if (skip[d]) continue;
             for (casadi_int i=0; i<it->arg.size(); ++i) {
               casadi_int el = it->arg[i];
               if (el>=0) {
                 if (dwork[el][d].is_empty(true)) {
                   dwork[el][d] = osens[d1][i];
                 } else {
                   dwork[el][d] += osens[d1][i];
                 }
               }
             }
             d1++;
           }
         }
       }
  
       // Get adjoint sensitivities
       for (casadi_int d=0; d<nadj; ++d) {
         for (casadi_int i=0; i<in_.size(); ++i) {
           asens[d][i] = in_[i].join_primitives(asens_split[d][i]);
         }
       }
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("ad_reverse", e.what());
     }
   }

References algorithm_, casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::enable_reverse_, casadi::XFunction< MXFunction, MX, MXNode >::in_, casadi::is_zero(), casadi::FunctionInternal::matching_res(), casadi::FunctionInternal::n_in_, casadi::ProtoFunction::name_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::XFunction< MXFunction, MX, MXNode >::out_, casadi::FunctionInternal::purgable(), casadi::FunctionInternal::replace_aseed(), casadi::FunctionInternal::size_in(), casadi::str(), casadi::ProtoFunction::verbose_, and workloc_.

◆ ad_weight()

double casadi::FunctionInternal::ad_weight ( ) const

virtualinherited

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

Definition at line 3522 of file function_internal.cpp.

                                            {
     // If reverse mode derivatives unavailable, use forward
     if (!enable_reverse_) return 0;
  
     // If forward mode derivatives unavailable, use reverse
     if (!enable_forward_ && !enable_fd_) return 1;
  
     // Use the (potentially user set) option
     return ad_weight_;
   }

References casadi::FunctionInternal::ad_weight_, casadi::FunctionInternal::enable_fd_, casadi::FunctionInternal::enable_forward_, and casadi::FunctionInternal::enable_reverse_.

Referenced by casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

◆ add_embedded()

void casadi::FunctionInternal::add_embedded	(	std::map< FunctionInternal *, std::pair< Function, size_t > > &	all_fun,
		const Function &	dep,
		casadi_int	max_depth
	)		const

inherited

Definition at line 3964 of file function_internal.cpp.

                                                        {
     // Add, if not already in graph and not null
     if (!dep.is_null() && all_fun.find(dep.get()) == all_fun.end()) {
       size_t index = all_fun.size();
       all_fun[dep.get()] = std::make_pair(dep, index);
       // Also add its dependencies
       if (max_depth > 0) dep->find(all_fun, max_depth - 1);
     }
   }

References casadi::FunctionInternal::find(), casadi::Function::get(), and casadi::GenericShared< Shared, Internal >::is_null().

Referenced by casadi::FunctionInternal::find(), casadi::Map::find(), casadi::MapSum::find(), find(), casadi::OracleFunction::find(), casadi::Switch::find(), casadi::SXFunction::find(), and casadi::BSplineInterpolant::find().

◆ adjViaJac()

bool casadi::FunctionInternal::adjViaJac ( casadi_int nadj ) const

virtualinherited

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

Definition at line 3255 of file function_internal.cpp.

                                                         {
     if (!enable_reverse_) return true;
     if (jac_penalty_==-1) return false;
  
     // Heuristic 1: Jac calculated via reverse mode likely cheaper
     if (jac_penalty_*static_cast<double>(nnz_out())<nadj) return true;
  
     // Heuristic 2: Jac calculated via forward mode likely cheaper
     double w = ad_weight();
     if ((enable_forward_ || enable_fd_) &&
         jac_penalty_*w*static_cast<double>(nnz_in())<(1-w)*static_cast<double>(nadj))
       return true; // NOLINT
  
     return false;
   }

References casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::enable_fd_, casadi::FunctionInternal::enable_forward_, casadi::FunctionInternal::enable_reverse_, casadi::FunctionInternal::jac_penalty_, casadi::FunctionInternal::nnz_in(), and casadi::FunctionInternal::nnz_out().

Referenced by casadi::FunctionInternal::call_reverse().

◆ all_scalar()

bool casadi::FunctionInternal::all_scalar ( ) const

inherited

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

Definition at line 4009 of file function_internal.cpp.

                                           {
     // Check inputs
     for (casadi_int i=0; i<n_in_; ++i) {
       if (!sparsity_in_[i].is_scalar()) return false;
     }
     // Check outputs
     for (casadi_int i=0; i<n_out_; ++i) {
       if (!sparsity_out_[i].is_scalar()) return false;
     }
     // All are scalar
     return true;
   }

References casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::FunctionInternal::sparsity_in_, and casadi::FunctionInternal::sparsity_out_.

Referenced by casadi::FunctionInternal::call().

◆ alloc()

void casadi::FunctionInternal::alloc	(	const Function &	f,
		bool	persistent = `false`,
		int	num_threads = `1`
	)

inherited

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

Definition at line 3203 of file function_internal.cpp.

                                                                                   {
     if (f.is_null()) return;
     size_t sz_arg, sz_res, sz_iw, sz_w;
     f.sz_work(sz_arg, sz_res, sz_iw, sz_w);
     alloc_arg(sz_arg*num_threads, persistent);
     alloc_res(sz_res*num_threads, persistent);
     alloc_iw(sz_iw*num_threads, persistent);
     alloc_w(sz_w*num_threads, persistent);
     registered_functions_.push_back(f);
   }

References casadi::FunctionInternal::alloc_arg(), casadi::FunctionInternal::alloc_iw(), casadi::FunctionInternal::alloc_res(), casadi::FunctionInternal::alloc_w(), casadi::GenericShared< Shared, Internal >::is_null(), casadi::FunctionInternal::registered_functions_, casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), casadi::FunctionInternal::sz_w(), and casadi::Function::sz_work().

Referenced by casadi::OracleFunction::finalize(), casadi::KinsolInterface::get_jtimes(), casadi::FiniteDiff::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::Switch::init(), casadi::Feasiblesqpmethod::init(), casadi::ImplicitToNlp::init(), casadi::QpToNlp::init(), casadi::Qrsqp::init(), casadi::Scpgen::init(), and casadi::Sqpmethod::init().

◆ alloc_arg()

void casadi::FunctionInternal::alloc_arg	(	size_t	sz_arg,
		bool	persistent = `false`
	)

inherited

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

Definition at line 3171 of file function_internal.cpp.

                                                                  {
     if (persistent) {
       sz_arg_per_ += sz_arg;
     } else {
       sz_arg_tmp_ = std::max(sz_arg_tmp_, sz_arg);
     }
   }

References casadi::FunctionInternal::sz_arg().

◆ alloc_iw()

void casadi::FunctionInternal::alloc_iw	(	size_t	sz_iw,
		bool	persistent = `false`
	)

inherited

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

Definition at line 3187 of file function_internal.cpp.

                                                                {
     if (persistent) {
       sz_iw_per_ += sz_iw;
     } else {
       sz_iw_tmp_ = std::max(sz_iw_tmp_, sz_iw);
     }
   }

References casadi::FunctionInternal::sz_iw().

◆ alloc_mem()

void* casadi::FunctionInternal::alloc_mem ( ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Definition at line 342 of file function_internal.hpp.

342 { return new FunctionMemory(); }

Referenced by casadi::FunctionInternal::codegen_checkout().

◆ alloc_res()

void casadi::FunctionInternal::alloc_res	(	size_t	sz_res,
		bool	persistent = `false`
	)

inherited

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

Definition at line 3179 of file function_internal.cpp.

                                                                  {
     if (persistent) {
       sz_res_per_ += sz_res;
     } else {
       sz_res_tmp_ = std::max(sz_res_tmp_, sz_res);
     }
   }

References casadi::FunctionInternal::sz_res().

◆ alloc_w()

void casadi::FunctionInternal::alloc_w	(	size_t	sz_w,
		bool	persistent = `false`
	)

inherited

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

Definition at line 3195 of file function_internal.cpp.

                                                              {
     if (persistent) {
       sz_w_per_ += sz_w;
     } else {
       sz_w_tmp_ = std::max(sz_w_tmp_, sz_w);
     }
   }

References casadi::FunctionInternal::sz_w().

◆ apply_simplify_passes()

void casadi::XFunction< MXFunction , MX , MXNode >::apply_simplify_passes	(	const std::vector< std::pair< std::string, casadi_int > > &	tasks,
		std::vector< MX > &	new_in,
		std::vector< MX > &	new_out
	)		const

inherited

Each pass is a (task, count) pair; count>0 runs the task that many times, count==0 runs it until a fixed point.

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

Definition at line 175 of file x_function.hpp.

                                          {
     for (const auto& tc : tasks) {
       const std::string& task = tc.first;
       // count>0: run exactly that many times; count==0: run until a fixed point
       casadi_int count = tc.second;
       casadi_assert(count>=0,
         "simplify task '" + task + "': run count must be >= 0 (0 = until fixed point)");
       casadi_int prev_nodes = -1;
       casadi_int max_iter = count==0 ? 100 : count;
       for (casadi_int it=0; it<max_iter; ++it) {
         if (task=="empty_inputs") {
           // What symbols occur in the outputs?
           std::vector<MatType> syms = MatType::symvar(veccat(new_out));
           // Loop over inputs
           for (MatType& e : new_in) {
             // If current input symbols do not occur in outputs
             if (!contains_any(syms, MatType::symvar(e))) {
               // Replace input by an empty matrix
               e = MatType(e.size());
             }
           }
         } else if (task=="combine_terms") {
           MatType::simplify_combine_terms(new_in, new_out);
         } else if (task=="cse") {
           new_out = MatType::cse(new_out);
         } else if (task=="ref_count") {
           MatType::simplify_ref_count(new_in, new_out);
         } else if (task=="const_folding") {
           MatType::simplify_const_folding(new_in, new_out);
         } else {
           casadi_error("No such simplify task: '" + task + "'.\n");
         }
         if (count!=0) continue;
         // Stop once the graph size stops shrinking
         casadi_int nodes = MatType::n_nodes(veccat(new_out));
         if (prev_nodes != -1 && nodes >= prev_nodes) break;
         prev_nodes = nodes;
       }
     }
   }

◆ cache()

Dict casadi::FunctionInternal::cache ( ) const

inherited

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

Definition at line 1163 of file function_internal.cpp.

                                      {
     // Return value
     Dict ret;
  
     // Retrieve all Function instances that haven't been deleted
     std::vector<std::string> keys;
     std::vector<Function> entries;
     cache_.cache(keys, entries);
  
     for (size_t i=0; i<keys.size(); ++i) {
       // Get the name of the key
       std::string s = keys[i];
       casadi_assert_dev(s.size() > 0);
       // Replace ':' with '_'
       std::replace(s.begin(), s.end(), ':', '_');
       // Remove trailing underscore, if any
       if (s.back() == '_') s.resize(s.size() - 1);
       // Add entry to function return
       ret[s] = entries[i];
     }
  
     return ret;
   }

References casadi::FunctionInternal::cache_.

◆ call()

template<typename M >

void casadi::FunctionInternal::call	(	const std::vector< M > &	arg,
		std::vector< M > &	res,
		bool	always_inline,
		bool	never_inline
	)		const

inherited

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

Definition at line 1622 of file function_internal.hpp.

                                                                            {
     // If all inputs are scalar ...
     if (all_scalar()) {
       // ... and some arguments are matrix-valued with matching dimensions ...
       bool matrix_call = false;
       std::pair<casadi_int, casadi_int> sz;
       for (auto&& a : arg) {
         if (!a.is_scalar() && !a.is_empty()) {
           if (!matrix_call) {
             // Matrix call
             matrix_call = true;
             sz = a.size();
           } else if (a.size()!=sz) {
             // Not same dimensions
             matrix_call = false;
             break;
           }
         }
       }
  
       // ... then, call multiple times
       if (matrix_call) {
         // Start with zeros
         res.resize(n_out_);
         M z = M::zeros(sz);
         for (auto&& a : res) a = z;
         // Call multiple times
         std::vector<M> arg1 = arg, res1;
         for (casadi_int c=0; c<sz.second; ++c) {
           for (casadi_int r=0; r<sz.first; ++r) {
             // Get scalar arguments
             for (casadi_int i=0; i<arg.size(); ++i) {
               if (arg[i].size()==sz) arg1[i] = arg[i](r, c);
             }
             // Call recursively with scalar arguments
             call(arg1, res1, always_inline, never_inline);
             // Get results
             casadi_assert_dev(res.size() == res1.size());
             for (casadi_int i=0; i<res.size(); ++i) res[i](r, c) = res1[i];
           }
         }
         // All elements assigned
         return;
       }
     }
  
     // Check if inputs need to be replaced
     casadi_int npar = 1;
     if (!matching_arg(arg, npar)) {
       return call(replace_arg(arg, npar), res, always_inline, never_inline);
     }
  
     // Call the type-specific method
     call_gen(arg, res, npar, always_inline, never_inline);
   }

References casadi::FunctionInternal::all_scalar(), casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::n_out_, and casadi::FunctionInternal::replace_arg().

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

◆ call_forward() [1/3]

void casadi::FunctionInternal::call_forward	(	const std::vector< MX > &	arg,
		const std::vector< MX > &	res,
		const std::vector< std::vector< MX > > &	fseed,
		std::vector< std::vector< MX > > &	fsens,
		bool	always_inline,
		bool	never_inline
	)		const

virtualinherited

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

Definition at line 3275 of file function_internal.cpp.

                                                           {
     casadi_assert(!(always_inline && never_inline), "Inconsistent options");
     casadi_assert(!always_inline, "Class " + class_name() +
                           " cannot be inlined in an MX expression");
  
     // Derivative information must be available
     casadi_assert(has_derivative(),
                           "Derivatives cannot be calculated for " + name_);
  
     // Number of directional derivatives
     casadi_int nfwd = fseed.size();
     fsens.resize(nfwd);
  
     // Quick return if no seeds
     if (nfwd==0) return;
  
     // Check if seeds need to have dimensions corrected
     casadi_int npar = 1;
     for (auto&& r : fseed) {
       if (!matching_arg(r, npar)) {
         FunctionInternal::call_forward(arg, res, replace_fseed(fseed, npar),
                                        fsens, always_inline, never_inline);
         return;
       }
     }
  
     // Calculating full Jacobian and then multiplying
     if (fwdViaJac(nfwd)) {
       // Multiply the Jacobian from the right
       std::vector<MX> darg = arg;
       darg.insert(darg.end(), res.begin(), res.end());
       std::vector<MX> J = jacobian()(darg);
       // Join forward seeds
       std::vector<MX> v(nfwd), all_fseed(n_in_);
       for (size_t i = 0; i < n_in_; ++i) {
         for (size_t d = 0; d < nfwd; ++d) v[d] = vec(fseed.at(d).at(i));
         all_fseed[i] = horzcat(v);
       }
       // Calculate forward sensitivities
       std::vector<MX> all_fsens(n_out_);
       std::vector<MX>::const_iterator J_it = J.begin();
       for (size_t oind = 0; oind < n_out_; ++oind) {
         for (size_t iind = 0; iind < n_in_; ++iind) {
           // Add contribution
           MX a = mtimes(*J_it++, all_fseed[iind]);
           all_fsens[oind] = all_fsens[oind].is_empty(true) ? a : all_fsens[oind] + a;
         }
       }
       // Split forward sensitivities
       for (size_t d = 0; d < nfwd; ++d) fsens[d].resize(n_out_);
       for (size_t i = 0; i < n_out_; ++i) {
         v = horzsplit(all_fsens[i]);
         casadi_assert_dev(v.size() == nfwd);
         for (size_t d = 0; d < nfwd; ++d) fsens[d][i] = reshape(v[d], size_out(i));
       }
     } else {
       // Evaluate in batches
       casadi_assert_dev(enable_forward_ || enable_fd_);
       casadi_int max_nfwd = max_num_dir_;
       if (!enable_fd_) {
         while (!has_forward(max_nfwd)) max_nfwd/=2;
       }
       casadi_int offset = 0;
       while (offset<nfwd) {
         // Number of derivatives, in this batch
         casadi_int nfwd_batch = std::min(nfwd-offset, max_nfwd);
  
         // All inputs and seeds
         std::vector<MX> darg;
         darg.reserve(n_in_ + n_out_ + n_in_);
         darg.insert(darg.end(), arg.begin(), arg.end());
         darg.insert(darg.end(), res.begin(), res.end());
         std::vector<MX> v(nfwd_batch);
         for (casadi_int i=0; i<n_in_; ++i) {
           for (casadi_int d=0; d<nfwd_batch; ++d) v[d] = fseed[offset+d][i];
           darg.push_back(horzcat(v));
         }
  
         // Create the evaluation node
         Function dfcn = self().forward(nfwd_batch);
         std::vector<MX> x = dfcn(darg);
  
         casadi_assert_dev(x.size()==n_out_);
  
         // Retrieve sensitivities
         for (casadi_int d=0; d<nfwd_batch; ++d) fsens[offset+d].resize(n_out_);
         for (casadi_int i=0; i<n_out_; ++i) {
           if (size2_out(i)>0) {
             v = horzsplit(x[i], size2_out(i));
             casadi_assert_dev(v.size()==nfwd_batch);
           } else {
             v = std::vector<MX>(nfwd_batch, MX(size_out(i)));
           }
           for (casadi_int d=0; d<nfwd_batch; ++d) fsens[offset+d][i] = v[d];
         }
  
         // Update offset
         offset += nfwd_batch;
       }
     }
   }

Referenced by casadi::Rootfinder::ad_forward(), casadi::Call::ad_forward(), ad_forward(), casadi::XFunction< DerivedType, MatType, NodeType >::call_forward(), casadi::MX::forward(), casadi::Integrator::get_forward_dae(), and casadi::Scpgen::init().

◆ call_forward() [2/3]

void casadi::XFunction< MXFunction , MX , MXNode >::call_forward	(	const std::vector< MX > &	arg,
		const std::vector< MX > &	res,
		const std::vector< std::vector< MX > > &	fseed,
		std::vector< std::vector< MX > > &	fsens,
		bool	always_inline,
		bool	never_inline
	)		const

overrideinherited

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

Definition at line 218 of file x_function.hpp.

                                                             {
     casadi_assert(!(always_inline && never_inline), "Inconsistent options");
     if (!should_inline(MatType::type_name()=="SX", always_inline, never_inline)) {
       // The non-inlining version is implemented in the base class
       return FunctionInternal::call_forward(arg, res, fseed, fsens,
                                             always_inline, never_inline);
     }
  
     // Quick return if no seeds
     if (fseed.empty()) {
       fsens.clear();
       return;
     }
  
     // Call inlining
     if (isInput(arg)) {
       // Argument agrees with in_, call ad_forward directly
       static_cast<const DerivedType*>(this)->ad_forward(fseed, fsens);
     } else {
       // Need to create a temporary function
       Function f("tmp_call_forward", arg, res);
       static_cast<DerivedType *>(f.get())->ad_forward(fseed, fsens);
     }
   }

◆ call_forward() [3/3]

void casadi::FunctionInternal::call_forward	(	const std::vector< SX > &	arg,
		const std::vector< SX > &	res,
		const std::vector< std::vector< SX > > &	fseed,
		std::vector< std::vector< SX > > &	fsens,
		bool	always_inline,
		bool	never_inline
	)		const

virtualinherited

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

Definition at line 3496 of file function_internal.cpp.

                                                           {
     casadi_assert(!(always_inline && never_inline), "Inconsistent options");
     if (fseed.empty()) { // Quick return if no seeds
       fsens.clear();
       return;
     }
     casadi_error("'forward' (SX) not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

◆ call_gen() [1/2]

void casadi::FunctionInternal::call_gen	(	const MXVector &	arg,
		MXVector &	res,
		casadi_int	npar,
		bool	always_inline,
		bool	never_inline
	)		const

inherited

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

Definition at line 4183 of file function_internal.cpp.

                                                         {
     if (npar==1) {
       eval_mx(arg, res, always_inline, never_inline);
     } else {
       // Split it up arguments
       std::vector<std::vector<MX>> v(npar, arg);
       std::vector<MX> t;
       for (int i=0; i<n_in_; ++i) {
         if (arg[i].size2()!=size2_in(i)) {
           t = horzsplit(arg[i], size2_in(i));
           casadi_assert_dev(t.size()==npar);
           for (int p=0; p<npar; ++p) v[p][i] = t[p];
         }
       }
       // Unroll the loop
       for (int p=0; p<npar; ++p) {
         eval_mx(v[p], t, always_inline, never_inline);
         v[p] = t;
       }
       // Concatenate results
       t.resize(npar);
       res.resize(n_out_);
       for (int i=0; i<n_out_; ++i) {
         for (int p=0; p<npar; ++p) t[p] = v[p][i];
         res[i] = horzcat(t);
       }
     }
   }

References casadi::FunctionInternal::eval_mx(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, and casadi::FunctionInternal::size2_in().

Referenced by casadi::FunctionInternal::call().

◆ call_gen() [2/2]

template<typename D >

void casadi::FunctionInternal::call_gen	(	const std::vector< Matrix< D > > &	arg,
		std::vector< Matrix< D > > &	res,
		casadi_int	npar,
		bool	always_inline,
		bool	never_inline
	)		const

inherited

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

Definition at line 1726 of file function_internal.hpp.

                                                                          {
     std::vector< Matrix<D> > arg2 = project_arg(arg, npar);
  
     // Which arguments require mapped evaluation
     std::vector<bool> mapped(n_in_);
     for (casadi_int i=0; i<n_in_; ++i) {
       mapped[i] = arg[i].size2()!=size2_in(i);
     }
  
     // Allocate results
     res.resize(n_out_);
     for (casadi_int i=0; i<n_out_; ++i) {
       if (!res[i].sparsity().is_stacked(sparsity_out(i), npar)) {
         res[i] = Matrix<D>::zeros(repmat(sparsity_out(i), 1, npar));
       }
     }
  
     // Allocate temporary memory if needed
     std::vector<casadi_int> iw_tmp(sz_iw());
     std::vector<D> w_tmp(sz_w());
  
     // Get pointers to input arguments
     std::vector<const D*> argp(sz_arg());
     for (casadi_int i=0; i<n_in_; ++i) argp[i]=get_ptr(arg2[i]);
  
     // Get pointers to output arguments
     std::vector<D*> resp(sz_res());
     for (casadi_int i=0; i<n_out_; ++i) resp[i]=get_ptr(res[i]);
  
     // For all parallel calls
     for (casadi_int p=0; p<npar; ++p) {
       // Call memory-less
       if (eval_gen(get_ptr(argp), get_ptr(resp),
                    get_ptr(iw_tmp), get_ptr(w_tmp), memory(0),
                    always_inline, never_inline)) {
         if (error_on_fail_) casadi_error("Evaluation failed");
       }
       // Update offsets
       if (p==npar-1) break;
       for (casadi_int i=0; i<n_in_; ++i) if (mapped[i]) argp[i] += nnz_in(i);
       for (casadi_int i=0; i<n_out_; ++i) resp[i] += nnz_out(i);
     }
   }

◆ call_reverse() [1/3]

void casadi::FunctionInternal::call_reverse	(	const std::vector< MX > &	arg,
		const std::vector< MX > &	res,
		const std::vector< std::vector< MX > > &	aseed,
		std::vector< std::vector< MX > > &	asens,
		bool	always_inline,
		bool	never_inline
	)		const

virtualinherited

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

Definition at line 3381 of file function_internal.cpp.

                                                           {
     casadi_assert(!(always_inline && never_inline), "Inconsistent options");
     casadi_assert(!always_inline, "Class " + class_name() +
                           " cannot be inlined in an MX expression");
  
     // Derivative information must be available
     casadi_assert(has_derivative(),
                           "Derivatives cannot be calculated for " + name_);
  
     // Number of directional derivatives
     casadi_int nadj = aseed.size();
     asens.resize(nadj);
  
     // Quick return if no seeds
     if (nadj==0) return;
  
     // Check if seeds need to have dimensions corrected
     casadi_int npar = 1;
     for (auto&& r : aseed) {
       if (!matching_res(r, npar)) {
         FunctionInternal::call_reverse(arg, res, replace_aseed(aseed, npar),
                                        asens, always_inline, never_inline);
         return;
       }
     }
  
     // Calculating full Jacobian and then multiplying likely cheaper
     if (adjViaJac(nadj)) {
       // Multiply the transposed Jacobian from the right
       std::vector<MX> darg = arg;
       darg.insert(darg.end(), res.begin(), res.end());
       std::vector<MX> J = jacobian()(darg);
       // Join adjoint seeds
       std::vector<MX> v(nadj), all_aseed(n_out_);
       for (size_t i = 0; i < n_out_; ++i) {
         for (size_t d = 0; d < nadj; ++d) v[d] = vec(aseed.at(d).at(i));
         all_aseed[i] = horzcat(v);
       }
       // Calculate adjoint sensitivities
       std::vector<MX> all_asens(n_in_);
       std::vector<MX>::const_iterator J_it = J.begin();
       for (size_t oind = 0; oind < n_out_; ++oind) {
         for (size_t iind = 0; iind < n_in_; ++iind) {
           // Add contribution
           MX a = mtimes((*J_it++).T(), all_aseed[oind]);
           all_asens[iind] = all_asens[iind].is_empty(true) ? a : all_asens[iind] + a;
         }
       }
       // Split adjoint sensitivities
       for (size_t d = 0; d < nadj; ++d) asens[d].resize(n_in_);
       for (size_t i = 0; i < n_in_; ++i) {
         v = horzsplit(all_asens[i]);
         casadi_assert_dev(v.size() == nadj);
         for (size_t d = 0; d < nadj; ++d) {
           if (asens[d][i].is_empty(true)) {
             asens[d][i] = reshape(v[d], size_in(i));
           } else {
             asens[d][i] += reshape(v[d], size_in(i));
           }
         }
       }
     } else {
       // Evaluate in batches
       casadi_assert_dev(enable_reverse_);
       casadi_int max_nadj = max_num_dir_;
  
       while (!has_reverse(max_nadj)) max_nadj/=2;
       casadi_int offset = 0;
       while (offset<nadj) {
         // Number of derivatives, in this batch
         casadi_int nadj_batch =  std::min(nadj-offset, max_nadj);
  
         // All inputs and seeds
         std::vector<MX> darg;
         darg.reserve(n_in_ + n_out_ + n_out_);
         darg.insert(darg.end(), arg.begin(), arg.end());
         darg.insert(darg.end(), res.begin(), res.end());
         std::vector<MX> v(nadj_batch);
         for (casadi_int i=0; i<n_out_; ++i) {
           for (casadi_int d=0; d<nadj_batch; ++d) v[d] = aseed[offset+d][i];
           darg.push_back(horzcat(v));
         }
  
         // Create the evaluation node
         Function dfcn = self().reverse(nadj_batch);
         std::vector<MX> x = dfcn(darg);
         casadi_assert_dev(x.size()==n_in_);
  
         // Retrieve sensitivities
         for (casadi_int d=0; d<nadj_batch; ++d) asens[offset+d].resize(n_in_);
         for (casadi_int i=0; i<n_in_; ++i) {
           if (size2_in(i)>0) {
             v = horzsplit(x[i], size2_in(i));
             casadi_assert_dev(v.size()==nadj_batch);
           } else {
             v = std::vector<MX>(nadj_batch, MX(size_in(i)));
           }
           for (casadi_int d=0; d<nadj_batch; ++d) {
             if (asens[offset+d][i].is_empty(true)) {
               asens[offset+d][i] = v[d];
             } else {
               asens[offset+d][i] += v[d];
             }
           }
         }
         // Update offset
         offset += nadj_batch;
       }
     }
   }

Referenced by casadi::Rootfinder::ad_reverse(), ad_reverse(), casadi::Call::ad_reverse(), casadi::XFunction< DerivedType, MatType, NodeType >::call_reverse(), casadi::Scpgen::init(), and casadi::MX::reverse().

◆ call_reverse() [2/3]

void casadi::XFunction< MXFunction , MX , MXNode >::call_reverse	(	const std::vector< MX > &	arg,
		const std::vector< MX > &	res,
		const std::vector< std::vector< MX > > &	aseed,
		std::vector< std::vector< MX > > &	asens,
		bool	always_inline,
		bool	never_inline
	)		const

overrideinherited

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

Definition at line 227 of file x_function.hpp.

                                                             {
     casadi_assert(!(always_inline && never_inline), "Inconsistent options");
     if (!should_inline(MatType::type_name()=="SX", always_inline, never_inline)) {
       // The non-inlining version is implemented in the base class
       return FunctionInternal::call_reverse(arg, res, aseed, asens,
                                             always_inline, never_inline);
     }
  
     // Quick return if no seeds
     if (aseed.empty()) {
       asens.clear();
       return;
     }
  
     // Call inlining
     if (isInput(arg)) {
       // Argument agrees with in_, call ad_reverse directly
       static_cast<const DerivedType*>(this)->ad_reverse(aseed, asens);
     } else {
       // Need to create a temporary function
       Function f("tmp_call_reverse", arg, res);
       static_cast<DerivedType *>(f.get())->ad_reverse(aseed, asens);
     }
   }

◆ call_reverse() [3/3]

void casadi::FunctionInternal::call_reverse	(	const std::vector< SX > &	arg,
		const std::vector< SX > &	res,
		const std::vector< std::vector< SX > > &	aseed,
		std::vector< std::vector< SX > > &	asens,
		bool	always_inline,
		bool	never_inline
	)		const

virtualinherited

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

Definition at line 3509 of file function_internal.cpp.

                                                           {
     casadi_assert(!(always_inline && never_inline), "Inconsistent options");
     if (aseed.empty()) { // Quick return if no seeds
       asens.clear();
       return;
     }
     casadi_error("'reverse' (SX) not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

◆ change_option()

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 2046 of file mx_function.cpp.

                                        {
     if (option_name == "print_instructions") {
       print_instructions_ = option_value;
     } else if (option_name == "dump_trace") {
       bool value = option_value;
       casadi_assert(!value || !jit_, "dump_trace is not supported for JIT evaluation");
       dump_trace_ = value;
     } else {
       // Option not found - continue to base classes
       XFunction<MXFunction, MX, MXNode>::change_option(option_name, option_value);
     }
   }

References casadi::FunctionInternal::change_option(), dump_trace_, casadi::FunctionInternal::jit_, and print_instructions_.

◆ check_arg()

template<typename M >

void casadi::FunctionInternal::check_arg	(	const std::vector< M > &	arg,
		casadi_int &	npar
	)		const

inherited

Raises errors.

Parameters

	npar[in]	normal usage: 1, disallow pararallel calls: -1
[out]	npar	max number of horizontal repetitions across all arguments (or -1)

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

Definition at line 1773 of file function_internal.hpp.

                                                                                   {
     casadi_assert(arg.size()==n_in_, "Incorrect number of inputs: Expected "
                           + str(n_in_) + ", got " + str(arg.size()));
     for (casadi_int i=0; i<n_in_; ++i) {
       if (!check_mat(arg[i].sparsity(), sparsity_in(i), npar)) {
         // Dimensions
         std::string d_arg = str(arg[i].size1()) + "-by-" + str(arg[i].size2());
         std::string d_in = str(size1_in(i)) + "-by-" + str(size2_in(i));
         std::string e = "Input " + str(i) + " (" + name_in_[i] + ") has mismatching shape. "
                      "Got " + d_arg + ". Allowed dimensions, in general, are:\n"
                      " - The input dimension N-by-M (here " + d_in + ")\n"
                      " - A scalar, i.e. 1-by-1\n"
                      " - M-by-N if N=1 or M=1 (i.e. a transposed vector)\n"
                      " - N-by-M1 if K*M1=M for some K (argument repeated horizontally)\n";
         if (npar!=-1) {
           e += " - N-by-P*M, indicating evaluation with multiple arguments (P must be a "
                      "multiple of " + str(npar) + " for consistency with previous inputs)";
         }
         casadi_error(e);
       }
     }
   }

References casadi::FunctionInternal::check_mat(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::size1_in(), casadi::FunctionInternal::size2_in(), casadi::FunctionInternal::sparsity_in(), and casadi::str().

Referenced by casadi::FunctionInternal::mapsum_mx(), and casadi::FunctionInternal::matching_arg().

◆ check_mat()

bool casadi::FunctionInternal::check_mat	(	const Sparsity &	arg,
		const Sparsity &	inp,
		casadi_int &	npar
	)

staticinherited

Helper function

Parameters

npar[in]	normal usage: 1, disallow pararallel calls: -1
npar[out]	required number of parallel calls (or -1)

Definition at line 3707 of file function_internal.cpp.

                                                                                              {
     // Matching dimensions
     if (arg.size()==inp.size()) return true;
     // Calling with a scalar - set all
     if (arg.is_scalar()) return true;
     // Vectors that are transposes of each other
     if (arg.is_vector() && inp.size()==std::make_pair(arg.size2(), arg.size1())) return true;
     // Horizontal repmat
     if (arg.size1()==inp.size1() && arg.size2()>0 && inp.size2()>0
         && inp.size2()%arg.size2()==0) return true;
     // Evaluate with multiple arguments
     if (npar!=-1 && arg.size1()==inp.size1() && arg.size2()>0 && inp.size2()>0
         && arg.size2()%(npar*inp.size2())==0) {
       npar *= arg.size2()/(npar*inp.size2());
       return true;
     }
     // Calling with empty matrix - set all to zero (after the structured branches above,
     // so that a 0-by-N argument can still be recognised as a parallel/repmat call)
     if (arg.is_empty()) return true;
     // No match
     return false;
   }

References casadi::Sparsity::is_empty(), casadi::Sparsity::is_scalar(), casadi::Sparsity::is_vector(), casadi::Sparsity::size(), casadi::Sparsity::size1(), and casadi::Sparsity::size2().

Referenced by casadi::FunctionInternal::check_arg(), casadi::FunctionInternal::check_res(), and casadi::FunctionInternal::mapsum_mx().

◆ check_mem_count()

virtual void casadi::ProtoFunction::check_mem_count ( casadi_int n ) const

inlinevirtualinherited

Purpose if to allow more helpful error messages

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

Reimplemented in casadi::FmuFunction.

Definition at line 181 of file function_internal.hpp.

181 { }

Referenced by casadi::ProtoFunction::checkout().

◆ check_res()

template<typename M >

void casadi::FunctionInternal::check_res	(	const std::vector< M > &	res,
		casadi_int &	npar
	)		const

inherited

Raises errors.

Parameters

	npar[in]	normal usage: 1, disallow pararallel calls: -1
[out]	npar	max number of horizontal repetitions across all arguments (or -1)

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

Definition at line 1797 of file function_internal.hpp.

                                                                                   {
     casadi_assert(res.size()==n_out_, "Incorrect number of outputs: Expected "
                           + str(n_out_) + ", got " + str(res.size()));
     for (casadi_int i=0; i<n_out_; ++i) {
       casadi_assert(check_mat(res[i].sparsity(), sparsity_out(i), npar),
                     "Output " + str(i) + " (" + name_out_[i] + ") has mismatching shape. "
                     "Expected " + str(size_out(i)) + ", got " + str(res[i].size()));
     }
   }

References casadi::FunctionInternal::check_mat(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::size_out(), casadi::FunctionInternal::sparsity_out(), and casadi::str().

Referenced by casadi::FunctionInternal::matching_res().

◆ checkout()

int casadi::ProtoFunction::checkout ( ) const

inherited

Definition at line 3916 of file function_internal.cpp.

                                     {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
     if (unused_.empty()) {
       check_mem_count(mem_.size()+1);
       // Allocate a new memory object
       void* m = alloc_mem();
       mem_.push_back(m);
       if (init_mem(m)) {
         casadi_error("Failed to create or initialize memory object");
       }
       return static_cast<int>(mem_.size()) - 1;
     } else {
       // Use an unused memory object
       int m = unused_.top();
       unused_.pop();
       return m;
     }
   }

References casadi::ProtoFunction::alloc_mem(), casadi::ProtoFunction::check_mem_count(), and casadi::ProtoFunction::init_mem().

Referenced by casadi::FunctionInternal::codegen_meta(), casadi::ProtoFunction::finalize(), and casadi::Sqpmethod::init_mem().

◆ class_name()

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

inlineoverridevirtual

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

Implements casadi::SharedObjectInternal.

Definition at line 129 of file mx_function.hpp.

129 {return "MXFunction";}

◆ clear_mem()

void casadi::ProtoFunction::clear_mem ( )

inherited

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

Definition at line 3804 of file function_internal.cpp.

                                 {
     for (auto&& i : mem_) {
       if (i!=nullptr) free_mem(i);
     }
     mem_.clear();
   }

References casadi::ProtoFunction::free_mem().

◆ codegen()

void casadi::FunctionInternal::codegen	(	CodeGenerator &	g,
		const std::string &	fname
	)		const

inherited

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

Definition at line 2510 of file function_internal.cpp.

                                                                                {
     // Define function
     g << "/* " << definition() << " */\n";
     g << "static " << signature(fname) << " {\n";
  
     // Reset local variables, flush buffer
     g.flush(g.body);
  
     g.scope_enter();
  
     if (dump_in_ || dump_out_) {
       Function F = shared_from_this<Function>();
       std::string cg_name = codegen_name(g, false);
       std::string dump_counter = g.shorthand(cg_name + "_dump_counter");
       g.auxiliaries << "static int " << dump_counter << " = 0;\n";
       if (g.thread_safe()) {
         g.define_local_mutex(F, cg_name + "_dump_mutex");
         std::string dump_mutex = g.local_mutex(F, cg_name + "_dump_mutex");
         g << "CASADI_MUTEX_LOCK(&" << dump_mutex << ");\n";
         g << "int dump_id_local = " << dump_counter << "++;\n";
         g << "CASADI_MUTEX_UNLOCK(&" << dump_mutex << ");\n";
       } else {
         g << "int dump_id_local = " << dump_counter << "++;\n";
       }
     }
  
     if (dump_in_) g.generate_dump(shared_from_this<Function>(), "arg", true);
     if (print_in_) g.generate_print(shared_from_this<Function>(), "arg", true);
  
     // Generate function body (to buffer)
     codegen_body(g);
  
     if (dump_out_) g.generate_dump(shared_from_this<Function>(), "res", false);
     if (print_out_) g.generate_print(shared_from_this<Function>(), "res", false);
  
     g.scope_exit();
  
     // Finalize the function
     g << "return 0;\n";
     g << "}\n\n";
  
     // Flush to function body
     g.flush(g.body);
   }

Referenced by casadi::CodeGenerator::add_dependency().

◆ codegen_alloc_mem()

void casadi::FunctionInternal::codegen_alloc_mem ( CodeGenerator & g ) const

virtualinherited

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

Reimplemented in casadi::External.

Definition at line 2654 of file function_internal.cpp.

                                                                  {
     bool needs_mem = codegen_needs_mem();
     if (needs_mem) {
       std::string name = codegen_name(g, false);
       std::string mem_counter = g.shorthand(name + "_mem_counter");
       g << "return " + mem_counter + "++;\n";
     }
   }

References casadi::FunctionInternal::codegen_name(), casadi::FunctionInternal::codegen_needs_mem(), and casadi::CodeGenerator::shorthand().

Referenced by casadi::CodeGenerator::add_dependency().

◆ codegen_body()

void casadi::MXFunction::codegen_body ( CodeGenerator & g ) const

overridevirtual

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

Implements casadi::XFunction< MXFunction, MX, MXNode >.

Definition at line 1350 of file mx_function.cpp.

                                                       {
     // Temporary variables and vectors
     g.init_local("arg1", "arg+" + str(n_in_));
     g.init_local("res1", "res+" + str(n_out_));
  
     g.reserve_work(workloc_.size()-1);
  
     // Operation number (for printing)
     casadi_int k=0;
  
     // Names of operation argument and results
     std::vector<casadi_int> arg, res;
  
     // State of work vector: reference or not (value types)
     std::vector<bool> work_is_ref(workloc_.size()-1, false);
  
     // State of operation arguments and results: reference or not
     std::vector<bool> arg_is_ref, res_is_ref;
  
     // Collect for each work vector element if reference or value needed
     std::vector<bool> needs_reference(workloc_.size()-1, false);
     std::vector<bool> needs_value(workloc_.size()-1, false);
  
     // Codegen the algorithm
     for (auto&& e : algorithm_) {
       // Generate comment
       if (g.verbose) {
         g << "/* #" << k << ": " << print(e) << " */\n";
       }
  
       // Get the names of the operation arguments
       arg.resize(e.arg.size());
       arg_is_ref.resize(e.arg.size());
       for (casadi_int i=0; i<e.arg.size(); ++i) {
         casadi_int j=e.arg.at(i);
         if (j>=0 && workloc_.at(j)!=workloc_.at(j+1)) {
           arg.at(i) = j;
           arg_is_ref.at(i) = work_is_ref.at(j);
         } else {
           arg.at(i) = -1;
           arg_is_ref.at(i) = false;
         }
       }
  
       // Get the names of the operation results
       res.resize(e.res.size());
       for (casadi_int i=0; i<e.res.size(); ++i) {
         casadi_int j=e.res.at(i);
         if (j>=0 && workloc_.at(j)!=workloc_.at(j+1)) {
           res.at(i) = j;
         } else {
           res.at(i) = -1;
         }
       }
  
       res_is_ref.resize(e.res.size());
       // By default, don't assume references
       std::fill(res_is_ref.begin(), res_is_ref.end(), false);
  
       if (print_instructions_ && e.op!=OP_INPUT && e.op!=OP_OUTPUT) {
         print_arg(g, k, e, arg, arg_is_ref);
       }
  
       // Generate operation
       e.data->generate(g, arg, res, arg_is_ref, res_is_ref);
  
       for (casadi_int i=0; i<e.res.size(); ++i) {
         casadi_int j=e.res.at(i);
         if (j>=0 && workloc_.at(j)!=workloc_.at(j+1)) {
           work_is_ref.at(j) = res_is_ref.at(i);
           if (res_is_ref.at(i)) {
             needs_reference[j] = true;
           } else {
             needs_value[j] = true;
           }
         }
       }
  
       if (print_instructions_ && e.op!=OP_INPUT && e.op!=OP_OUTPUT) {
         print_res(g, k, e, res, res_is_ref);
       }
  
       k++;
  
     }
  
     // Compute new work vector offsets, taking into account copy elision
     std::vector<casadi_int> cg_off(workloc_.size()-1, 0);
     casadi_int cg_wind = workloc_.front();
     for (casadi_int i=0; i<workloc_.size()-1; ++i) {
       casadi_int n=workloc_[i+1]-workloc_[i];
       cg_off[i] = cg_wind;
       if (n==0 || !needs_value[i]) continue;
       if (!g.codegen_scalars && n==1) continue;
       cg_wind += n;
     }
     g.set_codegen_sz_w(this, sz_w() - static_cast<size_t>(workloc_.back()-cg_wind));
  
     // Declare scalar work vector elements as local variables
     for (casadi_int i=0; i<workloc_.size()-1; ++i) {
       casadi_int n=workloc_[i+1]-workloc_[i];
       if (n==0) continue;
       /* Could use local variables for small work vector elements here, e.g.:
          ...
          } else if (n<10) {
          g << "w" << i << "[" << n << "]";
          } else {
          ...
       */
       if (!g.codegen_scalars && n==1) {
         g.local("w" + g.format_padded(i), "casadi_real");
       } else {
         if (needs_value[i]) {
           g.local("w" + g.format_padded(i), "casadi_real", "*");
           g.init_local("w" + g.format_padded(i), "w+" + str(cg_off[i]));
         }
         if (needs_reference[i]) {
           g.local("wr" + g.format_padded(i), "const casadi_real", "*");
         }
       }
     }
   }

References algorithm_, casadi::CodeGenerator::codegen_scalars, casadi::CodeGenerator::format_padded(), casadi::CodeGenerator::init_local(), casadi::CodeGenerator::local(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::OP_INPUT, casadi::OP_OUTPUT, print(), print_arg(), print_instructions_, print_res(), casadi::CodeGenerator::reserve_work(), casadi::CodeGenerator::set_codegen_sz_w(), casadi::str(), casadi::FunctionInternal::sz_w(), casadi::CodeGenerator::verbose, and workloc_.

◆ codegen_checkout()

void casadi::FunctionInternal::codegen_checkout ( CodeGenerator & g ) const

virtualinherited

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

Reimplemented in casadi::External.

Definition at line 2663 of file function_internal.cpp.

                                                                 {
     std::string name = codegen_name(g, false);
     std::string stack_counter = g.shorthand(name + "_unused_stack_counter");
     std::string stack = g.shorthand(name + "_unused_stack");
     std::string mem_counter = g.shorthand(name + "_mem_counter");
     std::string mem_array = g.shorthand(name + "_mem");
     std::string alloc_mem = g.shorthand(name + "_alloc_mem");
     std::string init_mem = g.shorthand(name + "_init_mem");
  
  
     g.auxiliaries << "static int " << mem_counter  << " = 0;\n";
     g.auxiliaries << "static int " << stack_counter  << " = -1;\n";
     g.auxiliaries << "static int " << stack << "[CASADI_MAX_NUM_THREADS];\n";
     g.auxiliaries << "static " << codegen_mem_type() <<
                " " << mem_array << "[CASADI_MAX_NUM_THREADS];\n\n";
  
     if (g.thread_safe()) {
       Function F = shared_from_this<Function>();
       g.define_local_mutex(F, name + "_mem_mutex");
       std::string mem_mutex = g.local_mutex(F, name + "_mem_mutex");
       g << "CASADI_MUTEX_LOCK(&" << mem_mutex << ");\n";
       g.scope_add_cleanup("CASADI_MUTEX_UNLOCK(&" + mem_mutex + ");\n");
     }
  
     g.local("mid", "int");
  
     g << "if (" << stack_counter << ">=0) {\n";
     g.scope_return(stack + "[" + stack_counter + "--]");
     g << "} else {\n";
     g << "if (" << mem_counter << "==CASADI_MAX_NUM_THREADS) {\n";
     g.scope_return("-1");
     g << "}\n";
     g << "mid = " << alloc_mem << "();\n";
     g << "if (mid<0) {\n";
     g.scope_return("-1");
     g << "}\n";
     g << "if (" << init_mem << "(mid)) {\n";
     g.scope_return("-1");
     g << "}\n";
     g.scope_return("mid");
     g << "}\n";
   }

References casadi::FunctionInternal::alloc_mem(), casadi::CodeGenerator::auxiliaries, casadi::FunctionInternal::codegen_mem_type(), casadi::FunctionInternal::codegen_name(), casadi::CodeGenerator::define_local_mutex(), casadi::ProtoFunction::init_mem(), casadi::CodeGenerator::local(), casadi::CodeGenerator::local_mutex(), casadi::CodeGenerator::scope_add_cleanup(), casadi::CodeGenerator::scope_return(), casadi::CodeGenerator::shorthand(), and casadi::CodeGenerator::thread_safe().

Referenced by casadi::CodeGenerator::add_dependency().

◆ codegen_declarations()

void casadi::MXFunction::codegen_declarations ( CodeGenerator & g ) const

overridevirtual

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

Implements casadi::XFunction< MXFunction, MX, MXNode >.

Definition at line 1320 of file mx_function.cpp.

                                                               {
  
     // Make sure that there are no free variables
     if (!free_vars_.empty()) {
       casadi_error("Code generation of '" + name_ + "' is not possible since variables "
                    + str(free_vars_) + " are free.");
     }
  
     // Generate code for the embedded functions
     for (auto&& a : algorithm_) {
       a.data->add_dependency(g);
     }
   }

References algorithm_, free_vars_, casadi::ProtoFunction::name_, and casadi::str().

◆ codegen_decref()

void casadi::MXFunction::codegen_decref ( CodeGenerator & g ) const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1342 of file mx_function.cpp.

                                                         {
     FunctionInternal::codegen_decref(g);
     std::set<void*> added;
     for (auto&& a : algorithm_) {
       a.data->codegen_decref(g, added);
     }
   }

References algorithm_, and casadi::FunctionInternal::codegen_decref().

◆ codegen_free_mem()

virtual void casadi::FunctionInternal::codegen_free_mem ( CodeGenerator & g ) const

inlinevirtualinherited

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

Reimplemented in casadi::XpressInterface, casadi::UnoInterface, casadi::OsqpInterface, casadi::MosekInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, casadi::MadmpecInterface, and casadi::External.

Definition at line 888 of file function_internal.hpp.

888 {}

Referenced by casadi::CodeGenerator::add_dependency().

◆ codegen_incref()

void casadi::MXFunction::codegen_incref ( CodeGenerator & g ) const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1334 of file mx_function.cpp.

                                                         {
     FunctionInternal::codegen_incref(g);
     std::set<void*> added;
     for (auto&& a : algorithm_) {
       a.data->codegen_incref(g, added);
     }
   }

References algorithm_, and casadi::FunctionInternal::codegen_incref().

◆ codegen_init_mem()

void casadi::FunctionInternal::codegen_init_mem ( CodeGenerator & g ) const

virtualinherited

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

Reimplemented in casadi::XpressInterface, casadi::UnoInterface, casadi::OsqpInterface, casadi::MosekInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, casadi::MadmpecInterface, and casadi::External.

Definition at line 2650 of file function_internal.cpp.

                                                                 {
     g << "return 0;\n";
   }

Referenced by casadi::CodeGenerator::add_dependency().

◆ codegen_mem()

std::string casadi::FunctionInternal::codegen_mem	(	CodeGenerator &	g,
		const std::string &	index = `"mem"`
	)		const

inherited

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

Definition at line 3051 of file function_internal.cpp.

                                                                                         {
     std::string name = codegen_name(g, false);
     std::string mem_array = g.shorthand(name + "_mem");
     return mem_array+"[" + index + "]";
   }

References casadi::FunctionInternal::codegen_name(), and casadi::CodeGenerator::shorthand().

◆ codegen_mem_is_opaque()

virtual bool casadi::FunctionInternal::codegen_mem_is_opaque ( ) const

inlinevirtualinherited

without a need for alloc_mem, init_mem, free_mem?

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

Reimplemented in casadi::External.

Definition at line 935 of file function_internal.hpp.

935 { return false; }

Referenced by casadi::CodeGenerator::add_dependency().

◆ codegen_mem_type()

virtual std::string casadi::FunctionInternal::codegen_mem_type ( ) const

inlinevirtualinherited

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

Reimplemented in casadi::Sqpmethod, casadi::XpressInterface, casadi::UnoInterface, casadi::OsqpInterface, casadi::MosekInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, and casadi::MadmpecInterface.

Definition at line 923 of file function_internal.hpp.

923 { return ""; }

Referenced by casadi::FunctionInternal::codegen_checkout().

◆ codegen_meta()

void casadi::FunctionInternal::codegen_meta ( CodeGenerator & g ) const

inherited

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

Definition at line 2726 of file function_internal.cpp.

                                                             {
     bool needs_mem = codegen_needs_mem();
     std::string name = codegen_name(g, false);
  
     // Checkout/release routines
     g << g.declare("int " + name_ + "_checkout(void)") << " {\n";
     if (needs_mem) {
       std::string checkout = g.shorthand(name + "_checkout");
       g << "return " << checkout << "();\n";
     } else {
       g << "return 0;\n";
     }
     g << "}\n\n";
  
     if (needs_mem) {
       g << g.declare("void " + name_ + "_release(int mem)") << " {\n";
       std::string release = g.shorthand(name + "_release");
       g << release << "(mem);\n";
     } else {
       g << g.declare("void " + name_ + "_release(int mem)") << " {\n";
     }
     g << "}\n\n";
  
     // Reference counter routines
     g << g.declare("void " + name_ + "_incref(void)") << " {\n";
     if (has_refcount_in_deps_) {
       std::string incref = g.shorthand(name + "_incref");
       g << incref << "();\n";
     }
     g << "}\n\n"
       << g.declare("void " + name_ + "_decref(void)") << " {\n";
     if (has_refcount_in_deps_) {
       std::string decref = g.shorthand(name + "_decref");
       g << decref << "();\n";
     }
     g << "}\n\n";
  
     // Number of inputs and outptus
     g << g.declare("casadi_int " + name_ + "_n_in(void)")
       << " { return " << n_in_ << ";}\n\n"
       << g.declare("casadi_int " + name_ + "_n_out(void)")
       << " { return " << n_out_ << ";}\n\n";
  
     // Default inputs
     g << g.declare("casadi_real " + name_ + "_default_in(casadi_int i)") << " {\n"
       << "switch (i) {\n";
     for (casadi_int i=0; i<n_in_; ++i) {
       double def = get_default_in(i);
       if (def!=0) g << "case " << i << ": return " << g.constant(def) << ";\n";
     }
     g << "default: return 0;\n}\n"
       << "}\n\n";
  
     // Input names
     g << g.declare("const char* " + name_ + "_name_in(casadi_int i)") << " {\n"
       << "switch (i) {\n";
     for (casadi_int i=0; i<n_in_; ++i) {
       g << "case " << i << ": return \"" << name_in_[i] << "\";\n";
     }
     g << "default: return 0;\n}\n"
       << "}\n\n";
  
     // Output names
     g << g.declare("const char* " + name_ + "_name_out(casadi_int i)") << " {\n"
       << "switch (i) {\n";
     for (casadi_int i=0; i<n_out_; ++i) {
       g << "case " << i << ": return \"" << name_out_[i] << "\";\n";
     }
     g << "default: return 0;\n}\n"
       << "}\n\n";
  
     // Codegen sparsities
     codegen_sparsities(g);
  
     // Function that returns work vector lengths
     g << g.declare(
         "int " + name_ + "_work(casadi_int *sz_arg, casadi_int* sz_res, "
         "casadi_int *sz_iw, casadi_int *sz_w)")
       << " {\n"
       << "if (sz_arg) *sz_arg = " << codegen_sz_arg(g) << ";\n"
       << "if (sz_res) *sz_res = " << codegen_sz_res(g) << ";\n"
       << "if (sz_iw) *sz_iw = " << codegen_sz_iw(g) << ";\n"
       << "if (sz_w) *sz_w = " << codegen_sz_w(g) << ";\n"
       << "return 0;\n"
       << "}\n\n";
  
     // Function that returns work vector lengths in bytes
     g << g.declare(
         "int " + name_ + "_work_bytes(casadi_int *sz_arg, casadi_int* sz_res, "
         "casadi_int *sz_iw, casadi_int *sz_w)")
       << " {\n"
       << "if (sz_arg) *sz_arg = " << codegen_sz_arg(g) << "*sizeof(const casadi_real*);\n"
       << "if (sz_res) *sz_res = " << codegen_sz_res(g) << "*sizeof(casadi_real*);\n"
       << "if (sz_iw) *sz_iw = " << codegen_sz_iw(g) << "*sizeof(casadi_int);\n"
       << "if (sz_w) *sz_w = " << codegen_sz_w(g) << "*sizeof(casadi_real);\n"
       << "return 0;\n"
       << "}\n\n";
  
     // Also add to header file to allow getting
      if (g.with_header) {
       g.header
         << "#define " << name_ << "_SZ_ARG " << codegen_sz_arg(g) << "\n"
         << "#define " << name_ << "_SZ_RES " << codegen_sz_res(g) << "\n"
         << "#define " << name_ << "_SZ_IW " << codegen_sz_iw(g) << "\n"
         << "#define " << name_ << "_SZ_W " << codegen_sz_w(g) << "\n";
      }
  
     // Which inputs are differentiable
     if (!all(is_diff_in_)) {
       g << g.declare("int " + name_ + "_diff_in(casadi_int i)") << " {\n"
         << "switch (i) {\n";
       for (casadi_int i=0; i<n_in_; ++i) {
         g << "case " << i << ": return " << is_diff_in_[i] << ";\n";
       }
       g << "default: return -1;\n}\n"
         << "}\n\n";
     }
  
     // Which outputs are differentiable
     if (!all(is_diff_out_)) {
       g << g.declare("int " + name_ + "_diff_out(casadi_int i)") << " {\n"
         << "switch (i) {\n";
       for (casadi_int i=0; i<n_out_; ++i) {
         g << "case " << i << ": return " << is_diff_out_[i] << ";\n";
       }
       g << "default: return -1;\n}\n"
         << "}\n\n";
     }
  
     // Generate mex gateway for the function
     if (g.mex) {
       // Begin conditional compilation
       g << "#ifdef MATLAB_MEX_FILE\n";
  
       // Declare wrapper
       g << "void mex_" << name_
         << "(int resc, mxArray *resv[], int argc, const mxArray *argv[]) {\n"
         << "casadi_int i;\n";
       g << "int mem;\n";
       // Work vectors, including input and output buffers
       casadi_int i_nnz = nnz_in(), o_nnz = nnz_out();
       size_t sz_w = this->sz_w();
       for (casadi_int i=0; i<n_in_; ++i) {
         const Sparsity& s = sparsity_in_[i];
         sz_w = std::max(sz_w, static_cast<size_t>(s.size1())); // To be able to copy a column
         sz_w = std::max(sz_w, static_cast<size_t>(s.size2())); // To be able to copy a row
       }
       sz_w += i_nnz + o_nnz;
       g << CodeGenerator::array("casadi_real", "w", sz_w);
       g << CodeGenerator::array("casadi_int", "iw", sz_iw());
       std::string fw = "w+" + str(i_nnz + o_nnz);
  
       // Copy inputs to buffers
       casadi_int offset=0;
       g << CodeGenerator::array("const casadi_real*", "arg", sz_arg(), "{0}");
  
       // Allocate output buffers
       g << "casadi_real* res[" << sz_res() << "] = {0};\n";
  
       // Check arguments
       g << "if (argc>" << n_in_ << ") mexErrMsgIdAndTxt(\"Casadi:RuntimeError\","
         << "\"Evaluation of \\\"" << name_ << "\\\" failed. Too many input arguments "
         << "(%d, max " << n_in_ << ")\", argc);\n";
  
       g << "if (resc>" << n_out_ << ") mexErrMsgIdAndTxt(\"Casadi:RuntimeError\","
         << "\"Evaluation of \\\"" << name_ << "\\\" failed. "
         << "Too many output arguments (%d, max " << n_out_ << ")\", resc);\n";
  
       for (casadi_int i=0; i<n_in_; ++i) {
         std::string p = "argv[" + str(i) + "]";
         g << "if (--argc>=0) arg[" << i << "] = "
           << g.from_mex(p, "w", offset, sparsity_in_[i], fw) << "\n";
         offset += nnz_in(i);
       }
  
       for (casadi_int i=0; i<n_out_; ++i) {
         if (i==0) {
           // if i==0, always store output (possibly ans output)
           g << "--resc;\n";
         } else {
           // Store output, if it exists
           g << "if (--resc>=0) ";
         }
         // Create and get pointer
         g << g.res(i) << " = w+" << str(offset) << ";\n";
         offset += nnz_out(i);
       }
       g << name_ << "_incref();\n";
       g << "mem = " << name_ << "_checkout();\n";
  
       // Call the function
       g << "i = " << name_ << "(arg, res, iw, " << fw << ", mem);\n"
         << "if (i) mexErrMsgIdAndTxt(\"Casadi:RuntimeError\",\"Evaluation of \\\"" << name_
         << "\\\" failed.\");\n";
       g << name_ << "_release(mem);\n";
       g << name_ << "_decref();\n";
  
       // Save results
       for (casadi_int i=0; i<n_out_; ++i) {
         g << "if (" << g.res(i) << ") resv[" << i << "] = "
           << g.to_mex(sparsity_out_[i], g.res(i)) << "\n";
       }
  
       // End conditional compilation and function
       g << "}\n"
         << "#endif\n\n";
     }
  
     if (g.main) {
       // Declare wrapper
       g << "casadi_int main_" << name_ << "(casadi_int argc, char* argv[]) {\n";
  
       g << "casadi_int j;\n";
       g << "casadi_real* a;\n";
       g << "const casadi_real* r;\n";
       g << "casadi_int flag;\n";
       if (needs_mem) g << "int mem;\n";
  
  
  
       // Work vectors and input and output buffers
       size_t nr = sz_w() + nnz_in() + nnz_out();
       g << CodeGenerator::array("casadi_int", "iw", sz_iw())
         << CodeGenerator::array("casadi_real", "w", nr);
  
       // Input buffers
       g << "const casadi_real* arg[" << sz_arg() << "];\n";
  
       // Output buffers
       g << "casadi_real* res[" << sz_res() << "];\n";
  
       casadi_int off=0;
       for (casadi_int i=0; i<n_in_; ++i) {
         g << "arg[" << i << "] = w+" << off << ";\n";
         off += nnz_in(i);
       }
       for (casadi_int i=0; i<n_out_; ++i) {
         g << "res[" << i << "] = w+" << off << ";\n";
         off += nnz_out(i);
       }
  
       // TODO(@jaeandersson): Read inputs from file. For now; read from stdin
       g << "a = w;\n"
         << "for (j=0; j<" << nnz_in() << "; ++j) "
         << "if (scanf(\"%lg\", a++)<=0) return 2;\n";
  
       if (has_refcount_in_deps_) {
         g << name_ << "_incref();\n";
       }
  
       if (needs_mem) {
         g << "mem = " << name_ << "_checkout();\n";
       }
  
       // Call the function
       g << "flag = " << name_ << "(arg, res, iw, w+" << off << ", ";
       if (needs_mem) {
         g << "mem";
       } else {
         g << "0";
       }
       g << ");\n";
       if (needs_mem) {
         g << name_ << "_release(mem);\n";
       }
  
       if (has_refcount_in_deps_) {
         g << name_ << "_decref();\n";
       }
  
       g << "if (flag) return flag;\n";
  
       // TODO(@jaeandersson): Write outputs to file. For now: print to stdout
       g << "r = w+" << nnz_in() << ";\n"
         << "for (j=0; j<" << nnz_out() << "; ++j) "
         << g.printf("%.16e ", "*r++") << "\n";
  
       // End with newline
       g << g.printf("\\n") << "\n";
  
       // Finalize function
       g << "return 0;\n"
         << "}\n\n";
     }
  
     if (g.with_mem) {
       // Allocate memory
       g << g.declare("casadi_functions* " + name_ + "_functions(void)") << " {\n"
         << "static casadi_functions fun = {\n"
         << name_ << "_incref,\n"
         << name_ << "_decref,\n"
         << name_ << "_checkout,\n"
         << name_ << "_release,\n"
         << name_ << "_default_in,\n"
         << name_ << "_n_in,\n"
         << name_ << "_n_out,\n"
         << name_ << "_name_in,\n"
         << name_ << "_name_out,\n"
         << name_ << "_sparsity_in,\n"
         << name_ << "_sparsity_out,\n"
         << name_ << "_work,\n"
         << name_ << "\n"
         << "};\n"
         << "return &fun;\n"
         << "}\n";
     }
     // Flush
     g.flush(g.body);
   }

Referenced by casadi::CodeGenerator::add().

◆ codegen_name()

std::string casadi::FunctionInternal::codegen_name	(	const CodeGenerator &	g,
		bool	ns = `true`
	)		const

virtualinherited

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

Definition at line 3036 of file function_internal.cpp.

                                                                                 {
     if (ns) {
       // Get the index of the function
       for (auto&& e : g.added_functions_) {
         if (e.f.get()==this) return e.codegen_name;
       }
     } else {
       for (casadi_int i=0;i<g.added_functions_.size();++i) {
         const auto & e = g.added_functions_[i];
         if (e.f.get()==this) return "f" + str(i);
       }
     }
     casadi_error("Function '" + name_ + "' not found");
   }

References casadi::CodeGenerator::added_functions_, casadi::ProtoFunction::name_, and casadi::str().

Referenced by casadi::FunctionInternal::codegen(), casadi::FunctionInternal::codegen_alloc_mem(), casadi::FatropInterface::codegen_body(), casadi::FunctionInternal::codegen_checkout(), casadi::FunctionInternal::codegen_decref(), casadi::FunctionInternal::codegen_incref(), casadi::FunctionInternal::codegen_mem(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_release(), casadi::CodeGenerator::mem(), and casadi::CodeGenerator::operator()().

◆ codegen_needs_mem()

virtual bool casadi::FunctionInternal::codegen_needs_mem ( ) const

inlinevirtualinherited

◆ codegen_release()

void casadi::FunctionInternal::codegen_release ( CodeGenerator & g ) const

virtualinherited

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

Reimplemented in casadi::External.

Definition at line 2706 of file function_internal.cpp.

                                                                {
     std::string name = codegen_name(g, false);
     std::string stack_counter = g.shorthand(name + "_unused_stack_counter");
     std::string stack = g.shorthand(name + "_unused_stack");
  
     if (g.thread_safe()) {
       Function F = shared_from_this<Function>();
       std::string mem_mutex = g.local_mutex(F, name + "_mem_mutex");
       g << "CASADI_MUTEX_LOCK(&" << mem_mutex << ");\n";
       g.scope_add_cleanup("CASADI_MUTEX_UNLOCK(&" + mem_mutex + ");\n");
     }
  
     g << stack << "[++" << stack_counter << "] = mem;\n";
     g.scope_return();
   }

References casadi::FunctionInternal::codegen_name(), casadi::CodeGenerator::local_mutex(), casadi::CodeGenerator::scope_add_cleanup(), casadi::CodeGenerator::scope_return(), casadi::CodeGenerator::shorthand(), and casadi::CodeGenerator::thread_safe().

Referenced by casadi::CodeGenerator::add_dependency().

◆ codegen_sparsities()

void casadi::FunctionInternal::codegen_sparsities ( CodeGenerator & g ) const

inherited

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

Definition at line 2722 of file function_internal.cpp.

                                                                   {
     g.add_io_sparsities(name_, sparsity_in_, sparsity_out_);
   }

References casadi::CodeGenerator::add_io_sparsities(), casadi::ProtoFunction::name_, casadi::FunctionInternal::sparsity_in_, and casadi::FunctionInternal::sparsity_out_.

Referenced by casadi::FunctionInternal::codegen_meta().

◆ codegen_sz_arg()

size_t casadi::FunctionInternal::codegen_sz_arg ( const CodeGenerator & g ) const

virtualinherited

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

Definition at line 3158 of file function_internal.cpp.

                                                                       {
     return sz_arg();
   }

References casadi::FunctionInternal::sz_arg().

Referenced by casadi::FunctionInternal::codegen_meta().

◆ codegen_sz_iw()

size_t casadi::FunctionInternal::codegen_sz_iw ( const CodeGenerator & g ) const

virtualinherited

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

Definition at line 3164 of file function_internal.cpp.

                                                                      {
     return sz_iw();
   }

References casadi::FunctionInternal::sz_iw().

Referenced by casadi::FunctionInternal::codegen_meta().

◆ codegen_sz_res()

size_t casadi::FunctionInternal::codegen_sz_res ( const CodeGenerator & g ) const

virtualinherited

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

Definition at line 3161 of file function_internal.cpp.

                                                                       {
     return sz_res();
   }

References casadi::FunctionInternal::sz_res().

Referenced by casadi::FunctionInternal::codegen_meta().

◆ codegen_sz_w()

size_t casadi::MXFunction::codegen_sz_w ( const CodeGenerator & g ) const

overridevirtual

Smaller than sz_w() when codegen elided copies: those work vector elements are references and take no room in 'w'.

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1473 of file mx_function.cpp.

                                                               {
     size_t sz_w;
     if (g.get_codegen_sz_w(this, sz_w)) return sz_w;
     return this->sz_w();
   }

References casadi::CodeGenerator::get_codegen_sz_w(), and casadi::FunctionInternal::sz_w().

◆ construct()

void casadi::ProtoFunction::construct ( const Dict & opts )

inherited

Prepares the function for evaluation

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

Definition at line 141 of file function_internal.cpp.

                                                 {
     // Sanitize dictionary is needed
     if (!Options::is_sane(opts)) {
       // Call recursively
       construct(Options::sanitize(opts));
       return;
     }
  
     // Make sure all options exist
     get_options().check(opts);
  
     // Initialize the class hierarchy
     try {
       init(opts);
     } catch(std::exception& e) {
       casadi_error("Error calling " + class_name() + "::init for '" + name_ + "':\n"
         + std::string(e.what()));
     }
  
     // Revisit class hierarchy in reverse order
     try {
       finalize();
     } catch(std::exception& e) {
       casadi_error("Error calling " + class_name() + "::finalize for '" + name_ + "':\n"
         + std::string(e.what()));
     }
   }

References casadi::Options::check(), casadi::SharedObjectInternal::class_name(), casadi::ProtoFunction::finalize(), casadi::ProtoFunction::get_options(), casadi::ProtoFunction::init(), casadi::Options::is_sane(), casadi::ProtoFunction::name_, and casadi::Options::sanitize().

Referenced by casadi::Function::create(), casadi::FmuFunction::factory(), casadi::FmuFunction::get_forward(), casadi::FmuFunction::get_jacobian(), casadi::LinearInterpolant::get_jacobian(), and casadi::FmuFunction::get_reverse().

◆ convert_arg() [1/2]

template<typename M >

std::vector< M > casadi::FunctionInternal::convert_arg ( const std::map< std::string, M > & arg ) const

inherited

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

Definition at line 1899 of file function_internal.hpp.

                                                      {
     // Get default inputs
     std::vector<M> arg_v(n_in_);
     for (casadi_int i=0; i<arg_v.size(); ++i) {
       arg_v[i] = get_default_in(i);
     }
  
     // Assign provided inputs
     for (auto&& e : arg) {
       arg_v.at(index_in(e.first)) = e.second;
     }
  
     return arg_v;
   }

References casadi::FunctionInternal::get_default_in(), casadi::FunctionInternal::index_in(), and casadi::FunctionInternal::n_in_.

◆ convert_arg() [2/2]

template<typename M >

std::map< std::string, M > casadi::FunctionInternal::convert_arg ( const std::vector< M > & arg ) const

inherited

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

Definition at line 1887 of file function_internal.hpp.

                                              {
     casadi_assert(arg.size()==n_in_, "Incorrect number of inputs: Expected "
                       + str(n_in_) + ", got " + str(arg.size()));
     std::map<std::string, M> ret;
     for (casadi_int i=0;i<n_in_;++i) {
       ret[name_in_[i]] = arg[i];
     }
     return ret;
   }

References casadi::FunctionInternal::n_in_, casadi::FunctionInternal::name_in_, and casadi::str().

◆ convert_res() [1/2]

template<typename M >

std::vector< M > casadi::FunctionInternal::convert_res ( const std::map< std::string, M > & res ) const

inherited

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

Definition at line 1928 of file function_internal.hpp.

                                                      {
     // Get default inputs
     std::vector<M> res_v(n_out_);
     for (casadi_int i=0; i<res_v.size(); ++i) {
       res_v[i] = std::numeric_limits<double>::quiet_NaN();
     }
  
     // Assign provided inputs
     for (auto&& e : res) {
       M a = e.second;
       res_v.at(index_out(e.first)) = a;
     }
     return res_v;
   }

References casadi::FunctionInternal::index_out(), and casadi::FunctionInternal::n_out_.

◆ convert_res() [2/2]

template<typename M >

std::map< std::string, M > casadi::FunctionInternal::convert_res ( const std::vector< M > & res ) const

inherited

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

Definition at line 1916 of file function_internal.hpp.

                                              {
     casadi_assert(res.size()==n_out_, "Incorrect number of outputs: Expected "
                       + str(n_out_) + ", got " + str(res.size()));
     std::map<std::string, M> ret;
     for (casadi_int i=0;i<n_out_;++i) {
       ret[name_out_[i]] = res[i];
     }
     return ret;
   }

References casadi::FunctionInternal::n_out_, casadi::FunctionInternal::name_out_, and casadi::str().

◆ debug_repr()

std::string casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::debug_repr ( const Internal * i ) const

inherited

Definition at line 62 of file generic_shared_internal.hpp.

                                                                                        {
     // Note: i != this because of something something multiple inheritance
     return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
   }

◆ definition()

std::string casadi::FunctionInternal::definition ( ) const

inherited

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

Definition at line 1134 of file function_internal.cpp.

                                                {
     std::stringstream s;
  
     // Print name
     s << name_ << ":(";
     // Print input arguments
     for (casadi_int i=0; i<n_in_; ++i) {
       if (!is_diff_in_.empty() && !is_diff_in_[i]) s << "#";
       s << name_in_[i] << sparsity_in_[i].postfix_dim() << (i==n_in_-1 ? "" : ",");
     }
     s << ")->(";
     // Print output arguments
     for (casadi_int i=0; i<n_out_; ++i) {
       if (!is_diff_out_.empty() && !is_diff_out_[i]) s << "#";
       s << name_out_[i] << sparsity_out_[i].postfix_dim() << (i==n_out_-1 ? "" : ",");
     }
     s << ")";
  
     return s.str();
   }

References casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::is_diff_out_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sparsity_in_, and casadi::FunctionInternal::sparsity_out_.

Referenced by casadi::FunctionInternal::codegen(), casadi::FunctionInternal::disp(), should_inline(), and casadi::SXFunction::should_inline().

◆ delayed_deserialize_members()

void casadi::XFunction< MXFunction , MX , MXNode >::delayed_deserialize_members ( DeserializingStream & s )

inherited

Definition at line 266 of file x_function.hpp.

                                                       {
     s.unpack("XFunction::out", out_);
   }

◆ delayed_serialize_members()

void casadi::XFunction< MXFunction , MX , MXNode >::delayed_serialize_members ( SerializingStream & s ) const

inherited

The out member is problematic to de/serialize before the sorted algorithm has a chance of laying out the expression graph efficiently

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

Definition at line 265 of file x_function.hpp.

                                                         {
     s.pack("XFunction::out", out_);
   }

◆ deserialize()

ProtoFunction * casadi::MXFunction::deserialize ( DeserializingStream & s )

static

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

Definition at line 2033 of file mx_function.cpp.

                                                                {
     return new MXFunction(s);
   }

References MXFunction().

◆ destroySingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::destroySingleton ( )

inlineprotectedinherited

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

                             {
       static_cast<Internal*>(this)->count--;
     }

◆ diff_prefix()

std::string casadi::FunctionInternal::diff_prefix ( const std::string & prefix ) const

inherited

Definition at line 2242 of file function_internal.cpp.

                                                                        {
     // Highest index found in current inputs and outputs
     casadi_int highest_index = 0;
     // Loop over both input names and output names
     for (const std::vector<std::string>& name_io : {name_in_, name_out_}) {
       for (const std::string& n : name_io) {
         // Find end of prefix, skip if no prefix
         size_t end = n.find('_');
         if (end >= n.size()) continue;
         // Skip if too short
         if (end < prefix.size()) continue;
         // Skip if wrong prefix
         if (n.compare(0, prefix.size(), prefix) != 0) continue;
         // Beginning of index
         size_t begin = prefix.size();
         // Check if any index
         casadi_int this_index;
         if (begin == end) {
           // No prefix, implicitly 1
           this_index = 1;
         } else {
           // Read index from string
           this_index = std::stoi(n.substr(begin, end - begin));
         }
         // Find the highest index
         if (this_index > highest_index) highest_index = this_index;
       }
     }
     // Return one higher index
     if (highest_index == 0) {
       return prefix + "_";
     } else {
       return prefix + std::to_string(highest_index + 1) + "_";
     }
   }

References casadi::FunctionInternal::name_in_, and casadi::FunctionInternal::name_out_.

Referenced by casadi::FunctionInternal::forward(), casadi::OnnxFunction::get_forward(), casadi::OnnxFunction::get_reverse(), casadi::OnnxFunction::has_derivative(), and casadi::FunctionInternal::reverse().

◆ disp()

void casadi::FunctionInternal::disp	(	std::ostream &	stream,
		bool	more
	)		const

overridevirtualinherited

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

Implements casadi::SharedObjectInternal.

Definition at line 1155 of file function_internal.cpp.

                                                                  {
     stream << definition() << " " << class_name();
     if (more) {
       stream << std::endl;
       disp_more(stream);
     }
   }

References casadi::SharedObjectInternal::class_name(), casadi::FunctionInternal::definition(), and casadi::FunctionInternal::disp_more().

Referenced by eval(), and casadi::SXFunction::eval().

◆ disp_more()

void casadi::MXFunction::disp_more ( std::ostream & stream ) const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 635 of file mx_function.cpp.

                                                      {
     stream << "Algorithm:";
     for (auto&& e : algorithm_) {
       InterruptHandler::check();
       stream << std::endl << print(e);
     }
   }

References algorithm_, casadi::InterruptHandler::check(), and print().

◆ dm_in() [1/2]

const std::vector< DM > casadi::FunctionInternal::dm_in ( ) const

inherited

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

Definition at line 3576 of file function_internal.cpp.

                                                     {
     std::vector<DM> ret(n_in_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = dm_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_in_.

Referenced by casadi::FunctionInternal::nz_in().

◆ dm_in() [2/2]

const DM casadi::FunctionInternal::dm_in ( casadi_int ind ) const

inherited

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

Definition at line 3552 of file function_internal.cpp.

                                                        {
     return DM::zeros(sparsity_in(ind));
   }

References casadi::FunctionInternal::sparsity_in(), and casadi::GenericMatrix< MatType >::zeros().

◆ dm_out() [1/2]

const std::vector< DM > casadi::FunctionInternal::dm_out ( ) const

inherited

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

Definition at line 3584 of file function_internal.cpp.

                                                      {
     std::vector<DM> ret(n_out_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = dm_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_out_.

Referenced by casadi::FunctionInternal::nz_out().

◆ dm_out() [2/2]

const DM casadi::FunctionInternal::dm_out ( casadi_int ind ) const

inherited

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

Definition at line 3556 of file function_internal.cpp.

                                                         {
     return DM::zeros(sparsity_out(ind));
   }

References casadi::FunctionInternal::sparsity_out(), and casadi::GenericMatrix< MatType >::zeros().

◆ ensure_stacked()

template<typename MatType >

MatType casadi::FunctionInternal::ensure_stacked	(	const MatType &	v,
		const Sparsity &	sp,
		casadi_int	n
	)

staticinherited

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

Definition at line 1945 of file function_internal.hpp.

                                                                                              {
     // Check dimensions
     if (v.size1() == sp.size1() && v.size2() == n * sp.size2()) {
       // Ensure that sparsity is a horizontal multiple of original input, or has no entries
       if (v.nnz() != 0 && !v.sparsity().is_stacked(sp, n)) {
         return project(v, repmat(sp, 1, n));
       }
     } else {
       // Correct empty sparsity
       casadi_assert_dev(v.is_empty());
       return MatType(sp.size1(), sp.size2() * n);
     }
     // No correction needed
     return v;
   }

References casadi::Sparsity::size1(), and casadi::Sparsity::size2().

◆ eval()

int casadi::MXFunction::eval	(	const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w,
		void *	mem
	)		const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 444 of file mx_function.cpp.

                                                   {
     auto trace = dump_trace_ ? open_trace(arg, static_cast<FunctionMemory*>(mem)->dump_id)
                             : nullptr;
   try {
     if (verbose_) casadi_message(name_ + "::eval");
     setup(mem, arg, res, iw, w);
     // Work vector and temporaries to hold pointers to operation input and outputs
     const double** arg1 = arg+n_in_;
     double** res1 = res+n_out_;
  
     // Make sure that there are no free variables
     if (!free_vars_.empty()) {
       std::stringstream ss;
       disp(ss, false);
       casadi_error("Cannot evaluate \"" + ss.str() + "\" since variables "
                    + str(free_vars_) + " are free.");
     }
  
     // Operation number (for printing)
     casadi_int k = 0;
  
     // Evaluate all of the nodes of the algorithm:
     // should only evaluate nodes that have not yet been calculated!
     for (auto&& e : algorithm_) {
       if (trace) trace_instruction(*trace, k, w, false);
       // Perform the operation
       if (e.op==OP_INPUT) {
         // Pass an input
         double *w1 = w+workloc_[e.res.front()];
         casadi_int nnz=e.data.nnz();
         casadi_int i=e.data->ind();
         casadi_int nz_offset=e.data->offset();
         if (arg[i]==nullptr) {
           std::fill(w1, w1+nnz, 0);
         } else {
           std::copy(arg[i]+nz_offset, arg[i]+nz_offset+nnz, w1);
         }
       } else if (e.op==OP_OUTPUT) {
         // Get an output
         double *w1 = w+workloc_[e.arg.front()];
         casadi_int nnz=e.data->dep().nnz();
         casadi_int i=e.data->ind();
         casadi_int nz_offset=e.data->offset();
         if (res[i]) std::copy(w1, w1+nnz, res[i]+nz_offset);
       } else {
         // Point pointers to the data corresponding to the element
         for (casadi_int i=0; i<e.arg.size(); ++i)
           arg1[i] = e.arg[i]>=0 ? w+workloc_[e.arg[i]] : nullptr;
         for (casadi_int i=0; i<e.res.size(); ++i)
           res1[i] = e.res[i]>=0 ? w+workloc_[e.res[i]] : nullptr;
  
         // Evaluate
         if (print_instructions_) print_arg(uout(), k, e, arg1);
         if (e.data->eval(arg1, res1, iw, w)) {
           if (trace) finish_trace(*trace, res, 1);
           return 1;
         }
         if (print_instructions_) print_res(uout(), k, e, res1);
       }
       if (trace) trace_instruction(*trace, k, w, true);
       // Increase counter
       k++;
     }
   } catch (...) {
     if (trace) *trace << "{\"event\":\"error\"}\n";
     throw;
   }
     if (trace) finish_trace(*trace, res, 0);
     return 0;
   }

References algorithm_, casadi::FunctionInternal::disp(), dump_trace_, casadi::FunctionInternal::finish_trace(), free_vars_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::FunctionInternal::open_trace(), print_arg(), print_instructions_, print_res(), casadi::FunctionInternal::setup(), casadi::str(), trace_instruction(), casadi::uout(), casadi::ProtoFunction::verbose_, and workloc_.

◆ eval_activity()

int casadi::MXFunction::eval_activity	(	const bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem
	)		const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 692 of file mx_function.cpp.

                                                                                               {
     // Temporaries to hold pointers to operation input and outputs
     const bvec_t** arg1=arg+n_in_;
     bvec_t** res1=res+n_out_;
  
     // Propagate signal activity forward (ignores is_diff: this is a value analysis)
     for (auto&& e : algorithm_) {
       if (e.op==OP_INPUT) {
         casadi_int nnz=e.data.nnz();
         casadi_int i=e.data->ind();
         casadi_int nz_offset=e.data->offset();
         const bvec_t* argi = arg[i];
         bvec_t* w1 = w + workloc_[e.res.front()];
         if (argi!=nullptr) {
           std::copy(argi+nz_offset, argi+nz_offset+nnz, w1);
         } else {
           std::fill_n(w1, nnz, 0);
         }
       } else if (e.op==OP_OUTPUT) {
         casadi_int nnz=e.data.dep().nnz();
         casadi_int i=e.data->ind();
         casadi_int nz_offset=e.data->offset();
         bvec_t* resi = res[i];
         bvec_t* w1 = w + workloc_[e.arg.front()];
         if (resi!=nullptr) std::copy(w1, w1+nnz, resi+nz_offset);
       } else {
         for (casadi_int i=0; i<e.arg.size(); ++i)
           arg1[i] = e.arg[i]>=0 ? w+workloc_[e.arg[i]] : nullptr;
         for (casadi_int i=0; i<e.res.size(); ++i)
           res1[i] = e.res[i]>=0 ? w+workloc_[e.res[i]] : nullptr;
         if (e.data->eval_activity(arg1, res1, iw, w)) return 1;
       }
     }
     return 0;
   }

References algorithm_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::OP_INPUT, casadi::OP_OUTPUT, and workloc_.

◆ eval_dm()

std::vector< DM > casadi::FunctionInternal::eval_dm ( const std::vector< DM > & arg ) const

virtualinherited

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

Reimplemented in casadi::CallbackInternal.

Definition at line 2225 of file function_internal.cpp.

                                                                         {
     casadi_error("'eval_dm' not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

Referenced by casadi::FunctionInternal::eval().

◆ eval_gen() [1/3]

int casadi::FunctionInternal::eval_gen	(	const bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem,
		bool	always_inline,
		bool	never_inline
	)		const

inlineinherited

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

Definition at line 448 of file function_internal.hpp.

                                                      {
       return sp_forward(arg, res, iw, w, mem);
     }

◆ eval_gen() [2/3]

int casadi::FunctionInternal::eval_gen	(	const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w,
		void *	mem,
		bool	always_inline,
		bool	never_inline
	)		const

inherited

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

Definition at line 1022 of file function_internal.cpp.

                                                    {
     casadi_int dump_id = (dump_in_ || dump_out_ || dump_) ? get_dump_id() : -1;
     if (dump_in_) dump_in(dump_id, arg);
     if (dump_ && dump_id==0) dump();
     if (print_in_) print_in(uout(), arg, false);
     auto *m = static_cast<FunctionMemory*>(mem);
  
     // Avoid memory corruption
     for (casadi_int i=0;i<n_in_;++i) {
       casadi_assert(arg[i]==nullptr || arg[i]+nnz_in(i)<=w || arg[i]>=w+sz_w(),
         "Memory corruption detected for input " + name_in_[i] + ".\n"+
         "arg[" + str(i) + "] " + str(arg[i]) + "-" + str(arg[i]+nnz_in(i)) +
         " intersects with w " + str(w)+"-"+str(w+sz_w())+".");
     }
     for (casadi_int i=0;i<n_out_;++i) {
       casadi_assert(res[i]==nullptr || res[i]+nnz_out(i)<=w || res[i]>=w+sz_w(),
         "Memory corruption detected for output " + name_out_[i]);
     }
     // Reset statistics
     for (auto&& s : m->fstats) s.second.reset();
     if (m->t_total) m->t_total->tic();
     m->dump_id = dump_id;
     int ret;
     if (eval_) {
       auto *m = static_cast<FunctionMemory*>(mem);
       m->stats_available = true;
       int mem_ = 0;
       if (checkout_) {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
         mem_ = checkout_();
       }
       ret = eval_(arg, res, iw, w, mem_);
       if (release_) {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
         release_(mem_);
       }
     } else {
       ret = eval(arg, res, iw, w, mem);
     }
     if (m->t_total) m->t_total->toc();
     // Show statistics
     print_time(m->fstats);
  
     if (dump_out_) dump_out(dump_id, res);
     if (print_out_) print_out(uout(), res, false);
     // Check all outputs for NaNs
     if (regularity_check_) {
       for (casadi_int i = 0; i < n_out_; ++i) {
         // Skip of not calculated
         if (!res[i]) continue;
         // Loop over nonzeros
         casadi_int nnz = this->nnz_out(i);
         for (casadi_int nz = 0; nz < nnz; ++nz) {
           if (isnan(res[i][nz]) || isinf(res[i][nz])) {
             // Throw readable error message
             casadi_error(str(res[i][nz]) + " detected for output " + name_out_[i] + " at "
               + sparsity_out(i).repr_el(nz));
           }
         }
       }
     }
     return ret;
   }

Referenced by casadi::FunctionInternal::call_gen().

◆ eval_gen() [3/3]

int casadi::FunctionInternal::eval_gen	(	const SXElem **	arg,
		SXElem **	res,
		casadi_int *	iw,
		SXElem *	w,
		void *	mem,
		bool	always_inline,
		bool	never_inline
	)		const

inlineinherited

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

Definition at line 444 of file function_internal.hpp.

                                                      {
       return eval_sx(arg, res, iw, w, mem, always_inline, never_inline);
     }

◆ eval_mx()

void casadi::MXFunction::eval_mx	(	const MXVector &	arg,
		MXVector &	res,
		bool	always_inline,
		bool	never_inline
	)		const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 822 of file mx_function.cpp.

                                                                         {
     always_inline = always_inline || always_inline_;
     never_inline = never_inline || never_inline_;
     if (verbose_) casadi_message(name_ + "::eval_mx");
     try {
       // Resize the number of outputs
       casadi_assert(arg.size()==n_in_, "Wrong number of input arguments");
       res.resize(out_.size());
  
       // Trivial inline by default if output known
       if (!never_inline && isInput(arg)) {
         std::copy(out_.begin(), out_.end(), res.begin());
         return;
       }
  
       // non-inlining call is implemented in the base-class
       if (!should_inline(false, always_inline, never_inline)) {
         FunctionInternal::eval_mx(arg, res, false, true);
         return;
       }
  
       // Symbolic work, non-differentiated
       std::vector<MX> swork(workloc_.size()-1);
       if (verbose_) casadi_message("Allocated work vector");
  
       // Split up inputs analogous to symbolic primitives
       std::vector<std::vector<MX> > arg_split(in_.size());
       for (casadi_int i=0; i<in_.size(); ++i) arg_split[i] = in_[i].split_primitives(arg[i]);
  
       // Allocate storage for split outputs
       std::vector<std::vector<MX> > res_split(out_.size());
       for (casadi_int i=0; i<out_.size(); ++i) res_split[i].resize(out_[i].n_primitives());
  
       std::vector<MX> arg1, res1;
  
       // Loop over computational nodes in forward order
       casadi_int alg_counter = 0;
       for (auto it=algorithm_.begin(); it!=algorithm_.end(); ++it, ++alg_counter) {
         if (it->op == OP_INPUT) {
           swork[it->res.front()] = project(arg_split.at(it->data->ind()).at(it->data->segment()),
                                            it->data.sparsity(), true);
         } else if (it->op==OP_OUTPUT) {
           // Collect the results
           res_split.at(it->data->ind()).at(it->data->segment()) = swork[it->arg.front()];
         } else if (it->op==OP_PARAMETER) {
           // Fetch parameter
           swork[it->res.front()] = it->data;
         } else {
           // Arguments of the operation
           arg1.resize(it->arg.size());
           for (casadi_int i=0; i<arg1.size(); ++i) {
             casadi_int el = it->arg[i]; // index of the argument
             arg1[i] = el<0 ? MX(it->data->dep(i).size()) : swork[el];
           }
  
           // Perform the operation
           res1.resize(it->res.size());
           it->data->eval_mx(arg1, res1);
  
           // Get the result
           for (casadi_int i=0; i<res1.size(); ++i) {
             casadi_int el = it->res[i]; // index of the output
             if (el>=0) swork[el] = res1[i];
           }
         }
       }
  
       // Join split outputs
       for (casadi_int i=0; i<res.size(); ++i) res[i] = out_[i].join_primitives(res_split[i]);
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("eval_mx", e.what());
     }
   }

References algorithm_, casadi::FunctionInternal::always_inline_, casadi::FunctionInternal::eval_mx(), casadi::XFunction< MXFunction, MX, MXNode >::in_, casadi::XFunction< MXFunction, MX, MXNode >::isInput(), casadi::FunctionInternal::n_in_, casadi::ProtoFunction::name_, casadi::FunctionInternal::never_inline_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::XFunction< MXFunction, MX, MXNode >::out_, should_inline(), casadi::ProtoFunction::verbose_, and workloc_.

◆ eval_sx()

int casadi::MXFunction::eval_sx	(	const SXElem **	arg,
		SXElem **	res,
		casadi_int *	iw,
		SXElem *	w,
		void *	mem,
		bool	always_inline,
		bool	never_inline
	)		const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1268 of file mx_function.cpp.

                                                    {
     always_inline = always_inline || always_inline_;
     never_inline = never_inline || never_inline_;
  
     // non-inlining call is implemented in the base-class
     if (!should_inline(true, always_inline, never_inline)) {
       return FunctionInternal::eval_sx(arg, res, iw, w, mem, false, true);
     }
  
     // Work vector and temporaries to hold pointers to operation input and outputs
     std::vector<const SXElem*> argp(sz_arg());
     std::vector<SXElem*> resp(sz_res());
  
     // Evaluate all of the nodes of the algorithm:
     // should only evaluate nodes that have not yet been calculated!
     for (auto&& a : algorithm_) {
       if (a.op==OP_INPUT) {
         // Pass an input
         SXElem *w1 = w+workloc_[a.res.front()];
         casadi_int nnz=a.data.nnz();
         casadi_int i=a.data->ind();
         casadi_int nz_offset=a.data->offset();
         if (arg[i]==nullptr) {
           std::fill(w1, w1+nnz, 0);
         } else {
           std::copy(arg[i]+nz_offset, arg[i]+nz_offset+nnz, w1);
         }
       } else if (a.op==OP_OUTPUT) {
         // Get the outputs
         SXElem *w1 = w+workloc_[a.arg.front()];
         casadi_int nnz=a.data.dep().nnz();
         casadi_int i=a.data->ind();
         casadi_int nz_offset=a.data->offset();
         if (res[i]) std::copy(w1, w1+nnz, res[i]+nz_offset);
       } else if (a.op==OP_PARAMETER) {
         continue; // FIXME
       } else {
         // Point pointers to the data corresponding to the element
         for (casadi_int i=0; i<a.arg.size(); ++i)
           argp[i] = a.arg[i]>=0 ? w+workloc_[a.arg[i]] : nullptr;
         for (casadi_int i=0; i<a.res.size(); ++i)
           resp[i] = a.res[i]>=0 ? w+workloc_[a.res[i]] : nullptr;
  
         // Evaluate
         if (a.data->eval_sx(get_ptr(argp), get_ptr(resp), iw, w)) return 1;
       }
     }
     return 0;
   }

References algorithm_, casadi::FunctionInternal::always_inline_, casadi::FunctionInternal::eval_sx(), casadi::get_ptr(), casadi::FunctionInternal::never_inline_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, should_inline(), casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_res(), and workloc_.

◆ export_code()

void casadi::XFunction< MXFunction , MX , MXNode >::export_code	(	const std::string &	lang,
		std::ostream &	stream,
		const Dict &	options
	)		const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 193 of file x_function.hpp.

                                                                                     {
  
     casadi_assert(!has_free(), "export_code needs a Function without free variables");
  
     casadi_assert(lang=="matlab", "Only matlab language supported for now.");
  
     // start function
     stream << "function [varargout] = " << name_ << "(varargin)" << std::endl;
  
     // Allocate space for output argument (segments)
     for (casadi_int i=0;i<n_out_;++i) {
       stream << "  argout_" << i <<  " = cell(" << nnz_out(i) << ",1);" << std::endl;
     }
  
     Dict opts;
     opts["indent_level"] = 1;
     export_code_body(lang, stream, opts);
  
     // Process the outputs
     for (casadi_int i=0;i<n_out_;++i) {
       const Sparsity& out = sparsity_out_.at(i);
       if (out.is_dense()) {
         // Special case if dense
         stream << "  varargout{" << i+1 <<  "} = reshape(vertcat(argout_" << i << "{:}), ";
         stream << out.size1() << ", " << out.size2() << ");" << std::endl;
       } else {
         // For sparse outputs, export sparsity and call 'sparse'
         Dict opts;
         opts["name"] = "sp";
         opts["indent_level"] = 1;
         opts["as_matrix"] = false;
         out.export_code("matlab", stream, opts);
         stream << "  varargout{" << i+1 <<  "} = ";
         stream << "sparse(sp_i, sp_j, vertcat(argout_" << i << "{:}), sp_m, sp_n);" << std::endl;
       }
     }
  
     // end function
     stream << "end" << std::endl;
     stream << "function y=nonzeros_gen(x)" << std::endl;
     stream << "  if isa(x,'casadi.SX') || isa(x,'casadi.MX') || isa(x,'casadi.DM')" << std::endl;
     stream << "    y = x{:};" << std::endl;
     stream << "  elseif isa(x,'sdpvar')" << std::endl;
     stream << "    b = getbase(x);" << std::endl;
     stream << "    f = find(sum(b~=0,2));" << std::endl;
     stream << "    y = sdpvar(length(f),1,[],getvariables(x),b(f,:));" << std::endl;
     stream << "  else" << std::endl;
     stream << "    y = nonzeros(x);" << std::endl;
     stream << "  end" << std::endl;
     stream << "end" << std::endl;
     stream << "function y=if_else_zero_gen(c,e)" << std::endl;
     stream << "  if isa(c+e,'casadi.SX') || isa(c+e,'casadi.MX') "
               "|| isa(c+e,'casadi.DM')" << std::endl;
     stream << "    y = if_else(c, e, 0);" << std::endl;
     stream << "  else" << std::endl;
     stream << "    if c" << std::endl;
     stream << "        y = x;" << std::endl;
     stream << "    else" << std::endl;
     stream << "        y = 0;" << std::endl;
     stream << "    end" << std::endl;
     stream << "  end" << std::endl;
     stream << "end" << std::endl;
  
  
   }

◆ export_code_body()

void casadi::MXFunction::export_code_body	(	const std::string &	lang,
		std::ostream &	stream,
		const Dict &	options
	)		const

overridevirtual

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

Implements casadi::XFunction< MXFunction, MX, MXNode >.

Definition at line 1654 of file mx_function.cpp.

                                                  {
  
     // Default values for options
     casadi_int indent_level = 0;
  
     // Read options
     for (auto&& op : options) {
       if (op.first=="indent_level") {
         indent_level = op.second;
       } else {
         casadi_error("Unknown option '" + op.first + "'.");
       }
     }
  
     // Construct indent string
     std::string indent;
     for (casadi_int i=0;i<indent_level;++i) {
       indent += "  ";
     }
  
     Function f = shared_from_this<Function>();
  
     // Loop over algorithm
     for (casadi_int k=0;k<f.n_instructions();++k) {
       // Get operation
       casadi_int op = static_cast<casadi_int>(f.instruction_id(k));
       // Get MX node
       MX x = f.instruction_MX(k);
       // Get input positions into workvector
       std::vector<casadi_int> o = f.instruction_output(k);
       // Get output positions into workvector
       std::vector<casadi_int> i = f.instruction_input(k);
  
       switch (op) {
         case OP_INPUT:
           ss << indent << "w" << o[0] << " = varargin{" << i[0]+1 << "};" << std::endl;
           break;
         case OP_OUTPUT:
           {
             Dict info = x.info();
             casadi_int segment = info["segment"];
             x.dep(0).sparsity().export_code("matlab", ss,
               {{"name", "sp_in"}, {"indent_level", indent_level}, {"as_matrix", true}});
             ss << indent << "argout_" << o[0] << "{" << (1+segment) << "} = ";
             ss << "w" << i[0] << "(sp_in==1);" << std::endl;
           }
           break;
         case OP_CONST:
           {
             DM v = static_cast<DM>(x);
             Dict opts;
             opts["name"] = "m";
             opts["indent_level"] = indent_level;
             v.export_code("matlab", ss, opts);
             ss << indent << "w" << o[0] << " = m;" << std::endl;
           }
           break;
         case OP_SQ:
           ss << indent << "w" << o[0] << " = " << "w" << i[0] << ".^2;" << std::endl;
           break;
         case OP_MTIMES:
           ss << indent << "w" << o[0] << " = ";
           ss << "w" << i[1] << "*w" << i[2] << "+w" << i[0] << ";" << std::endl;
           break;
         case OP_MUL:
           {
             std::string prefix = (x.dep(0).is_scalar() || x.dep(1).is_scalar()) ? "" : ".";
             ss << indent << "w" << o[0] << " = " << "w" << i[0] << prefix << "*w" << i[1] << ";";
             ss << std::endl;
           }
           break;
         case OP_TWICE:
           ss << indent << "w" << o[0] << " = 2*w" << i[0] << ";" << std::endl;
           break;
         case OP_INV:
           ss << indent << "w" << o[0] << " = 1./w" << i[0] << ";" << std::endl;
           break;
         case OP_DOT:
           ss << indent << "w" << o[0] << " = dot(w" << i[0] << ",w" << i[1]<< ");" << std::endl;
           break;
         case OP_BILIN:
           ss << indent << "w" << o[0] << " = w" << i[1] << ".'*w" << i[0]<< "*w" << i[2] << ";";
           ss << std::endl;
           break;
         case OP_RANK1:
           ss << indent << "w" << o[0] << " = w" << i[0] << "+";
           ss << "w" << i[1] << "*w" << i[2] << "*w" << i[3] << ".';";
           ss << std::endl;
           break;
         case OP_FABS:
           ss << indent << "w" << o[0] << " = abs(w" << i[0] << ");" << std::endl;
           break;
         case OP_DETERMINANT:
           ss << indent << "w" << o[0] << " = det(w" << i[0] << ");" << std::endl;
           break;
         case OP_INVERSE:
           ss << indent << "w" << o[0] << " = inv(w" << i[0] << ");";
           ss << "w" << o[0] << "(w" << o[0] << "==0) = 1e-200;" << std::endl;
           break;
         case OP_SOLVE:
           {
             bool tr = x.info()["tr"];
             if (tr) {
               ss << indent << "w" << o[0] << " = ((w" << i[1] << ".')\\w" << i[0] << ").';";
               ss << std::endl;
             } else {
               ss << indent << "w" << o[0] << " = w" << i[1] << "\\w" << i[0] << ";" << std::endl;
             }
             ss << "w" << o[0] << "(w" << o[0] << "==0) = 1e-200;" << std::endl;
           }
           break;
         case OP_DIV:
           {
             std::string prefix = (x.dep(0).is_scalar() || x.dep(1).is_scalar()) ? "" : ".";
             ss << indent << "w" << o[0] << " = " << "w" << i[0] << prefix << "/w" << i[1] << ";";
             ss << std::endl;
           }
           break;
         case OP_POW:
         case OP_CONSTPOW:
           ss << indent << "w" << o[0] << " = " << "w" << i[0] << ".^w" << i[1] << ";" << std::endl;
           break;
         case OP_TRANSPOSE:
           ss << indent << "w" << o[0] << " = " << "w" << i[0] << ".';" << std::endl;
           break;
         case OP_HORZCAT:
         case OP_VERTCAT:
           {
             ss << indent << "w" << o[0] << " = [";
             for (casadi_int e : i) {
               ss << "w" << e << (op==OP_HORZCAT ? " " : ";");
             }
             ss << "];" << std::endl;
           }
           break;
         case OP_DIAGCAT:
           {
             for (casadi_int k=0;k<i.size();++k) {
               x.dep(k).sparsity().export_code("matlab", ss,
                 {{"name", "sp_in" + str(k)}, {"indent_level", indent_level}, {"as_matrix", true}});
             }
             ss << indent << "w" << o[0] << " = [";
             for (casadi_int k=0;k<i.size();++k) {
               ss << "w" << i[k] << "(sp_in" << k << "==1);";
             }
             ss << "];" << std::endl;
             Dict opts;
             opts["name"] = "sp";
             opts["indent_level"] = indent_level;
             opts["as_matrix"] = false;
             x.sparsity().export_code("matlab", ss, opts);
             ss << indent << "w" << o[0] << " = ";
             ss << "sparse(sp_i, sp_j, w" << o[0] << ", sp_m, sp_n);" << std::endl;
           }
           break;
         case OP_HORZSPLIT:
         case OP_VERTSPLIT:
           {
             Dict info = x.info();
             std::vector<casadi_int> offset = info["offset"];
             casadi::Function output = info["output"];
             std::vector<Sparsity> sp;
             for (casadi_int i=0;i<output.n_out();i++)
               sp.push_back(output.sparsity_out(i));
             for (casadi_int k=0;k<o.size();++k) {
               if (o[k]==-1) continue;
               x.dep(0).sparsity().export_code("matlab", ss,
                 {{"name", "sp_in"}, {"indent_level", indent_level}, {"as_matrix", true}});
               ss << indent << "tmp = w" << i[0]<< "(sp_in==1);" << std::endl;
               Dict opts;
               opts["name"] = "sp";
               opts["indent_level"] = indent_level;
               opts["as_matrix"] = false;
               sp[k].export_code("matlab", ss, opts);
               ss << indent << "w" << o[k] << " = sparse(sp_i, sp_j, ";
               ss << "tmp(" << offset[k]+1 << ":" << offset[k+1] << "), sp_m, sp_n);" << std::endl;
             }
           }
           break;
         case OP_GETNONZEROS:
         case OP_SETNONZEROS:
           {
             Dict info = x.info();
  
             std::string nonzeros;
             if (info.find("nz")!=info.end()) {
               nonzeros = "1+" + str(info["nz"]);
             } else if (info.find("slice")!=info.end()) {
               Dict s = info["slice"];
               casadi_int start = s["start"];
               casadi_int step = s["step"];
               casadi_int stop = s["stop"];
               nonzeros = str(start+1) + ":" + str(step) + ":" + str(stop);
               nonzeros = "nonzeros(" + nonzeros + ")";
             } else {
               Dict inner = info["inner"];
               Dict outer = info["outer"];
               casadi_int inner_start = inner["start"];
               casadi_int inner_step  = inner["step"];
               casadi_int inner_stop  = inner["stop"];
               casadi_int outer_start = outer["start"];
               casadi_int outer_step  = outer["step"];
               casadi_int outer_stop  = outer["stop"];
               std::string inner_slice = "(" + str(inner_start) + ":" +
                 str(inner_step) + ":" + str(inner_stop-1)+")";
               std::string outer_slice = "(" + str(outer_start+1) + ":" +
                 str(outer_step) + ":" + str(outer_stop)+")";
               casadi_int N = range(outer_start, outer_stop, outer_step).size();
               casadi_int M = range(inner_start, inner_stop, inner_step).size();
               nonzeros = "repmat("+ inner_slice  +"', 1, " + str(N) + ")+" +
                          "repmat("+ outer_slice  +", " + str(M) + ", 1)";
               nonzeros = "nonzeros(" + nonzeros + ")";
             }
  
             Dict opts;
             opts["name"] = "sp";
             opts["indent_level"] = indent_level;
             opts["as_matrix"] = false;
             x.sparsity().export_code("matlab", ss, opts);
  
             if (op==OP_GETNONZEROS) {
               x.dep(0).sparsity().export_code("matlab", ss,
                 {{"name", "sp_in"}, {"indent_level", indent_level}, {"as_matrix", true}});
               //ss << indent << "w" << i[0] << "" << std::endl;
               //ss << indent << "size(w" << i[0] << ")" << std::endl;
               ss << indent << "in_flat = w" << i[0] << "(sp_in==1);" << std::endl;
               //ss << indent << "in_flat" << std::endl;
               //ss << indent << "size(in_flat)" << std::endl;
               ss << indent << "w" << o[0] << " = in_flat(" << nonzeros << ");" << std::endl;
             } else {
               x.dep(0).sparsity().export_code("matlab", ss,
                 {{"name", "sp_in0"}, {"indent_level", indent_level}, {"as_matrix", true}});
               x.dep(1).sparsity().export_code("matlab", ss,
                 {{"name", "sp_in1"}, {"indent_level", indent_level}, {"as_matrix", true}});
               ss << indent << "in_flat = w" << i[1] << "(sp_in1==1);" << std::endl;
               ss << indent << "w" << o[0] << " = w" << i[0] << "(sp_in0==1);" << std::endl;
               ss << indent << "w" << o[0] << "(" << nonzeros << ")  = ";
               if (info["add"]) ss << "w" << o[0] << "(" << nonzeros << ") + ";
               ss << "in_flat;";
             }
             ss << indent << "w" << o[0] << " = ";
             ss << "sparse(sp_i, sp_j, w" << o[0] << ", sp_m, sp_n);" << std::endl;
           }
           break;
         case OP_PROJECT:
           {
             Dict opts;
             opts["name"] = "sp";
             opts["indent_level"] = indent_level;
             x.sparsity().export_code("matlab", ss, opts);
             ss << indent << "w" << o[0] << " = ";
             ss << "sparse(sp_i, sp_j, w" << i[0] << "(sp==1), sp_m, sp_n);" << std::endl;
           }
           break;
         case OP_NORM1:
           ss << indent << "w" << o[0] << " = norm(w" << i[0] << ", 1);" << std::endl;
           break;
         case OP_NORM2:
           ss << indent << "w" << o[0] << " = norm(w" << i[0] << ", 2);" << std::endl;
           break;
         case OP_NORMF:
           ss << indent << "w" << o[0] << " = norm(w" << i[0] << ", 'fro');" << std::endl;
           break;
         case OP_NORMINF:
           ss << indent << "w" << o[0] << " = norm(w" << i[0] << ", inf);" << std::endl;
           break;
         case OP_MMIN:
           ss << indent << "w" << o[0] << " = min(w" << i[0] << ");" << std::endl;
           break;
         case OP_MMAX:
           ss << indent << "w" << o[0] << " = max(w" << i[0] << ");" << std::endl;
           break;
         case OP_NOT:
           ss << indent << "w" << o[0] << " = ~" << "w" << i[0] << ";" << std::endl;
           break;
         case OP_OR:
           ss << indent << "w" << o[0] << " = w" << i[0] << " | w" << i[1] << ";" << std::endl;
           break;
         case OP_AND:
           ss << indent << "w" << o[0] << " = w" << i[0] << " & w" << i[1] << ";" << std::endl;
           break;
         case OP_NE:
           ss << indent << "w" << o[0] << " = w" << i[0] << " ~= w" << i[1] << ";" << std::endl;
           break;
         case OP_IF_ELSE_ZERO:
           ss << indent << "w" << o[0] << " = ";
           ss << "if_else_zero_gen(w" << i[0] << ", w" << i[1] << ");" << std::endl;
           break;
         case OP_RESHAPE:
           {
             x.dep(0).sparsity().export_code("matlab", ss,
               {{"name", "sp_in"}, {"indent_level", indent_level}, {"as_matrix", true}});
             x.sparsity().export_code("matlab", ss,
               {{"name", "sp_out"}, {"indent_level", indent_level}, {"as_matrix", false}});
             ss << indent << "w" << o[0] << " = sparse(sp_out_i, sp_out_j, ";
             ss << "w" << i[0] << "(sp_in==1), sp_out_m, sp_out_n);" << std::endl;
           }
           break;
         default:
           if (x.is_binary()) {
             ss << indent << "w" << o[0] << " = " << casadi::casadi_math<double>::print(op,
               "w"+std::to_string(i[0]), "w"+std::to_string(i[1])) << ";" << std::endl;
           } else if (x.is_unary()) {
             ss << indent << "w" << o[0] << " = " << casadi::casadi_math<double>::print(op,
               "w"+std::to_string(i[0])) << ";" << std::endl;
           } else {
             ss << "unknown" + x.class_name() << std::endl;
           }
       }
     }
   }

References casadi::SharedObject::class_name(), casadi::MX::dep(), casadi::Matrix< Scalar >::export_code(), casadi::Sparsity::export_code(), casadi::FunctionInternal::info(), casadi::MX::info(), casadi::Function::instruction_id(), casadi::Function::instruction_input(), casadi::Function::instruction_MX(), casadi::Function::instruction_output(), casadi::MX::is_binary(), casadi::GenericMatrix< MatType >::is_scalar(), casadi::MX::is_unary(), casadi::Function::n_instructions(), casadi::OP_AND, casadi::OP_BILIN, casadi::OP_CONST, casadi::OP_CONSTPOW, casadi::OP_DETERMINANT, casadi::OP_DIAGCAT, casadi::OP_DIV, casadi::OP_DOT, casadi::OP_FABS, casadi::OP_GETNONZEROS, casadi::OP_HORZCAT, casadi::OP_HORZSPLIT, casadi::OP_IF_ELSE_ZERO, casadi::OP_INPUT, casadi::OP_INV, casadi::OP_INVERSE, casadi::OP_MMAX, casadi::OP_MMIN, casadi::OP_MTIMES, casadi::OP_MUL, casadi::OP_NE, casadi::OP_NORM1, casadi::OP_NORM2, casadi::OP_NORMF, casadi::OP_NORMINF, casadi::OP_NOT, casadi::OP_OR, casadi::OP_OUTPUT, casadi::OP_POW, casadi::OP_PROJECT, casadi::OP_RANK1, casadi::OP_RESHAPE, casadi::OP_SETNONZEROS, casadi::OP_SOLVE, casadi::OP_SQ, casadi::OP_TRANSPOSE, casadi::OP_TWICE, casadi::OP_VERTCAT, casadi::OP_VERTSPLIT, casadi::casadi_math< T >::print(), casadi::range(), casadi::MX::sparsity(), and casadi::str().

◆ factory()

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 108 of file x_function.hpp.

                                   {
  
     Dict g_ops = generate_options("tmp");
     Dict f_options;
     f_options["helper_options"] = g_ops;
     f_options["final_options"] = g_ops;
     update_dict(f_options, opts, true);
  
     Dict final_options;
     extract_from_dict_inplace(f_options, "final_options", final_options);
     final_options["allow_duplicate_io_names"] = true;
  
     // Create an expression factory
     Factory<MatType> f;
     for (casadi_int i=0; i<in_.size(); ++i) f.add_input(name_in_[i], in_[i], is_diff_in_[i]);
     for (casadi_int i=0; i<out_.size(); ++i) f.add_output(name_out_[i], out_[i], is_diff_out_[i]);
     f.add_dual(aux);
  
     // Specify input expressions to be calculated
     std::vector<std::string> ret_iname;
     for (const std::string& s : s_in) {
       try {
         ret_iname.push_back(f.request_input(s));
       } catch (CasadiException& ex) {
         casadi_error("Cannot process factory input \"" + s + "\":" + ex.what());
       }
     }
  
     // Specify output expressions to be calculated
     std::vector<std::string> ret_oname;
     for (const std::string& s : s_out) {
       try {
         ret_oname.push_back(f.request_output(s));
       } catch (CasadiException& ex) {
         casadi_error("Cannot process factory output \"" + s + "\":" + ex.what());
       }
     }
  
     // Calculate expressions
     f.calculate(f_options);
  
     // Get input expressions
     std::vector<MatType> ret_in;
     ret_in.reserve(s_in.size());
     for (const std::string& s : s_in) ret_in.push_back(f.get_input(s));
  
     // Get output expressions
     std::vector<MatType> ret_out;
     ret_out.reserve(s_out.size());
     for (const std::string& s : s_out) ret_out.push_back(f.get_output(s));
  
     // Create function and return
     Dict final_options_allow_free = final_options;
     final_options_allow_free["allow_free"] = true;
     final_options_allow_free["allow_duplicate_io_names"] = true;
     Function ret(name, ret_in, ret_out, ret_iname, ret_oname, final_options_allow_free);
     if (ret.has_free()) {
       // Substitute free variables with zeros
       // We assume that the free variables are caused by false positive dependencies
       std::vector<MatType> free_in = MatType::get_free(ret);
       std::vector<MatType> free_sub = free_in;
       for (auto&& e : free_sub) e = MatType::zeros(e.sparsity());
       ret_out = substitute(ret_out, free_in, free_sub);
       ret = Function(name, ret_in, ret_out, ret_iname, ret_oname, final_options);
     }
     return ret;
   }

◆ finalize()

void casadi::FunctionInternal::finalize ( )

overridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Reimplemented in casadi::PiqpInterface, and casadi::OracleFunction.

Definition at line 732 of file function_internal.cpp.

                                   {
     if (codegen_needs_mem()) has_refcount_ = true;
     if (dump_in_ || dump_out_) has_refcount_ = true;
  
     has_refcount_in_deps_ = has_refcount_;
  
     // Does any embedded function have reference counting for codegen?
     for (const Function& f : shared_from_this<Function>().find_functions(0)) {
       if (f->has_refcount_in_deps_) {
         has_refcount_in_deps_ = true;
         break;
       }
     }
  
     if (jit_) {
       jit_name_ = jit_base_name_;
       jit_directory_ = get_jit_directory(jit_options_);
       if (jit_temp_suffix_) {
         jit_name_ = temporary_file(jit_name_, ".c", jit_directory_);
         jit_name_ = std::string(jit_name_.begin()+jit_directory_.size(),
                                 jit_name_.begin()+jit_name_.size()-2);
       }
       if (has_codegen()) {
         if (compiler_.is_null()) {
           if (verbose_) casadi_message("Codegenerating function '" + name_ + "'.");
           // JIT everything
           Dict opts;
           // Override the default to avoid random strings in the generated code
           opts["prefix"] = "jit";
           CodeGenerator gen(jit_name_, opts);
           gen.add(self());
           if (verbose_) casadi_message("Compiling function '" + name_ + "'..");
           compiler_ = Importer(gen.generate(jit_directory_), compiler_plugin_, jit_options_);
           if (verbose_) casadi_message("Compiling function '" + name_ + "' done.");
         }
         // Try to load
         eval_ = (eval_t) compiler_.get_function(name_);
         checkout_ = (casadi_checkout_t) compiler_.get_function(name_ + "_checkout");
         release_ = (casadi_release_t) compiler_.get_function(name_ + "_release");
         incref_ = (signal_t) compiler_.get_function(name_ + "_incref");
         decref_ = (signal_t) compiler_.get_function(name_ + "_decref");
         casadi_assert(eval_!=nullptr, "Cannot load JIT'ed function.");
         if (incref_) incref_();
       } else {
         // Just jit dependencies
         jit_dependencies(jit_name_);
       }
     }
  
     // Finalize base classes
     ProtoFunction::finalize();
  
     // Dump if requested
     if (dump_) dump();
   }

Referenced by casadi::FunctionInternal::deserialize(), casadi::CallbackInternal::finalize(), casadi::Conic::finalize(), and casadi::OracleFunction::finalize().

◆ find()

void casadi::MXFunction::find	(	std::map< FunctionInternal *, std::pair< Function, size_t > > &	all_fun,
		casadi_int	max_depth
	)		const

overridevirtual

Reimplemented from casadi::FunctionInternal.

Definition at line 2037 of file mx_function.cpp.

                                   {
     // Call to base class
     FunctionInternal::find(all_fun, max_depth);
     for (auto&& e : algorithm_) {
       if (e.op == OP_CALL) add_embedded(all_fun, e.data.which_function(), max_depth);
     }
   }

References casadi::FunctionInternal::add_embedded(), algorithm_, casadi::FunctionInternal::find(), and casadi::OP_CALL.

◆ finish_trace()

void casadi::FunctionInternal::finish_trace	(	std::ostream &	trace,
		double **	res,
		int	ret
	)		const

protectedinherited

Definition at line 868 of file function_internal.cpp.

                                                                {
     if (ret == 0) {
       trace << "{\"event\":\"outputs\",\"values\":[";
       for (casadi_int i = 0; i < n_out_; ++i) {
         if (i) trace << ",";
         trace_values(trace, res[i], nnz_out(i));
       }
       trace << "]}\n";
     }
     trace << "{\"event\":\"end\",\"status\":" << ret << "}\n";
     trace.flush();
     casadi_assert(trace.good(), "Failed to write dump_trace for '" + name_ + "'");
   }

References casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::nnz_out(), and casadi::FunctionInternal::trace_values().

Referenced by eval(), and casadi::SXFunction::eval().

◆ format_time()

void casadi::ProtoFunction::format_time	(	char *	buffer,
		double	time
	)		const

inherited

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

Definition at line 4117 of file function_internal.cpp.

                                                                  {
     // Always of width 8
     casadi_assert_dev(time>=0);
     double log_time = log10(time);
     int magn = static_cast<int>(floor(log_time));
     int iprefix = static_cast<int>(floor(log_time/3));
     if (iprefix<-4) {
       sprint(buffer, 10, "       0");
       return;
     }
     if (iprefix>=5) {
       sprint(buffer, 10, "     inf");
       return;
     }
     char prefixes[] = "TGMk munp";
     char prefix = prefixes[4-iprefix];
  
     int rem = magn-3*iprefix;
     double time_normalized = time/pow(10, 3*iprefix);
  
     if (rem==0) {
       sprint(buffer, 10, "  %1.2f%cs", time_normalized, prefix);
     } else if (rem==1) {
       sprint(buffer, 10, " %2.2f%cs", time_normalized, prefix);
     } else {
       sprint(buffer, 10, "%3.2f%cs", time_normalized, prefix);
     }
   }

References casadi::ProtoFunction::sprint().

Referenced by casadi::ProtoFunction::print_time().

◆ forward()

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

inherited

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

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

Definition at line 2278 of file function_internal.cpp.

                                                           {
     casadi_assert_dev(nfwd>=0);
     // Used wrapped function if forward not available
     if (!enable_forward_ && !enable_fd_) {
       // Derivative information must be available
       casadi_assert(has_derivative(), "Derivatives cannot be calculated for " + name_);
       return wrap().forward(nfwd);
     }
     // Retrieve/generate cached
     Function f;
     std::string fname = forward_name(name_, nfwd);
     if (!incache(fname, f)) {
       casadi_int i;
       // Prefix to be used for forward seeds, sensitivities
       std::string pref = diff_prefix("fwd");
       // Names of inputs
       std::vector<std::string> inames;
       for (i=0; i<n_in_; ++i) inames.push_back(name_in_[i]);
       for (i=0; i<n_out_; ++i) inames.push_back("out_" + name_out_[i]);
       for (i=0; i<n_in_; ++i) inames.push_back(pref + name_in_[i]);
       // Names of outputs
       std::vector<std::string> onames;
       for (i=0; i<n_out_; ++i) onames.push_back(pref + name_out_[i]);
       // Options
       Dict opts = combine(forward_options_, der_options_);
       if (enable_forward_) {
         opts = combine(opts, generate_options("forward"));
       } else {
         opts = combine(opts, FunctionInternal::generate_options("forward"));
       }
       opts["derivative_of"] = self();
       // Generate derivative function
       casadi_assert_dev(enable_forward_ || enable_fd_);
       if (enable_forward_) {
         f = get_forward(nfwd, fname, inames, onames, opts);
       } else {
         opts = combine(opts, fd_options_);
         // Get FD method
         if (fd_method_.empty() || fd_method_=="central") {
           f = Function::create(new CentralDiff(fname, nfwd), opts);
         } else if (fd_method_=="forward") {
           f = Function::create(new ForwardDiff(fname, nfwd), opts);
         } else if (fd_method_=="backward") {
           f = Function::create(new BackwardDiff(fname, nfwd), opts);
         } else if (fd_method_=="smoothing") {
           f = Function::create(new Smoothing(fname, nfwd), opts);
         } else {
           casadi_error("Unknown 'fd_method': " + fd_method_);
         }
       }
       // Consistency check for inputs
       casadi_assert_dev(f.n_in()==n_in_ + n_out_ + n_in_);
       casadi_int ind=0;
       for (i=0; i<n_in_; ++i) f.assert_size_in(ind++, size1_in(i), size2_in(i));
       for (i=0; i<n_out_; ++i) f.assert_size_in(ind++, size1_out(i), size2_out(i));
       for (i=0; i<n_in_; ++i) f.assert_size_in(ind++, size1_in(i), nfwd*size2_in(i));
       // Consistency check for outputs
       casadi_assert_dev(f.n_out()==n_out_);
       for (i=0; i<n_out_; ++i) f.assert_sparsity_out(i, sparsity_out(i), nfwd);
       // Save to cache
       tocache_if_missing(f);
     }
     return f;
   }

Referenced by casadi::FunctionInternal::call_forward(), and casadi::Function::forward().

◆ forward_name()

static std::string casadi::FunctionInternal::forward_name	(	const std::string &	fcn,
		casadi_int	nfwd
	)

inlinestaticinherited

Definition at line 651 of file function_internal.hpp.

                                                                          {
       return "fwd" + str(nfwd) + "_" + fcn;
     }

References casadi::str().

◆ free_mem()

void casadi::FunctionInternal::free_mem ( void * mem ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Definition at line 347 of file function_internal.hpp.

347 { delete static_cast<FunctionMemory*>(mem); }

Referenced by casadi::FunctionInternal::codegen_decref().

◆ free_mx()

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

inlineoverridevirtual

Reimplemented from casadi::FunctionInternal.

Definition at line 276 of file mx_function.hpp.

276 {return free_vars_;}

◆ free_sx()

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

virtualinherited

Reimplemented in casadi::SXFunction.

Definition at line 3628 of file function_internal.cpp.

                                                 {
     casadi_error("'free_sx' only defined for 'SXFunction'");
   }

◆ from_compact()

Sparsity casadi::FunctionInternal::from_compact	(	casadi_int	oind,
		casadi_int	iind,
		const Sparsity &	sp
	)		const

inherited

Definition at line 2043 of file function_internal.cpp.

                                 {
     // Return value
     Sparsity r = sp;
     // Insert rows if sparse output
     if (numel_out(oind) != r.size1()) {
       casadi_assert_dev(r.size1() == nnz_out(oind));
       r.enlargeRows(numel_out(oind), sparsity_out(oind).find());
     }
     // Insert columns if sparse input
     if (numel_in(iind) != r.size2()) {
       casadi_assert_dev(r.size2() == nnz_in(iind));
       r.enlargeColumns(numel_in(iind), sparsity_in(iind).find());
     }
     // Return non-compact pattern
     return r;
   }

References casadi::Sparsity::enlargeColumns(), casadi::Sparsity::enlargeRows(), casadi::FunctionInternal::find(), casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::numel_in(), casadi::FunctionInternal::numel_out(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::FunctionInternal::sparsity_in(), and casadi::FunctionInternal::sparsity_out().

Referenced by casadi::FunctionInternal::jac_sparsity().

◆ fwd_seed()

template<typename MatType >

std::vector< std::vector< MatType > > casadi::FunctionInternal::fwd_seed ( casadi_int nfwd ) const

inherited

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

Definition at line 1582 of file function_internal.hpp.

                                   {
     std::vector<std::vector<MatType>> fseed(nfwd);
     for (casadi_int dir=0; dir<nfwd; ++dir) {
       fseed[dir].resize(n_in_);
       for (casadi_int iind=0; iind<n_in_; ++iind) {
         std::string n = "f" + str(dir) + "_" +  name_in_[iind];
         Sparsity sp = is_diff_in_[iind] ? sparsity_in(iind) : Sparsity(size_in(iind));
         fseed[dir][iind] = MatType::sym(n, sp);
       }
     }
     return fseed;
   }

References casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::size_in(), casadi::FunctionInternal::sparsity_in(), and casadi::str().

◆ fwdViaJac()

bool casadi::FunctionInternal::fwdViaJac ( casadi_int nfwd ) const

virtualinherited

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

Definition at line 3239 of file function_internal.cpp.

                                                         {
     if (!enable_forward_ && !enable_fd_) return true;
     if (jac_penalty_==-1) return false;
  
     // Heuristic 1: Jac calculated via forward mode likely cheaper
     if (jac_penalty_*static_cast<double>(nnz_in())<nfwd) return true;
  
     // Heuristic 2: Jac calculated via reverse mode likely cheaper
     double w = ad_weight();
     if (enable_reverse_ &&
         jac_penalty_*(1-w)*static_cast<double>(nnz_out())<w*static_cast<double>(nfwd))
       return true; // NOLINT
  
     return false;
   }

References casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::enable_fd_, casadi::FunctionInternal::enable_forward_, casadi::FunctionInternal::enable_reverse_, casadi::FunctionInternal::jac_penalty_, casadi::FunctionInternal::nnz_in(), and casadi::FunctionInternal::nnz_out().

Referenced by casadi::FunctionInternal::call_forward().

◆ generate_dependencies()

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

virtualinherited

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

Reimplemented in casadi::OracleFunction.

Definition at line 3068 of file function_internal.cpp.

                                                                         {
     casadi_error("'generate_dependencies' not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

◆ generate_in()

void casadi::FunctionInternal::generate_in	(	const std::string &	fname,
		const double **	arg
	)		const

inherited

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

Definition at line 794 of file function_internal.cpp.

                                                                                      {
     // Set up output stream
     auto of_ptr = Filesystem::ofstream_ptr(fname);
     std::ostream& of = *of_ptr;
     normalized_setup(of);
  
     // Encode each input
     for (casadi_int i=0; i<n_in_; ++i) {
       const double* v = arg[i];
       for (casadi_int k=0;k<nnz_in(i);++k) {
         normalized_out(of, v ? v[k] : 0);
         of << std::endl;
       }
     }
   }

References casadi::FunctionInternal::n_in_, casadi::FunctionInternal::nnz_in(), casadi::normalized_out(), casadi::normalized_setup(), and casadi::Filesystem::ofstream_ptr().

◆ generate_lifted()

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

overridevirtual

(see Albersmeyer2010 paper)

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1479 of file mx_function.cpp.

                                                                                 {
     std::vector<MX> swork(workloc_.size()-1);
  
     std::vector<MX> arg1, res1;
  
     // Get input primitives
     std::vector<std::vector<MX> > in_split(in_.size());
     for (casadi_int i=0; i<in_.size(); ++i) in_split[i] = in_[i].primitives();
  
     // Definition of intermediate variables
     std::vector<MX> y;
     std::vector<MX> g;
     std::vector<std::vector<MX> > f_G(out_.size());
     for (casadi_int i=0; i<out_.size(); ++i) f_G[i].resize(out_[i].n_primitives());
  
     // Initial guess for intermediate variables
     std::vector<MX> x_init;
  
     // Temporary std::stringstream
     std::stringstream ss;
  
     for (casadi_int algNo=0; algNo<2; ++algNo) {
       for (auto&& e : algorithm_) {
         switch (e.op) {
         case OP_LIFT:
           {
             MX& arg = swork[e.arg.at(0)];
             MX& arg_init = swork[e.arg.at(1)];
             MX& res = swork[e.res.front()];
             switch (algNo) {
             case 0:
               ss.str(std::string());
               ss << "y" << y.size();
               y.push_back(MX::sym(ss.str(), arg.sparsity()));
               g.push_back(arg);
               res = y.back();
               break;
             case 1:
               x_init.push_back(arg_init);
               res = arg_init;
               break;
             }
             break;
           }
         case OP_INPUT:
           swork[e.res.front()] = in_split.at(e.data->ind()).at(e.data->segment());
           break;
         case OP_PARAMETER:
           swork[e.res.front()] = e.data;
           break;
         case OP_OUTPUT:
           if (algNo==0) {
             f_G.at(e.data->ind()).at(e.data->segment()) = swork[e.arg.front()];
           }
           break;
         default:
           {
             // Arguments of the operation
             arg1.resize(e.arg.size());
             for (casadi_int i=0; i<arg1.size(); ++i) {
               casadi_int el = e.arg[i]; // index of the argument
               arg1[i] = el<0 ? MX(e.data->dep(i).size()) : swork[el];
             }
  
             // Perform the operation
             res1.resize(e.res.size());
             e.data->eval_mx(arg1, res1);
  
             // Get the result
             for (casadi_int i=0; i<res1.size(); ++i) {
               casadi_int el = e.res[i]; // index of the output
               if (el>=0) swork[el] = res1[i];
             }
           }
         }
       }
     }
  
     // Definition of intermediate variables
     std::vector<MX> f_in = in_;
     f_in.insert(f_in.end(), y.begin(), y.end());
     std::vector<MX> f_out;
     for (casadi_int i=0; i<out_.size(); ++i) f_out.push_back(out_[i].join_primitives(f_G[i]));
     f_out.insert(f_out.end(), g.begin(), g.end());
     vdef_fcn = Function("lifting_variable_definition", f_in, f_out);
  
     // Initial guess of intermediate variables
     f_in = in_;
     f_out = x_init;
     vinit_fcn = Function("lifting_variable_guess", f_in, f_out);
   }

References algorithm_, casadi::FunctionInternal::Function, casadi::XFunction< MXFunction, MX, MXNode >::in_, casadi::OP_INPUT, casadi::OP_LIFT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::XFunction< MXFunction, MX, MXNode >::out_, casadi::GenericMatrix< MatType >::size(), casadi::MX::sparsity(), casadi::GenericMatrix< MX >::sym(), and workloc_.

◆ generate_options()

Dict casadi::MXFunction::generate_options ( const std::string & target = "clone" ) const

overridevirtual

Reimplemented from casadi::FunctionInternal.

Definition at line 82 of file mx_function.cpp.

                                                                  {
     Dict opts = FunctionInternal::generate_options(target);
     opts["dump_trace"] = dump_trace_;
     if (target=="clone") opts["default_in"] = default_in_;
     opts["live_variables"] = live_variables_;
     opts["print_instructions"] = print_instructions_;
     return opts;
   }

References default_in_, dump_trace_, casadi::FunctionInternal::generate_options(), live_variables_, and print_instructions_.

◆ generate_out()

void casadi::FunctionInternal::generate_out	(	const std::string &	fname,
		double **	res
	)		const

inherited

Definition at line 810 of file function_internal.cpp.

                                                                                 {
     // Set up output stream
     auto of_ptr = Filesystem::ofstream_ptr(fname);
     std::ostream& of = *of_ptr;
     normalized_setup(of);
  
     // Encode each input
     for (casadi_int i=0; i<n_out_; ++i) {
       const double* v = res[i];
       for (casadi_int k=0;k<nnz_out(i);++k) {
         normalized_out(of, v ? v[k] : std::numeric_limits<double>::quiet_NaN());
         of << std::endl;
       }
     }
   }

References casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_out(), casadi::normalized_out(), casadi::normalized_setup(), and casadi::Filesystem::ofstream_ptr().

◆ get_abstol()

virtual double casadi::FunctionInternal::get_abstol ( ) const

inlinevirtualinherited

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

Reimplemented in casadi::SundialsInterface, casadi::Smoothing, casadi::CentralDiff, and casadi::ForwardDiff.

Definition at line 1135 of file function_internal.hpp.

                                       {
       return eps;
     }

References casadi::eps.

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

◆ get_default_in()

double casadi::MXFunction::get_default_in ( casadi_int ind ) const

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 322 of file mx_function.hpp.

322 { return default_in_.at(ind);}

◆ get_diff_in()

virtual bool casadi::FunctionInternal::get_diff_in ( casadi_int i )

inlinevirtualinherited

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

Reimplemented in casadi::BSplineInterpolant, casadi::Interpolant, casadi::GenericExternal, casadi::Expm, and casadi::BlazingSplineFunction.

Definition at line 1152 of file function_internal.hpp.

1152 { return true; }

Referenced by casadi::GenericExternal::get_diff_in(), and casadi::FunctionInternal::init().

◆ get_diff_out()

virtual bool casadi::FunctionInternal::get_diff_out ( casadi_int i )

inlinevirtualinherited

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

Reimplemented in casadi::GenericExternal.

Definition at line 1157 of file function_internal.hpp.

1157 { return true; }

Referenced by casadi::GenericExternal::get_diff_out(), and casadi::FunctionInternal::init().

◆ get_forward()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 129 of file x_function.hpp.

                                         {
     try {
       // Seeds
       std::vector<std::vector<MatType> > fseed = fwd_seed<MatType>(nfwd), fsens;
  
       // Evaluate symbolically
       static_cast<const DerivedType*>(this)->ad_forward(fseed, fsens);
       casadi_assert_dev(fsens.size()==fseed.size());
  
       // All inputs of the return function
       std::vector<MatType> ret_in(inames.size());
       std::copy(in_.begin(), in_.end(), ret_in.begin());
       for (casadi_int i=0; i<n_out_; ++i) {
         ret_in.at(n_in_+i) = MatType::sym(inames[n_in_+i], Sparsity(out_.at(i).size()));
       }
       std::vector<MatType> v(nfwd);
       for (casadi_int i=0; i<n_in_; ++i) {
         for (casadi_int d=0; d<nfwd; ++d) v[d] = fseed[d][i];
         ret_in.at(n_in_ + n_out_ + i) = horzcat(v);
       }
  
       // All outputs of the return function
       std::vector<MatType> ret_out(onames.size());
       for (casadi_int i=0; i<n_out_; ++i) {
         if (is_diff_out_[i]) {
           // Concatenate sensitivities, correct sparsity pattern if needed
           for (casadi_int d=0; d<nfwd; ++d) v[d] = fsens[d][i];
           ret_out.at(i) = ensure_stacked(horzcat(v), sparsity_out(i), nfwd);
         } else {
           // Output is non-differentable
           ret_out.at(i) = MatType(size1_out(i), size2_out(i) * nfwd);
         }
       }
  
       Dict options = opts;
       options["allow_duplicate_io_names"] = true;
       // Assemble function and return
       return Function(name, ret_in, ret_out, inames, onames, options);
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("get_forward", e.what());
     }
   }

◆ get_free()

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

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 286 of file mx_function.hpp.

                                                    {
       std::vector<std::string> ret;
       for (auto&& e : free_vars_) ret.push_back(e.name());
       return ret;
     }

Referenced by init().

◆ get_function() [1/2]

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 729 of file mx_function.cpp.

                                                       {
     std::map<std::string, bool> flagged;
     for (auto it=algorithm_.begin(); it!=algorithm_.end(); it++) {
       if (it->op==OP_CALL) {
         const Function &f = it->data->which_function();
         if (flagged.find(f.name())==flagged.end()) {
           flagged[f.name()] = true;
         }
       }
     }
     std::vector<std::string> ret;
     for (auto it : flagged) {
       ret.push_back(it.first);
     }
     return ret;
   }

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

◆ get_function() [2/2]

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 746 of file mx_function.cpp.

                                                                       {
     for (auto it=algorithm_.begin(); it!=algorithm_.end(); it++) {
       if (it->op==OP_CALL) {
         const Function &f = it->data->which_function();
         if (name==f.name()) return f;
       }
     }
     casadi_error("No such function '" + name + "'.");
   }

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

◆ get_jac_sparsity()

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

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kz Get, if necessary generate, the sparsity of a Jacobian block

Reimplemented in casadi::FmuFunction, casadi::GenericExternal, casadi::Expm, and casadi::CallbackInternal.

Definition at line 1986 of file function_internal.cpp.

                             {
     if (symmetric) {
       casadi_assert(sparsity_out_[oind].is_dense(),
         "Symmetry exploitation in Jacobian assumes dense expression. "
         "A potential workaround is to apply densify().");
     }
     // Check if we are able to propagate dependencies through the function
     if (has_spfwd() || has_sprev()) {
       // Get weighting factor
       double w = sp_weight();
  
       // Skip generation, assume dense
       if (w == -1) return Sparsity();
  
       Sparsity sp;
       if (nnz_in(iind) > 3*bvec_size && nnz_out(oind) > 3*bvec_size &&
             GlobalOptions::hierarchical_sparsity) {
         if (symmetric) {
           sp = get_jac_sparsity_hierarchical_symm(oind, iind);
         } else {
           sp = get_jac_sparsity_hierarchical(oind, iind);
         }
       } else {
         // Number of nonzero inputs and outputs
         casadi_int nz_in = nnz_in(iind);
         casadi_int nz_out = nnz_out(oind);
  
         // Number of forward sweeps we must make
         casadi_int nsweep_fwd = nz_in/bvec_size;
         if (nz_in%bvec_size) nsweep_fwd++;
  
         // Number of adjoint sweeps we must make
         casadi_int nsweep_adj = nz_out/bvec_size;
         if (nz_out%bvec_size) nsweep_adj++;
  
         // Use forward mode?
         if (w*static_cast<double>(nsweep_fwd) <= (1-w)*static_cast<double>(nsweep_adj)) {
           sp = get_jac_sparsity_gen<true>(oind, iind);
         } else {
           sp = get_jac_sparsity_gen<false>(oind, iind);
         }
       }
       return sp;
     } else {
       // Not calculated
       return Sparsity();
     }
   }

Referenced by casadi::Expm::get_jac_sparsity(), casadi::GenericExternal::get_jac_sparsity(), and casadi::FunctionInternal::jac_sparsity().

◆ get_jac_sparsity_gen()

template<bool fwd>

Sparsity casadi::FunctionInternal::get_jac_sparsity_gen	(	casadi_int	oind,
		casadi_int	iind
	)		const

inherited

Definition at line 1331 of file function_internal.cpp.

                                                                                         {
     // Number of nonzero inputs and outputs
     casadi_int nz_in = nnz_in(iind);
     casadi_int nz_out = nnz_out(oind);
  
     // Evaluation buffers
     std::vector<typename JacSparsityTraits<fwd>::arg_t> arg(sz_arg(), nullptr);
     std::vector<bvec_t*> res(sz_res(), nullptr);
     std::vector<casadi_int> iw(sz_iw());
     std::vector<bvec_t> w(sz_w(), 0);
  
     // Seeds and sensitivities
     std::vector<bvec_t> seed(nz_in, 0);
     arg[iind] = get_ptr(seed);
     std::vector<bvec_t> sens(nz_out, 0);
     res[oind] = get_ptr(sens);
     if (!fwd) std::swap(seed, sens);
  
     // Number of forward sweeps we must make
     casadi_int nsweep = seed.size() / bvec_size;
     if (seed.size() % bvec_size) nsweep++;
  
     // Print
     if (verbose_) {
       casadi_message(str(nsweep) + std::string(fwd ? " forward" : " reverse") + " sweeps "
                      "needed for " + str(seed.size()) + " directions");
     }
  
     // Progress
     casadi_int progress = -10;
  
     // Temporary vectors
     std::vector<casadi_int> jcol, jrow;
  
     // Loop over the variables, bvec_size variables at a time
     for (casadi_int s=0; s<nsweep; ++s) {
  
       // Print progress
       if (verbose_) {
         casadi_int progress_new = (s*100)/nsweep;
         // Print when entering a new decade
         if (progress_new / 10 > progress / 10) {
           progress = progress_new;
           casadi_message(str(progress) + " %");
         }
       }
  
       // Nonzero offset
       casadi_int offset = s*bvec_size;
  
       // Number of local seed directions
       casadi_int ndir_local = seed.size()-offset;
       ndir_local = std::min(static_cast<casadi_int>(bvec_size), ndir_local);
  
       for (casadi_int i=0; i<ndir_local; ++i) {
         seed[offset+i] |= bvec_t(1)<<i;
       }
  
       // Propagate the dependencies
       JacSparsityTraits<fwd>::sp(this, get_ptr(arg), get_ptr(res),
                                   get_ptr(iw), get_ptr(w), memory(0));
  
       // Loop over the nonzeros of the output
       for (casadi_int el=0; el<sens.size(); ++el) {
  
         // Get the sparsity sensitivity
         bvec_t spsens = sens[el];
  
         if (!fwd) {
           // Clear the sensitivities for the next sweep
           sens[el] = 0;
         }
  
         // If there is a dependency in any of the directions
         if (spsens!=0) {
  
           // Loop over seed directions
           for (casadi_int i=0; i<ndir_local; ++i) {
  
             // If dependents on the variable
             if ((bvec_t(1) << i) & spsens) {
               // Add to pattern
               jcol.push_back(el);
               jrow.push_back(i+offset);
             }
           }
         }
       }
  
       // Remove the seeds
       for (casadi_int i=0; i<ndir_local; ++i) {
         seed[offset+i] = 0;
       }
     }
  
     // Construct sparsity pattern and return
     if (!fwd) swap(jrow, jcol);
     Sparsity ret = Sparsity::triplet(nz_out, nz_in, jcol, jrow);
     if (verbose_) {
       casadi_message("Formed Jacobian sparsity pattern (dimension " + str(ret.size()) + ", "
           + str(ret.nnz()) + " (" + str(ret.density()) + " %) nonzeros.");
     }
     return ret;
   }

◆ get_jac_sparsity_hierarchical()

Sparsity casadi::FunctionInternal::get_jac_sparsity_hierarchical	(	casadi_int	oind,
		casadi_int	iind
	)		const

inherited

Decide which ad_mode to take

Definition at line 1671 of file function_internal.cpp.

                                                                                                  {
     // Number of nonzero inputs
     casadi_int nz_in = nnz_in(iind);
  
     // Number of nonzero outputs
     casadi_int nz_out = nnz_out(oind);
  
     // Seeds and sensitivities
     std::vector<bvec_t> s_in(nz_in, 0);
     std::vector<bvec_t> s_out(nz_out, 0);
  
     // Evaluation buffers
     std::vector<const bvec_t*> arg_fwd(sz_arg(), nullptr);
     std::vector<bvec_t*> arg_adj(sz_arg(), nullptr);
     arg_fwd[iind] = arg_adj[iind] = get_ptr(s_in);
     std::vector<bvec_t*> res(sz_res(), nullptr);
     res[oind] = get_ptr(s_out);
     std::vector<casadi_int> iw(sz_iw());
     std::vector<bvec_t> w(sz_w());
  
     // Sparsity triplet accumulator
     std::vector<casadi_int> jcol, jrow;
  
     // Cols of the coarse blocks
     std::vector<casadi_int> coarse_col(2, 0); coarse_col[1] = nz_out;
     // Rows of the coarse blocks
     std::vector<casadi_int> coarse_row(2, 0); coarse_row[1] = nz_in;
  
     // Cols of the fine blocks
     std::vector<casadi_int> fine_col;
  
     // Rows of the fine blocks
     std::vector<casadi_int> fine_row;
  
     // In each iteration, subdivide each coarse block in this many fine blocks
     casadi_int subdivision = bvec_size;
  
     Sparsity r = Sparsity::dense(1, 1);
  
     // The size of a block
     casadi_int granularity_row = nz_in;
     casadi_int granularity_col = nz_out;
  
     bool use_fwd = true;
  
     casadi_int nsweeps = 0;
  
     bool hasrun = false;
  
     // Get weighting factor
     double sp_w = sp_weight();
  
     // Lookup table for bvec_t
     std::vector<bvec_t> bvec_lookup;
     bvec_lookup.reserve(bvec_size);
     for (casadi_int i=0;i<bvec_size;++i) {
       bvec_lookup.push_back(bvec_t(1) << i);
     }
  
     while (!hasrun || coarse_col.size()!=nz_out+1 || coarse_row.size()!=nz_in+1) {
       if (verbose_) {
         casadi_message("Block size: " + str(granularity_col) + " x " + str(granularity_row));
       }
  
       // Clear the sparsity triplet acccumulator
       jcol.clear();
       jrow.clear();
  
       // Clear the fine block structure
       fine_row.clear();
       fine_col.clear();
  
       // r transpose will be needed in the algorithm
       Sparsity rT = r.T();
  
       // Forward mode
       Sparsity D1 = rT.uni_coloring(r);
       // Adjoint mode
       Sparsity D2 = r.uni_coloring(rT);
       if (verbose_) {
         casadi_message("Coloring on " + str(r.dim()) + " (fwd seeps: " + str(D1.size2()) +
                  " , adj sweeps: " + str(D2.size1()) + ")");
       }
  
       // Use whatever required less colors if we tried both (with preference to forward mode)
       double fwd_cost = static_cast<double>(use_fwd ? granularity_row : granularity_col) *
         sp_w*static_cast<double>(D1.size2());
       double adj_cost = static_cast<double>(use_fwd ? granularity_col : granularity_row) *
         (1-sp_w)*static_cast<double>(D2.size2());
       use_fwd = fwd_cost <= adj_cost;
       if (verbose_) {
         casadi_message(std::string(use_fwd ? "Forward" : "Reverse") + " mode chosen "
             "(fwd cost: " + str(fwd_cost) + ", adj cost: " + str(adj_cost) + ")");
       }
  
       // Get seeds and sensitivities
       bvec_t* seed_v = use_fwd ? get_ptr(s_in) : get_ptr(s_out);
       bvec_t* sens_v = use_fwd ? get_ptr(s_out) : get_ptr(s_in);
  
       // The number of zeros in the seed and sensitivity directions
       casadi_int nz_seed = use_fwd ? nz_in  : nz_out;
       casadi_int nz_sens = use_fwd ? nz_out : nz_in;
  
       // Clear the seeds
       for (casadi_int i=0; i<nz_seed; ++i) seed_v[i]=0;
  
       // Choose the active jacobian coloring scheme
       Sparsity D = use_fwd ? D1 : D2;
  
       // Adjoint mode amounts to swapping
       if (!use_fwd) {
         std::swap(coarse_col, coarse_row);
         std::swap(granularity_col, granularity_row);
         std::swap(r, rT);
       }
  
       // Subdivide the coarse block cols
       for (casadi_int k=0;k<coarse_col.size()-1;++k) {
         casadi_int diff = coarse_col[k+1]-coarse_col[k];
         casadi_int new_diff = diff/subdivision;
         if (diff%subdivision>0) new_diff++;
         std::vector<casadi_int> temp = range(coarse_col[k], coarse_col[k+1], new_diff);
         fine_col.insert(fine_col.end(), temp.begin(), temp.end());
       }
       // Subdivide the coarse block rows
       for (casadi_int k=0;k<coarse_row.size()-1;++k) {
         casadi_int diff = coarse_row[k+1]-coarse_row[k];
         casadi_int new_diff = diff/subdivision;
         if (diff%subdivision>0) new_diff++;
         std::vector<casadi_int> temp = range(coarse_row[k], coarse_row[k+1], new_diff);
         fine_row.insert(fine_row.end(), temp.begin(), temp.end());
       }
       if (fine_row.back()!=coarse_row.back()) fine_row.push_back(coarse_row.back());
       if (fine_col.back()!=coarse_col.back()) fine_col.push_back(coarse_col.back());
  
       granularity_col = fine_col[1] - fine_col[0];
       granularity_row = fine_row[1] - fine_row[0];
  
       // The index into the bvec bit vector
       casadi_int bvec_i = 0;
  
       // Create lookup tables for the fine blocks
       std::vector<casadi_int> fine_col_lookup = lookupvector(fine_col, nz_sens+1);
       std::vector<casadi_int> fine_row_lookup = lookupvector(fine_row, nz_seed+1);
  
       // Triplet data used as a lookup table
       std::vector<casadi_int> lookup_col;
       std::vector<casadi_int> lookup_row;
       std::vector<casadi_int> lookup_value;
  
  
       // The maximum number of fine blocks contained in one coarse block
       casadi_int n_fine_blocks_max = 0;
       for (casadi_int i=0;i<coarse_row.size()-1;++i) {
         casadi_int del = fine_row_lookup[coarse_row[i+1]]-fine_row_lookup[coarse_row[i]];
         n_fine_blocks_max = std::max(n_fine_blocks_max, del);
       }
  
       // Loop over all coarse seed directions from the coloring
       for (casadi_int csd=0; csd<D.size2(); ++csd) {
  
         casadi_int fci_offset = 0;
         casadi_int fci_cap = bvec_size-bvec_i;
  
         // Flag to indicate if all fine blocks have been handled
         bool f_finished = false;
  
         // Loop while not finished
         while (!f_finished) {
  
           // Loop over all coarse rows that are found in the coloring for this coarse seed direction
           for (casadi_int k=D.colind(csd); k<D.colind(csd+1); ++k) {
             casadi_int cci = D.row(k);
  
             // The first and last rows of the fine block
             casadi_int fci_start = fine_row_lookup[coarse_row[cci]];
             casadi_int fci_end   = fine_row_lookup[coarse_row[cci+1]];
  
             // Local counter that modifies index into bvec
             casadi_int bvec_i_mod = 0;
  
             casadi_int value = -bvec_i + fci_offset + fci_start;
  
             // Loop over the rows of the fine block
             for (casadi_int fci = fci_offset; fci < std::min(fci_end-fci_start, fci_cap); ++fci) {
  
               // Loop over the coarse block cols that appear in the coloring
               // for the current coarse seed direction
               for (casadi_int cri=rT.colind(cci);cri<rT.colind(cci+1);++cri) {
                 lookup_col.push_back(rT.row(cri));
                 lookup_row.push_back(bvec_i+bvec_i_mod);
                 lookup_value.push_back(value);
               }
  
               // Toggle on seeds
               bvec_toggle(seed_v, fine_row[fci+fci_start], fine_row[fci+fci_start+1],
                           bvec_i+bvec_i_mod);
               bvec_i_mod++;
             }
           }
  
           // Bump bvec_i for next major coarse direction
           bvec_i+= std::min(n_fine_blocks_max, fci_cap);
  
           // Check if bvec buffer is full
           if (bvec_i==bvec_size || csd==D.size2()-1) {
             // Calculate sparsity for bvec_size directions at once
  
             // Statistics
             nsweeps+=1;
  
             // Construct lookup table
             IM lookup = IM::triplet(lookup_row, lookup_col, lookup_value, bvec_size,
                                     coarse_col.size());
  
             // Propagate the dependencies
             if (use_fwd) {
               JacSparsityTraits<true>::sp(this, get_ptr(arg_fwd), get_ptr(res),
                 get_ptr(iw), get_ptr(w), memory(0));
             } else {
               std::fill(w.begin(), w.end(), 0);
               JacSparsityTraits<false>::sp(this, get_ptr(arg_adj), get_ptr(res),
                 get_ptr(iw), get_ptr(w), memory(0));
             }
  
             // Temporary bit work vector
             bvec_t spsens;
  
             // Loop over the cols of coarse blocks
             for (casadi_int cri=0;cri<coarse_col.size()-1;++cri) {
  
               // Loop over the cols of fine blocks within the current coarse block
               for (casadi_int fri=fine_col_lookup[coarse_col[cri]];
                    fri<fine_col_lookup[coarse_col[cri+1]];++fri) {
                 // Lump individual sensitivities together into fine block
                 bvec_or(sens_v, spsens, fine_col[fri], fine_col[fri+1]);
  
                 // Next iteration if no sparsity
                 if (!spsens) continue;
  
                 // Loop over all bvec_bits
                 for (casadi_int bvec_i=0;bvec_i<bvec_size;++bvec_i) {
                   if (spsens & bvec_lookup[bvec_i]) {
                     // if dependency is found, add it to the new sparsity pattern
                     casadi_int ind = lookup.sparsity().get_nz(bvec_i, cri);
                     if (ind==-1) continue;
                     jrow.push_back(bvec_i+lookup->at(ind));
                     jcol.push_back(fri);
                   }
                 }
               }
             }
  
             // Clear the forward seeds/adjoint sensitivities, ready for next bvec sweep
             std::fill(s_in.begin(), s_in.end(), 0);
  
             // Clear the adjoint seeds/forward sensitivities, ready for next bvec sweep
             std::fill(s_out.begin(), s_out.end(), 0);
  
             // Clean lookup table
             lookup_col.clear();
             lookup_row.clear();
             lookup_value.clear();
           }
  
           if (n_fine_blocks_max>fci_cap) {
             fci_offset += std::min(n_fine_blocks_max, fci_cap);
             bvec_i = 0;
             fci_cap = bvec_size;
           } else {
             f_finished = true;
           }
  
         }
  
       }
  
       // Swap results if adjoint mode was used
       if (use_fwd) {
         // Construct fine sparsity pattern
         r = Sparsity::triplet(fine_row.size()-1, fine_col.size()-1, jrow, jcol);
         coarse_col = fine_col;
         coarse_row = fine_row;
       } else {
         // Construct fine sparsity pattern
         r = Sparsity::triplet(fine_col.size()-1, fine_row.size()-1, jcol, jrow);
         coarse_col = fine_row;
         coarse_row = fine_col;
       }
       hasrun = true;
     }
     if (verbose_) {
       casadi_message("Number of sweeps: " + str(nsweeps));
       casadi_message("Formed Jacobian sparsity pattern (dimension " + str(r.size()) + ", " +
           str(r.nnz()) + " (" + str(r.density()) + " %) nonzeros.");
     }
  
     return r.T();
   }

Referenced by casadi::FunctionInternal::get_jac_sparsity().

◆ get_jac_sparsity_hierarchical_symm()

Sparsity casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm	(	casadi_int	oind,
		casadi_int	iind
	)		const

inherited

A flavor of get_jac_sparsity_gen that does hierarchical block structure recognition for symmetric Jacobians

Definition at line 1436 of file function_internal.cpp.

                              {
     casadi_assert_dev(has_spfwd());
  
     // Number of nonzero inputs
     casadi_int nz = nnz_in(iind);
     casadi_assert_dev(nz==nnz_out(oind));
  
     // Evaluation buffers
     std::vector<const bvec_t*> arg(sz_arg(), nullptr);
     std::vector<bvec_t*> res(sz_res(), nullptr);
     std::vector<casadi_int> iw(sz_iw());
     std::vector<bvec_t> w(sz_w());
  
     // Seeds
     std::vector<bvec_t> seed(nz, 0);
     arg[iind] = get_ptr(seed);
  
     // Sensitivities
     std::vector<bvec_t> sens(nz, 0);
     res[oind] = get_ptr(sens);
  
     // Sparsity triplet accumulator
     std::vector<casadi_int> jcol, jrow;
  
     // Cols/rows of the coarse blocks
     std::vector<casadi_int> coarse(2, 0); coarse[1] = nz;
  
     // Cols/rows of the fine blocks
     std::vector<casadi_int> fine;
  
     // In each iteration, subdivide each coarse block in this many fine blocks
     casadi_int subdivision = bvec_size;
  
     Sparsity r = Sparsity::dense(1, 1);
  
     // The size of a block
     casadi_int granularity = nz;
  
     casadi_int nsweeps = 0;
  
     bool hasrun = false;
  
     while (!hasrun || coarse.size()!=nz+1) {
       if (verbose_) casadi_message("Block size: " + str(granularity));
  
       // Clear the sparsity triplet acccumulator
       jcol.clear();
       jrow.clear();
  
       // Clear the fine block structure
       fine.clear();
  
       Sparsity D = r.star_coloring();
  
       if (verbose_) {
         casadi_message("Star coloring on " + str(r.dim()) + ": "
           + str(D.size2()) + " <-> " + str(D.size1()));
       }
  
       // Clear the seeds
       std::fill(seed.begin(), seed.end(), 0);
  
       // Subdivide the coarse block
       for (casadi_int k=0; k<coarse.size()-1; ++k) {
         casadi_int diff = coarse[k+1]-coarse[k];
         casadi_int new_diff = diff/subdivision;
         if (diff%subdivision>0) new_diff++;
         std::vector<casadi_int> temp = range(coarse[k], coarse[k+1], new_diff);
         fine.insert(fine.end(), temp.begin(), temp.end());
       }
       if (fine.back()!=coarse.back()) fine.push_back(coarse.back());
  
       granularity = fine[1] - fine[0];
  
       // The index into the bvec bit vector
       casadi_int bvec_i = 0;
  
       // Create lookup tables for the fine blocks
       std::vector<casadi_int> fine_lookup = lookupvector(fine, nz+1);
  
       // Triplet data used as a lookup table
       std::vector<casadi_int> lookup_col;
       std::vector<casadi_int> lookup_row;
       std::vector<casadi_int> lookup_value;
  
       // The maximum number of fine blocks contained in one coarse block
       casadi_int n_fine_blocks_max = 0;
       for (casadi_int i=0;i<coarse.size()-1;++i) {
         casadi_int del = fine_lookup[coarse[i+1]]-fine_lookup[coarse[i]];
         n_fine_blocks_max = std::max(n_fine_blocks_max, del);
       }
  
       // Loop over all coarse seed directions from the coloring
       for (casadi_int csd=0; csd<D.size2(); ++csd) {
  
  
         casadi_int fci_offset = 0;
         casadi_int fci_cap = bvec_size-bvec_i;
  
         // Flag to indicate if all fine blocks have been handled
         bool f_finished = false;
  
         // Loop while not finished
         while (!f_finished) {
  
           // Loop over all coarse rows that are found in the coloring for this coarse seed direction
           for (casadi_int k=D.colind(csd); k<D.colind(csd+1); ++k) {
             casadi_int cci = D.row(k);
  
             // The first and last rows of the fine block
             casadi_int fci_start = fine_lookup[coarse[cci]];
             casadi_int fci_end   = fine_lookup[coarse[cci+1]];
  
             // Local counter that modifies index into bvec
             casadi_int bvec_i_mod = 0;
  
             casadi_int value = -bvec_i + fci_offset + fci_start;
  
             //casadi_assert_dev(value>=0);
  
             // Loop over the rows of the fine block
             for (casadi_int fci = fci_offset; fci<std::min(fci_end-fci_start, fci_cap); ++fci) {
  
               // Loop over the coarse block cols that appear in the
               // coloring for the current coarse seed direction
               for (casadi_int cri=r.colind(cci);cri<r.colind(cci+1);++cri) {
                 lookup_col.push_back(r.row(cri));
                 lookup_row.push_back(bvec_i+bvec_i_mod);
                 lookup_value.push_back(value);
               }
  
               // Toggle on seeds
               bvec_toggle(get_ptr(seed), fine[fci+fci_start], fine[fci+fci_start+1],
                           bvec_i+bvec_i_mod);
               bvec_i_mod++;
             }
           }
  
           // Bump bvec_i for next major coarse direction
           bvec_i += std::min(n_fine_blocks_max, fci_cap);
  
           // Check if bvec buffer is full
           if (bvec_i==bvec_size || csd==D.size2()-1) {
             // Calculate sparsity for bvec_size directions at once
  
             // Statistics
             nsweeps+=1;
  
             // Construct lookup table
             IM lookup = IM::triplet(lookup_row, lookup_col, lookup_value,
                                     bvec_size, coarse.size());
  
             std::reverse(lookup_col.begin(), lookup_col.end());
             std::reverse(lookup_row.begin(), lookup_row.end());
             std::reverse(lookup_value.begin(), lookup_value.end());
             IM duplicates =
               IM::triplet(lookup_row, lookup_col, lookup_value, bvec_size, coarse.size())
               - lookup;
             duplicates = sparsify(duplicates);
             lookup(duplicates.sparsity()) = -bvec_size;
  
             // Propagate the dependencies
             JacSparsityTraits<true>::sp(this, get_ptr(arg), get_ptr(res),
               get_ptr(iw), get_ptr(w), nullptr);
  
             // Temporary bit work vector
             bvec_t spsens;
  
             // Loop over the cols of coarse blocks
             for (casadi_int cri=0; cri<coarse.size()-1; ++cri) {
  
               // Loop over the cols of fine blocks within the current coarse block
               for (casadi_int fri=fine_lookup[coarse[cri]];fri<fine_lookup[coarse[cri+1]];++fri) {
                 // Lump individual sensitivities together into fine block
                 bvec_or(get_ptr(sens), spsens, fine[fri], fine[fri+1]);
  
                 // Loop over all bvec_bits
                 for (casadi_int bvec_i=0;bvec_i<bvec_size;++bvec_i) {
                   if (spsens & (bvec_t(1) << bvec_i)) {
                     // if dependency is found, add it to the new sparsity pattern
                     casadi_int ind = lookup.sparsity().get_nz(bvec_i, cri);
                     if (ind==-1) continue;
                     casadi_int lk = lookup->at(ind);
                     if (lk>-bvec_size) {
                       jrow.push_back(bvec_i+lk);
                       jcol.push_back(fri);
                       jrow.push_back(fri);
                       jcol.push_back(bvec_i+lk);
                     }
                   }
                 }
               }
             }
  
             // Clear the forward seeds/adjoint sensitivities, ready for next bvec sweep
             std::fill(seed.begin(), seed.end(), 0);
  
             // Clean lookup table
             lookup_col.clear();
             lookup_row.clear();
             lookup_value.clear();
           }
  
           if (n_fine_blocks_max>fci_cap) {
             fci_offset += std::min(n_fine_blocks_max, fci_cap);
             bvec_i = 0;
             fci_cap = bvec_size;
           } else {
             f_finished = true;
           }
         }
       }
  
       // Construct fine sparsity pattern
       r = Sparsity::triplet(fine.size()-1, fine.size()-1, jrow, jcol);
  
       // There may be false positives here that are not present
       // in the reverse mode that precedes it.
       // This can lead to an assymetrical result
       //  cf. #1522
       r=r*r.T();
  
       coarse = fine;
       hasrun = true;
     }
     if (verbose_) {
       casadi_message("Number of sweeps: " + str(nsweeps));
       casadi_message("Formed Jacobian sparsity pattern (dimension " + str(r.size()) +
           ", " + str(r.nnz()) + " (" + str(r.density()) + " %) nonzeros.");
     }
  
     return r.T();
   }

Referenced by casadi::FunctionInternal::get_jac_sparsity().

◆ get_jacobian()

Function casadi::XFunction< MXFunction , MX , MXNode >::get_jacobian	(	const std::string &	name,
		const std::vector< std::string > &	inames,
		const std::vector< std::string > &	onames,
		const Dict &	opts
	)		const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 151 of file x_function.hpp.

                                          {
     try {
       // Select only differentiable inputs and outputs
       std::vector<MatType> diff_in = vector_select(in_, is_diff_in_);
       std::vector<MatType> diff_out = vector_select(out_, is_diff_out_);
  
       std::vector<MatType> non_diff_in = vector_select(in_, is_diff_in_, true);
  
       // Create flattened function with only differentiable inputs/outputs
       Dict tmp_options = generate_options("tmp");
       tmp_options["allow_free"] = true;
       tmp_options["allow_duplicate_io_names"] = true;
       std::vector<bool> tmp_is_diff = {true};
       if (!non_diff_in.empty()) tmp_is_diff.push_back(false);
  
       tmp_options["is_diff_in"] = tmp_is_diff;
       std::vector<MatType> tmp_args = {veccat(diff_in)};
       if (!non_diff_in.empty()) tmp_args.push_back(veccat(non_diff_in));
  
       Function tmp("flattened_" + name_, tmp_args, {veccat(diff_out)}, tmp_options);
       // Expression for the Jacobian of differentiable inputs/outputs only
       MatType J = tmp.get<DerivedType>()->jac(Dict()).at(0);
  
       // Split up Jacobian into blocks (only for differentiable inputs/outputs)
       std::vector<casadi_int> r_offset = {0}, c_offset = {0};
       for (auto& e : diff_out) r_offset.push_back(r_offset.back() + e.numel());
       for (auto& e : diff_in) c_offset.push_back(c_offset.back() + e.numel());
       auto Jblocks = MatType::blocksplit(J, r_offset, c_offset);
  
       // Assemble full Jacobian output, inserting zeros for non-differentiable blocks
       std::vector<MatType> ret_out;
       ret_out.reserve(onames.size());
       casadi_int diff_i = 0;
       for (casadi_int i=0; i<n_out_; ++i) {
         casadi_int diff_j = 0;
         for (casadi_int j=0; j<n_in_; ++j) {
           if (is_diff_out_.at(i) && is_diff_in_.at(j)) {
             ret_out.push_back(Jblocks.at(diff_i).at(diff_j));
             diff_j++;
           } else {
             ret_out.push_back(MatType(out_.at(i).numel(), in_.at(j).numel()));
           }
         }
         if (is_diff_out_.at(i)) diff_i++;
       }
  
       // All inputs of the return function
       std::vector<MatType> ret_in(inames.size());
       std::copy(in_.begin(), in_.end(), ret_in.begin());
       for (casadi_int i=0; i<n_out_; ++i) {
         ret_in.at(n_in_+i) = MatType::sym(inames[n_in_+i], Sparsity(out_.at(i).size()));
       }
  
       Dict options = opts;
       options["allow_free"] = true;
       options["allow_duplicate_io_names"] = true;
  
       if (opts.find("is_diff_in")==opts.end()) {
         std::vector<bool> is_diff_in = join(is_diff_in_, is_diff_out_);
         options["is_diff_in"] = is_diff_in;
       }
  
       if (opts.find("is_diff_out")==opts.end()) {
         std::vector<bool> is_diff_out;
         for (casadi_int i=0; i<n_out_; ++i) {
           for (casadi_int j=0; j<n_in_; ++j) {
             is_diff_out.push_back(is_diff_in_[j] && is_diff_out_[i]);
           }
         }
         options["is_diff_out"] = is_diff_out;
       }
  
       // Assemble function and return
       return Function(name, ret_in, ret_out, inames, onames, options);
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("get_jacobian", e.what());
     }
   }

◆ get_jit_directory()

std::string casadi::FunctionInternal::get_jit_directory ( const Dict & jit_options )

staticinherited

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

Definition at line 710 of file function_internal.cpp.

                                                                        {
     // Start with default temp work dir
     std::string jit_directory = GlobalOptions::getTempWorkDir();
  
     // Get user-specified directory
     std::string directory;
     directory = get_from_dict(jit_options, "directory", std::string(""));
  
     // What if directory itself is absolute?
     if (Filesystem::is_absolute(directory)) {
       // Override
       jit_directory = directory;
     } else {
       jit_directory = jit_directory + directory;
       if (Filesystem::is_enabled()) {
         jit_directory = Filesystem::absolute(jit_directory);
       }
     }
  
     return Filesystem::ensure_trailing_slash(jit_directory);
   }

References casadi::Filesystem::absolute(), casadi::Filesystem::ensure_trailing_slash(), casadi::get_from_dict(), casadi::GlobalOptions::getTempWorkDir(), casadi::Filesystem::is_absolute(), and casadi::Filesystem::is_enabled().

Referenced by casadi::FunctionInternal::finalize(), and casadi::ShellCompiler::init().

◆ get_max_in()

virtual double casadi::FunctionInternal::get_max_in ( casadi_int ind ) const

inlinevirtualinherited

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

Definition at line 1106 of file function_internal.hpp.

                                                     {
       return inf;
     }

References casadi::inf.

◆ get_min_in()

virtual double casadi::FunctionInternal::get_min_in ( casadi_int ind ) const

inlinevirtualinherited

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

Definition at line 1113 of file function_internal.hpp.

                                                     {
       return -inf;
     }

References casadi::inf.

◆ get_n_in()

size_t casadi::XFunction< MXFunction , MX , MXNode >::get_n_in ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 237 of file x_function.hpp.

237 { return in_.size(); }

◆ get_n_out()

size_t casadi::XFunction< MXFunction , MX , MXNode >::get_n_out ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 238 of file x_function.hpp.

238 { return out_.size(); }

◆ get_name_in()

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

virtualinherited

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

Reimplemented in casadi::Rootfinder, casadi::OnnxFunction, casadi::Nlpsol, casadi::MapSum, casadi::Map, casadi::Interpolant, casadi::Integrator, casadi::FiniteDiff, casadi::External, casadi::Dple, casadi::Conic, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

Definition at line 673 of file function_internal.cpp.

                                                       {
     if (!derivative_of_.is_null()) {
       std::string n = derivative_of_.name();
       if (name_ == "jac_" + n || name_ == "adj1_" + n) {
         if (i < derivative_of_.n_in()) {
           // Same as nondifferentiated function
           return derivative_of_.name_in(i);
         } else if (i < derivative_of_.n_in() + derivative_of_.n_out()) {
           // Nondifferentiated output
           return "out_" + derivative_of_.name_out(i - derivative_of_.n_in());
         } else {
           // Adjoint seed
           return "adj_" + derivative_of_.name_out(i - derivative_of_.n_in()
             - derivative_of_.n_out());
         }
       }
     }
     // Default name
     return "i" + str(i);
   }

References casadi::FunctionInternal::derivative_of_, casadi::GenericShared< Shared, Internal >::is_null(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name(), casadi::ProtoFunction::name_, casadi::Function::name_in(), casadi::Function::name_out(), and casadi::str().

Referenced by casadi::External::get_name_in(), and casadi::FunctionInternal::init().

◆ get_name_out()

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

virtualinherited

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

Reimplemented in casadi::Rootfinder, casadi::OnnxFunction, casadi::Nlpsol, casadi::MapSum, casadi::Map, casadi::Interpolant, casadi::Integrator, casadi::FiniteDiff, casadi::External, casadi::Dple, casadi::Conic, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

Definition at line 694 of file function_internal.cpp.

                                                        {
     if (!derivative_of_.is_null()) {
       std::string n = derivative_of_.name();
       if (name_ == "jac_" + n) {
         // Jacobian block
         casadi_int oind = i / derivative_of_.n_in(), iind = i % derivative_of_.n_in();
         return "jac_" + derivative_of_.name_out(oind) + "_" + derivative_of_.name_in(iind);
       } else if (name_ == "adj1_" + n) {
         // Adjoint sensitivity
         return "adj_" + derivative_of_.name_in(i);
       }
     }
     // Default name
     return "o" + str(i);
   }

References casadi::FunctionInternal::derivative_of_, casadi::GenericShared< Shared, Internal >::is_null(), casadi::Function::n_in(), casadi::Function::name(), casadi::ProtoFunction::name_, casadi::Function::name_in(), casadi::Function::name_out(), and casadi::str().

Referenced by casadi::External::get_name_out(), and casadi::FunctionInternal::init().

◆ get_nominal_in()

virtual std::vector<double> casadi::FunctionInternal::get_nominal_in ( casadi_int ind ) const

inlinevirtualinherited

Reimplemented in casadi::FmuFunction.

Definition at line 1117 of file function_internal.hpp.

                                                                    {
       return std::vector<double>(nnz_in(ind), 1.);
     }

Referenced by casadi::FmuFunction::get_nominal_in().

◆ get_nominal_out()

virtual std::vector<double> casadi::FunctionInternal::get_nominal_out ( casadi_int ind ) const

inlinevirtualinherited

Reimplemented in casadi::FmuFunction.

Definition at line 1121 of file function_internal.hpp.

                                                                     {
       return std::vector<double>(nnz_out(ind), 1.);
     }

Referenced by casadi::FmuFunction::get_nominal_out().

◆ get_options()

const Options& casadi::MXFunction::get_options ( ) const

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 141 of file mx_function.hpp.

141 { return options_;}

casadi::MXFunction::options_

static const Options options_

Options.

Definition: mx_function.hpp:140

◆ get_partition()

void casadi::FunctionInternal::get_partition	(	casadi_int	iind,
		casadi_int	oind,
		Sparsity &	D1,
		Sparsity &	D2,
		bool	compact,
		bool	symmetric,
		bool	allow_forward,
		bool	allow_reverse
	)		const

inherited

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

Definition at line 2126 of file function_internal.cpp.

                                                                                      {
     if (verbose_) casadi_message(name_ + "::get_partition");
     casadi_assert(allow_forward || allow_reverse, "Inconsistent options");
  
     // Sparsity pattern with transpose
     Sparsity &AT = jac_sparsity(oind, iind, compact, symmetric);
     Sparsity A = symmetric ? AT : AT.T();
  
     // Get seed matrices by graph coloring
     if (symmetric) {
       casadi_assert_dev(enable_forward_ || enable_fd_);
       casadi_assert_dev(allow_forward);
  
       // Star coloring if symmetric
       if (verbose_) casadi_message("FunctionInternal::getPartition star_coloring");
       D1 = A.star_coloring();
       if (verbose_) {
         casadi_message("Star coloring completed: " + str(D1.size2())
           + " directional derivatives needed ("
                  + str(A.size1()) + " without coloring).");
       }
  
     } else {
       casadi_assert_dev(enable_forward_ || enable_fd_ || enable_reverse_);
       // Get weighting factor
       double w = ad_weight();
  
       // Which AD mode?
       if (w==1) allow_forward = false;
       if (w==0) allow_reverse = false;
       casadi_assert(allow_forward || allow_reverse, "Conflicting ad weights");
  
       // Best coloring encountered so far (relatively tight upper bound)
       double best_coloring = std::numeric_limits<double>::infinity();
  
       // Test forward mode first?
       bool test_fwd_first = allow_forward && w*static_cast<double>(A.size1()) <=
         (1-w)*static_cast<double>(A.size2());
       casadi_int mode_fwd = test_fwd_first ? 0 : 1;
  
       // Test both coloring modes
       for (casadi_int mode=0; mode<2; ++mode) {
         // Is this the forward mode?
         bool fwd = mode==mode_fwd;
  
         // Skip?
         if (!allow_forward && fwd) continue;
         if (!allow_reverse && !fwd) continue;
  
         // Perform the coloring
         if (fwd) {
           if (verbose_) casadi_message("Unidirectional coloring (forward mode)");
           bool d = best_coloring>=w*static_cast<double>(A.size1());
           casadi_int max_colorings_to_test =
             d ? A.size1() : static_cast<casadi_int>(floor(best_coloring/w));
           D1 = AT.uni_coloring(A, max_colorings_to_test);
           if (D1.is_null()) {
             if (verbose_) {
               casadi_message("Forward mode coloring interrupted (more than "
                              + str(max_colorings_to_test) + " needed).");
             }
           } else {
             if (verbose_) {
               casadi_message("Forward mode coloring completed: "
                              + str(D1.size2()) + " directional derivatives needed ("
                              + str(A.size1()) + " without coloring).");
             }
             D2 = Sparsity();
             best_coloring = w*static_cast<double>(D1.size2());
           }
         } else {
           if (verbose_) casadi_message("Unidirectional coloring (adjoint mode)");
           bool d = best_coloring>=(1-w)*static_cast<double>(A.size2());
           casadi_int max_colorings_to_test =
             d ? A.size2() : static_cast<casadi_int>(floor(best_coloring/(1-w)));
  
           D2 = A.uni_coloring(AT, max_colorings_to_test);
           if (D2.is_null()) {
             if (verbose_) {
               casadi_message("Adjoint mode coloring interrupted (more than "
                             + str(max_colorings_to_test) + " needed).");
             }
           } else {
             if (verbose_) {
               casadi_message("Adjoint mode coloring completed: "
                              + str(D2.size2()) + " directional derivatives needed ("
                              + str(A.size2()) + " without coloring).");
             }
             D1 = Sparsity();
             best_coloring = (1-w)*static_cast<double>(D2.size2());
           }
         }
       }
  
     }
   }

References casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::enable_fd_, casadi::FunctionInternal::enable_forward_, casadi::FunctionInternal::enable_reverse_, casadi::GenericShared< Shared, Internal >::is_null(), casadi::FunctionInternal::jac_sparsity(), casadi::ProtoFunction::name_, casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::Sparsity::star_coloring(), casadi::str(), casadi::Sparsity::T(), casadi::Sparsity::uni_coloring(), and casadi::ProtoFunction::verbose_.

◆ get_reltol()

virtual double casadi::FunctionInternal::get_reltol ( ) const

inlinevirtualinherited

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

Reimplemented in casadi::SundialsInterface.

Definition at line 1128 of file function_internal.hpp.

                                       {
       return eps;
     }

References casadi::eps.

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

◆ get_reverse()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 140 of file x_function.hpp.

                                         {
     try {
       // Seeds
       std::vector<std::vector<MatType> > aseed = symbolicAdjSeed(nadj, out_), asens;
  
       // Evaluate symbolically
       static_cast<const DerivedType*>(this)->ad_reverse(aseed, asens);
  
       // All inputs of the return function
       std::vector<MatType> ret_in(inames.size());
       std::copy(in_.begin(), in_.end(), ret_in.begin());
       for (casadi_int i=0; i<n_out_; ++i) {
         ret_in.at(n_in_ + i) = MatType::sym(inames[n_in_+i], Sparsity(out_.at(i).size()));
       }
       std::vector<MatType> v(nadj);
       for (casadi_int i=0; i<n_out_; ++i) {
         for (casadi_int d=0; d<nadj; ++d) v[d] = aseed[d][i];
         ret_in.at(n_in_ + n_out_ + i)  = horzcat(v);
       }
  
       // All outputs of the return function
       std::vector<MatType> ret_out(onames.size());
       for (casadi_int i=0; i<n_in_; ++i) {
         if (is_diff_in_[i]) {
           // Concatenate sensitivities, correct sparsity pattern if needed
           for (casadi_int d=0; d<nadj; ++d) v[d] = asens[d][i];
           ret_out.at(i) = ensure_stacked(horzcat(v), sparsity_in(i), nadj);
         } else {
           // Input is non-differentable
           ret_out.at(i) = MatType(size1_in(i), size2_in(i) * nadj);
         }
       }
  
       Dict options = opts;
       options["allow_duplicate_io_names"] = true;
       // Assemble function and return
       return Function(name, ret_in, ret_out, inames, onames, options);
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("get_reverse", e.what());
     }
   }

◆ get_sparsity_in()

Sparsity casadi::XFunction< MXFunction , MX , MXNode >::get_sparsity_in ( casadi_int i )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 245 of file x_function.hpp.

245 { return in_.at(i).sparsity();}

◆ get_sparsity_out()

Sparsity casadi::XFunction< MXFunction , MX , MXNode >::get_sparsity_out ( casadi_int i )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 246 of file x_function.hpp.

246 { return out_.at(i).sparsity();}

◆ get_stats()

Dict casadi::MXFunction::get_stats ( void * mem ) const

overridevirtual

Reimplemented from casadi::FunctionInternal.

Definition at line 1967 of file mx_function.cpp.

                                             {
     Dict stats = XFunction::get_stats(mem);
  
     Function dep;
     for (auto&& e : algorithm_) {
       if (e.op==OP_CALL) {
         Function d = e.data.which_function();
         if (d.is_a("Conic", true) || d.is_a("Nlpsol")) {
           if (!dep.is_null()) return stats;
           dep = d;
         }
       }
     }
     if (dep.is_null()) return stats;
     return dep.stats(1);
   }

References algorithm_, casadi::FunctionInternal::get_stats(), casadi::Function::is_a(), casadi::GenericShared< Shared, Internal >::is_null(), casadi::OP_CALL, and casadi::Function::stats().

◆ getAdaptorSolverName()

virtual std::string casadi::FunctionInternal::getAdaptorSolverName ( ) const

inlinevirtualinherited

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

Definition at line 306 of file function_internal.hpp.

306 { return ""; }

◆ getCount()

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

inherited

Definition at line 60 of file generic_shared_internal.hpp.

                                                                      {
     return static_cast<const Internal*>(this)->count;
   }

◆ has_codegen()

bool casadi::XFunction< MXFunction , MX , MXNode >::has_codegen ( ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 205 of file x_function.hpp.

205 { return true;}

◆ has_derivative()

bool casadi::FunctionInternal::has_derivative ( ) const

inherited

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

Definition at line 3235 of file function_internal.cpp.

                                               {
     return enable_forward_ || enable_reverse_ || enable_jacobian_ || enable_fd_;
   }

References casadi::FunctionInternal::enable_fd_, casadi::FunctionInternal::enable_forward_, casadi::FunctionInternal::enable_jacobian_, and casadi::FunctionInternal::enable_reverse_.

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::forward(), casadi::OnnxFunction::has_forward(), casadi::OnnxFunction::has_jacobian(), casadi::OnnxFunction::has_reverse(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::reverse(), and casadi::OnnxFunction::wrap_derivative().

◆ has_eval_dm()

virtual bool casadi::FunctionInternal::has_eval_dm ( ) const

inlinevirtualinherited

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

Reimplemented in casadi::CallbackInternal.

Definition at line 437 of file function_internal.hpp.

437 { return false;}

Referenced by casadi::FunctionInternal::eval().

◆ has_forward()

bool casadi::XFunction< MXFunction , MX , MXNode >::has_forward ( casadi_int nfwd ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 128 of file x_function.hpp.

128 { return true;}

◆ has_free()

bool casadi::MXFunction::has_free ( ) const

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 281 of file mx_function.hpp.

281 { return !free_vars_.empty();}

Referenced by init(), and should_inline().

◆ has_function()

virtual bool casadi::FunctionInternal::has_function ( const std::string & fname ) const

inlinevirtualinherited

Reimplemented in casadi::OracleFunction, casadi::MapSum, and casadi::Map.

Definition at line 371 of file function_internal.hpp.

371 {return false;}

◆ has_jac_sparsity()

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

inlinevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kz Get, if necessary generate, the sparsity of a Jacobian block

Reimplemented in casadi::FmuFunction, casadi::GenericExternal, casadi::Expm, and casadi::CallbackInternal.

Definition at line 646 of file function_internal.hpp.

646 { return false;}

Referenced by casadi::FunctionInternal::get_sparsity_out(), casadi::GenericExternal::has_jac_sparsity(), and casadi::FunctionInternal::jac_sparsity().

◆ has_jacobian()

bool casadi::XFunction< MXFunction , MX , MXNode >::has_jacobian ( ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 150 of file x_function.hpp.

150 { return true;}

◆ has_memory()

bool casadi::ProtoFunction::has_memory ( int ind ) const

inherited

Definition at line 3912 of file function_internal.cpp.

                                               {
     return ind<mem_.size();
   }

◆ has_option()

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

inherited

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

Definition at line 1113 of file function_internal.cpp.

                                                                    {
     return get_options().find(option_name) != nullptr;
   }

References casadi::Options::find(), and casadi::ProtoFunction::get_options().

◆ has_reverse()

bool casadi::XFunction< MXFunction , MX , MXNode >::has_reverse ( casadi_int nadj ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 139 of file x_function.hpp.

139 { return true;}

◆ has_spfwd()

bool casadi::XFunction< MXFunction , MX , MXNode >::has_spfwd ( ) const

inlineoverridevirtualinherited

Is the class able to propagate seeds through the algorithm?

Reimplemented from casadi::FunctionInternal.

Definition at line 82 of file x_function.hpp.

82 { return true;}

◆ has_sprev()

bool casadi::XFunction< MXFunction , MX , MXNode >::has_sprev ( ) const

inlineoverridevirtualinherited

Is the class able to propagate seeds through the algorithm?

Reimplemented from casadi::FunctionInternal.

Definition at line 83 of file x_function.hpp.

83 { return true;}

◆ incache()

bool casadi::FunctionInternal::incache	(	const std::string &	fname,
		Function &	f,
		const std::string &	suffix = `""`
	)		const

inherited

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

Definition at line 1187 of file function_internal.cpp.

                                      {
     return cache_.incache(fname + ":" + suffix, f);
   }

References casadi::FunctionInternal::cache_.

Referenced by casadi::MapSum::create(), casadi::OracleFunction::create_function(), casadi::FunctionInternal::forward(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::map(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::wrap().

◆ index_in()

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

inlineinherited

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

Definition at line 1162 of file function_internal.hpp.

                                                      {
       for (casadi_int i=0; i<name_in_.size(); ++i) {
         if (name_in_[i]==name) return i;
       }
       casadi_error("FunctionInternal::index_in: could not find entry \""
                    + name + "\". Available names are: " + str(name_in_) + ".");
       return -1;
     }

References casadi::str().

Referenced by casadi::FunctionInternal::convert_arg().

◆ index_out()

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

inlineinherited

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

Definition at line 1174 of file function_internal.hpp.

                                                       {
       for (casadi_int i=0; i<name_out_.size(); ++i) {
         if (name_out_[i]==name) return i;
       }
       casadi_error("FunctionInternal::index_out: could not find entry \""
                    + name + "\". Available names are: " + str(name_out_) + ".");
       return -1;
     }

References casadi::str().

Referenced by casadi::FunctionInternal::convert_res().

◆ info()

Dict casadi::FunctionInternal::info ( ) const

virtualinherited

Obtain information about function

Reimplemented in casadi::Switch, casadi::OnnxFunction, and casadi::Map.

Definition at line 3271 of file function_internal.cpp.

                                     {
     return Dict();
   }

Referenced by export_code_body(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::Blocksqp::filterLineSearch(), casadi::Blocksqp::fullstep(), casadi::OnnxFunction::info(), casadi::BSplineInterpolant::init(), casadi::Blocksqp::kktErrorReduction(), casadi::Feasiblesqpmethod::print_iteration(), casadi::Sqpmethod::print_iteration(), casadi::Blocksqp::secondOrderCorrection(), casadi::SnoptInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Sqpmethod::solve(), and casadi::Sqpmethod::solve_elastic_mode().

◆ init()

void casadi::MXFunction::init ( const Dict & opts )

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 115 of file mx_function.cpp.

                                         {
     // Call the init function of the base class
     XFunction<MXFunction, MX, MXNode>::init(opts);
     if (verbose_) casadi_message(name_ + "::init");
  
     // Default (temporary) options
     live_variables_ = true;
     print_instructions_ = false;
     bool cse_opt = false;
     bool allow_free = false;
  
     // Read options
     for (auto&& op : opts) {
       if (op.first=="default_in") {
         default_in_ = op.second;
       } else if (op.first=="live_variables") {
         live_variables_ = op.second;
       } else if (op.first=="dump_trace") {
         dump_trace_ = op.second;
       } else if (op.first=="print_instructions") {
         print_instructions_ = op.second;
       } else if (op.first=="cse") {
         cse_opt = op.second;
       } else if (op.first=="allow_free") {
         allow_free = op.second;
       }
     }
  
     casadi_assert(!dump_trace_ || !jit_, "dump_trace is not supported for JIT evaluation");
  
     // Check/set default inputs
     if (default_in_.empty()) {
       default_in_.resize(n_in_, 0);
     } else {
       casadi_assert(default_in_.size()==n_in_,
                             "Option 'default_in' has incorrect length");
     }
  
     // Check if naked MultiOutput nodes are present
     for (const MX& e : out_) {
       casadi_assert(!e->has_output(),
         "Function output contains MultiOutput nodes. "
         "You must use get_output() to make a concrete instance.");
     }
  
     if (cse_opt) out_ = cse(out_);
  
     // Stack used to sort the computational graph
     std::stack<MXNode*> s;
  
     // All nodes
     std::vector<MXNode*> nodes;
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(MX::get_mutex_temp());
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Add the list of nodes
     for (casadi_int ind=0; ind<out_.size(); ++ind) {
       // Loop over primitives of each output
       std::vector<MX> prim = out_[ind].primitives();
       casadi_int nz_offset=0;
       for (casadi_int p=0; p<prim.size(); ++p) {
         // Get the nodes using a depth first search
         s.push(prim[p].get());
         sort_depth_first(s, nodes);
         // Add an output instruction ("data" below will take ownership)
         nodes.push_back(new Output(prim[p], ind, p, nz_offset));
         // Update offset
         nz_offset += prim[p].nnz();
       }
     }
  
     // Set the temporary variables to be the corresponding place in the sorted graph
     for (casadi_int i=0; i<nodes.size(); ++i) {
       nodes[i]->temp = i;
     }
  
     // Place in the algorithm for each node
     std::vector<casadi_int> place_in_alg;
     place_in_alg.reserve(nodes.size());
  
     // Input instructions
     std::vector<std::pair<casadi_int, MXNode*> > symb_loc;
  
     // Count the number of times each node is used
     std::vector<casadi_int> refcount(nodes.size(), 0);
  
     // Get the sequence of instructions for the virtual machine
     algorithm_.resize(0);
     algorithm_.reserve(nodes.size());
     for (MXNode* n : nodes) {
  
       // Get the operation
       casadi_int op = n->op();
  
       // Store location if parameter (or input)
       if (op==OP_PARAMETER) {
         symb_loc.push_back(std::make_pair(algorithm_.size(), n));
       }
  
       // If a new element in the algorithm needs to be added
       if (op>=0) {
         AlgEl ae;
         ae.op = op;
         ae.data.own(n);
         ae.arg.resize(n->n_dep());
         for (casadi_int i=0; i<n->n_dep(); ++i) {
           ae.arg[i] = n->dep(i)->temp;
         }
         ae.res.resize(n->nout());
         if (n->has_output()) {
           std::fill(ae.res.begin(), ae.res.end(), -1);
         } else if (!ae.res.empty()) {
           ae.res[0] = n->temp;
         }
  
         // Increase the reference count of the dependencies
         for (casadi_int c=0; c<ae.arg.size(); ++c) {
           if (ae.arg[c]>=0) {
             refcount[ae.arg[c]]++;
           }
         }
  
         // Save to algorithm
         place_in_alg.push_back(algorithm_.size());
         algorithm_.push_back(ae);
  
       } else { // Function output node
         // Get the output index
         casadi_int oind = n->which_output();
  
         // Get the index of the parent node
         casadi_int pind = place_in_alg[n->dep(0)->temp];
  
         // Save location in the algorithm element corresponding to the parent node
         casadi_int& otmp = algorithm_[pind].res.at(oind);
         if (otmp<0) {
           otmp = n->temp; // First time this function output is encountered, save to algorithm
         } else {
           n->temp = otmp; // Function output is a duplicate, use the node encountered first
         }
  
         // Not in the algorithm
         place_in_alg.push_back(-1);
       }
     }
  
     // Place in the work vector for each of the nodes in the tree (overwrites the reference counter)
     std::vector<casadi_int>& place = place_in_alg; // Reuse memory as it is no longer needed
     place.resize(nodes.size());
  
     // Stack with unused elements in the work vector, sorted by sparsity pattern
     SPARSITY_MAP<casadi_int, std::stack<casadi_int> > unused_all;
  
     // Work vector size
     casadi_int worksize = 0;
  
     // Find a place in the work vector for the operation
     for (auto&& e : algorithm_) {
  
       // There are two tasks, allocate memory of the result and free the
       // memory off the arguments, order depends on whether inplace is possible
       casadi_int first_to_free = 0;
       casadi_int last_to_free = e.data->n_inplace();
       for (casadi_int task=0; task<2; ++task) {
  
         // Dereference or free the memory of the arguments
         for (casadi_int c=last_to_free-1; c>=first_to_free; --c) { // reverse order so that the
                                                           // first argument will end up
                                                           // at the top of the stack
  
           // Index of the argument
           casadi_int& ch_ind = e.arg[c];
           if (ch_ind>=0) {
  
             // Decrease reference count and add to the stack of
             // unused variables if the count hits zero
             casadi_int remaining = --refcount[ch_ind];
  
             // Free variable for reuse
             if (live_variables_ && remaining==0) {
  
               // Get a pointer to the sparsity pattern of the argument that can be freed
               casadi_int nnz = nodes[ch_ind]->sparsity().nnz();
  
               // Add to the stack of unused work vector elements for the current sparsity
               unused_all[nnz].push(place[ch_ind]);
             }
  
             // Point to the place in the work vector instead of to the place in the list of nodes
             ch_ind = place[ch_ind];
           }
         }
  
         // Nothing more to allocate
         if (task==1) break;
  
         // Free the rest in the next iteration
         first_to_free = last_to_free;
         last_to_free = e.arg.size();
  
         // Allocate/reuse memory for the results of the operation
         for (casadi_int c=0; c<e.res.size(); ++c) {
           if (e.res[c]>=0) {
  
             // Are reuse of variables (live variables) enabled?
             if (live_variables_) {
               // Get a pointer to the sparsity pattern node
               casadi_int nnz = e.data->sparsity(c).nnz();
  
               // Get a reference to the stack for the current sparsity
               std::stack<casadi_int>& unused = unused_all[nnz];
  
               // Try to reuse a variable from the stack if possible (last in, first out)
               if (!unused.empty()) {
                 e.res[c] = place[e.res[c]] = unused.top();
                 unused.pop();
                 continue; // Success, no new element needed in the work vector
               }
             }
  
             // Allocate a new element in the work vector
             e.res[c] = place[e.res[c]] = worksize++;
           }
         }
       }
     }
  
     if (verbose_) {
       if (live_variables_) {
         casadi_message("Using live variables: work array is " + str(worksize)
                        + " instead of " + str(nodes.size()));
       } else {
         casadi_message("Live variables disabled.");
       }
     }
  
     // Allocate work vectors (numeric)
     workloc_.resize(worksize+1);
     std::fill(workloc_.begin(), workloc_.end(), -1);
     size_t wind=0, sz_w=0;
     for (auto&& e : algorithm_) {
       if (e.op!=OP_OUTPUT) {
         for (casadi_int c=0; c<e.res.size(); ++c) {
           if (e.res[c]>=0) {
             alloc_arg(e.data->sz_arg());
             alloc_res(e.data->sz_res());
             alloc_iw(e.data->sz_iw());
             // workloc_ (register offsets) is shared by VM eval and codegen, so
             // the scratch region must cover whichever needs more
             sz_w = std::max(sz_w, std::max(e.data->sz_w(), e.data->codegen_sz_w()));
             if (workloc_[e.res[c]] < 0) {
               workloc_[e.res[c]] = wind;
               wind += e.data->sparsity(c).nnz();
             }
           }
         }
       }
     }
     workloc_.back()=wind;
     for (casadi_int i=0; i<workloc_.size(); ++i) {
       if (workloc_[i]<0) workloc_[i] = i==0 ? 0 : workloc_[i-1];
       workloc_[i] += sz_w;
     }
     sz_w += wind;
     alloc_w(sz_w);
  
     // Reset the temporary variables
     for (casadi_int i=0; i<nodes.size(); ++i) {
       if (nodes[i]) {
         nodes[i]->temp = 0;
       }
     }
  
     // Now mark each input's place in the algorithm
     for (auto it=symb_loc.begin(); it!=symb_loc.end(); ++it) {
       it->second->temp = it->first+1;
     }
  
     // Add input instructions, loop over inputs
     for (casadi_int ind=0; ind<in_.size(); ++ind) {
       // Loop over symbolic primitives of each input
       std::vector<MX> prim = in_[ind].primitives();
       casadi_int nz_offset=0;
       for (casadi_int p=0; p<prim.size(); ++p) {
         casadi_int i = prim[p].get_temp()-1;
         if (i>=0) {
           // Mark read
           prim[p].set_temp(0);
  
           // Replace parameter with input instruction
           algorithm_[i].data.own(new Input(prim[p].sparsity(), ind, p, nz_offset));
           algorithm_[i].op = OP_INPUT;
         }
         nz_offset += prim[p]->nnz();
       }
     }
  
     // Locate free variables
     free_vars_.clear();
     for (auto it=symb_loc.begin(); it!=symb_loc.end(); ++it) {
       casadi_int i = it->second->temp-1;
       if (i>=0) {
         // Save to list of free parameters
         free_vars_.push_back(MX::create(it->second));
  
         // Remove marker
         it->second->temp=0;
       }
     }
  
     if (!allow_free && has_free()) {
       casadi_error(name_ + "::init: Initialization failed since variables [" +
       join(get_free(), ", ") + "] are free. These symbols occur in the output expressions "
       "but you forgot to declare these as inputs. "
       "Set option 'allow_free' to allow free variables.");
     }
  
     // Does any nodes require reference counting for codegen?
     // NOTE: this excludes CALL nodes
     for (auto&& a : algorithm_) {
       if (a.data->has_refcount()) {
         has_refcount_ = true;
         break;
       }
     }
  
   }

◆ init_mem()

int casadi::ProtoFunction::init_mem ( void * mem ) const

virtualinherited

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

Definition at line 921 of file function_internal.cpp.

                                              {
     auto *m = static_cast<ProtoFunctionMemory*>(mem);
     if (record_time_) {
       m->add_stat("total");
       m->t_total = &m->fstats.at("total");
     } else {
       m->t_total = nullptr;
     }
     return 0;
   }

References casadi::ProtoFunctionMemory::add_stat(), and casadi::ProtoFunction::record_time_.

Referenced by casadi::ProtoFunction::checkout(), casadi::FunctionInternal::codegen_checkout(), casadi::Conic::init_mem(), casadi::FmuFunction::init_mem(), casadi::LinsolInternal::init_mem(), casadi::OracleFunction::init_mem(), casadi::OnnxRuntimeInterface::init_mem(), casadi::SlicotDple::init_mem(), casadi::SlicotExpm::init_mem(), and casadi::OracleFunction::local_init_mem().

◆ initSingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::initSingleton ( )

inlineprotectedinherited

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(static_cast<Internal*>(this)->count==0);
       static_cast<Internal*>(this)->count++;
     }

◆ instruction_constant()

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

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 3649 of file function_internal.cpp.

                                                                   {
     casadi_error("'instruction_constant' not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

◆ instruction_id()

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

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 317 of file mx_function.hpp.

317 { return algorithm_.at(k).op;}

◆ instruction_input()

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 95 of file mx_function.cpp.

                                                                         {
     auto e = algorithm_.at(k);
     if (e.op==OP_INPUT) {
       const IOInstruction* io = static_cast<const IOInstruction*>(e.data.get());
       return { io->ind() };
     } else {
       return e.arg;
     }
   }

References algorithm_, and casadi::OP_INPUT.

◆ instruction_MX()

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 91 of file mx_function.cpp.

                                                   {
     return algorithm_.at(k).data;
   }

References algorithm_.

◆ instruction_output()

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 105 of file mx_function.cpp.

                                                                          {
     auto e = algorithm_.at(k);
     if (e.op==OP_OUTPUT) {
       const IOInstruction* io = static_cast<const IOInstruction*>(e.data.get());
       return { io->ind() };
     } else {
       return e.res;
     }
   }

References algorithm_, and casadi::OP_OUTPUT.

◆ instructions_sx()

SX casadi::FunctionInternal::instructions_sx ( ) const

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 3661 of file function_internal.cpp.

                                              {
     casadi_error("'instructions_sx' not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

◆ is_a()

bool casadi::MXFunction::is_a	(	const std::string &	type,
		bool	recursive
	)		const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1579 of file mx_function.cpp.

                                                                    {
     return type=="MXFunction"
       || (recursive && XFunction<MXFunction,
           MX, MXNode>::is_a(type, recursive));
   }

References MXFunction().

◆ isInput()

bool casadi::XFunction< MXFunction , MX , MXNode >::isInput ( const std::vector< MX > & arg ) const

virtualinherited

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

Definition at line 210 of file x_function.hpp.

                                                {
     // Check if arguments matches the input expressions, in which case
     // the output is known to be the output expressions
     const casadi_int checking_depth = 2;
     for (casadi_int i=0; i<arg.size(); ++i) {
       if (!is_equal(arg[i], in_[i], checking_depth)) {
         return false;
       }
     }
     return true;
   }

◆ jac()

std::vector< MX > casadi::XFunction< MXFunction , MX , MXNode >::jac ( const Dict & opts ) const

inherited

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

Definition at line 98 of file x_function.hpp.

                               {
     try {
       // Read options
       bool compact = false;
       bool symmetric = false;
       bool allow_forward = true;
       bool allow_reverse = true;
       for (auto&& op : opts) {
         if (op.first=="compact") {
           compact = op.second;
         } else if (op.first=="symmetric") {
           symmetric = op.second;
         } else if (op.first=="allow_forward") {
           allow_forward = op.second;
         } else if (op.first=="allow_reverse") {
           allow_reverse = op.second;
         } else if (op.first=="verbose") {
           continue;
         } else {
           casadi_error("No such Jacobian option: " + std::string(op.first));
         }
       }
  
       // Return object
       std::vector<MatType> ret(n_in_ * n_out_);
  
       // Quick return if trivially empty
       if (nnz_in() == 0 || nnz_out() == 0) {
         for (casadi_int i = 0; i < n_out_; ++i) {
           for (casadi_int j = 0; j < n_in_; ++j) {
             if (compact) {
               ret[i * n_in_ + j] = MatType(nnz_out(i), nnz_in(j));
             } else {
               ret[i * n_in_ + j] = MatType(numel_out(i), numel_in(j));
             }
           }
         }
         return ret;
       }
  
       // FIXME(@jaeandersson)
       casadi_int iind = 0, oind = 0;
       casadi_assert(n_in_>=1 && is_diff_in_[0], "Not implemented");
       casadi_assert(n_in_ == 1 || !any(vector_tail(is_diff_in_)), "Not implemented");
       casadi_assert(n_out_ == 1, "Not implemented");
  
       // Create return object
       ret.at(0) = MatType::zeros(jac_sparsity(0, 0, false, symmetric).T());
       if (verbose_) casadi_message("Allocated return value");
  
       // Quick return if empty
       if (ret.at(0).nnz()==0) {
         ret.at(0) = ret.at(0).T();
         return ret;
       }
  
       // Get a bidirectional partition
       Sparsity D1, D2;
       get_partition(iind, oind, D1, D2, true, symmetric, allow_forward, allow_reverse);
       if (verbose_) casadi_message("Graph coloring completed");
  
       // Get the number of forward and adjoint sweeps
       casadi_int nfdir = D1.is_null() ? 0 : D1.size2();
       casadi_int nadir = D2.is_null() ? 0 : D2.size2();
  
       // Number of derivative directions supported by the function
       casadi_int max_nfdir = max_num_dir_;
       casadi_int max_nadir = max_num_dir_;
  
       // Current forward and adjoint direction
       casadi_int offset_nfdir = 0, offset_nadir = 0;
  
       // Evaluation result (known)
       std::vector<MatType> res(out_);
  
       // Forward and adjoint seeds and sensitivities
       std::vector<std::vector<MatType> > fseed, aseed, fsens, asens;
  
       // Get the sparsity of the Jacobian block
       Sparsity jsp = jac_sparsity(0, 0, true, symmetric).T();
       const casadi_int* jsp_colind = jsp.colind();
       const casadi_int* jsp_row = jsp.row();
  
       // Input sparsity
       std::vector<casadi_int> input_col = sparsity_in_.at(iind).get_col();
       const casadi_int* input_row = sparsity_in_.at(iind).row();
  
       // Output sparsity
       std::vector<casadi_int> output_col = sparsity_out_.at(oind).get_col();
       const casadi_int* output_row = sparsity_out_.at(oind).row();
  
       // Get transposes and mappings for jacobian sparsity pattern if we are using forward mode
       if (verbose_) casadi_message("jac transposes and mapping");
       std::vector<casadi_int> mapping;
       Sparsity jsp_trans;
       if (nfdir>0) {
         jsp_trans = jsp.transpose(mapping);
       }
  
       // The nonzeros of the sensitivity matrix
       std::vector<casadi_int> nzmap, nzmap2;
  
       // Additions to the jacobian matrix
       std::vector<casadi_int> adds, adds2;
  
       // Temporary vector
       std::vector<casadi_int> tmp;
  
       // Progress
       casadi_int progress = -10;
  
       // Number of sweeps
       casadi_int nsweep_fwd = nfdir/max_nfdir;   // Number of sweeps needed for the forward mode
       if (nfdir%max_nfdir>0) nsweep_fwd++;
       casadi_int nsweep_adj = nadir/max_nadir;   // Number of sweeps needed for the adjoint mode
       if (nadir%max_nadir>0) nsweep_adj++;
       casadi_int nsweep = std::max(nsweep_fwd, nsweep_adj);
       if (verbose_) {
         casadi_message(str(nsweep) + " sweeps needed for " + str(nfdir) + " forward and "
                        + str(nadir) + " reverse directions");
       }
  
       // Sparsity of the seeds
       std::vector<casadi_int> seed_col, seed_row;
  
       // Evaluate until everything has been determined
       for (casadi_int s=0; s<nsweep; ++s) {
         // Print progress
         if (verbose_) {
           casadi_int progress_new = (s*100)/nsweep;
           // Print when entering a new decade
           if (progress_new / 10 > progress / 10) {
             progress = progress_new;
             casadi_message(str(progress) + " %");
           }
         }
  
         // Number of forward and adjoint directions in the current "batch"
         casadi_int nfdir_batch = std::min(nfdir - offset_nfdir, max_nfdir);
         casadi_int nadir_batch = std::min(nadir - offset_nadir, max_nadir);
  
         // Forward seeds
         fseed.resize(nfdir_batch);
         for (casadi_int d=0; d<nfdir_batch; ++d) {
           // Nonzeros of the seed matrix
           seed_col.clear();
           seed_row.clear();
  
           // For all the directions
           for (casadi_int el = D1.colind(offset_nfdir+d); el<D1.colind(offset_nfdir+d+1); ++el) {
  
             // Get the direction
             casadi_int c = D1.row(el);
  
             // Give a seed in the direction
             seed_col.push_back(input_col[c]);
             seed_row.push_back(input_row[c]);
           }
  
           // initialize to zero
           fseed[d].resize(n_in_);
           for (casadi_int ind=0; ind<fseed[d].size(); ++ind) {
             casadi_int nrow = size1_in(ind), ncol = size2_in(ind); // Input dimensions
             if (ind==iind) {
               fseed[d][ind] = MatType::ones(Sparsity::triplet(nrow, ncol, seed_row, seed_col));
             } else {
               fseed[d][ind] = MatType(nrow, ncol);
             }
           }
         }
  
         // Adjoint seeds
         aseed.resize(nadir_batch);
         for (casadi_int d=0; d<nadir_batch; ++d) {
           // Nonzeros of the seed matrix
           seed_col.clear();
           seed_row.clear();
  
           // For all the directions
           for (casadi_int el = D2.colind(offset_nadir+d); el<D2.colind(offset_nadir+d+1); ++el) {
  
             // Get the direction
             casadi_int c = D2.row(el);
  
             // Give a seed in the direction
             seed_col.push_back(output_col[c]);
             seed_row.push_back(output_row[c]);
           }
  
           //initialize to zero
           aseed[d].resize(n_out_);
           for (casadi_int ind=0; ind<aseed[d].size(); ++ind) {
             casadi_int nrow = size1_out(ind), ncol = size2_out(ind); // Output dimensions
             if (ind==oind) {
               aseed[d][ind] = MatType::ones(Sparsity::triplet(nrow, ncol, seed_row, seed_col));
             } else {
               aseed[d][ind] = MatType(nrow, ncol);
             }
           }
         }
  
         // Forward sensitivities
         fsens.resize(nfdir_batch);
         for (casadi_int d=0; d<nfdir_batch; ++d) {
           // initialize to zero
           fsens[d].resize(n_out_);
           for (casadi_int oind=0; oind<fsens[d].size(); ++oind) {
             fsens[d][oind] = MatType::zeros(sparsity_out_.at(oind));
           }
         }
  
         // Adjoint sensitivities
         asens.resize(nadir_batch);
         for (casadi_int d=0; d<nadir_batch; ++d) {
           // initialize to zero
           asens[d].resize(n_in_);
           for (casadi_int ind=0; ind<asens[d].size(); ++ind) {
             asens[d][ind] = MatType::zeros(sparsity_in_.at(ind));
           }
         }
  
         // Evaluate symbolically
         if (!fseed.empty()) {
           casadi_assert_dev(aseed.empty());
           if (verbose_) casadi_message("Calling 'ad_forward'");
           static_cast<const DerivedType*>(this)->ad_forward(fseed, fsens);
           if (verbose_) casadi_message("Back from 'ad_forward'");
         } else if (!aseed.empty()) {
           casadi_assert_dev(fseed.empty());
           if (verbose_) casadi_message("Calling 'ad_reverse'");
           static_cast<const DerivedType*>(this)->ad_reverse(aseed, asens);
           if (verbose_) casadi_message("Back from 'ad_reverse'");
         }
  
         // Carry out the forward sweeps
         for (casadi_int d=0; d<nfdir_batch; ++d) {
           // Skip if nothing to add
           if (fsens[d][oind].nnz()==0) {
             continue;
           }
  
           // If symmetric, see how many times each output appears
           if (symmetric) {
             // Initialize to zero
             tmp.resize(nnz_out(oind));
             std::fill(tmp.begin(), tmp.end(), 0);
  
             // "Multiply" Jacobian sparsity by seed vector
             for (casadi_int el = D1.colind(offset_nfdir+d); el<D1.colind(offset_nfdir+d+1); ++el) {
  
               // Get the input nonzero
               casadi_int c = D1.row(el);
  
               // Propagate dependencies
               for (casadi_int el_jsp=jsp_colind[c]; el_jsp<jsp_colind[c+1]; ++el_jsp) {
                 tmp[jsp_row[el_jsp]]++;
               }
             }
           }
  
           // Locate the nonzeros of the forward sensitivity matrix
           sparsity_out_.at(oind).find(nzmap);
           fsens[d][oind].sparsity().get_nz(nzmap);
  
           if (symmetric) {
             sparsity_in_.at(iind).find(nzmap2);
             fsens[d][oind].sparsity().get_nz(nzmap2);
           }
  
           // Assignments to the Jacobian
           adds.resize(fsens[d][oind].nnz());
           std::fill(adds.begin(), adds.end(), -1);
           if (symmetric) {
             adds2.resize(adds.size());
             std::fill(adds2.begin(), adds2.end(), -1);
           }
  
           // For all the input nonzeros treated in the sweep
           for (casadi_int el = D1.colind(offset_nfdir+d); el<D1.colind(offset_nfdir+d+1); ++el) {
  
             // Get the input nonzero
             casadi_int c = D1.row(el);
             //casadi_int f2_out;
             //if (symmetric) {
             //  f2_out = nzmap2[c];
             //}
  
             // Loop over the output nonzeros corresponding to this input nonzero
             for (casadi_int el_out = jsp_trans.colind(c); el_out<jsp_trans.colind(c+1); ++el_out) {
  
               // Get the output nonzero
               casadi_int r_out = jsp_trans.row(el_out);
  
               // Get the forward sensitivity nonzero
               casadi_int f_out = nzmap[r_out];
               if (f_out<0) continue; // Skip if structurally zero
  
               // The nonzero of the Jacobian now treated
               casadi_int elJ = mapping[el_out];
  
               if (symmetric) {
                 if (tmp[r_out]==1) {
                   adds[f_out] = el_out;
                   adds2[f_out] = elJ;
                 }
               } else {
                 // Get the output seed
                 adds[f_out] = elJ;
               }
             }
           }
  
           // Get entries in fsens[d][oind] with nonnegative indices
           tmp.resize(adds.size());
           casadi_int sz = 0;
           for (casadi_int i=0; i<adds.size(); ++i) {
             if (adds[i]>=0) {
               adds[sz] = adds[i];
               tmp[sz++] = i;
             }
           }
           adds.resize(sz);
           tmp.resize(sz);
  
           // Add contribution to the Jacobian
           ret.at(0).nz(adds) = fsens[d][oind].nz(tmp);
  
           if (symmetric) {
             // Get entries in fsens[d][oind] with nonnegative indices
             tmp.resize(adds2.size());
             sz = 0;
             for (casadi_int i=0; i<adds2.size(); ++i) {
               if (adds2[i]>=0) {
                 adds2[sz] = adds2[i];
                 tmp[sz++] = i;
               }
             }
             adds2.resize(sz);
             tmp.resize(sz);
  
             // Add contribution to the Jacobian
             ret.at(0).nz(adds2) = fsens[d][oind].nz(tmp);
           }
         }
  
         // Add elements to the Jacobian matrix
         for (casadi_int d=0; d<nadir_batch; ++d) {
           // Skip if nothing to add
           if (asens[d][iind].nnz()==0) {
             continue;
           }
  
           // Locate the nonzeros of the adjoint sensitivity matrix
           sparsity_in_.at(iind).find(nzmap);
           asens[d][iind].sparsity().get_nz(nzmap);
  
           // Collect the (Jacobian nonzero, sensitivity nonzero) assignment pairs
           adds.clear();
           tmp.clear();
  
           // For all the output nonzeros treated in the sweep
           for (casadi_int el = D2.colind(offset_nadir+d); el<D2.colind(offset_nadir+d+1); ++el) {
  
             // Get the output nonzero
             casadi_int r = D2.row(el);
  
             // Loop over the input nonzeros that influences this output nonzero
             for (casadi_int elJ = jsp.colind(r); elJ<jsp.colind(r+1); ++elJ) {
  
               // Get the input nonzero
               casadi_int inz = jsp.row(elJ);
  
               // Get the corresponding adjoint sensitivity nonzero
               casadi_int anz = nzmap[inz];
               if (anz<0) continue;
  
               // Queue the assignment
               adds.push_back(elJ);
               tmp.push_back(anz);
             }
           }
  
           // Add contribution to the Jacobian in a single batched assignment
           ret.at(0).nz(adds) = asens[d][iind].nz(tmp);
         }
  
         // Update direction offsets
         offset_nfdir += nfdir_batch;
         offset_nadir += nadir_batch;
       }
  
       // Return
       for (MatType& Jb : ret) Jb = Jb.T();
       return ret;
  
     } catch (std::exception& e) {
       CASADI_THROW_ERROR("jac", e.what());
     }
   }

◆ jac_is_symm()

bool casadi::FunctionInternal::jac_is_symm	(	casadi_int	oind,
		casadi_int	iind
	)		const

virtualinherited

Definition at line 1973 of file function_internal.cpp.

                                                                            {
     // If derivative expression
     if (!derivative_of_.is_null()) {
       std::string n = derivative_of_.name();
       // Reverse move
       if (name_ == "adj1_" + n) {
         if (iind == oind) return true;
       }
     }
     // Not symmetric by default
     return false;
   }

References casadi::FunctionInternal::derivative_of_, casadi::GenericShared< Shared, Internal >::is_null(), casadi::Function::name(), and casadi::ProtoFunction::name_.

◆ jac_sparsity()

Sparsity & casadi::FunctionInternal::jac_sparsity	(	casadi_int	oind,
		casadi_int	iind,
		bool	compact,
		bool	symmetric
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kz Get, if necessary generate, the sparsity of a Jacobian block

Definition at line 2061 of file function_internal.cpp.

                             {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     // Safe access to jac_sparsity_
     std::lock_guard<std::mutex> lock(jac_sparsity_mtx_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
     // If first call, allocate cache
     for (bool c : {false, true}) {
       if (jac_sparsity_[c].empty()) jac_sparsity_[c].resize(n_in_ * n_out_);
     }
     // Flat index
     casadi_int ind = iind + oind * n_in_;
     // Reference to the block
     Sparsity& jsp = jac_sparsity_[compact].at(ind);
     // If null, generate
     if (jsp.is_null()) {
       // Use (non)-compact pattern, if given
       Sparsity& jsp_other = jac_sparsity_[!compact].at(ind);
       if (!jsp_other.is_null()) {
         jsp = compact ? to_compact(oind, iind, jsp_other) : from_compact(oind, iind, jsp_other);
       } else {
         // Generate pattern
         Sparsity sp;
         bool sp_is_compact;
         if (!is_diff_out_.at(oind) || !is_diff_in_.at(iind)) {
           // All-zero sparse
           sp = Sparsity(nnz_out(oind), nnz_in(iind));
           sp_is_compact = true;
         } else {
           // Use internal routine to determine sparsity
           if (has_spfwd() || has_sprev() || has_jac_sparsity(oind, iind)) {
             sp = get_jac_sparsity(oind, iind, symmetric);
           }
           // If null, dense
           if (sp.is_null()) sp = Sparsity::dense(nnz_out(oind), nnz_in(iind));
           // Is the return the compact pattern?
           sp_is_compact = sp.size1() == nnz_out(oind) && sp.size2() == nnz_in(iind);
         }
         // Save to cache and convert if needed
         if (sp_is_compact == compact) {
           jsp = sp;
         } else {
           jsp_other = sp;
           jsp = compact ? to_compact(oind, iind, sp) : from_compact(oind, iind, sp);
         }
       }
     }
  
     // Make sure the Jacobian is symmetric if requested, cf. #1522, #3074, #3134
     if (symmetric) {
       if (compact) {
         Sparsity sp = from_compact(oind, iind, jsp);
         if (!sp.is_symmetric()) {
           sp = sp * sp.T();
           jsp = to_compact(oind, iind, sp);
         }
       } else {
         if (!jsp.is_symmetric()) jsp = jsp * jsp.T();
       }
     }
  
     // Return a reference to the block
     return jsp;
   }

Referenced by casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::sp_forward_block(), and casadi::FunctionInternal::sp_reverse().

◆ jacobian()

Function casadi::FunctionInternal::jacobian ( ) const

inherited

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

Definition at line 2461 of file function_internal.cpp.

                                             {
     // Used wrapped function if jacobian not available
     if (!has_jacobian()) {
       // Derivative information must be available
       casadi_assert(has_derivative(),
                             "Derivatives cannot be calculated for " + name_);
       return wrap().jacobian();
     }
     // Retrieve/generate cached
     Function f;
     std::string fname = "jac_" + name_;
     if (!incache(fname, f)) {
       // Names of inputs
       std::vector<std::string> inames;
       for (casadi_int i=0; i<n_in_; ++i) inames.push_back(name_in_[i]);
       for (casadi_int i=0; i<n_out_; ++i) inames.push_back("out_" + name_out_[i]);
       // Names of outputs
       std::vector<std::string> onames;
       onames.reserve(n_in_ * n_out_);
       for (size_t oind = 0; oind < n_out_; ++oind) {
         for (size_t iind = 0; iind < n_in_; ++iind) {
           onames.push_back("jac_" + name_out_[oind] + "_" + name_in_[iind]);
         }
       }
       // Options
       Dict opts = combine(jacobian_options_, der_options_);
       opts["derivative_of"] = self();
       // Generate derivative function
       casadi_assert_dev(enable_jacobian_);
       f = get_jacobian(fname, inames, onames, opts);
       // Consistency checks
       casadi_assert(f.n_in() == inames.size(),
         "Mismatching input signature, expected " + str(inames));
       casadi_assert(f.n_out() == onames.size(),
         "Mismatching output signature, expected " + str(onames));
       // Save to cache
       tocache_if_missing(f);
     }
     return f;
   }

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), and casadi::Function::jacobian().

◆ jit_dependencies()

virtual void casadi::FunctionInternal::jit_dependencies ( const std::string & fname )

inlinevirtualinherited

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

Reimplemented in casadi::OracleFunction.

Definition at line 950 of file function_internal.hpp.

950 {}

Referenced by casadi::FunctionInternal::finalize().

◆ map()

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

inherited

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

Definition at line 1200 of file function_internal.cpp.

                                                                                      {
     Function f;
     if (parallelization=="serial") {
       // Serial maps are cached
       std::string fname = "map" + str(n) + "_" + name_;
       if (!incache(fname, f)) {
         // Create new serial map
         f = Map::create(parallelization, self(), n);
         casadi_assert_dev(f.name()==fname);
         // Save in cache
         tocache_if_missing(f);
       }
     } else {
       // Non-serial maps are not cached
       f = Map::create(parallelization, self(), n);
     }
     return f;
   }

References casadi::Map::create(), casadi::FunctionInternal::incache(), casadi::Function::name(), casadi::ProtoFunction::name_, casadi::str(), and casadi::FunctionInternal::tocache_if_missing().

Referenced by casadi::Dple::get_forward(), casadi::Dple::get_reverse(), and casadi::FunctionInternal::mapsum_mx().

◆ mapsum_mx()

std::vector< MX > casadi::FunctionInternal::mapsum_mx	(	const std::vector< MX > &	arg,
		const std::string &	parallelization
	)

inherited

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

Definition at line 3670 of file function_internal.cpp.

                                                                 {
     if (x.empty()) return x;
     // Check number of arguments
     casadi_assert(x.size()==n_in_, "mapsum_mx: Wrong number_i of arguments");
     // Number of parallel calls
     casadi_int npar = 1;
     // Check/replace arguments
     std::vector<MX> x_mod(x.size());
     for (casadi_int i=0; i<n_in_; ++i) {
       if (check_mat(x[i].sparsity(), sparsity_in_[i], npar)) {
         x_mod[i] = replace_mat(x[i], sparsity_in_[i], npar);
       } else {
         // Mismatching sparsity: The following will throw an error message
         npar = 0;
         check_arg(x, npar);
       }
     }
  
     casadi_int n = 1;
     for (casadi_int i=0; i<x_mod.size(); ++i) {
       n = std::max(x_mod[i].size2() / size2_in(i), n);
     }
  
     std::vector<casadi_int> reduce_in;
     for (casadi_int i=0; i<x_mod.size(); ++i) {
       if (x_mod[i].size2()/size2_in(i)!=n) {
         reduce_in.push_back(i);
       }
     }
  
     Function ms = self().map("mapsum", parallelization, n, reduce_in, range(n_out_));
  
     // Call the internal function
     return ms(x_mod);
   }

References casadi::FunctionInternal::check_arg(), casadi::FunctionInternal::check_mat(), casadi::FunctionInternal::map(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::range(), casadi::replace_mat(), casadi::FunctionInternal::size2_in(), and casadi::FunctionInternal::sparsity_in_.

◆ matching_arg()

template<typename M >

bool casadi::FunctionInternal::matching_arg	(	const std::vector< M > &	arg,
		casadi_int &	npar
	)		const

inherited

Raises errors

Parameters

	npar[in]	normal usage: 1, disallow pararallel calls: -1
[out]	npar	max number of horizontal repetitions across all arguments (or -1)

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

Definition at line 1808 of file function_internal.hpp.

                                                                                      {
     check_arg(arg, npar);
     for (casadi_int i=0; i<n_in_; ++i) {
       if (arg.at(i).size1()!=size1_in(i)) return false;
       if (arg.at(i).size2()!=size2_in(i) && arg.at(i).size2()!=npar*size2_in(i)) return false;
     }
     return true;
   }

References casadi::FunctionInternal::check_arg(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::size1_in(), and casadi::FunctionInternal::size2_in().

Referenced by ad_forward(), casadi::SXFunction::ad_forward(), casadi::FunctionInternal::call(), casadi::FunctionInternal::call_forward(), and casadi::FunctionInternal::nz_in().

◆ matching_res()

template<typename M >

bool casadi::FunctionInternal::matching_res	(	const std::vector< M > &	arg,
		casadi_int &	npar
	)		const

inherited

Raises errors

Parameters

	npar[in]	normal usage: 1, disallow pararallel calls: -1
[out]	npar	max number of horizontal repetitions across all arguments (or -1)

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

Definition at line 1818 of file function_internal.hpp.

                                                                                      {
     check_res(res, npar);
     for (casadi_int i=0; i<n_out_; ++i) {
       if (res.at(i).size1()!=size1_out(i)) return false;
       if (res.at(i).size2()!=size2_out(i) && res.at(i).size2()!=npar*size2_out(i)) return false;
     }
     return true;
   }

References casadi::FunctionInternal::check_res(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::size1_out(), and casadi::FunctionInternal::size2_out().

Referenced by ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::FunctionInternal::call_reverse(), and casadi::FunctionInternal::nz_out().

◆ memory()

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

inherited

Definition at line 3905 of file function_internal.cpp.

                                            {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
     return mem_.at(ind);
   }

Referenced by casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::Sqpmethod::solve_ela_QP(), and casadi::Sqpmethod::solve_QP().

◆ merge()

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

virtualinherited

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

Reimplemented in casadi::BlazingSplineFunction.

Definition at line 3620 of file function_internal.cpp.

3621 {

3622 }

◆ mx_in() [1/2]

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1575 of file mx_function.cpp.

                                               {
     return in_;
   }

References casadi::XFunction< MXFunction, MX, MXNode >::in_.

◆ mx_in() [2/2]

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

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1571 of file mx_function.cpp.

                                                  {
     return in_.at(ind);
   }

References casadi::XFunction< MXFunction, MX, MXNode >::in_.

◆ mx_out() [1/2]

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

virtualinherited

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

Definition at line 3608 of file function_internal.cpp.

                                                      {
     std::vector<MX> ret(n_out_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = mx_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_out_.

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

◆ mx_out() [2/2]

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

virtualinherited

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

Definition at line 3596 of file function_internal.cpp.

                                                         {
     return MX::sym(name_out_.at(ind), sparsity_out(ind));
   }

References casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sparsity_out(), and casadi::GenericMatrix< MX >::sym().

◆ n_instructions()

casadi_int casadi::MXFunction::n_instructions ( ) const

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 307 of file mx_function.hpp.

307 { return algorithm_.size();}

Referenced by MXFunction().

◆ n_nodes()

casadi_int casadi::MXFunction::n_nodes ( ) const

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 305 of file mx_function.hpp.

305 { return algorithm_.size();}

◆ nnz_in() [1/2]

casadi_int casadi::FunctionInternal::nnz_in ( ) const

inherited

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

Definition at line 2420 of file function_internal.cpp.

                                             {
     casadi_int ret=0;
     for (casadi_int iind=0; iind<n_in_; ++iind) ret += nnz_in(iind);
     return ret;
   }

References casadi::FunctionInternal::n_in_.

◆ nnz_in() [2/2]

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

inlineinherited

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

Definition at line 1010 of file function_internal.hpp.

1010 { return sparsity_in(ind).nnz(); }

casadi::Sparsity::nnz

casadi_int nnz() const

Get the number of (structural) non-zeros.

Definition: sparsity.cpp:148

◆ nnz_out() [1/2]

casadi_int casadi::FunctionInternal::nnz_out ( ) const

inherited

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

Definition at line 2426 of file function_internal.cpp.

                                              {
     casadi_int ret=0;
     for (casadi_int oind=0; oind<n_out_; ++oind) ret += nnz_out(oind);
     return ret;
   }

References casadi::FunctionInternal::n_out_.

◆ nnz_out() [2/2]

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

inlineinherited

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

Definition at line 1012 of file function_internal.hpp.

1012 { return sparsity_out(ind).nnz(); }

◆ numel_in() [1/2]

casadi_int casadi::FunctionInternal::numel_in ( ) const

inherited

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

Definition at line 2432 of file function_internal.cpp.

                                               {
     casadi_int ret=0;
     for (casadi_int iind=0; iind<n_in_; ++iind) ret += numel_in(iind);
     return ret;
   }

References casadi::FunctionInternal::n_in_.

Referenced by casadi::FunctionInternal::from_compact(), and casadi::Integrator::get_reverse().

◆ numel_in() [2/2]

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

inlineinherited

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

Definition at line 1020 of file function_internal.hpp.

1020 { return sparsity_in(ind).numel(); }

casadi::Sparsity::numel

casadi_int numel() const

The total number of elements, including structural zeros, i.e. size2()*size1()

Definition: sparsity.cpp:132

◆ numel_out() [1/2]

casadi_int casadi::FunctionInternal::numel_out ( ) const

inherited

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

Definition at line 2438 of file function_internal.cpp.

                                                {
     casadi_int ret=0;
     for (casadi_int oind=0; oind<n_out_; ++oind) ret += numel_out(oind);
     return ret;
   }

References casadi::FunctionInternal::n_out_.

Referenced by casadi::FunctionInternal::from_compact(), and casadi::Integrator::get_reverse().

◆ numel_out() [2/2]

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

inlineinherited

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

Definition at line 1021 of file function_internal.hpp.

1021 { return sparsity_out(ind).numel(); }

◆ nz_in() [1/2]

std::vector< double > casadi::FunctionInternal::nz_in ( const std::vector< DM > & arg ) const

inherited

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

Definition at line 3760 of file function_internal.cpp.

                                                                           {
     // Disallow parallel inputs
     casadi_int npar = -1;
     if (!matching_arg(arg, npar)) {
       return nz_in(replace_arg(arg, npar));
     }
  
     std::vector<DM> arg2 = project_arg(arg, 1);
     std::vector<double> ret(nnz_in());
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_in_;++i) {
       const double* e = arg2.at(i).ptr();
       std::copy(e, e+nnz_in(i), ret.begin()+offset);
       offset+= nnz_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::project_arg(), and casadi::FunctionInternal::replace_arg().

Referenced by casadi::SXFunction::call_activity(), casadi::SXFunction::call_fwd(), casadi::SXFunction::call_rev(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical().

◆ nz_in() [2/2]

std::vector< DM > casadi::FunctionInternal::nz_in ( const std::vector< double > & arg ) const

inherited

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

Definition at line 3730 of file function_internal.cpp.

                                                                           {
     casadi_assert(nnz_in()==arg.size(),
       "Dimension mismatch. Expecting " + str(nnz_in()) +
       ", got " + str(arg.size()) + " instead.");
  
     std::vector<DM> ret = dm_in();
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_in_;++i) {
       DM& r = ret.at(i);
       std::copy(arg.begin()+offset, arg.begin()+offset+nnz_in(i), r.ptr());
       offset+= nnz_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::dm_in(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::nnz_in(), casadi::Matrix< Scalar >::ptr(), and casadi::str().

◆ nz_out() [1/2]

std::vector< double > casadi::FunctionInternal::nz_out ( const std::vector< DM > & res ) const

inherited

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

Definition at line 3778 of file function_internal.cpp.

                                                                            {
     // Disallow parallel inputs
     casadi_int npar = -1;
     if (!matching_res(res, npar)) {
       return nz_out(replace_res(res, npar));
     }
  
     std::vector<DM> res2 = project_res(res, 1);
     std::vector<double> ret(nnz_out());
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_out_;++i) {
       const double* e = res2.at(i).ptr();
       std::copy(e, e+nnz_out(i), ret.begin()+offset);
       offset+= nnz_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::matching_res(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::project_res(), and casadi::FunctionInternal::replace_res().

Referenced by casadi::SXFunction::call_activity(), casadi::SXFunction::call_fwd(), casadi::SXFunction::call_rev(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical().

◆ nz_out() [2/2]

std::vector< DM > casadi::FunctionInternal::nz_out ( const std::vector< double > & res ) const

inherited

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

Definition at line 3745 of file function_internal.cpp.

                                                                            {
     casadi_assert(nnz_out()==res.size(),
       "Dimension mismatch. Expecting " + str(nnz_out()) +
       ", got " + str(res.size()) + " instead.");
  
     std::vector<DM> ret = dm_out();
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_out_;++i) {
       DM& r = ret.at(i);
       std::copy(res.begin()+offset, res.begin()+offset+nnz_out(i), r.ptr());
       offset+= nnz_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::dm_out(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_out(), casadi::Matrix< Scalar >::ptr(), and casadi::str().

◆ open_trace()

std::unique_ptr< std::ostream > casadi::FunctionInternal::open_trace	(	const double **	arg,
		casadi_int	dump_id
	)		const

protectedinherited

Definition at line 847 of file function_internal.cpp.

                                                            {
     if (dump_id < 0) dump_id = get_dump_id();
     std::stringstream filename;
     filename << dump_dir_ << filesep() << name_ << "." << std::setfill('0')
              << std::setw(6) << dump_id << ".trace.jsonl";
     auto output = Filesystem::ofstream_ptr(filename.str());
     std::ostream& trace = *output;
     normalized_setup(trace);
     trace << "{\"event\":\"header\",\"format\":\"casadi_trace\",\"version\":1,"
           << "\"function\":\"" << name_ << "\",\"type\":\"" << class_name()
           << "\",\"dump_id\":" << dump_id << "}\n";
     trace << "{\"event\":\"inputs\",\"values\":[";
     for (casadi_int i = 0; i < n_in_; ++i) {
       if (i) trace << ",";
       trace_values(trace, arg[i], nnz_in(i));
     }
     trace << "]}\n";
     return output;
   }

References casadi::SharedObjectInternal::class_name(), casadi::FunctionInternal::dump_dir_, casadi::filename(), casadi::filesep(), casadi::FunctionInternal::n_in_, casadi::ProtoFunction::name_, casadi::FunctionInternal::nnz_in(), casadi::normalized_setup(), casadi::Filesystem::ofstream_ptr(), and casadi::FunctionInternal::trace_values().

Referenced by eval(), and casadi::SXFunction::eval().

◆ oracle()

const Function & casadi::FunctionInternal::oracle ( ) const

virtualinherited

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

Reimplemented in casadi::OracleFunction.

Definition at line 3997 of file function_internal.cpp.

                                                  {
     casadi_error("'oracle' not defined for " + class_name());
     static Function singleton;
     return singleton;
   }

References casadi::SharedObjectInternal::class_name().

Referenced by casadi::Function::oracle(), and casadi::DaeBuilder::oracle().

◆ order()

std::vector< MX > casadi::MXFunction::order ( const std::vector< MX > & expr )

static

Definition at line 2060 of file mx_function.cpp.

                                                            {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(MX::get_mutex_temp());
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
     // Stack used to sort the computational graph
     std::stack<MXNode*> s;
  
     // All nodes
     std::vector<MXNode*> nodes;
  
     // Add the list of nodes
     for (casadi_int ind=0; ind<expr.size(); ++ind) {
       // Loop over primitives of each output
       std::vector<MX> prim = expr[ind].primitives();
       for (casadi_int p=0; p<prim.size(); ++p) {
         // Get the nodes using a depth first search
         s.push(prim[p].get());
         XFunction<MXFunction, MX, MXNode>::sort_depth_first(s, nodes);
       }
     }
  
     // Clear temporary markers
     for (casadi_int i=0; i<nodes.size(); ++i) {
       nodes[i]->temp = 0;
     }
  
     std::vector<MX> ret(nodes.size());
     for (casadi_int i=0; i<nodes.size(); ++i) {
       ret[i].own(nodes[i]);
     }
  
     return ret;
   }

References casadi::XFunction< DerivedType, MatType, NodeType >::sort_depth_first().

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

◆ print() [1/2]

std::string casadi::MXFunction::print ( const AlgEl & el ) const

Definition at line 533 of file mx_function.cpp.

                                                    {
     std::stringstream s;
     if (el.op==OP_OUTPUT) {
       s << "output[" << el.data->ind() << "][" << el.data->segment() << "]"
         << " = @" << el.arg.at(0);
     } else if (el.op==OP_SETNONZEROS || el.op==OP_ADDNONZEROS) {
       if (el.res.front()!=el.arg.at(0)) {
         s << "@" << el.res.front() << " = @" << el.arg.at(0) << "; ";
       }
       std::vector<std::string> arg(2);
       arg[0] = "@" + str(el.res.front());
       arg[1] = "@" + str(el.arg.at(1));
       s << el.data->disp(arg);
     } else {
       if (el.res.size()==1) {
         s << "@" << el.res.front() << " = ";
       } else {
         s << "{";
         for (casadi_int i=0; i<el.res.size(); ++i) {
           if (i!=0) s << ", ";
           if (el.res[i]>=0) {
             s << "@" << el.res[i];
           } else {
             s << "NULL";
           }
         }
         s << "} = ";
       }
       std::vector<std::string> arg;
       if (el.op!=OP_INPUT) {
         arg.resize(el.arg.size());
         for (casadi_int i=0; i<el.arg.size(); ++i) {
           if (el.arg[i]>=0) {
             arg[i] = "@" + str(el.arg[i]);
           } else {
             arg[i] = "NULL";
           }
         }
       }
       s << el.data->disp(arg);
     }
     return s.str();
   }

References casadi::MXAlgEl::arg, casadi::MXAlgEl::data, casadi::MXNode::disp(), casadi::MXNode::ind(), casadi::MXAlgEl::op, casadi::OP_ADDNONZEROS, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_SETNONZEROS, casadi::MXAlgEl::res, casadi::MXNode::segment(), and casadi::str().

Referenced by codegen_body(), disp_more(), print_arg(), and print_res().

◆ print() [2/2]

void casadi::ProtoFunction::print	(	const char *	fmt,
			...
	)		const

inherited

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

Definition at line 4158 of file function_internal.cpp.

                                                       {
     // Variable number of arguments
     va_list args;
     va_start(args, fmt);
     // Static & dynamic buffers
     char buf[256];
     size_t buf_sz = sizeof(buf);
     char* buf_dyn = nullptr;
     // Try to print with a small buffer
     casadi_int n = vsnprintf(buf, buf_sz, fmt, args);
     // Need a larger buffer?
     if (n>static_cast<casadi_int>(buf_sz)) {
       buf_sz = static_cast<size_t>(n+1);
       buf_dyn = new char[buf_sz];
       n = vsnprintf(buf_dyn, buf_sz, fmt, args);
     }
     // Print buffer content
     if (n>=0) uout() << (buf_dyn ? buf_dyn : buf) << std::flush;
     // Cleanup
     delete[] buf_dyn;
     va_end(args);
     // Throw error if failure
     casadi_assert(n>=0, "Print failure while processing '" + std::string(fmt) + "'");
   }

References casadi::uout().

◆ print_arg() [1/2]

void casadi::MXFunction::print_arg	(	CodeGenerator &	g,
		casadi_int	k,
		const AlgEl &	el,
		const std::vector< casadi_int > &	arg,
		const std::vector< bool > &	arg_is_ref
	)		const

Definition at line 593 of file mx_function.cpp.

                                                                                {
     g << g.printf(name_ + ":" + str(k) + ": " + print(el) + " inputs:\\n") << "\n";
     for (size_t i = 0; i < el.arg.size(); ++i) {
       if (arg[i]>=0) {
         g << g.printf(str(i) + ": ");
         std::string a = g.work(arg[i], el.data->dep(i).nnz(), arg_is_ref[i]);
         g << g.print_canonical(el.data->dep(i).sparsity(), a);
         g << g.printf("\\n") << "\n";
       }
     }
   }

References casadi::MXAlgEl::arg, casadi::MXAlgEl::data, casadi::MXNode::dep(), casadi::ProtoFunction::name_, casadi::GenericMatrix< MatType >::nnz(), print(), casadi::CodeGenerator::print_canonical(), casadi::CodeGenerator::printf(), casadi::MX::sparsity(), casadi::str(), and casadi::CodeGenerator::work().

◆ print_arg() [2/2]

void casadi::MXFunction::print_arg	(	std::ostream &	stream,
		casadi_int	k,
		const AlgEl &	el,
		const double **	arg
	)		const

Definition at line 577 of file mx_function.cpp.

                               {
     stream << name_ << ":" << k << ": " << print(el) << " inputs:" << std::endl;
     for (size_t i = 0; i < el.arg.size(); ++i) {
       if (arg[i]) {
         stream << i << ": ";
         if (print_canonical_) {
           print_canonical(stream, el.data->dep(i).sparsity(), arg[i]);
         } else {
           DM::print_default(stream, el.data->dep(i).sparsity(), arg[i], true);
         }
         stream << std::endl;
       }
     }
   }

References casadi::MXAlgEl::arg, casadi::MXAlgEl::data, casadi::MXNode::dep(), casadi::ProtoFunction::name_, print(), casadi::FunctionInternal::print_canonical(), casadi::FunctionInternal::print_canonical_, casadi::Matrix< double >::print_default(), and casadi::MX::sparsity().

Referenced by codegen_body(), and eval().

◆ print_canonical() [1/3]

void casadi::FunctionInternal::print_canonical	(	std::ostream &	stream,
		casadi_int	sz,
		const double *	nz
	)

staticinherited

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

Definition at line 966 of file function_internal.cpp.

                                                                                             {
     StreamStateGuard backup(stream);
     normalized_setup(stream);
     if (nz) {
       stream << "[";
       for (casadi_int i=0; i<sz; ++i) {
         if (i>0) stream << ", ";
         normalized_out(stream, nz[i]);
       }
       stream << "]";
     } else {
       stream << "NULL";
     }
   }

References casadi::normalized_out(), and casadi::normalized_setup().

◆ print_canonical() [2/3]

void casadi::FunctionInternal::print_canonical	(	std::ostream &	stream,
		const Sparsity &	sp,
		const double *	nz
	)

staticinherited

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

Definition at line 981 of file function_internal.cpp.

                                             {
     StreamStateGuard backup(stream);
     normalized_setup(stream);
     if (nz) {
       if (!sp.is_scalar(true)) {
         stream << sp.dim(false) << ": ";
         stream << "[";
       }
       for (casadi_int i=0; i<sp.nnz(); ++i) {
         if (i>0) stream << ", ";
         normalized_out(stream, nz[i]);
       }
       if (!sp.is_scalar(true)) {
         stream << "]";
         if (!sp.is_dense()) {
           stream << ", colind: [";
           for (casadi_int i=0; i<sp.size2()+1; ++i) {
             if (i>0) stream << ", ";
             stream << sp.colind()[i];
           }
           stream << "]";
           stream << ", row: [";
           for (casadi_int i=0; i<sp.nnz(); ++i) {
             if (i>0) stream << ", ";
             stream << sp.row()[i];
           }
           stream << "]";
         }
       }
     } else {
       stream << "NULL";
     }
   }

References casadi::Sparsity::colind(), casadi::Sparsity::dim(), casadi::Sparsity::is_dense(), casadi::Sparsity::is_scalar(), casadi::Sparsity::nnz(), casadi::normalized_out(), casadi::normalized_setup(), casadi::Sparsity::row(), and casadi::Sparsity::size2().

Referenced by casadi::Monitor::eval(), print_arg(), casadi::SXFunction::print_arg(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_out(), print_res(), and casadi::SXFunction::print_res().

◆ print_canonical() [3/3]

void casadi::FunctionInternal::print_canonical	(	std::ostream &	stream,
		double	a
	)

staticinherited

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

Definition at line 1016 of file function_internal.cpp.

                                                                      {
     StreamStateGuard backup(stream);
     normalized_setup(stream);
     normalized_out(stream, a);
   }

References casadi::normalized_out(), and casadi::normalized_setup().

◆ print_dimensions()

void casadi::FunctionInternal::print_dimensions ( std::ostream & stream ) const

inherited

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

Definition at line 1092 of file function_internal.cpp.

                                                                   {
     stream << " Number of inputs: " << n_in_ << std::endl;
     for (casadi_int i=0; i<n_in_; ++i) {
       stream << "  Input " << i  << " (\"" << name_in_[i] << "\"): "
              << sparsity_in_[i].dim() << std::endl;
     }
     stream << " Number of outputs: " << n_out_ << std::endl;
     for (casadi_int i=0; i<n_out_; ++i) {
       stream << "  Output " << i  << " (\"" << name_out_[i] << "\"): "
              << sparsity_out_[i].dim() << std::endl;
     }
   }

References casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sparsity_in_, and casadi::FunctionInternal::sparsity_out_.

◆ print_in()

void casadi::FunctionInternal::print_in	(	std::ostream &	stream,
		const double **	arg,
		bool	truncate
	)		const

inherited

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

Definition at line 932 of file function_internal.cpp.

                                                                                              {
     stream << "Function " << name_ << " (" << this << ")" << std::endl;
     for (casadi_int i=0; i<n_in_; ++i) {
       stream << "Input " << i << " (" << name_in_[i] << "): ";
       if (arg[i]) {
         if (print_canonical_) {
           print_canonical(stream, sparsity_in_[i], arg[i]);
         } else {
           DM::print_default(stream, sparsity_in_[i], arg[i], truncate);
         }
         stream << std::endl;
       } else {
         stream << "NULL" << std::endl;
       }
     }
   }

References casadi::FunctionInternal::n_in_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::print_canonical(), casadi::FunctionInternal::print_canonical_, casadi::Matrix< double >::print_default(), and casadi::FunctionInternal::sparsity_in_.

Referenced by casadi::FunctionInternal::eval_gen().

◆ print_option()

void casadi::ProtoFunction::print_option	(	const std::string &	name,
		std::ostream &	stream
	)		const

inherited

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

Definition at line 1109 of file function_internal.cpp.

                                                                                   {
     get_options().print_one(name, stream);
   }

References casadi::ProtoFunction::get_options(), and casadi::Options::print_one().

◆ print_options()

void casadi::ProtoFunction::print_options ( std::ostream & stream ) const

inherited

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

Definition at line 1105 of file function_internal.cpp.

                                                             {
     get_options().print_all(stream);
   }

References casadi::ProtoFunction::get_options(), and casadi::Options::print_all().

◆ print_out()

void casadi::FunctionInternal::print_out	(	std::ostream &	stream,
		double **	res,
		bool	truncate
	)		const

inherited

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

Definition at line 949 of file function_internal.cpp.

                                                                                         {
     stream << "Function " << name_ << " (" << this << ")" << std::endl;
     for (casadi_int i=0; i<n_out_; ++i) {
       stream << "Output " << i << " (" << name_out_[i] << "): ";
       if (res[i]) {
         if (print_canonical_) {
           print_canonical(stream, sparsity_out_[i], res[i]);
         } else {
           DM::print_default(stream, sparsity_out_[i], res[i], truncate);
         }
         stream << std::endl;
       } else {
         stream << "NULL" << std::endl;
       }
     }
   }

References casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::print_canonical(), casadi::FunctionInternal::print_canonical_, casadi::Matrix< double >::print_default(), and casadi::FunctionInternal::sparsity_out_.

Referenced by casadi::FunctionInternal::eval_gen().

◆ print_res() [1/2]

void casadi::MXFunction::print_res	(	CodeGenerator &	g,
		casadi_int	k,
		const AlgEl &	el,
		const std::vector< casadi_int > &	res,
		const std::vector< bool > &	res_is_ref
	)		const

Definition at line 606 of file mx_function.cpp.

                                                                                {
     g << g.printf(name_ + ":" + str(k) + ": " + print(el) + " outputs:\\n") << "\n";
     for (size_t i = 0; i < el.res.size(); ++i) {
       if (res[i]>=0) {
         g << g.printf(str(i) + ": ");
         std::string a = g.work(res[i], el.data->sparsity(i).nnz(), res_is_ref[i]);
         g << g.print_canonical(el.data->sparsity(i), a);
         g << g.printf("\\n") << "\n";
       }
     }
   }

References casadi::MXAlgEl::data, casadi::ProtoFunction::name_, casadi::Sparsity::nnz(), print(), casadi::CodeGenerator::print_canonical(), casadi::CodeGenerator::printf(), casadi::MXAlgEl::res, casadi::MXNode::sparsity(), casadi::str(), and casadi::CodeGenerator::work().

◆ print_res() [2/2]

void casadi::MXFunction::print_res	(	std::ostream &	stream,
		casadi_int	k,
		const AlgEl &	el,
		double **	res
	)		const

Definition at line 619 of file mx_function.cpp.

                           {
     stream << name_ << ":" << k << ": " << print(el) << " outputs:" << std::endl;
     for (size_t i = 0; i < el.res.size(); ++i) {
       if (res[i]) {
         stream << i << ": ";
         if (print_canonical_) {
           print_canonical(stream, el.data->sparsity(i), res[i]);
         } else {
           DM::print_default(stream, el.data->sparsity(i), res[i], true);
         }
         stream << std::endl;
       }
     }
   }

References casadi::MXAlgEl::data, casadi::ProtoFunction::name_, print(), casadi::FunctionInternal::print_canonical(), casadi::FunctionInternal::print_canonical_, casadi::Matrix< double >::print_default(), casadi::MXAlgEl::res, and casadi::MXNode::sparsity().

Referenced by codegen_body(), and eval().

◆ print_time()

void casadi::ProtoFunction::print_time ( const std::map< std::string, FStats > & fstats ) const

inherited

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

Definition at line 4078 of file function_internal.cpp.

                                                                               {
     if (!print_time_) return;
     // Length of the name being printed
     size_t name_len=0;
     for (auto &&s : fstats) {
       name_len = std::max(s.first.size(), name_len);
     }
     name_len = std::max(name_.size(), name_len);
  
     // Print name with a given length. Format: "%NNs "
     char namefmt[10];
     sprint(namefmt, sizeof(namefmt), "%%%ds ", static_cast<casadi_int>(name_len));
  
     // Print header
     print(namefmt, name_.c_str());
  
     print(" : %8s %10s %8s %10s %9s\n", "t_proc", "(avg)", "t_wall", "(avg)", "n_eval");
  
  
     char buffer_proc[10];
     char buffer_wall[10];
     char buffer_proc_avg[10];
     char buffer_wall_avg[10];
  
     // Print keys
     for (const auto &s : fstats) {
       if (s.second.n_call!=0) {
         print(namefmt, s.first.c_str());
         format_time(buffer_proc, s.second.t_proc);
         format_time(buffer_wall, s.second.t_wall);
         format_time(buffer_proc_avg, s.second.t_proc/s.second.n_call);
         format_time(buffer_wall_avg, s.second.t_wall/s.second.n_call);
         print(" | %s (%s) %s (%s) %9d\n",
           buffer_proc, buffer_proc_avg,
           buffer_wall, buffer_wall_avg, s.second.n_call);
       }
     }
   }

References casadi::ProtoFunction::format_time(), casadi::ProtoFunction::name_, casadi::ProtoFunction::print(), casadi::ProtoFunction::print_time_, and casadi::ProtoFunction::sprint().

Referenced by casadi::FunctionInternal::eval_gen().

◆ project_arg()

template<typename M >

std::vector< M > casadi::FunctionInternal::project_arg	(	const std::vector< M > &	arg,
		casadi_int	npar
	)		const

inherited

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

Definition at line 1680 of file function_internal.hpp.

                                                               {
     casadi_assert_dev(arg.size()==n_in_);
  
     // Which arguments require mapped evaluation
     std::vector<bool> mapped(n_in_);
     for (casadi_int i=0; i<n_in_; ++i) {
       mapped[i] = arg[i].size2()!=size2_in(i);
     }
  
     // Check if matching input sparsity
     std::vector<bool> matching(n_in_);
     bool any_mismatch = false;
     for (casadi_int i=0; i<n_in_; ++i) {
       if (mapped[i]) {
         matching[i] = arg[i].sparsity().is_stacked(sparsity_in(i), npar);
       } else {
         matching[i] = arg[i].sparsity()==sparsity_in(i);
       }
       any_mismatch = any_mismatch || !matching[i];
     }
  
     // Correct input sparsity
     if (any_mismatch) {
       std::vector<M> arg2(arg);
       for (casadi_int i=0; i<n_in_; ++i) {
         if (!matching[i]) {
           if (mapped[i]) {
             arg2[i] = project(arg2[i], repmat(sparsity_in(i), 1, npar));
           } else {
             arg2[i] = project(arg2[i], sparsity_in(i));
           }
         }
       }
       return arg2;
     }
     return arg;
   }

References casadi::FunctionInternal::n_in_, casadi::FunctionInternal::size2_in(), and casadi::FunctionInternal::sparsity_in().

Referenced by casadi::FunctionInternal::call_gen(), and casadi::FunctionInternal::nz_in().

◆ project_res()

template<typename M >

std::vector< M > casadi::FunctionInternal::project_res	(	const std::vector< M > &	arg,
		casadi_int	npar
	)		const

inherited

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

Definition at line 1720 of file function_internal.hpp.

                                                                 {
       return arg;
   }

Referenced by casadi::FunctionInternal::nz_out().

◆ purgable()

template<typename MatType >

bool casadi::FunctionInternal::purgable ( const std::vector< MatType > & seed )

staticinherited

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

Definition at line 1573 of file function_internal.hpp.

                                                              {
     for (auto i=v.begin(); i!=v.end(); ++i) {
       if (!i->is_zero()) return false;
     }
     return true;
   }

Referenced by ad_forward(), and ad_reverse().

◆ release()

void casadi::ProtoFunction::release ( int mem ) const

inherited

Definition at line 3937 of file function_internal.cpp.

                                            {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
     unused_.push(mem);
   }

Referenced by casadi::FunctionInternal::codegen_meta().

◆ replace_arg()

template<typename M >

std::vector< M > casadi::FunctionInternal::replace_arg	(	const std::vector< M > &	arg,
		casadi_int	npar
	)		const

inherited

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

Definition at line 1855 of file function_internal.hpp.

                                                               {
     std::vector<M> r(arg.size());
     for (casadi_int i=0; i<r.size(); ++i) r[i] = replace_mat(arg[i], sparsity_in(i), npar);
     return r;
   }

References casadi::replace_mat(), and casadi::FunctionInternal::sparsity_in().

Referenced by casadi::FunctionInternal::call(), casadi::FunctionInternal::nz_in(), and casadi::FunctionInternal::replace_fseed().

◆ replace_aseed() [1/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_aseed	(	const std::vector< std::vector< M > > &	aseed,
		casadi_int	npar
	)		const

inherited

Definition at line 1879 of file function_internal.hpp.

                                                                               {
     std::vector<std::vector<M> > r(aseed.size());
     for (casadi_int d=0; d<r.size(); ++d) r[d] = replace_res(aseed[d], npar);
     return r;
   }

References casadi::FunctionInternal::replace_res().

◆ replace_aseed() [2/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_aseed	(	const std::vector< std::vector< M >> &	aseed,
		casadi_int	npar
	)		const

inherited

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

Referenced by ad_reverse(), casadi::SXFunction::ad_reverse(), and casadi::FunctionInternal::call_reverse().

◆ replace_fseed() [1/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_fseed	(	const std::vector< std::vector< M > > &	fseed,
		casadi_int	npar
	)		const

inherited

Definition at line 1871 of file function_internal.hpp.

                                                                               {
     std::vector<std::vector<M> > r(fseed.size());
     for (casadi_int d=0; d<r.size(); ++d) r[d] = replace_arg(fseed[d], npar);
     return r;
   }

References casadi::FunctionInternal::replace_arg().

◆ replace_fseed() [2/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_fseed	(	const std::vector< std::vector< M >> &	fseed,
		casadi_int	npar
	)		const

inherited

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

Referenced by ad_forward(), casadi::SXFunction::ad_forward(), and casadi::FunctionInternal::call_forward().

◆ replace_res()

template<typename M >

std::vector< M > casadi::FunctionInternal::replace_res	(	const std::vector< M > &	res,
		casadi_int	npar
	)		const

inherited

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

Definition at line 1863 of file function_internal.hpp.

                                                               {
     std::vector<M> r(res.size());
     for (casadi_int i=0; i<r.size(); ++i) r[i] = replace_mat(res[i], sparsity_out(i), npar);
     return r;
   }

References casadi::replace_mat(), and casadi::FunctionInternal::sparsity_out().

Referenced by casadi::FunctionInternal::nz_out(), and casadi::FunctionInternal::replace_aseed().

◆ reset_dump_count()

void casadi::FunctionInternal::reset_dump_count ( )

inherited

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

Definition at line 471 of file function_internal.cpp.

                                           {
     dump_count_ = 0;
   }

References casadi::FunctionInternal::dump_count_.

◆ reverse()

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

inherited

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

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

Definition at line 2343 of file function_internal.cpp.

                                                           {
     casadi_assert_dev(nadj>=0);
     // Used wrapped function if reverse not available
     if (!enable_reverse_) {
       // Derivative information must be available
       casadi_assert(has_derivative(), "Derivatives cannot be calculated for " + name_);
       return wrap().reverse(nadj);
     }
     // Retrieve/generate cached
     Function f;
     std::string fname = reverse_name(name_, nadj);
     if (!incache(fname, f)) {
       casadi_int i;
       // Prefix to be used for adjoint seeds, sensitivities
       std::string pref = diff_prefix("adj");
       // Names of inputs
       std::vector<std::string> inames;
       for (i=0; i<n_in_; ++i) inames.push_back(name_in_[i]);
       for (i=0; i<n_out_; ++i) inames.push_back("out_" + name_out_[i]);
       for (i=0; i<n_out_; ++i) inames.push_back(pref + name_out_[i]);
       // Names of outputs
       std::vector<std::string> onames;
       for (casadi_int i=0; i<n_in_; ++i) onames.push_back(pref + name_in_[i]);
       // Options
       Dict opts = combine(reverse_options_, der_options_);
       opts = combine(opts, generate_options("reverse"));
       opts["derivative_of"] = self();
       // Generate derivative function
       casadi_assert_dev(enable_reverse_);
       f = get_reverse(nadj, fname, inames, onames, opts);
       // Consistency check for inputs
       casadi_assert_dev(f.n_in()==n_in_ + n_out_ + n_out_);
       casadi_int ind=0;
       for (i=0; i<n_in_; ++i) f.assert_size_in(ind++, size1_in(i), size2_in(i));
       for (i=0; i<n_out_; ++i) f.assert_size_in(ind++, size1_out(i), size2_out(i));
       for (i=0; i<n_out_; ++i) f.assert_size_in(ind++, size1_out(i), nadj*size2_out(i));
       // Consistency check for outputs
       casadi_assert_dev(f.n_out()==n_in_);
       for (i=0; i<n_in_; ++i) f.assert_sparsity_out(i, sparsity_in(i), nadj);
       // Save to cache
       tocache_if_missing(f);
     }
     return f;
   }

Referenced by casadi::FunctionInternal::call_reverse(), and casadi::Function::reverse().

◆ reverse_name()

static std::string casadi::FunctionInternal::reverse_name	(	const std::string &	fcn,
		casadi_int	nadj
	)

inlinestaticinherited

Definition at line 675 of file function_internal.hpp.

                                                                          {
       return "adj" + str(nadj) + "_" + fcn;
     }

References casadi::str().

Referenced by casadi::FunctionInternal::reverse(), and casadi::FixedStepIntegrator::stepB().

◆ self()

Function casadi::FunctionInternal::self ( ) const

inlineinherited

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

Definition at line 355 of file function_internal.hpp.

355 { return shared_from_this<Function>();}

Referenced by casadi::casadi_uno_term_cb_cpp(), casadi::ConoptInterface::cb_2dlagrstr(), casadi::ConoptInterface::cb_2dlagrval(), casadi::ConoptInterface::cb_fd_eval(), casadi::ConoptInterface::cb_fdevalini(), casadi::ConoptInterface::cb_progress(), and casadi::ConoptInterface::cb_read_matrix().

◆ serialize()

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

inherited

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

Definition at line 4451 of file function_internal.cpp.

                                                           {
     serialize_type(s);
     serialize_body(s);
   }

References casadi::ProtoFunction::serialize_body(), and casadi::ProtoFunction::serialize_type().

◆ serialize_base_function()

virtual std::string casadi::ProtoFunction::serialize_base_function ( ) const

inlinevirtualinherited

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

Reimplemented in casadi::LinearInterpolantJac, casadi::Rootfinder, casadi::OnnxFunction, casadi::Nlpsol, casadi::MapSum, casadi::Map, casadi::Interpolant, casadi::Integrator, casadi::External, casadi::Conic, and casadi::BlazingSplineFunction.

Definition at line 243 of file function_internal.hpp.

                                                       {
       return class_name();
     }

Referenced by casadi::FunctionInternal::serialize_type().

◆ serialize_body()

void casadi::MXFunction::serialize_body ( SerializingStream & s ) const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 1984 of file mx_function.cpp.

                                                             {
     XFunction<MXFunction, MX, MXNode>::serialize_body(s);
  
     s.version("MXFunction", 3);
     s.pack("MXFunction::n_instr", algorithm_.size());
  
     // Loop over algorithm
     for (const auto& e : algorithm_) {
       s.pack("MXFunction::alg::data", e.data);
       s.pack("MXFunction::alg::arg", e.arg);
       s.pack("MXFunction::alg::res", e.res);
     }
  
     s.pack("MXFunction::workloc", workloc_);
     s.pack("MXFunction::free_vars", free_vars_);
     s.pack("MXFunction::default_in", default_in_);
     s.pack("MXFunction::live_variables", live_variables_);
     s.pack("MXFunction::print_instructions", print_instructions_);
     s.pack("MXFunction::dump_trace", dump_trace_);
  
     XFunction<MXFunction, MX, MXNode>::delayed_serialize_members(s);
   }

References algorithm_, default_in_, casadi::XFunction< DerivedType, MatType, NodeType >::delayed_serialize_members(), dump_trace_, free_vars_, live_variables_, casadi::SerializingStream::pack(), print_instructions_, casadi::XFunction< DerivedType, MatType, NodeType >::serialize_body(), casadi::SerializingStream::version(), and workloc_.

◆ serialize_type()

void casadi::FunctionInternal::serialize_type ( SerializingStream & s ) const

overridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Reimplemented in casadi::LinearInterpolantJac, casadi::LinearInterpolant, casadi::Rootfinder, casadi::OnnxFunction, casadi::Nlpsol, casadi::MapSum, casadi::Map, casadi::Interpolant, and casadi::Integrator.

Definition at line 4243 of file function_internal.cpp.

                                                                   {
     s.pack("FunctionInternal::base_function", serialize_base_function());
   }

References casadi::SerializingStream::pack(), and casadi::ProtoFunction::serialize_base_function().

Referenced by casadi::Conic::serialize_type(), casadi::GenericExternal::serialize_type(), casadi::Integrator::serialize_type(), casadi::Interpolant::serialize_type(), casadi::Map::serialize_type(), casadi::MapSum::serialize_type(), casadi::Nlpsol::serialize_type(), casadi::OnnxFunction::serialize_type(), casadi::Rootfinder::serialize_type(), and casadi::LinearInterpolantJac::serialize_type().

◆ set_jac_sparsity()

void casadi::FunctionInternal::set_jac_sparsity	(	casadi_int	oind,
		casadi_int	iind,
		const Sparsity &	sp
	)

protectedinherited

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

Definition at line 4022 of file function_internal.cpp.

                                                                                               {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     // Safe access to jac_sparsity_
     std::lock_guard<std::mutex> lock(jac_sparsity_mtx_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi_int ind = iind + oind * n_in_;
     jac_sparsity_[false].resize(n_in_ * n_out_);
     jac_sparsity_[false].at(ind) = sp;
     jac_sparsity_[true].resize(n_in_ * n_out_);
     jac_sparsity_[true].at(ind) = to_compact(oind, iind, sp);
   }

References casadi::FunctionInternal::jac_sparsity_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, and casadi::FunctionInternal::to_compact().

◆ set_temp()

virtual void casadi::FunctionInternal::set_temp	(	void *	mem,
		const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w
	)		const

inlinevirtualinherited

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

Reimplemented in casadi::FatropConicInterface, and casadi::OracleFunction.

Definition at line 1279 of file function_internal.hpp.

1280 {}

Referenced by casadi::FunctionInternal::setup().

◆ set_work()

virtual void casadi::FunctionInternal::set_work	(	void *	mem,
		const double **&	arg,
		double **&	res,
		casadi_int *&	iw,
		double *&	w
	)		const

inlinevirtualinherited

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

Reimplemented in casadi::Sqpmethod, casadi::Scpgen, casadi::Qrsqp, casadi::Qrqp, casadi::Newton, casadi::ImplicitToNlp, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::XpressInterface, casadi::WorhpInterface, casadi::UnoInterface, casadi::SundialsInterface, casadi::KinsolInterface, casadi::SnoptInterface, casadi::SlicotExpm, casadi::SlicotDple, casadi::SLEQPInterface, casadi::MosekInterface, casadi::MadnlpInterface, casadi::KnitroInterface, casadi::IpoptInterface, casadi::HpipmInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::FatropConicInterface, casadi::DaqpInterface, casadi::ConoptInterface, casadi::ClarabelInterface, casadi::MadmpecInterface, casadi::BonminInterface, casadi::Blocksqp, casadi::AmplInterface, casadi::AlpaqaInterface, casadi::Rootfinder, casadi::Nlpsol, casadi::FixedStepIntegrator, casadi::Integrator, and casadi::Conic.

Definition at line 1273 of file function_internal.hpp.

1274 {}

Referenced by casadi::Integrator::set_work(), casadi::SlicotDple::set_work(), casadi::SlicotExpm::set_work(), and casadi::FunctionInternal::setup().

◆ setup()

void casadi::FunctionInternal::setup	(	void *	mem,
		const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w
	)		const

inherited

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

Definition at line 3796 of file function_internal.cpp.

                                                                 {
     set_work(mem, arg, res, iw, w);
     set_temp(mem, arg, res, iw, w);
     auto *m = static_cast<FunctionMemory*>(mem);
     m->stats_available = true;
   }

References casadi::FunctionInternal::set_temp(), casadi::FunctionInternal::set_work(), and casadi::FunctionMemory::stats_available.

Referenced by casadi::Conic::eval(), casadi::Nlpsol::eval(), casadi::CallbackInternal::eval(), casadi::FiniteDiff::eval(), casadi::FmuFunction::eval(), casadi::Integrator::eval(), casadi::Map::eval(), casadi::OmpMap::eval(), casadi::ThreadMap::eval(), casadi::MapSum::eval(), eval(), casadi::Rootfinder::eval(), casadi::Switch::eval(), casadi::SXFunction::eval(), casadi::SlicotDple::eval(), casadi::SlicotExpm::eval(), casadi::BSplineInterpolant::eval(), and casadi::LinearInterpolant::eval().

◆ shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
       B ret;
       ret.own(static_cast<Internal*>(this));
       return ret;
     }

◆ shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                      {
       casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
       B ret;
       ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
       return ret;
     }

◆ should_inline()

bool casadi::MXFunction::should_inline	(	bool	with_sx,
		bool	always_inline,
		bool	never_inline
	)		const

overridevirtual

Inline calls?

Implements casadi::XFunction< MXFunction, MX, MXNode >.

Definition at line 1640 of file mx_function.cpp.

                                                                                           {
     // If inlining has been specified
     casadi_assert(!(always_inline && never_inline),
       "Inconsistent options for " + definition());
     casadi_assert(!(never_inline && has_free()),
       "Must inline " + definition());
     if (always_inline) return true;
     if (never_inline) return false;
     // Functions with free variables must be inlined
     if (has_free()) return true;
     // Default inlining only when called with sx
     return with_sx;
   }

References casadi::FunctionInternal::definition(), and has_free().

Referenced by eval_mx(), and eval_sx().

◆ signature()

std::string casadi::FunctionInternal::signature ( const std::string & fname ) const

inherited

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

Definition at line 2555 of file function_internal.cpp.

                                                                     {
     return "int " + fname + "(const casadi_real** arg, casadi_real** res, "
                             "casadi_int* iw, casadi_real* w, int mem)";
   }

Referenced by casadi::CodeGenerator::add(), casadi::FunctionInternal::codegen(), casadi::External::codegen_declarations(), and casadi::OnnxFunction::init().

◆ signature_unrolled()

std::string casadi::FunctionInternal::signature_unrolled ( const std::string & fname ) const

inherited

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

Definition at line 2560 of file function_internal.cpp.

                                                                              {
     std::vector<std::string> args;
     for (auto e : name_in_) {
       args.push_back("const casadi_real* " + str(e));
     }
     for (auto e : name_out_) {
       args.push_back("casadi_real* " + str(e));
     }
     args.push_back("const casadi_real** arg");
     args.push_back("casadi_real** res");
     args.push_back("casadi_int* iw");
     args.push_back("casadi_real* w");
     args.push_back("int mem");
     return "int " + fname + "_unrolled(" + join(args, ", ") + ")";
   }

References casadi::join(), casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, and casadi::str().

Referenced by casadi::CodeGenerator::add().

◆ simplify_passes()

Function casadi::XFunction< MXFunction , MX , MXNode >::simplify_passes ( const std::vector< std::pair< std::string, casadi_int > > & tasks ) const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 166 of file x_function.hpp.

                                                                      {
     std::vector<MatType> new_in = in_;
     std::vector<MatType> new_out = out_;
     Dict final_options = generate_options("clone");
     final_options["allow_duplicate_io_names"] = true;
     final_options["allow_free"] = true;
     apply_simplify_passes(tasks, new_in, new_out);
     return Function(name_, new_in, new_out, name_in_, name_out_, final_options);
   }

◆ size1_in()

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

inlineinherited

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

Definition at line 1029 of file function_internal.hpp.

1029 { return sparsity_in(ind).size1(); }

casadi::Sparsity::size1

casadi_int size1() const

Get the number of rows.

Definition: sparsity.cpp:124

Referenced by casadi::FunctionInternal::check_arg(), casadi::FmuFunction::eval(), casadi::FmuFunction::eval_task(), casadi::FunctionInternal::forward(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::FunctionInternal::matching_arg(), and casadi::FunctionInternal::reverse().

◆ size1_out()

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

inlineinherited

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

Definition at line 1031 of file function_internal.hpp.

1031 { return sparsity_out(ind).size1(); }

Referenced by casadi::FmuFunction::eval_task(), casadi::FunctionInternal::forward(), casadi::Integrator::get_forward(), casadi::LinearInterpolantJac::get_jacobian(), casadi::FunctionInternal::matching_res(), and casadi::FunctionInternal::reverse().

◆ size2_in()

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

inlineinherited

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

Definition at line 1030 of file function_internal.hpp.

1030 { return sparsity_in(ind).size2(); }

casadi::Sparsity::size2

casadi_int size2() const

Get the number of columns.

Definition: sparsity.cpp:128

Referenced by casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::check_arg(), casadi::FunctionInternal::forward(), casadi::Integrator::get_reverse(), casadi::FunctionInternal::mapsum_mx(), casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::project_arg(), and casadi::FunctionInternal::reverse().

◆ size2_out()

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

inlineinherited

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

Definition at line 1032 of file function_internal.hpp.

1032 { return sparsity_out(ind).size2(); }

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::forward(), casadi::Integrator::get_forward(), casadi::LinearInterpolantJac::get_jacobian(), casadi::FunctionInternal::matching_res(), and casadi::FunctionInternal::reverse().

◆ size_in()

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

inlineinherited

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

Definition at line 1033 of file function_internal.hpp.

                                                                   {
       return sparsity_in(ind).size();
     }

Referenced by casadi::Rootfinder::ad_forward(), casadi::Rootfinder::ad_reverse(), ad_reverse(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::fwd_seed(), casadi::Dple::get_forward(), and casadi::Dple::get_reverse().

◆ size_out()

std::pair<casadi_int, casadi_int> casadi::FunctionInternal::size_out ( casadi_int ind ) const

inlineinherited

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

Definition at line 1036 of file function_internal.hpp.

                                                                    {
       return sparsity_out(ind).size();
     }

Referenced by ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::check_res(), casadi::FunctionInternal::eval(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), and casadi::Nlpsol::init().

◆ slice()

Function casadi::XFunction< MXFunction , MX , MXNode >::slice	(	const std::string &	name,
		const std::vector< casadi_int > &	order_in,
		const std::vector< casadi_int > &	order_out,
		const Dict &	opts
	)		const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 160 of file x_function.hpp.

                                                                           {
     // Return expressions
     std::vector<MatType> ret_in, ret_out;
     std::vector<std::string> ret_in_name, ret_out_name;
  
     // Reorder inputs
     for (casadi_int k : order_in) {
       ret_in.push_back(in_.at(k));
       ret_in_name.push_back(name_in_.at(k));
     }
  
     // Reorder outputs
     for (casadi_int k : order_out) {
       ret_out.push_back(out_.at(k));
       ret_out_name.push_back(name_out_.at(k));
     }
  
     // Assemble function
     return Function(name, ret_in, ret_out,
                     ret_in_name, ret_out_name, opts);
   }

◆ sort_depth_first()

void casadi::XFunction< MXFunction , MX , MXNode >::sort_depth_first	(	std::stack< MXNode * > &	s,
		std::vector< MXNode * > &	nodes
	)

staticinherited

This function modifies the temp member of the nodes, making it not thread-safe.

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

Definition at line 93 of file x_function.hpp.

                                                            {
     while (!s.empty()) {
       // Get the topmost element
       NodeType* t = s.top();
       // If the last element on the stack has not yet been added
       if (t && t->temp>=0) {
         // Get the index of the next dependency
         casadi_int next_dep = t->temp++;
         // If there is any dependency which has not yet been added
         if (next_dep < t->n_dep()) {
           // Add dependency to stack
           s.push(static_cast<NodeType*>(t->dep(next_dep).get()));
         } else {
           // if no dependencies need to be added, we can add the node to the algorithm
           nodes.push_back(t);
           // Mark the node as found
           t->temp = -1;
           // Remove from stack
           s.pop();
         }
       } else {
         // If the last element on the stack has already been added
         s.pop();
       }
     }
   }

◆ sp_forward()

int casadi::MXFunction::sp_forward	(	const bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem
	)		const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 643 of file mx_function.cpp.

                                                                                            {
     // Fall back when forward mode not allowed
     if (sp_weight()==1 || sp_weight()==-1)
       return FunctionInternal::sp_forward(arg, res, iw, w, mem);
     // Temporaries to hold pointers to operation input and outputs
     const bvec_t** arg1=arg+n_in_;
     bvec_t** res1=res+n_out_;
  
     // Propagate sparsity forward
     for (auto&& e : algorithm_) {
       if (e.op==OP_INPUT) {
         // Pass input seeds
         casadi_int nnz=e.data.nnz();
         casadi_int i=e.data->ind();
         casadi_int nz_offset=e.data->offset();
         const bvec_t* argi = arg[i];
         bvec_t* w1 = w + workloc_[e.res.front()];
         if (argi!=nullptr && is_diff_in_[i]) {
           std::copy(argi+nz_offset, argi+nz_offset+nnz, w1);
         } else {
           std::fill_n(w1, nnz, 0);
         }
       } else if (e.op==OP_OUTPUT) {
         // Get the output sensitivities
         casadi_int nnz=e.data.dep().nnz();
         casadi_int i=e.data->ind();
         casadi_int nz_offset=e.data->offset();
         bvec_t* resi = res[i];
         bvec_t* w1 = w + workloc_[e.arg.front()];
         if (resi!=nullptr && is_diff_out_[i]) {
           std::copy(w1, w1+nnz, resi+nz_offset);
         } else if (resi!=nullptr) {
           std::fill_n(resi+nz_offset, nnz, 0);
         }
       } else {
         // Point pointers to the data corresponding to the element
         for (casadi_int i=0; i<e.arg.size(); ++i)
           arg1[i] = e.arg[i]>=0 ? w+workloc_[e.arg[i]] : nullptr;
         for (casadi_int i=0; i<e.res.size(); ++i)
           res1[i] = e.res[i]>=0 ? w+workloc_[e.res[i]] : nullptr;
  
         // Propagate sparsity forwards
         if (e.data->sp_forward(arg1, res1, iw, w)) return 1;
       }
     }
     return 0;
   }

References algorithm_, casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::is_diff_out_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::FunctionInternal::sp_forward(), casadi::FunctionInternal::sp_weight(), and workloc_.

◆ sp_forward_block()

int casadi::FunctionInternal::sp_forward_block	(	const bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem,
		casadi_int	oind,
		casadi_int	iind
	)		const

virtualinherited

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

Definition at line 3102 of file function_internal.cpp.

                                                                                     {
     // Get the sparsity of the Jacobian block
     Sparsity sp = jac_sparsity(oind, iind, true, false);
     if (sp.is_null() || sp.nnz() == 0) return 0; // Skip if zero
     // Carry out the sparse matrix-vector multiplication
     casadi_int d1 = sp.size2();
     const casadi_int *colind = sp.colind(), *row = sp.row();
     for (casadi_int cc=0; cc<d1; ++cc) {
       for (casadi_int el = colind[cc]; el < colind[cc+1]; ++el) {
         res[oind][row[el]] |= arg[iind][cc];
       }
     }
     return 0;
   }

References casadi::Sparsity::colind(), casadi::GenericShared< Shared, Internal >::is_null(), casadi::FunctionInternal::jac_sparsity(), casadi::Sparsity::nnz(), casadi::Sparsity::row(), and casadi::Sparsity::size2().

Referenced by casadi::FunctionInternal::sp_forward().

◆ sp_reverse()

int casadi::MXFunction::sp_reverse	(	bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem
	)		const

overridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 756 of file mx_function.cpp.

                                                   {
     // Fall back when reverse mode not allowed
     if (sp_weight()==0 || sp_weight()==-1)
       return FunctionInternal::sp_reverse(arg, res, iw, w, mem);
     // Temporaries to hold pointers to operation input and outputs
     bvec_t** arg1=arg+n_in_;
     bvec_t** res1=res+n_out_;
  
     std::fill_n(w, sz_w(), 0);
  
     // Propagate sparsity backwards
     for (auto it=algorithm_.rbegin(); it!=algorithm_.rend(); it++) {
       if (it->op==OP_INPUT) {
         // Get the input sensitivities and clear it from the work vector
         casadi_int nnz=it->data.nnz();
         casadi_int i=it->data->ind();
         casadi_int nz_offset=it->data->offset();
         bvec_t* argi = arg[i];
         bvec_t* w1 = w + workloc_[it->res.front()];
         if (argi!=nullptr && is_diff_in_[i])
           for (casadi_int k=0; k<nnz; ++k) argi[nz_offset+k] |= w1[k];
         std::fill_n(w1, nnz, 0);
       } else if (it->op==OP_OUTPUT) {
         // Pass output seeds
         casadi_int nnz=it->data.dep().nnz();
         casadi_int i=it->data->ind();
         casadi_int nz_offset=it->data->offset();
         bvec_t* resi = res[i] ? res[i] + nz_offset : nullptr;
         bvec_t* w1 = w + workloc_[it->arg.front()];
         if (resi!=nullptr && is_diff_out_[i]) {
           for (casadi_int k=0; k<nnz; ++k) w1[k] |= resi[k];
           std::fill_n(resi, nnz, 0);
         }
       } else {
         // Point pointers to the data corresponding to the element
         for (casadi_int i=0; i<it->arg.size(); ++i)
           arg1[i] = it->arg[i]>=0 ? w+workloc_[it->arg[i]] : nullptr;
         for (casadi_int i=0; i<it->res.size(); ++i)
           res1[i] = it->res[i]>=0 ? w+workloc_[it->res[i]] : nullptr;
  
         // Propagate sparsity backwards
         if (it->data->sp_reverse(arg1, res1, iw, w)) return 1;
       }
     }
     return 0;
   }

References algorithm_, casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::is_diff_out_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::FunctionInternal::sp_reverse(), casadi::FunctionInternal::sp_weight(), casadi::FunctionInternal::sz_w(), and workloc_.

◆ sp_weight()

double casadi::FunctionInternal::sp_weight ( ) const

virtualinherited

sparsity propagation

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

Definition at line 3533 of file function_internal.cpp.

                                            {
     // If reverse mode propagation unavailable, use forward
     if (!has_sprev()) return 0;
  
     // If forward mode propagation unavailable, use reverse
     if (!has_spfwd()) return 1;
  
     // Use the (potentially user set) option
     return ad_weight_sp_;
   }

References casadi::FunctionInternal::ad_weight_sp_, casadi::FunctionInternal::has_spfwd(), and casadi::FunctionInternal::has_sprev().

Referenced by casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), sp_forward(), casadi::SXFunction::sp_forward(), sp_reverse(), casadi::SXFunction::sp_reverse(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

◆ sparsity_in()

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

inlineinherited

◆ sparsity_out()

const Sparsity& casadi::FunctionInternal::sparsity_out ( casadi_int ind ) const

inlineinherited

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

Definition at line 1046 of file function_internal.hpp.

1046 { return sparsity_out_.at(ind); }

◆ sprint()

void casadi::ProtoFunction::sprint	(	char *	buf,
		size_t	buf_sz,
		const char *	fmt,
			...
	)		const

inherited

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

Definition at line 4146 of file function_internal.cpp.

                                                                                  {
     // Variable number of arguments
     va_list args;
     va_start(args, fmt);
     // Print to buffer
     casadi_int n = vsnprintf(buf, buf_sz, fmt, args);
     // Cleanup
     va_end(args);
     // Throw error if failure
     casadi_assert(n>=0 && n<buf_sz, "Print failure while processing '" + std::string(fmt) + "'");
   }

Referenced by casadi::ProtoFunction::format_time(), and casadi::ProtoFunction::print_time().

◆ string_from_UnifiedReturnStatus()

std::string casadi::FunctionInternal::string_from_UnifiedReturnStatus ( UnifiedReturnStatus status )

staticinherited

Definition at line 4214 of file function_internal.cpp.

                                                                                         {
     switch (status) {
       case SOLVER_RET_LIMITED:  return "SOLVER_RET_LIMITED";
       case SOLVER_RET_NAN:  return "SOLVER_RET_NAN";
       case SOLVER_RET_SUCCESS:  return "SOLVER_RET_SUCCESS";
       default: return "SOLVER_RET_UNKNOWN";
     }
   }

References casadi::SOLVER_RET_LIMITED, casadi::SOLVER_RET_NAN, and casadi::SOLVER_RET_SUCCESS.

Referenced by casadi::Conic::get_stats(), casadi::Nlpsol::get_stats(), and casadi::Rootfinder::get_stats().

◆ substitute_inplace()

void casadi::MXFunction::substitute_inplace	(	std::vector< MX > &	vdef,
		std::vector< MX > &	ex
	)		const

Definition at line 1585 of file mx_function.cpp.

                                                                                   {
     std::vector<MX> work(workloc_.size()-1);
     std::vector<MX> oarg, ores;
  
     // Output segments
     std::vector<std::vector<MX>> out_split(out_.size());
     for (casadi_int i = 0; i < out_split.size(); ++i) out_split[i].resize(out_[i].n_primitives());
  
     // Evaluate algorithm
     for (auto it=algorithm_.begin(); it!=algorithm_.end(); ++it) {
       switch (it->op) {
       case OP_INPUT:
         casadi_assert(it->data->segment()==0, "Not implemented");
         work.at(it->res.front())
           = out_.at(it->data->ind()).join_primitives(out_split.at(it->data->ind()));
         break;
       case OP_PARAMETER:
       case OP_CONST:
         work.at(it->res.front()) = it->data;
         break;
       case OP_OUTPUT:
         out_split.at(it->data->ind()).at(it->data->segment()) = work.at(it->arg.front());
         break;
       default:
         {
           // Arguments of the operation
           oarg.resize(it->arg.size());
           for (casadi_int i=0; i<oarg.size(); ++i) {
             casadi_int el = it->arg[i];
             oarg[i] = el<0 ? MX(it->data->dep(i).size()) : work.at(el);
           }
  
           // Perform the operation
           ores.resize(it->res.size());
           it->data->eval_mx(oarg, ores);
  
           // Get the result
           for (casadi_int i=0; i<ores.size(); ++i) {
             casadi_int el = it->res[i];
             if (el>=0) work.at(el) = ores[i];
           }
         }
       }
     }
     // Join primitives
     for (size_t k = 0; k < out_split.size(); ++k) {
       MX a = out_.at(k).join_primitives(out_split.at(k));
       if (k < vdef.size()) {
         vdef.at(k) = a;
       } else {
         ex.at(k - vdef.size()) = a;
       }
     }
   }

References algorithm_, casadi::OP_CONST, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::OP_PARAMETER, casadi::XFunction< MXFunction, MX, MXNode >::out_, and workloc_.

◆ sx_in() [1/2]

const std::vector< SX > casadi::FunctionInternal::sx_in ( ) const

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 3560 of file function_internal.cpp.

                                                     {
     std::vector<SX> ret(n_in_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = sx_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_in_.

◆ sx_in() [2/2]

const SX casadi::FunctionInternal::sx_in ( casadi_int ind ) const

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 3544 of file function_internal.cpp.

                                                        {
     return SX::sym(name_in_.at(ind), sparsity_in(ind));
   }

References casadi::FunctionInternal::name_in_, casadi::FunctionInternal::sparsity_in(), and casadi::GenericMatrix< Matrix< Scalar > >::sym().

◆ sx_out() [1/2]

const std::vector< SX > casadi::FunctionInternal::sx_out ( ) const

virtualinherited

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

Definition at line 3568 of file function_internal.cpp.

                                                      {
     std::vector<SX> ret(n_out_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = sx_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_out_.

◆ sx_out() [2/2]

const SX casadi::FunctionInternal::sx_out ( casadi_int ind ) const

virtualinherited

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

Definition at line 3548 of file function_internal.cpp.

                                                         {
     return SX::sym(name_out_.at(ind), sparsity_out(ind));
   }

References casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sparsity_out(), and casadi::GenericMatrix< Matrix< Scalar > >::sym().

◆ symbolic_output()

std::vector< MX > casadi::MXFunction::symbolic_output ( const std::vector< MX > & arg ) const

overridevirtual

Reimplemented from casadi::FunctionInternal.

Definition at line 804 of file mx_function.cpp.

                                                                           {
     // Check if input is given
     const casadi_int checking_depth = 2;
     bool input_given = true;
     for (casadi_int i=0; i<arg.size() && input_given; ++i) {
       if (!is_equal(arg[i], in_[i], checking_depth)) {
         input_given = false;
       }
     }
  
     // Return output if possible, else fall back to base class
     if (input_given) {
       return out_;
     } else {
       return FunctionInternal::symbolic_output(arg);
     }
   }

References casadi::XFunction< MXFunction, MX, MXNode >::in_, casadi::is_equal(), casadi::XFunction< MXFunction, MX, MXNode >::out_, and casadi::FunctionInternal::symbolic_output().

◆ symbolicAdjSeed()

template<typename MatType >

std::vector< std::vector< MatType > > casadi::FunctionInternal::symbolicAdjSeed	(	casadi_int	nadj,
		const std::vector< MatType > &	v
	)		const

inherited

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

Definition at line 1598 of file function_internal.hpp.

                                                                       {
     std::vector<std::vector<MatType> > aseed(nadj, v);
     for (casadi_int dir=0; dir<nadj; ++dir) {
       // Replace symbolic inputs
       casadi_int oind=0;
       for (typename std::vector<MatType>::iterator i=aseed[dir].begin();
           i!=aseed[dir].end();
           ++i, ++oind) {
         // Name of the adjoint seed
         std::stringstream ss;
         ss << "a";
         if (nadj>1) ss << dir << "_";
         ss << oind;
  
         // Save to matrix
         *i = MatType::sym(ss.str(), is_diff_out_[oind] ? i->sparsity() : Sparsity(i->size()));
  
       }
     }
     return aseed;
   }

References casadi::FunctionInternal::is_diff_out_.

◆ sz_arg()

size_t casadi::FunctionInternal::sz_arg ( ) const

inlineinherited

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

Definition at line 1218 of file function_internal.hpp.

1218 { return sz_arg_per_ + sz_arg_tmp_;}

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::alloc_arg(), casadi::FunctionInternal::call_gen(), casadi::OmpMap::codegen_body(), casadi::ThreadMap::codegen_body(), casadi::ThreadMap::codegen_declarations(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sz_arg(), casadi::OmpMap::eval(), eval_sx(), casadi::OracleFunction::finalize(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::External::init(), casadi::Nlpsol::init(), casadi::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::Qrqp::init(), and casadi::FunctionInternal::sz_work().

◆ sz_iw()

size_t casadi::FunctionInternal::sz_iw ( ) const

inlineinherited

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

Definition at line 1228 of file function_internal.hpp.

1228 { return sz_iw_per_ + sz_iw_tmp_;}

◆ sz_res()

size_t casadi::FunctionInternal::sz_res ( ) const

inlineinherited

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

Definition at line 1223 of file function_internal.hpp.

1223 { return sz_res_per_ + sz_res_tmp_;}

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::alloc_res(), casadi::FunctionInternal::call_gen(), casadi::OmpMap::codegen_body(), casadi::ThreadMap::codegen_body(), casadi::ThreadMap::codegen_declarations(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sz_res(), casadi::OmpMap::eval(), eval_sx(), casadi::OracleFunction::finalize(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::External::init(), casadi::Nlpsol::init(), casadi::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::Qrqp::init(), and casadi::FunctionInternal::sz_work().

◆ sz_w()

size_t casadi::FunctionInternal::sz_w ( ) const

inlineinherited

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

Definition at line 1233 of file function_internal.hpp.

1233 { return sz_w_per_ + sz_w_tmp_;}

◆ sz_work()

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

inherited

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

Definition at line 3150 of file function_internal.cpp.

                                                                     {
     sz_arg = this->sz_arg();
     sz_res = this->sz_res();
     sz_iw = this->sz_iw();
     sz_w = this->sz_w();
   }

References casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), and casadi::FunctionInternal::sz_w().

◆ to_compact()

Sparsity casadi::FunctionInternal::to_compact	(	casadi_int	oind,
		casadi_int	iind,
		const Sparsity &	sp
	)		const

inherited

Definition at line 2036 of file function_internal.cpp.

                                 {
     // Strip rows and columns
     std::vector<casadi_int> mapping;
     return sp.sub(sparsity_out(oind).find(), sparsity_in(iind).find(), mapping);
   }

References casadi::FunctionInternal::find(), casadi::FunctionInternal::sparsity_in(), casadi::FunctionInternal::sparsity_out(), and casadi::Sparsity::sub().

Referenced by casadi::FunctionInternal::jac_sparsity(), and casadi::FunctionInternal::set_jac_sparsity().

◆ tocache()

void casadi::FunctionInternal::tocache	(	const Function &	f,
		const std::string &	suffix = `""`
	)		const

inherited

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

Definition at line 1192 of file function_internal.cpp.

                                                                                  {
     cache_.tocache(f.name() + ":" + suffix, f);
   }

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

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::BlazingSplineFunction::get_jacobian(), and casadi::FunctionInternal::init().

◆ tocache_if_missing()

void casadi::FunctionInternal::tocache_if_missing	(	Function &	f,
		const std::string &	suffix = `""`
	)		const

inherited

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

Definition at line 1196 of file function_internal.cpp.

                                                                                       {
     cache_.tocache_if_missing(f.name() + ":" + suffix, f);
   }

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

Referenced by casadi::MapSum::create(), casadi::OracleFunction::create_function(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::map(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::wrap().

◆ trace_instruction()

void casadi::MXFunction::trace_instruction	(	std::ostream &	trace,
		casadi_int	k,
		const double *	w,
		bool	output
	)		const

Definition at line 516 of file mx_function.cpp.

                                           {
     const auto& e = algorithm_.at(k);
     const auto& slots = output ? e.res : e.arg;
     casadi_int n = slots.size();
     if (e.op == OP_INPUT && !output) n = 0;
     if (e.op == OP_OUTPUT && output) n = 0;
     trace << "{\"instruction\":" << k << ",\"op\":" << e.op
           << ",\"phase\":\"" << (output ? "outputs" : "inputs") << "\",\"values\":[";
     for (casadi_int i = 0; i < n; ++i) {
       if (i) trace << ",";
       casadi_int nnz = output ? e.data->sparsity(i).nnz() : e.data->dep(i).nnz();
       trace_values(trace, slots[i] < 0 ? nullptr : w + workloc_[slots[i]], nnz);
     }
     trace << "]}\n";
   }

References algorithm_, casadi::OP_INPUT, casadi::OP_OUTPUT, casadi::FunctionInternal::trace_values(), and workloc_.

Referenced by eval().

◆ trace_values()

void casadi::FunctionInternal::trace_values	(	std::ostream &	trace,
		const double *	values,
		casadi_int	nnz
	)

staticprotectedinherited

Definition at line 826 of file function_internal.cpp.

                                                                         {
     if (!values) {
       trace << "null";
       return;
     }
     trace << "[";
     for (casadi_int i = 0; i < nnz; ++i) {
       if (i) trace << ",";
       double v = values[i];
       if (isnan(v)) {
         trace << "\"nan\"";
       } else if (isinf(v)) {
         trace << (v < 0 ? "\"-inf\"" : "\"inf\"");
       } else {
         normalized_out(trace, v);
       }
     }
     trace << "]";
   }

References casadi::normalized_out().

Referenced by casadi::FunctionInternal::finish_trace(), casadi::FunctionInternal::open_trace(), trace_instruction(), and casadi::SXFunction::trace_instruction().

◆ uses_output()

virtual bool casadi::FunctionInternal::uses_output ( ) const

inlinevirtualinherited

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

Reimplemented in casadi::Rootfinder, casadi::OnnxFunction, casadi::Nlpsol, casadi::FiniteDiff, and casadi::CallbackInternal.

Definition at line 626 of file function_internal.hpp.

626 {return false;}

Referenced by casadi::FunctionInternal::get_sparsity_in().

◆ weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

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

Definition at line 67 of file generic_shared_internal.hpp.

                                                                                   {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     auto* w = weak_ref_.load(std::memory_order_acquire);
     if (!w) {
       auto* nw = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
       GenericWeakRef<Shared, Internal>* expected = nullptr;
       if (weak_ref_.compare_exchange_strong(
             expected, nw, std::memory_order_release, std::memory_order_acquire)) {
         w = nw;
       } else {
         delete nw; // lost the race; another thread published first
         w = expected;
       }
     }
     return w;
 #else
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
   }

◆ which_depends()

std::vector< bool > casadi::XFunction< MXFunction , MX , MXNode >::which_depends	(	const std::string &	s_in,
		const std::vector< std::string > &	s_out,
		casadi_int	order,
		bool	tr = `false`
	)		const

overridevirtualinherited

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_xu

Reimplemented from casadi::FunctionInternal.

Definition at line 120 of file x_function.hpp.

                                        {
  
     // Input arguments
     auto it = std::find(name_in_.begin(), name_in_.end(), s_in);
     casadi_assert_dev(it!=name_in_.end());
     MatType arg = in_.at(it-name_in_.begin());
  
     // Output arguments
     std::vector<MatType> res;
     for (auto&& s : s_out) {
       it = std::find(name_out_.begin(), name_out_.end(), s);
       casadi_assert_dev(it!=name_out_.end());
       res.push_back(out_.at(it-name_out_.begin()));
     }
  
     // Extract variables entering nonlinearly
     return MatType::which_depends(veccat(res), arg, order, tr);
   }

◆ wrap() [1/2]

Function casadi::FunctionInternal::wrap ( ) const

inherited

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

Definition at line 1240 of file function_internal.cpp.

                                         {
     return wrap("wrap_" + name_);
   }

References casadi::ProtoFunction::name_.

Referenced by casadi::FunctionInternal::eval_mx(), casadi::FunctionInternal::factory(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::slice().

◆ wrap() [2/2]

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

inherited

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

Definition at line 1244 of file function_internal.cpp.

                                                              {
     Function f;
     if (!incache(name, f)) {
       // Options
       Dict opts;
       opts["derivative_of"] = derivative_of_;
       opts["ad_weight"] = ad_weight();
       opts["ad_weight_sp"] = sp_weight();
       opts["max_num_dir"] = max_num_dir_;
       opts["is_diff_in"] = is_diff_in_;
       opts["is_diff_out"] = is_diff_out_;
       // Wrap the function
       std::vector<MX> arg = mx_in();
       std::vector<MX> res = self()(arg);
       f = Function(name, arg, res, name_in_, name_out_, opts);
       // Save in cache
       tocache_if_missing(f);
     }
     return f;
   }

References casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::derivative_of_, casadi::FunctionInternal::Function, casadi::FunctionInternal::incache(), casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::is_diff_out_, casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::mx_in(), casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sp_weight(), and casadi::FunctionInternal::tocache_if_missing().

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

◆ wrap_as_needed() [1/2]

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

inherited

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

Definition at line 1219 of file function_internal.cpp.

                                                                   {
     return wrap_as_needed("wrap_" + name_, opts);
   }

References casadi::ProtoFunction::name_, and casadi::FunctionInternal::wrap_as_needed().

◆ wrap_as_needed() [2/2]

Function casadi::FunctionInternal::wrap_as_needed	(	const std::string &	name,
		const Dict &	opts
	)		const

inherited

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

Definition at line 1223 of file function_internal.cpp.

                                                                                          {
     if (opts.empty() && name==name_) return shared_from_this<Function>();
     // Options
     Dict my_opts = opts;
     my_opts["derivative_of"] = derivative_of_;
     if (my_opts.find("ad_weight")==my_opts.end())
       my_opts["ad_weight"] = ad_weight();
     if (my_opts.find("ad_weight_sp")==my_opts.end())
       my_opts["ad_weight_sp"] = sp_weight();
     if (my_opts.find("max_num_dir")==my_opts.end())
       my_opts["max_num_dir"] = max_num_dir_;
     // Wrap the function
     std::vector<MX> arg = mx_in();
     std::vector<MX> res = self()(arg);
     return Function(name, arg, res, name_in_, name_out_, my_opts);
   }

References casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::derivative_of_, casadi::FunctionInternal::Function, casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::mx_in(), casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, and casadi::FunctionInternal::sp_weight().

Referenced by casadi::Function::wrap_as_needed(), and casadi::FunctionInternal::wrap_as_needed().

Member Data Documentation

◆ ad_weight_

double casadi::FunctionInternal::ad_weight_

inherited

Definition at line 1420 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ ad_weight_sp_

double casadi::FunctionInternal::ad_weight_sp_

inherited

Definition at line 1420 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::sp_weight().

◆ algorithm_

std::vector<AlgEl> casadi::MXFunction::algorithm_

◆ always_inline_

bool casadi::FunctionInternal::always_inline_

inherited

Definition at line 1309 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::eval_mx(), eval_mx(), casadi::SXFunction::eval_mx(), casadi::FunctionInternal::eval_sx(), eval_sx(), casadi::SXFunction::eval_sx(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ cache_

WeakCache<std::string, Function> casadi::FunctionInternal::cache_

mutableinherited

Definition at line 1391 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::cache(), casadi::FunctionInternal::incache(), casadi::FunctionInternal::tocache(), and casadi::FunctionInternal::tocache_if_missing().

◆ cache_init_

Dict casadi::FunctionInternal::cache_init_

inherited

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

Definition at line 1388 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ checkout_

casadi_checkout_t casadi::FunctionInternal::checkout_

inherited

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

Definition at line 1358 of file function_internal.hpp.

Referenced by casadi::GenericExternal::any_symbol_found(), casadi::External::codegen_checkout(), casadi::External::codegen_declarations(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionBuffer::FunctionBuffer(), casadi::FunctionInternal::FunctionInternal(), casadi::GenericExternal::init_external(), and casadi::FunctionBuffer::operator=().

◆ compiler_

Importer casadi::FunctionInternal::compiler_

inherited

Definition at line 1409 of file function_internal.hpp.

◆ compiler_plugin_

std::string casadi::FunctionInternal::compiler_plugin_

inherited

Definition at line 1408 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::Scpgen::init(), casadi::OracleFunction::jit_dependencies(), and casadi::FunctionInternal::serialize_body().

◆ custom_jacobian_

Function casadi::FunctionInternal::custom_jacobian_

inherited

Definition at line 1460 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ decref_

signal_t casadi::FunctionInternal::decref_

inherited

Definition at line 1368 of file function_internal.hpp.

Referenced by casadi::External::any_symbol_found(), casadi::External::codegen_declarations(), casadi::External::codegen_decref(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::External::init_external(), and casadi::FunctionInternal::~FunctionInternal().

◆ default_in_

std::vector<double> casadi::MXFunction::default_in_

Definition at line 91 of file mx_function.hpp.

Referenced by generate_options(), init(), MXFunction(), and serialize_body().

◆ der_options_

Dict casadi::FunctionInternal::der_options_

inherited

Definition at line 1457 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::serialize_body().

◆ derivative_of_

Function casadi::FunctionInternal::derivative_of_

inherited

Definition at line 1402 of file function_internal.hpp.

◆ deserialize_map

std::map< std::string, ProtoFunction *(*)(DeserializingStream &)> casadi::FunctionInternal::deserialize_map

staticinherited

Initial value:

= {
    {"MXFunction", MXFunction::deserialize},
    {"SXFunction", SXFunction::deserialize},
    {"Interpolant", Interpolant::deserialize},
    {"Switch", Switch::deserialize},
    {"ForwardDiff", ForwardDiff::deserialize},
    {"BackwardDiff", BackwardDiff::deserialize},
    {"CentralDiff", CentralDiff::deserialize},
    {"Smoothing", Smoothing::deserialize},
 
    {"Map", Map::deserialize},
    {"MapSum", MapSum::deserialize},
    {"Nlpsol", Nlpsol::deserialize},
    {"Rootfinder", Rootfinder::deserialize},
    {"Integrator", Integrator::deserialize},
    {"External", External::deserialize},
    {"Conic", Conic::deserialize},
    {"FmuFunction", FmuFunction::deserialize},
    {"BlazingSplineFunction", BlazingSplineFunction::deserialize},
    {"Onnx", OnnxFunction::deserialize}
  }

Definition at line 1514 of file function_internal.hpp.

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

◆ dump_

bool casadi::FunctionInternal::dump_

inherited

Definition at line 1448 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), and casadi::FunctionInternal::init().

◆ dump_count_

casadi_int casadi::FunctionInternal::dump_count_

mutableinherited

Definition at line 1469 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), and casadi::FunctionInternal::reset_dump_count().

◆ dump_dir_

std::string casadi::FunctionInternal::dump_dir_

inherited

Definition at line 1451 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::CodeGenerator::generate_dump(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::open_trace(), and casadi::FunctionInternal::serialize_body().

◆ dump_format_

std::string casadi::FunctionInternal::dump_format_

inherited

Definition at line 1454 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::CodeGenerator::generate_dump(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_in_

bool casadi::FunctionInternal::dump_in_

inherited

Definition at line 1448 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::codegen(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_out_

bool casadi::FunctionInternal::dump_out_

inherited

Definition at line 1448 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::codegen(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_trace_

bool casadi::MXFunction::dump_trace_ = false

Definition at line 98 of file mx_function.hpp.

Referenced by change_option(), eval(), generate_options(), init(), MXFunction(), and serialize_body().

◆ enable_fd_

bool casadi::FunctionInternal::enable_fd_

inherited

Definition at line 1416 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), casadi::JitFunction::JitFunction(), and casadi::FunctionInternal::serialize_body().

◆ enable_fd_op_

bool casadi::FunctionInternal::enable_fd_op_

inherited

Definition at line 1417 of file function_internal.hpp.

Referenced by casadi::FmuFunction::FmuFunction(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_forward_

bool casadi::FunctionInternal::enable_forward_

inherited

Definition at line 1416 of file function_internal.hpp.

Referenced by ad_forward(), casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_forward_op_

bool casadi::FunctionInternal::enable_forward_op_

inherited

Definition at line 1417 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_jacobian_

bool casadi::FunctionInternal::enable_jacobian_

inherited

Definition at line 1416 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), and casadi::FunctionInternal::serialize_body().

◆ enable_jacobian_op_

bool casadi::FunctionInternal::enable_jacobian_op_

inherited

Definition at line 1417 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_reverse_

bool casadi::FunctionInternal::enable_reverse_

inherited

Definition at line 1416 of file function_internal.hpp.

Referenced by ad_reverse(), casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::serialize_body().

◆ enable_reverse_op_

bool casadi::FunctionInternal::enable_reverse_op_

inherited

Definition at line 1417 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ error_on_fail_

bool casadi::ProtoFunction::error_on_fail_

inherited

Definition at line 263 of file function_internal.hpp.

◆ eval_

eval_t casadi::FunctionInternal::eval_

inherited

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

Definition at line 1353 of file function_internal.hpp.

Referenced by casadi::FunctionBuffer::_eval(), casadi::GenericExternal::any_symbol_found(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), and casadi::GenericExternal::init_external().

◆ fd_method_

std::string casadi::FunctionInternal::fd_method_

inherited

Definition at line 1435 of file function_internal.hpp.

Referenced by casadi::FmuFunction::change_option(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FmuFunction::init(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ fd_options_

Dict casadi::FunctionInternal::fd_options_

inherited

Definition at line 1429 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::forward(), casadi::FunctionInternal::generate_options(), and casadi::FunctionInternal::init().

◆ fd_step_

double casadi::FunctionInternal::fd_step_

inherited

Definition at line 1432 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ forward_options_

Dict casadi::FunctionInternal::forward_options_

inherited

Definition at line 1457 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ free_vars_

std::vector<MX> casadi::MXFunction::free_vars_

Definition at line 88 of file mx_function.hpp.

Referenced by codegen_declarations(), eval(), init(), MXFunction(), and serialize_body().

◆ has_refcount_

bool casadi::FunctionInternal::has_refcount_

inherited

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

Definition at line 1378 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::codegen_decref(), casadi::FunctionInternal::codegen_incref(), casadi::DaqpInterface::DaqpInterface(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::External::init(), init(), and casadi::FunctionInternal::serialize_body().

◆ has_refcount_in_deps_

bool casadi::FunctionInternal::has_refcount_in_deps_

inherited

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

Definition at line 1383 of file function_internal.hpp.

Referenced by casadi::CodeGenerator::add_dependency(), casadi::FunctionInternal::codegen_meta(), and casadi::FunctionInternal::finalize().

◆ in_

std::vector<MX > casadi::XFunction< MXFunction , MX , MXNode >::in_

inherited

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

Definition at line 274 of file x_function.hpp.

◆ incref_

signal_t casadi::FunctionInternal::incref_

inherited

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

Definition at line 1368 of file function_internal.hpp.

Referenced by casadi::External::any_symbol_found(), casadi::External::codegen_declarations(), casadi::External::codegen_incref(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), and casadi::External::init_external().

◆ inputs_check_

bool casadi::FunctionInternal::inputs_check_

inherited

Definition at line 1426 of file function_internal.hpp.

Referenced by casadi::Nlpsol::check_inputs(), casadi::Conic::eval(), casadi::SqicInterface::evaluate(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), and casadi::GurobiInterface::solve().

◆ is_diff_in_

std::vector<bool> casadi::FunctionInternal::is_diff_in_

inherited

◆ is_diff_out_

std::vector<bool> casadi::FunctionInternal::is_diff_out_

inherited

Definition at line 1315 of file function_internal.hpp.

◆ jac_penalty_

double casadi::FunctionInternal::jac_penalty_

inherited

Definition at line 1413 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ jac_sparsity_

std::vector<Sparsity> casadi::FunctionInternal::jac_sparsity_[2]

mutableinherited

Definition at line 1394 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::jac_sparsity(), and casadi::FunctionInternal::set_jac_sparsity().

◆ jacobian_options_

Dict casadi::FunctionInternal::jacobian_options_

inherited

Definition at line 1457 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), and casadi::FunctionInternal::serialize_body().

◆ jit_

bool casadi::FunctionInternal::jit_

inherited

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

Definition at line 1326 of file function_internal.hpp.

Referenced by change_option(), casadi::SXFunction::change_option(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), init(), casadi::SXFunction::init(), casadi::JitFunction::JitFunction(), casadi::OracleFunction::OracleFunction(), casadi::FunctionInternal::serialize_body(), casadi::OracleFunction::serialize_body(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_base_name_

std::string casadi::FunctionInternal::jit_base_name_

inherited

Definition at line 1343 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ jit_cleanup_

bool casadi::FunctionInternal::jit_cleanup_

inherited

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

Definition at line 1331 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_directory_

std::string casadi::FunctionInternal::jit_directory_

inherited

Definition at line 1342 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_name_

std::string casadi::FunctionInternal::jit_name_

inherited

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

Definition at line 1341 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_options_

Dict casadi::FunctionInternal::jit_options_

inherited

Definition at line 1410 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::Scpgen::init(), casadi::OracleFunction::jit_dependencies(), and casadi::FunctionInternal::serialize_body().

◆ jit_serialize_

std::string casadi::FunctionInternal::jit_serialize_

inherited

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

Definition at line 1336 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::OracleFunction::OracleFunction(), casadi::FunctionInternal::serialize_body(), and casadi::OracleFunction::serialize_body().

◆ jit_temp_suffix_

bool casadi::FunctionInternal::jit_temp_suffix_

inherited

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

Definition at line 1348 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ live_variables_

bool casadi::MXFunction::live_variables_

Definition at line 94 of file mx_function.hpp.

Referenced by generate_options(), init(), MXFunction(), and serialize_body().

◆ max_io_

casadi_int casadi::FunctionInternal::max_io_

inherited

Definition at line 1445 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ max_num_dir_

casadi_int casadi::FunctionInternal::max_num_dir_

inherited

Definition at line 1423 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

◆ n_in_

size_t casadi::FunctionInternal::n_in_

inherited

Definition at line 1312 of file function_internal.hpp.

◆ n_out_

size_t casadi::FunctionInternal::n_out_

inherited

Definition at line 1312 of file function_internal.hpp.

◆ name_

std::string casadi::ProtoFunction::name_

inherited

Definition at line 248 of file function_internal.hpp.

◆ name_in_

std::vector<std::string> casadi::FunctionInternal::name_in_

inherited

Definition at line 1321 of file function_internal.hpp.

◆ name_out_

std::vector<std::string> casadi::FunctionInternal::name_out_

inherited

Definition at line 1321 of file function_internal.hpp.

◆ never_inline_

bool casadi::FunctionInternal::never_inline_

inherited

Definition at line 1309 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::eval_mx(), eval_mx(), casadi::SXFunction::eval_mx(), casadi::FunctionInternal::eval_sx(), eval_sx(), casadi::SXFunction::eval_sx(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ options_

const Options casadi::MXFunction::options_

static

Initial value:

= {{&FunctionInternal::options_},
     {{"default_in",
       {OT_DOUBLEVECTOR,
        "Default input values"}},
      {"live_variables",
       {OT_BOOL,
        "Reuse variables in the work vector"}},
      {"dump_trace",
       {OT_BOOL,
        "Dump interpreted instruction values to name.NNNNNN.trace.jsonl in dump_dir, "
        "using the dump_in/dump_out counter. [false]"}},
      {"print_instructions",
       {OT_BOOL,
        "Print each operation during evaluation. Influenced by print_canonical."}},
      {"cse",
       {OT_BOOL,
        "Perform common subexpression elimination (complexity is N*log(N) in graph size)"}},
      {"allow_free",
       {OT_BOOL,
        "Allow construction with free variables (Default: false)"}},
      {"allow_duplicate_io_names",
       {OT_BOOL,
        "Allow construction with duplicate io names (Default: false)"}}
     }
  }

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

Definition at line 140 of file mx_function.hpp.

◆ out_

std::vector<MX > casadi::XFunction< MXFunction , MX , MXNode >::out_

inherited

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

Definition at line 279 of file x_function.hpp.

◆ print_canonical_

bool casadi::FunctionInternal::print_canonical_

inherited

Definition at line 1442 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), print_arg(), casadi::SXFunction::print_arg(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_out(), print_res(), casadi::SXFunction::print_res(), and casadi::FunctionInternal::serialize_body().

◆ print_in_

bool casadi::FunctionInternal::print_in_

inherited

Definition at line 1438 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::codegen(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ print_instructions_

bool casadi::MXFunction::print_instructions_

Definition at line 97 of file mx_function.hpp.

Referenced by change_option(), codegen_body(), eval(), generate_options(), init(), MXFunction(), and serialize_body().

◆ print_out_

bool casadi::FunctionInternal::print_out_

inherited

Definition at line 1439 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::codegen(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ print_time_

bool casadi::ProtoFunction::print_time_

inherited

Definition at line 254 of file function_internal.hpp.

Referenced by casadi::FixedStepIntegrator::create_advanced(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::FunctionInternal::init(), casadi::Nlpsol::Nlpsol(), casadi::ProtoFunction::print_time(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

◆ record_time_

bool casadi::ProtoFunction::record_time_

inherited

Definition at line 257 of file function_internal.hpp.

Referenced by casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::FunctionInternal::init(), casadi::ProtoFunction::init_mem(), casadi::LinsolInternal::init_mem(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

◆ registered_functions_

std::vector<Function> casadi::FunctionInternal::registered_functions_

inherited

Definition at line 1463 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::find(), casadi::FunctionInternal::FunctionInternal(), and casadi::FunctionInternal::serialize_body().

◆ regularity_check_

bool casadi::ProtoFunction::regularity_check_

inherited

Definition at line 260 of file function_internal.hpp.

Referenced by casadi::OracleFunction::calc_function(), casadi::ProtoFunction::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

◆ release_

casadi_release_t casadi::FunctionInternal::release_

inherited

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

Definition at line 1363 of file function_internal.hpp.

Referenced by casadi::GenericExternal::any_symbol_found(), casadi::External::codegen_declarations(), casadi::External::codegen_release(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::GenericExternal::init_external(), casadi::FunctionBuffer::operator=(), and casadi::FunctionBuffer::~FunctionBuffer().

◆ reverse_options_

Dict casadi::FunctionInternal::reverse_options_

inherited

Definition at line 1457 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::serialize_body().

◆ sparsity_in_

std::vector<Sparsity> casadi::FunctionInternal::sparsity_in_

inherited

Definition at line 1318 of file function_internal.hpp.

◆ sparsity_out_

std::vector<Sparsity> casadi::FunctionInternal::sparsity_out_

inherited

◆ stats_

Dict casadi::FunctionInternal::stats_

inherited

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

Definition at line 1373 of file function_internal.hpp.

◆ user_data_

void* casadi::FunctionInternal::user_data_

inherited

Definition at line 1405 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), and casadi::FunctionInternal::init().

◆ verbose_

bool casadi::ProtoFunction::verbose_

inherited

Definition at line 251 of file function_internal.hpp.

◆ workloc_

std::vector<casadi_int> casadi::MXFunction::workloc_

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

Definition at line 82 of file mx_function.hpp.

Referenced by ad_forward(), ad_reverse(), codegen_body(), eval(), eval_activity(), eval_mx(), eval_sx(), generate_lifted(), init(), MXFunction(), serialize_body(), casadi::MX::simplify_const_folding(), casadi::simplify_const_folding_order(), casadi::MX::simplify_ref_count(), sp_forward(), sp_reverse(), substitute_inplace(), and trace_instruction().

◆ workstate_

std::vector<bool> casadi::MXFunction::workstate_

Definition at line 85 of file mx_function.hpp.

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

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Member Typedef Documentation

◆ AlgEl

◆ weak_ref_type

Constructor & Destructor Documentation

◆ MXFunction() [1/2]

◆ ~MXFunction()

◆ MXFunction() [2/2]

Member Function Documentation

◆ ad_forward()

◆ ad_reverse()

◆ ad_weight()

◆ add_embedded()

◆ adjViaJac()

◆ all_scalar()

◆ alloc()

◆ alloc_arg()

◆ alloc_iw()

◆ alloc_mem()

◆ alloc_res()

◆ alloc_w()

◆ apply_simplify_passes()

◆ cache()

◆ call()

◆ call_forward() [1/3]

◆ call_forward() [2/3]

◆ call_forward() [3/3]

◆ call_gen() [1/2]

◆ call_gen() [2/2]

◆ call_reverse() [1/3]

◆ call_reverse() [2/3]

◆ call_reverse() [3/3]

◆ change_option()

◆ check_arg()

◆ check_mat()

◆ check_mem_count()

◆ check_res()

◆ checkout()

◆ class_name()

◆ clear_mem()

◆ codegen()

◆ codegen_alloc_mem()

◆ codegen_body()

◆ codegen_checkout()

◆ codegen_declarations()

◆ codegen_decref()

◆ codegen_free_mem()

◆ codegen_incref()

◆ codegen_init_mem()

◆ codegen_mem()

◆ codegen_mem_is_opaque()

◆ codegen_mem_type()

◆ codegen_meta()

◆ codegen_name()

◆ codegen_needs_mem()

◆ codegen_release()

◆ codegen_sparsities()

◆ codegen_sz_arg()

◆ codegen_sz_iw()

◆ codegen_sz_res()

◆ codegen_sz_w()

◆ construct()

◆ convert_arg() [1/2]

◆ convert_arg() [2/2]

◆ convert_res() [1/2]

◆ convert_res() [2/2]

◆ debug_repr()

◆ definition()

◆ delayed_deserialize_members()

◆ delayed_serialize_members()

◆ deserialize()

◆ destroySingleton()

◆ diff_prefix()