'fast_newton' plugin for Rootfinder More...

#include <fast_newton.hpp>

Detailed Description

Implements simple newton iterations to solve an implicit function.

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

List of available options
Id	Type	Description
abstol	OT_DOUBLE	Stopping criterion tolerance on \|\|g\|\|__inf)
abstolStep	OT_DOUBLE	Stopping criterion tolerance on step size
max_iter	OT_INT	Maximum number of Newton iterations to perform before returning.

Author: Joris Gillis

Date: 2018

List of available options
Id	Type	Description	Used in
abstol	OT_DOUBLE	Stopping criterion tolerance on \|\|g\|\|__inf)	casadi::FastNewton
abstolStep	OT_DOUBLE	Stopping criterion tolerance on step size	casadi::FastNewton
ad_weight	OT_DOUBLE	Weighting factor for derivative calculation.When there is an option of either using forward or reverse mode directional derivatives, the condition ad_weightnf<=(1-ad_weight)na is used where nf and na are estimates of the number of forward/reverse mode directional derivatives needed. By default, ad_weight is calculated automatically, but this can be overridden by setting this option. In particular, 0 means forcing forward mode and 1 forcing reverse mode. Leave unset for (class specific) heuristics.	casadi::FunctionInternal
ad_weight_sp	OT_DOUBLE	Weighting factor for sparsity pattern calculation calculation.Overrides default behavior. Set to 0 and 1 to force forward and reverse mode respectively. Cf. option "ad_weight". When set to -1, sparsity is completely ignored and dense matrices are used.	casadi::FunctionInternal
always_inline	OT_BOOL	Force inlining.	casadi::FunctionInternal
cache	OT_DICT	Prepopulate the function cache. Default: empty	casadi::FunctionInternal
common_options	OT_DICT	Options for auto-generated functions	casadi::OracleFunction
compiler	OT_STRING	Just-in-time compiler plugin to be used.	casadi::FunctionInternal
constraints	OT_INTVECTOR	Constrain the unknowns. 0 (default): no constraint on ui, 1: ui >= 0.0, -1: ui <= 0.0, 2: ui > 0.0, -2: ui < 0.0.	casadi::Rootfinder
custom_jacobian	OT_FUNCTION	Override CasADi's AD. Use together with 'jac_penalty': 0. Note: Highly experimental. Syntax may break often.	casadi::FunctionInternal
der_options	OT_DICT	Default options to be used to populate forward_options, reverse_options, and jacobian_options before those options are merged in.	casadi::FunctionInternal
derivative_of	OT_FUNCTION	The function is a derivative of another function. The type of derivative (directional derivative, Jacobian) is inferred from the function name.	casadi::FunctionInternal
dump	OT_BOOL	Dump function to file upon first evaluation. [false]	casadi::FunctionInternal
dump_dir	OT_STRING	Directory to dump inputs/outputs to. Make sure the directory exists [.]	casadi::FunctionInternal
dump_format	OT_STRING	Choose file format to dump matrices. See DM.from_file [mtx]	casadi::FunctionInternal
dump_in	OT_BOOL	Dump numerical values of inputs to file (readable with DM.from_file) [default: false]	casadi::FunctionInternal
dump_out	OT_BOOL	Dump numerical values of outputs to file (readable with DM.from_file) [default: false]	casadi::FunctionInternal
enable_fd	OT_BOOL	Enable derivative calculation by finite differencing. [default: false]]	casadi::FunctionInternal
enable_forward	OT_BOOL	Enable derivative calculation using generated functions for Jacobian-times-vector products - typically using forward mode AD - if available. [default: true]	casadi::FunctionInternal
enable_jacobian	OT_BOOL	Enable derivative calculation using generated functions for Jacobians of all differentiable outputs with respect to all differentiable inputs - if available. [default: true]	casadi::FunctionInternal
enable_reverse	OT_BOOL	Enable derivative calculation using generated functions for transposed Jacobian-times-vector products - typically using reverse mode AD - if available. [default: true]	casadi::FunctionInternal
error_on_fail	OT_BOOL	Throw exceptions when function evaluation fails (default true).	casadi::ProtoFunction
expand	OT_BOOL	Replace MX with SX expressions in problem formulation [false] This happens before creating derivatives unless indicated by postpone_expand	casadi::OracleFunction
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
implicit_input	OT_INT	Index of the input that corresponds to the actual root-finding	casadi::Rootfinder
implicit_output	OT_INT	Index of the output that corresponds to the actual root-finding	casadi::Rootfinder
input_scheme	OT_STRINGVECTOR	Deprecated option (ignored)	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_function	OT_FUNCTION	Function object for calculating the Jacobian (autogenerated by default)	casadi::Rootfinder
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
linear_solver	OT_STRING	User-defined linear solver class. Needed for sensitivities.	casadi::Rootfinder
linear_solver_options	OT_DICT	Options to be passed to the linear solver.	casadi::Rootfinder
max_io	OT_INT	Acceptable number of inputs and outputs. Warn if exceeded.	casadi::FunctionInternal
max_iter	OT_INT	Maximum number of Newton iterations to perform before returning.	casadi::FastNewton
max_num_dir	OT_INT	Specify the maximum number of directions for derivative functions. Overrules the builtin optimized_num_dir.	casadi::FunctionInternal
monitor	OT_STRINGVECTOR	Set of user problem functions to be monitored	casadi::OracleFunction
never_inline	OT_BOOL	Forbid inlining.	casadi::FunctionInternal
output_scheme	OT_STRINGVECTOR	Deprecated option (ignored)	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
postpone_expand	OT_BOOL	When expand is active, postpone it until after creation of derivatives. Default: False	casadi::OracleFunction
print_in	OT_BOOL	Print numerical values of inputs [default: false]	casadi::FunctionInternal
print_out	OT_BOOL	Print numerical values of outputs [default: false]	casadi::FunctionInternal
print_time	OT_BOOL	print information about execution time. Implies record_time.	casadi::ProtoFunction
record_time	OT_BOOL	record information about execution time, for retrieval with stats().	casadi::ProtoFunction
regularity_check	OT_BOOL	Throw exceptions when NaN or Inf appears during evaluation	casadi::ProtoFunction
reverse_options	OT_DICT	Options to be passed to a reverse mode constructor	casadi::FunctionInternal
show_eval_warnings	OT_BOOL	Show warnings generated from function evaluations [true]	casadi::OracleFunction
specific_options	OT_DICT	Options for specific auto-generated functions, overwriting the defaults from common_options. Nested dictionary.	casadi::OracleFunction
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 63 of file fast_newton.hpp.

Inheritance diagram for casadi::FastNewton:

[legend]

Collaboration diagram for casadi::FastNewton:

[legend]

Public Types
typedef Rootfinder (	Creator) (const std::string &name, const Function &oracle)

using	weak_ref_type = WeakRefInternal

typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	FastNewton (const std::string &name, const Function &f)
	Constructor. More...

	~FastNewton () override
	Destructor. More...

const char *	plugin_name () const override

std::string	class_name () const override
	Readable name of the internal class. More...

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

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

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

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

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

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

int	solve (void *mem) const override
	Solve the system of equations and calculate derivatives. More...

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

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

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

int	eval (const double arg, double res, casadi_int iw, double w, void *mem) const override
	Evaluate numerically. 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	sp_reverse (bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem) const override
	Propagate sparsity backwards. More...

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

virtual void	ad_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
	Create call to (cached) derivative function, forward mode. More...

virtual void	ad_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
	Create call to (cached) derivative function, reverse mode. More...

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

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

void	finalize () override
	Finalize initialization. More...

void	join_results (OracleMemory *m) const
	Combine results from different threads. More...

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

void	expand ()

Function	create_function (const Function &oracle, const std::string &fname, const std::vector< std::string > &s_in, const std::vector< std::string > &s_out, const Function::AuxOut &aux=Function::AuxOut(), const Dict &opts=Dict())

Function	create_function (const std::string &fname, const std::vector< std::string > &s_in, const std::vector< std::string > &s_out, const Function::AuxOut &aux=Function::AuxOut(), const Dict &opts=Dict())

Function	create_function (const std::string &fname, const std::vector< MX > &e_in, const std::vector< MX > &e_out, const std::vector< std::string > &s_in, const std::vector< std::string > &s_out, const Dict &opts=Dict())

Function	create_forward (const std::string &fname, casadi_int nfwd)

void	set_function (const Function &fcn, const std::string &fname, bool jit=false)

void	set_function (const Function &fcn)

int	calc_function (OracleMemory m, const std::string &fcn, const double const *arg=nullptr, int thread_id=0) const

int	calc_sp_forward (const std::string &fcn, const bvec_t arg, bvec_t res, casadi_int iw, bvec_t w) const

int	calc_sp_reverse (const std::string &fcn, bvec_t arg, bvec_t res, casadi_int iw, bvec_t w) const

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

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

virtual bool	monitored (const std::string &name) const

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

std::string	generate_dependencies (const std::string &fname, const Dict &opts) const override
	Export / Generate C code for the generated functions. More...

void	jit_dependencies (const std::string &fname) override
	JIT for dependencies. More...

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

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

virtual void	codegen_body_enter (CodeGenerator &g) const
	Generate code for the function body. More...

virtual void	codegen_body_exit (CodeGenerator &g) const
	Generate code for the function body. More...

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

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

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

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

virtual 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

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

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

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

virtual int	eval_sx (const SXElem arg, SXElem res, casadi_int iw, SXElem w, void *mem, bool always_inline, bool never_inline) const
	Evaluate with symbolic scalars. More...

virtual void	eval_mx (const MXVector &arg, MXVector &res, bool always_inline, bool never_inline) const
	Evaluate with symbolic matrices. More...

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

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

virtual Function	slice (const std::string &name, const std::vector< casadi_int > &order_in, const std::vector< casadi_int > &order_out, const Dict &opts) const
	returns a new function with a selection of inputs/outputs of the original 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< MX >	free_mx () const
	Get free variables (MX) More...

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

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

virtual void	generate_lifted (Function &vdef_fcn, Function &vinit_fcn) const
	Extract the functions needed for the Lifted Newton method. More...

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

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

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

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

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

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

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

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

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

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_incref (CodeGenerator &g) const
	Codegen incref for dependencies. More...

virtual void	codegen_decref (CodeGenerator &g) const
	Codegen decref for dependencies. 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	has_codegen () const
	Is codegen supported? More...

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

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

virtual void	disp_more (std::ostream &stream) const
	Print more. 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...

virtual std::vector< std::string >	get_free () const
	Print free variables. 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_default_in (casadi_int ind) const
	Get default input value. 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...

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 bool	is_a (const std::string &type, bool recursive) const
	Check if the function is of a particular type. More...

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

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

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


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


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

std::string	get_name_out (casadi_int i) override
	Names of function input and outputs. 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...


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


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


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

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

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


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_in (casadi_int ind) const
	Get function input(s) and output(s) More...

virtual const std::vector< MX >	mx_in () 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...


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::vector< MX >	symbolic_output (const std::vector< MX > &arg) const
	Get a vector of symbolic variables corresponding to the 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 size_t	codegen_sz_w (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 Rootfinder *	creator (const std::string &name, const Function &f)
	Create a new Rootfinder. More...

static ProtoFunction *	deserialize (DeserializingStream &s)
	Deserialize into MX. More...

static std::string	shortname ()
	Short name. More...

template<typename XType >
static Function	create_oracle (const std::map< std::string, XType > &d, const Dict &opts)
	Convert dictionary to Problem. 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...

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 bool	has_plugin (const std::string &pname, bool verbose=false)
	Check if a plugin is available or can be loaded. More...

static const Options &	plugin_options (const std::string &pname)
	Get the plugin options. More...

static Deserialize	plugin_deserialize (const std::string &pname)
	Get the plugin deserialize_map. More...

static Plugin	pluginFromRegFcn (RegFcn regfcn)
	Instantiate a Plugin struct from a factory function. More...

static Plugin	load_plugin (const std::string &pname, bool register_plugin=true, bool needs_lock=true)
	Load a plugin dynamically. More...

static handle_t	load_library (const std::string &libname, std::string &resultpath, bool global)
	Load a library dynamically. More...

static void	registerPlugin (const Plugin &plugin, bool needs_lock=true)
	Register an integrator in the factory. More...

static void	registerPlugin (RegFcn regfcn, bool needs_lock=true)
	Register an integrator in the factory. More...

static Plugin &	getPlugin (const std::string &pname)
	Load and get the creator function. More...

static Rootfinder *	instantiate (const std::string &fname, const std::string &pname, Problem problem)


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

Public Attributes
casadi_int	n_
	Number of equations. More...

Linsol	linsol_
	Linear solver. More...

Sparsity	sp_jac_

std::vector< casadi_int >	u_c_
	Constraints on decision variables. More...

casadi_int	iin_
	Indices of the input and output that correspond to the actual root-finding. More...

casadi_int	iout_

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

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

bool	has_refcount_
	Reference counting in codegen? 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_

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_

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 const std::string	meta_doc
	A documentation string. More...

static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...

static const std::string	infix_ = "rootfinder"
	Infix. More...

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

Protected Member Functions
	FastNewton (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...

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

Protected Attributes
casadi_int	max_iter_
	Maximum number of Newton iterations. More...

double	abstol_
	Absolute tolerance that should be met on residual. More...

double	abstolStep_
	Absolute tolerance that should be met on step. More...

Function	jac_g_x_
	Reference to jacobian function. More...

Sparsity	sp_v_
	Data for qr. More...

Sparsity	sp_r_

std::vector< casadi_int >	prinv_

std::vector< casadi_int >	pc_

Function	oracle_
	Oracle: Used to generate other functions. More...

Dict	common_options_
	Options for creating functions. More...

Dict	specific_options_

bool	show_eval_warnings_
	Show evaluation warnings. More...

int	max_num_threads_

std::map< std::string, RegFun >	all_functions_

std::vector< std::string >	monitor_

size_t	stride_arg_

size_t	stride_res_

size_t	stride_iw_

size_t	stride_w_

bool	post_expand_

static const Options	options_
	Options. More...

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

Member Typedef Documentation

◆ Creator

typedef Rootfinder*(* casadi::Rootfinder::Creator) (const std::string &name, const Function &oracle)

inherited

Definition at line 196 of file rootfinder_impl.hpp.

◆ RegFcn

typedef int(* casadi::PluginInterface< Rootfinder >::RegFcn) (Plugin *plugin)

inherited

Definition at line 73 of file plugin_interface.hpp.

◆ weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

◆ FastNewton() [1/2]

casadi::FastNewton::FastNewton	(	const std::string &	name,
		const Function &	f
	)

explicit

Definition at line 49 of file fast_newton.cpp.

50 : Rootfinder(name, f) {

51 }

casadi::Rootfinder::Rootfinder

Rootfinder(const std::string &name, const Function &oracle)

Constructor.

Definition: rootfinder.cpp:161

◆ ~FastNewton()

casadi::FastNewton::~FastNewton ( )

override

Definition at line 53 of file fast_newton.cpp.

                           {
     clear_mem();
   }

References casadi::ProtoFunction::clear_mem().

◆ FastNewton() [2/2]

casadi::FastNewton::FastNewton ( DeserializingStream & s )

explicitprotected

Definition at line 255 of file fast_newton.cpp.

                                                : Rootfinder(s) {
     s.version("Newton", 1);
     s.unpack("Newton::max_iter", max_iter_);
     s.unpack("Newton::abstol", abstol_);
     s.unpack("Newton::abstolStep", abstolStep_);
     s.unpack("Newton::jac_g_x", jac_g_x_);
     s.unpack("Newton::sp_v", sp_v_);
     s.unpack("Newton::sp_r", sp_r_);
     s.unpack("Newton::prinv", prinv_);
     s.unpack("Newton::pc", pc_);
   }

References abstol_, abstolStep_, jac_g_x_, max_iter_, pc_, prinv_, sp_r_, sp_v_, casadi::DeserializingStream::unpack(), and casadi::DeserializingStream::version().

Member Function Documentation

◆ ad_forward()

void casadi::Rootfinder::ad_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_1ok

Definition at line 450 of file rootfinder.cpp.

                                                        {
     // Number of directional derivatives
     casadi_int nfwd = fseed.size();
     fsens.resize(nfwd);
  
     // Quick return if no seeds
     if (nfwd==0) return;
  
     // Propagate through f_
     std::vector<MX> f_arg(arg);
     f_arg.at(iin_) = res.at(iout_);
     std::vector<MX> f_res(res);
     f_res.at(iout_) = MX(size_in(iin_)); // zero residual
     std::vector<std::vector<MX> > f_fseed(fseed);
     for (casadi_int d=0; d<nfwd; ++d) {
       f_fseed[d].at(iin_) = MX(size_in(iin_)); // ignore seeds for guess
     }
     oracle_->call_forward(f_arg, f_res, f_fseed, fsens,
                           always_inline, never_inline);
  
     // Get expression of Jacobian
     Function jac = get_function("jac_g_x");
     MX J = jac(f_arg).front();
  
     // Solve for all the forward derivatives at once
     std::vector<MX> rhs(nfwd);
     for (casadi_int d=0; d<nfwd; ++d) rhs[d] = vec(fsens[d][iout_]);
     rhs = horzsplit(J->get_solve(-horzcat(rhs), false, linsol_));
     for (casadi_int d=0; d<nfwd; ++d) fsens[d][iout_] = reshape(rhs[d], size_in(iin_));
  
     // Propagate to auxiliary outputs
     if (n_out_>1) {
       for (casadi_int d=0; d<nfwd; ++d) f_fseed[d][iin_] = fsens[d][iout_];
       oracle_->call_forward(f_arg, f_res, f_fseed, fsens,
                             always_inline, never_inline);
       for (casadi_int d=0; d<nfwd; ++d) fsens[d][iout_] = f_fseed[d][iin_]; // Otherwise overwritten
     }
   }

References casadi::FunctionInternal::call_forward(), casadi::OracleFunction::get_function(), casadi::MXNode::get_solve(), casadi::Rootfinder::iin_, casadi::Rootfinder::iout_, casadi::Rootfinder::linsol_, casadi::FunctionInternal::n_out_, casadi::OracleFunction::oracle_, and casadi::FunctionInternal::size_in().

◆ ad_reverse()

void casadi::Rootfinder::ad_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_1ol

Definition at line 493 of file rootfinder.cpp.

                                                        {
  
     // Number of directional derivatives
     casadi_int nadj = aseed.size();
     asens.resize(nadj);
  
     // Quick return if no seeds
     if (nadj==0) return;
  
     // Get expression of Jacobian
     std::vector<MX> f_arg(arg);
     f_arg[iin_] = res.at(iout_);
     Function jac = get_function("jac_g_x");
     MX J = jac(f_arg).front();
  
     // Get adjoint seeds for calling f
     std::vector<MX> f_res(res);
     f_res[iout_] = MX(size_in(iin_)); // zero residual
     std::vector<std::vector<MX> > f_aseed(nadj);
     for (casadi_int d=0; d<nadj; ++d) {
       f_aseed[d].resize(n_out_);
       for (casadi_int i=0; i<n_out_; ++i) f_aseed[d][i] = i==iout_ ? f_res[iout_] : aseed[d][i];
     }
  
     // Propagate dependencies from auxiliary outputs
     std::vector<MX> rhs(nadj);
     std::vector<std::vector<MX> > asens_aux;
     if (n_out_>1) {
       oracle_->call_reverse(f_arg, f_res, f_aseed, asens_aux, always_inline, never_inline);
       for (casadi_int d=0; d<nadj; ++d) rhs[d] = vec(asens_aux[d][iin_] + aseed[d][iout_]);
     } else {
       for (casadi_int d=0; d<nadj; ++d) rhs[d] = vec(aseed[d][iout_]);
     }
  
     // Solve for all the adjoint seeds at once
     rhs = horzsplit(J->get_solve(-horzcat(rhs), true, linsol_));
     for (casadi_int d=0; d<nadj; ++d) {
       for (casadi_int i=0; i<n_out_; ++i) {
         if (i==iout_) {
           f_aseed[d][i] = reshape(rhs[d], size_out(i));
         } else {
           // Avoid counting the auxiliary seeds twice
           f_aseed[d][i] = MX(size_out(i));
         }
       }
     }
  
     // No dependency on guess (1)
     std::vector<MX> tmp(nadj);
     for (casadi_int d=0; d<nadj; ++d) {
       asens[d].resize(n_in_);
       tmp[d] = asens[d][iin_].is_empty(true) ? MX(size_in(iin_)) : asens[d][iin_];
     }
  
     // Propagate through f_
     oracle_->call_reverse(f_arg, f_res, f_aseed, asens, always_inline, never_inline);
  
     // No dependency on guess (2)
     for (casadi_int d=0; d<nadj; ++d) {
       asens[d][iin_] = tmp[d];
     }
  
     // Add contribution from auxiliary outputs
     if (n_out_>1) {
       for (casadi_int d=0; d<nadj; ++d) {
         for (casadi_int i=0; i<n_in_; ++i) if (i!=iin_) asens[d][i] += asens_aux[d][i];
       }
     }
   }

References casadi::FunctionInternal::call_reverse(), casadi::OracleFunction::get_function(), casadi::MXNode::get_solve(), casadi::Rootfinder::iin_, casadi::Rootfinder::iout_, casadi::Rootfinder::linsol_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::OracleFunction::oracle_, casadi::FunctionInternal::size_in(), and casadi::FunctionInternal::size_out().

◆ ad_weight()

double casadi::FunctionInternal::ad_weight ( ) const

virtualinherited

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

Definition at line 3190 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::Function::expand(), 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 *, Function > &	all_fun,
		const Function &	dep,
		casadi_int	max_depth
	)		const

inherited

Definition at line 3633 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()) {
       // Add to map
       all_fun[dep.get()] = dep;
       // 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::MXFunction::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 2925 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 3664 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 2874 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);
   }

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

Referenced by casadi::FunctionInternal::alloc(), casadi::External::init(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::OmpMap::init(), casadi::ThreadMap::init(), casadi::MapSum::init(), casadi::MXFunction::init(), casadi::Nlpsol::init(), casadi::SXFunction::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::BSplineInterpolant::init(), and casadi::Qrqp::init().

◆ 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 2858 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::FastNewton::alloc_mem ( ) const

inlineoverridevirtual

Reimplemented from casadi::OracleFunction.

Definition at line 95 of file fast_newton.hpp.

95 { return new FastNewtonMemory();}

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

Referenced by casadi::FunctionInternal::alloc(), casadi::External::init(), casadi::FiniteDiff::init(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::OmpMap::init(), casadi::ThreadMap::init(), casadi::MapSum::init(), casadi::MXFunction::init(), casadi::Nlpsol::init(), casadi::SXFunction::init(), casadi::Blocksqp::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::BSplineInterpolant::init(), and casadi::Qrqp::init().

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

◆ cache()

Dict casadi::FunctionInternal::cache ( ) const

inherited

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

Definition at line 970 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_.

◆ calc_function()

int casadi::OracleFunction::calc_function	(	OracleMemory *	m,
		const std::string &	fcn,
		const double const	arg = `nullptr`,
		int	thread_id = `0`
	)		const

inherited

Definition at line 302 of file oracle_function.cpp.

                                                              {
   auto ml = m->thread_local_mem.at(thread_id);
   // Is the function monitored?
   bool monitored = this->monitored(fcn);
  
   // Print progress
   if (monitored) casadi_message("Calling \"" + fcn + "\"");
  
   // Respond to a possible Crl+C signals
   // Python interrupt checker needs the GIL.
   // We may not have access to it in a multi-threaded context
   // See issue #2955
   if (max_num_threads_==1) InterruptHandler::check();
  
   // Get function
   const Function& f = get_function(fcn);
  
   // Get statistics structure
   FStats& fstats = ml->fstats.at(fcn);
  
   // Number of inputs and outputs
   casadi_int n_in = f.n_in(), n_out = f.n_out();
  
   // Prepare stats, start timer
   ScopedTiming tic(fstats);
  
   // Input buffers
   if (arg) {
     std::fill_n(ml->arg, n_in, nullptr);
     for (casadi_int i=0; i<n_in; ++i) ml->arg[i] = *arg++;
   }
  
   // Print inputs nonzeros
   if (monitored) {
     std::stringstream s;
     s << fcn << " input nonzeros:\n";
     for (casadi_int i=0; i<n_in; ++i) {
       s << " " << i << " (" << f.name_in(i) << "): ";
       if (ml->arg[i]) {
         // Print nonzeros
         s << "[";
         for (casadi_int k=0; k<f.nnz_in(i); ++k) {
           if (k!=0) s << ", ";
           DM::print_scalar(s, ml->arg[i][k]);
         }
         s << "]\n";
       } else {
         // All zero input
         s << "0\n";
       }
     }
     casadi_message(s.str());
   }
  
   // Evaluate memory-less
   try {
     if (f(ml->arg, ml->res, ml->iw, ml->w)) {
       // Recoverable error
       if (monitored) casadi_message(name_ + ":" + fcn + " failed");
       return 1;
     }
   } catch(std::exception& ex) {
     // Fatal error: Generate stack trace
     casadi_error("Error in " + name_ + ":" + fcn + ":" + std::string(ex.what()));
   }
  
   // Print output nonzeros
   if (monitored) {
     std::stringstream s;
     s << fcn << " output nonzeros:\n";
     for (casadi_int i=0; i<n_out; ++i) {
       s << " " << i << " (" << f.name_out(i) << "): ";
       if (ml->res[i]) {
         // Print nonzeros
         s << "[";
         for (casadi_int k=0; k<f.nnz_out(i); ++k) {
           if (k!=0) s << ", ";
           DM::print_scalar(s, ml->res[i][k]);
         }
         s << "]\n";
       } else {
         // Ignored output
         s << " N/A\n";
       }
     }
     casadi_message(s.str());
   }
  
   // Make sure not NaN or Inf
   for (casadi_int i=0; i<n_out; ++i) {
     if (!ml->res[i]) continue;
     if (!std::all_of(ml->res[i], ml->res[i]+f.nnz_out(i), [](double v) { return isfinite(v);})) {
       std::stringstream ss;
  
       auto it = std::find_if(ml->res[i], ml->res[i] + f.nnz_out(i),
         [](double v) { return !isfinite(v);});
       casadi_int k = std::distance(ml->res[i], it);
       bool is_nan = isnan(ml->res[i][k]);
       ss << name_ << ":" << fcn << " failed: " << (is_nan? "NaN" : "Inf") <<
       " detected for output " << f.name_out(i) << ", at " << f.sparsity_out(i).repr_el(k) << ".";
  
       if (regularity_check_) {
         casadi_error(ss.str());
       } else {
         if (show_eval_warnings_) casadi_warning(ss.str());
       }
       return -1;
     }
   }
  
   // Success
   return 0;
 }

References casadi::InterruptHandler::check(), casadi::OracleFunction::get_function(), casadi::OracleFunction::max_num_threads_, casadi::OracleFunction::monitored(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::ProtoFunction::name_, casadi::Function::name_in(), casadi::Function::name_out(), casadi::Function::nnz_in(), casadi::Function::nnz_out(), casadi::Matrix< double >::print_scalar(), casadi::ProtoFunction::regularity_check_, casadi::Sparsity::repr_el(), casadi::OracleFunction::show_eval_warnings_, casadi::Function::sparsity_out(), and casadi::OracleMemory::thread_local_mem.

◆ calc_sp_forward()

int casadi::OracleFunction::calc_sp_forward	(	const std::string &	fcn,
		const bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w
	)		const

inherited

Definition at line 418 of file oracle_function.cpp.

                                      {
   return get_function(fcn)(arg, res, iw, w);
 }

References casadi::OracleFunction::get_function().

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::fdae_sp_forward(), and casadi::Integrator::fquad_sp_forward().

◆ calc_sp_reverse()

int casadi::OracleFunction::calc_sp_reverse	(	const std::string &	fcn,
		bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w
	)		const

inherited

Definition at line 423 of file oracle_function.cpp.

                                      {
   return get_function(fcn).rev(arg, res, iw, w);
 }

References casadi::OracleFunction::get_function().

Referenced by casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_reverse(), casadi::Integrator::fdae_sp_reverse(), and casadi::Integrator::fquad_sp_reverse().

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

◆ call_forward() [1/2]

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 2945 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)) {
         return FunctionInternal::call_forward(arg, res, replace_fseed(fseed, npar),
                                             fsens, always_inline, never_inline);
       }
     }
  
     // 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(), casadi::MXFunction::ad_forward(), casadi::XFunction< DerivedType, MatType, NodeType >::call_forward(), casadi::MX::forward(), casadi::Integrator::get_forward_dae(), and casadi::Scpgen::init().

◆ call_forward() [2/2]

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 3164 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 3838 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 1640 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/2]

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 3050 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)) {
         return FunctionInternal::call_reverse(arg, res, replace_aseed(aseed, npar),
                                             asens, always_inline, never_inline);
       }
     }
  
     // 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(), casadi::MXFunction::ad_reverse(), casadi::Call::ad_reverse(), casadi::XFunction< DerivedType, MatType, NodeType >::call_reverse(), casadi::Scpgen::init(), and casadi::MX::reverse().

◆ call_reverse() [2/2]

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 3177 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::FunctionInternal::change_option	(	const std::string &	option_name,
		const GenericType &	option_value
	)

overridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Reimplemented in casadi::MXFunction.

Definition at line 423 of file function_internal.cpp.

                                        {
     if (option_name == "print_in") {
       print_in_ = option_value;
     } else if (option_name == "print_out") {
       print_out_ = option_value;
     } else if (option_name=="ad_weight") {
       ad_weight_ = option_value;
     } else if (option_name=="ad_weight_sp") {
       ad_weight_sp_ = option_value;
     } else if (option_name=="dump") {
       dump_ = option_value;
     } else if (option_name=="dump_in") {
       dump_in_ = option_value;
     } else if (option_name=="dump_out") {
       dump_out_ = option_value;
     } else if (option_name=="dump_dir") {
       dump_dir_ = option_value.to_string();
     } else if (option_name=="dump_format") {
       dump_format_ = option_value.to_string();
     } else {
       // Option not found - continue to base classes
       ProtoFunction::change_option(option_name, option_value);
     }
   }

References casadi::FunctionInternal::ad_weight_, casadi::FunctionInternal::ad_weight_sp_, casadi::ProtoFunction::change_option(), casadi::FunctionInternal::dump_, casadi::FunctionInternal::dump_dir_, casadi::FunctionInternal::dump_format_, casadi::FunctionInternal::dump_in_, casadi::FunctionInternal::dump_out_, casadi::FunctionInternal::print_in_, casadi::FunctionInternal::print_out_, and casadi::GenericType::to_string().

Referenced by casadi::FmuFunction::change_option(), and casadi::MXFunction::change_option().

◆ 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 1687 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 3376 of file function_internal.cpp.

                                                                                              {
     // Matching dimensions
     if (arg.size()==inp.size()) return true;
     // Calling with empty matrix - set all to zero
     if (arg.is_empty()) 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;
     if (npar==-1) return false;
     // Evaluate with multiple arguments
     if (arg.size1()==inp.size1() && arg.size2()>0 && inp.size2()>0
         && arg.size2()%(npar*inp.size2())==0) {
       npar *= arg.size2()/(npar*inp.size2());
       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 179 of file function_internal.hpp.

179 { }

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 1711 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 3585 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::ProtoFunction::finalize(), casadi::FunctionBuffer::FunctionBuffer(), and casadi::Sqpmethod::init_mem().

◆ class_name()

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

inlineoverridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 75 of file fast_newton.hpp.

75 { return "FastNewton";}

◆ clear_mem()

void casadi::ProtoFunction::clear_mem ( )

inherited

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

Definition at line 3473 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 2306 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();
  
     // Generate function body (to buffer)
     codegen_body(g);
  
     g.scope_exit();
  
     // Finalize the function
     g << "return 0;\n";
     g << "}\n\n";
  
     // Flush to function body
     g.flush(g.body);
   }

References casadi::CodeGenerator::body, casadi::FunctionInternal::codegen_body(), casadi::FunctionInternal::definition(), casadi::CodeGenerator::flush(), casadi::CodeGenerator::scope_enter(), casadi::CodeGenerator::scope_exit(), and casadi::FunctionInternal::signature().

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 2354 of file function_internal.cpp.

                                                                  {
     bool needs_mem = !codegen_mem_type().empty();
     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_mem_type(), casadi::FunctionInternal::codegen_name(), and casadi::CodeGenerator::shorthand().

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

◆ codegen_body()

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

overridevirtual

Reimplemented from casadi::FunctionInternal.

Definition at line 170 of file fast_newton.cpp.

                                                       {
     g.add_auxiliary(CodeGenerator::AUX_NEWTON);
  
     g.local("m", "struct casadi_newton_mem");
  
     g << "m.n = " << n_ << ";\n";
     g << "m.abstol = " << abstol_ << ";\n";
     g << "m.abstol_step = " << abstolStep_ << ";\n";
  
     casadi_int w_offset = 0;
     g << "m.x = w;\n"; w_offset+=n_;
     g << "m.g = w+" + str(w_offset) + ";\n"; w_offset+=n_;
     g << "m.jac_g_x = w+" + str(w_offset) + ";\n"; w_offset+=sp_jac_.nnz();
  
     g << "m.sp_a = " + g.sparsity(sp_jac_)+ ";\n";
     g << "m.sp_v = " + g.sparsity(sp_v_)+ ";\n";
     g << "m.sp_r = " + g.sparsity(sp_r_)+ ";\n";
     g << "m.prinv = " + g.constant(prinv_)+ ";\n";
     g << "m.pc = " + g.constant(pc_)+ ";\n";
  
     g << "m.lin_w = w+" + str(w_offset) + ";\n"; w_offset+=sp_jac_.size1()+sp_jac_.size2();
     g << "m.lin_v = w+" + str(w_offset) + ";\n"; w_offset+=sp_v_.nnz();
     g << "m.lin_r = w+" + str(w_offset) + ";\n"; w_offset+=sp_r_.nnz();
     g << "m.lin_beta = w+" + str(w_offset) + ";\n"; w_offset+=sp_jac_.size2();
  
     g.comment("Get the initial guess");
     g << g.copy(g.arg(iin_), n_, "m.x") << "\n";
  
     g.local("iter", "casadi_int");
     g << "for (iter=0; iter<" + str(max_iter_) + "; ++iter) {\n";
  
     g.comment("(re)calculate f and J");
     // Use x to evaluate J
     for (casadi_int i=0;i<n_in_;++i) {
       g << g.arg(i+n_in_) << " = " << (i==iin_? "m.x" : g.arg(i)) << ";\n";
     }
     g << g.res(n_out_) + " = m.jac_g_x;\n";
     for (casadi_int i=0;i<n_out_;++i) {
       g << g.res(i+n_out_+1) + " = " << (i==iout_? "m.g" : g.res(i)) << ";\n";
     }
     std::string flag = g(get_function("jac_g_x"),
       "arg+" + str(n_in_), "res+" + str(n_out_), "iw", "w+" + str(w_offset));
     g << "if (" << flag << ") return 1;\n";
     g << "if (casadi_newton(&m)) break;\n";
     g << "}\n";
  
     // Get the solution
     g.comment("Get the solution");
     g << g.copy("m.x", n_, g.res(iout_)) << "\n";
   }

◆ codegen_body_enter()

void casadi::OracleFunction::codegen_body_enter ( CodeGenerator & g ) const

virtualinherited

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

Reimplemented in casadi::Nlpsol.

Definition at line 295 of file oracle_function.cpp.

                                                                 {
     g.local("d_oracle", "struct casadi_oracle_data");
   }

References casadi::CodeGenerator::local().

Referenced by casadi::Nlpsol::codegen_body_enter().

◆ codegen_body_exit()

void casadi::OracleFunction::codegen_body_exit ( CodeGenerator & g ) const

virtualinherited

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

Reimplemented in casadi::Nlpsol.

Definition at line 299 of file oracle_function.cpp.

299 {

300 }

Referenced by casadi::Nlpsol::codegen_body_exit().

◆ 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 2363 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";
     g << "int mid;\n";
     g << "if (" << stack_counter << ">=0) {\n";
     g << "return " << stack << "[" << stack_counter << "--];\n";
     g << "} else {\n";
     g << "if (" << mem_counter << "==CASADI_MAX_NUM_THREADS) return -1;\n";
     g << "mid = " << alloc_mem << "();\n";
     g << "if (mid<0) return -1;\n";
     g << "if(" << init_mem << "(mid)) return -1;\n";
     g << "return mid;\n";
     g << "}\n";
   }

References casadi::FunctionInternal::alloc_mem(), casadi::CodeGenerator::auxiliaries, casadi::FunctionInternal::codegen_mem_type(), casadi::FunctionInternal::codegen_name(), casadi::ProtoFunction::init_mem(), and casadi::CodeGenerator::shorthand().

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

◆ codegen_declarations()

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

overridevirtual

Reimplemented from casadi::FunctionInternal.

Definition at line 221 of file fast_newton.cpp.

                                                               {
     g.add_dependency(get_function("jac_g_x"));
   }

References casadi::CodeGenerator::add_dependency(), and casadi::OracleFunction::get_function().

◆ codegen_decref()

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

inlinevirtualinherited

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

Reimplemented in casadi::MXFunction, and casadi::External.

Definition at line 849 of file function_internal.hpp.

849 {}

Referenced by casadi::CodeGenerator::add_dependency(), and casadi::FunctionInternal::codegen_meta().

◆ 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::OsqpInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, and casadi::External.

Definition at line 864 of file function_internal.hpp.

864 {}

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

◆ codegen_incref()

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

inlinevirtualinherited

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

Reimplemented in casadi::MXFunction, and casadi::External.

Definition at line 844 of file function_internal.hpp.

844 {}

Referenced by casadi::CodeGenerator::add_dependency(), and casadi::FunctionInternal::codegen_meta().

◆ 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::OsqpInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, and casadi::External.

Definition at line 2350 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 2732 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_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::OsqpInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, and casadi::External.

Definition at line 899 of file function_internal.hpp.

899 { return ""; }

Referenced by casadi::CodeGenerator::add_dependency(), casadi::FunctionInternal::codegen_alloc_mem(), casadi::FunctionInternal::codegen_checkout(), casadi::FunctionInternal::codegen_meta(), casadi::CodeGenerator::operator()(), and casadi::CodeGenerator::setup_callback().

◆ codegen_meta()

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

inherited

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

Definition at line 2400 of file function_internal.cpp.

                                                             {
     bool needs_mem = !codegen_mem_type().empty();
  
     g << g.declare("int " + name_ + "_alloc_mem(void)") << " {\n";
     if (needs_mem) {
       g << "return " << codegen_name(g) << "_alloc_mem();\n";
     } else {
       g << "return 0;\n";
     }
     g << "}\n\n";
  
     g << g.declare("int " + name_ + "_init_mem(int mem)") << " {\n";
     if (needs_mem) {
       g << "return " << codegen_name(g) << "_init_mem(mem);\n";
     } else {
       g << "return 0;\n";
     }
     g << "}\n\n";
  
     g << g.declare("void " + name_ + "_free_mem(int mem)") << " {\n";
     if (needs_mem) {
       g << codegen_name(g) << "_free_mem(mem);\n";
     }
     g << "}\n\n";
  
     // Checkout/release routines
     g << g.declare("int " + name_ + "_checkout(void)") << " {\n";
     if (needs_mem) {
       g << "return " << codegen_name(g) << "_checkout();\n";
     } else {
       g << "return 0;\n";
     }
     g << "}\n\n";
  
     if (needs_mem) {
       g << g.declare("void " + name_ + "_release(int mem)") << " {\n";
       g << codegen_name(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";
     codegen_incref(g);
     g << "}\n\n"
       << g.declare("void " + name_ + "_decref(void)") << " {\n";
     codegen_decref(g);
     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 (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";
       }
       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("%g ", "*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_ << "_alloc_mem,\n"
         //<< name_ << "_init_mem,\n"
         //<< name_ << "_free_mem,\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 2717 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_alloc_mem(), casadi::FunctionInternal::codegen_checkout(), casadi::Call::codegen_decref(), casadi::Call::codegen_incref(), casadi::FunctionInternal::codegen_mem(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_release(), and casadi::CodeGenerator::mem().

◆ 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 2389 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");
     g << stack << "[++" << stack_counter << "] = mem;\n";
   }

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

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 2396 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 2829 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 2835 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 2832 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::FunctionInternal::codegen_sz_w ( const CodeGenerator & g ) const

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 2838 of file function_internal.cpp.

                                                                     {
     return sz_w();
   }

References casadi::FunctionInternal::sz_w().

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

◆ 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 137 of file function_internal.cpp.

                                                 {
     // Sanitize dictionary is needed
     if (!Options::is_sane(opts)) {
       // Call recursively
       return construct(Options::sanitize(opts));
     }
  
     // 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 1811 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 1799 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 1840 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 1828 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().

◆ create_forward()

Function casadi::OracleFunction::create_forward	(	const std::string &	fname,
		casadi_int	nfwd
	)

inherited

Create an oracle function as a forward derivative of a different function

Definition at line 278 of file oracle_function.cpp.

                                                                                {
   // Create derivative
   Function ret = get_function(fname).forward(nfwd);
   std::string fwd_name = forward_name(fname, nfwd);  // may be different from ret.name()
   if (!has_function(fwd_name)) set_function(ret, fwd_name, true);
   return ret;
 }

References casadi::FunctionInternal::forward_name(), casadi::OracleFunction::get_function(), casadi::OracleFunction::has_function(), and casadi::OracleFunction::set_function().

Referenced by casadi::Integrator::init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::SLEQPInterface::init(), casadi::SundialsInterface::init(), and casadi::RungeKutta::setup_step().

◆ create_function() [1/3]

Function casadi::OracleFunction::create_function	(	const Function &	oracle,
		const std::string &	fname,
		const std::vector< std::string > &	s_in,
		const std::vector< std::string > &	s_out,
		const Function::AuxOut &	aux = `Function::AuxOut()`,
		const Dict &	opts = `Dict()`
	)

inherited

Create an oracle function, using a different oracle function Temporary addition to allow transition from one oracle formulation to another.

Definition at line 235 of file oracle_function.cpp.

                       {
   // Print progress
   if (verbose_) {
     casadi_message(name_ + "::create_function " + fname + ":" + str(s_in) + "->" + str(s_out));
   }
  
   // Check if function is already in cache
   Function ret;
   if (incache(fname, ret)) {
     // Consistency checks
     casadi_assert(ret.n_in() == s_in.size(), fname + " has wrong number of inputs");
     casadi_assert(ret.n_out() == s_out.size(), fname + " has wrong number of outputs");
   } else {
     // Retrieve specific set of options if available
     Dict specific_options;
     auto it = specific_options_.find(fname);
     if (it!=specific_options_.end()) specific_options = it->second;
  
     // Combine specific and common options
     Dict opt = combine(specific_options, common_options_);
     opt = combine(opts, opt);
  
     // Generate the function
     ret = oracle.factory(fname, s_in, s_out, aux, opt);
  
     // Make sure that it's sound
     if (ret.has_free()) {
       casadi_error("Cannot create '" + fname + "' since " + str(ret.get_free()) + " are free.");
     }
  
     // Add to cache
     tocache_if_missing(ret);
   }
  
   // Save and return
   set_function(ret, fname, true);
   return ret;
 }

References casadi::combine(), casadi::OracleFunction::common_options_, casadi::Function::factory(), casadi::Function::get_free(), casadi::Function::has_free(), casadi::FunctionInternal::incache(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::ProtoFunction::name_, casadi::OracleFunction::oracle(), casadi::OracleFunction::set_function(), casadi::OracleFunction::specific_options_, casadi::str(), casadi::FunctionInternal::tocache_if_missing(), and casadi::ProtoFunction::verbose_.

◆ create_function() [2/3]

Function casadi::OracleFunction::create_function	(	const std::string &	fname,
		const std::vector< MX > &	e_in,
		const std::vector< MX > &	e_out,
		const std::vector< std::string > &	s_in,
		const std::vector< std::string > &	s_out,
		const Dict &	opts = `Dict()`
	)

inherited

Create an oracle function from MX

Definition at line 187 of file oracle_function.cpp.

                         {
  
   // Print progress
   if (verbose_) {
     casadi_message(name_ + "::create_function " + fname + ":" + str(s_in) + "->" + str(s_out));
   }
  
   // Check if function is already in cache
   Function ret;
   if (incache(fname, ret)) {
     // Consistency checks
     casadi_assert(ret.n_in() == s_in.size(), fname + " has wrong number of inputs");
     casadi_assert(ret.n_out() == s_out.size(), fname + " has wrong number of outputs");
   } else {
     // Retrieve specific set of options if available
     Dict specific_options;
     auto it = specific_options_.find(fname);
     if (it!=specific_options_.end()) specific_options = it->second;
  
     // Combine specific and common options
     Dict opt = combine(specific_options, common_options_);
     opt = combine(opts, opt);
  
     // Generate the function
     ret = Function(fname, e_in, e_out, s_in, s_out, opt);
  
     // Make sure that it's sound
     if (ret.has_free()) {
       casadi_error("Cannot create '" + fname + "' since " + str(ret.get_free()) + " are free.");
     }
  
     // TODO(jgillis) Conditionally convert to SX
  
     // Add to cache
     tocache_if_missing(ret);
   }
  
   // Save and return
   set_function(ret, fname, true);
   return ret;
  
 }

References casadi::combine(), casadi::OracleFunction::common_options_, casadi::FunctionInternal::Function, casadi::Function::get_free(), casadi::Function::has_free(), casadi::FunctionInternal::incache(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::ProtoFunction::name_, casadi::OracleFunction::set_function(), casadi::OracleFunction::specific_options_, casadi::str(), casadi::FunctionInternal::tocache_if_missing(), and casadi::ProtoFunction::verbose_.

◆ create_function() [3/3]

Function casadi::OracleFunction::create_function	(	const std::string &	fname,
		const std::vector< std::string > &	s_in,
		const std::vector< std::string > &	s_out,
		const Function::AuxOut &	aux = `Function::AuxOut()`,
		const Dict &	opts = `Dict()`
	)

inherited

Create an oracle function

Definition at line 179 of file oracle_function.cpp.

                       {
   return create_function(oracle_, fname, s_in, s_out, aux, opts);
 }

References casadi::OracleFunction::create_function(), and casadi::OracleFunction::oracle_.

◆ create_oracle()

template<typename XType >

Function casadi::Rootfinder::create_oracle	(	const std::map< std::string, XType > &	d,
		const Dict &	opts
	)

staticinherited

Definition at line 122 of file rootfinder.cpp.

                                                    {
     std::vector<XType> rfp_in(RFP_NUM_IN), rfp_out(RFP_NUM_OUT);
     for (auto&& i : d) {
       if (i.first=="x") {
         rfp_in[RFP_X]=i.second;
       } else if (i.first=="p") {
         rfp_in[RFP_P]=i.second;
       } else if (i.first=="g") {
         rfp_out[RFP_G]=i.second;
       } else {
         casadi_error("No such field: " + i.first);
       }
     }
  
     // Options for the oracle
     Dict oracle_options;
     Dict::const_iterator it = opts.find("oracle_options");
     if (it!=opts.end()) {
       // "oracle_options" has been set
       oracle_options = it->second;
     } else if ((it=opts.find("verbose")) != opts.end()) {
       // "oracle_options" has not been set, but "verbose" has
       oracle_options["verbose"] = it->second;
     }
  
     // Create oracle
     return Function("rfp", rfp_in, rfp_out, {"x", "p"}, {"g"}, oracle_options);
   }

References casadi::FunctionInternal::Function, casadi::RFP_G, casadi::RFP_NUM_IN, casadi::RFP_NUM_OUT, casadi::RFP_P, and casadi::RFP_X.

Referenced by casadi::rootfinder().

◆ creator()

static Rootfinder* casadi::FastNewton::creator	(	const std::string &	name,
		const Function &	f
	)

inlinestatic

Definition at line 78 of file fast_newton.hpp.

                                                                          {
       return new FastNewton(name, f);
     }

Referenced by casadi::casadi_register_rootfinder_fast_newton().

◆ 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 941 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(), casadi::MXFunction::should_inline(), and casadi::SXFunction::should_inline().

◆ deserialize()

static ProtoFunction* casadi::FastNewton::deserialize ( DeserializingStream & s )

inlinestatic

Definition at line 123 of file fast_newton.hpp.

123 { return new FastNewton(s); }

Referenced by casadi::casadi_register_rootfinder_fast_newton().

◆ 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 2043 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(), 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 962 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 casadi::MXFunction::eval(), and casadi::SXFunction::eval().

◆ disp_more()

virtual void casadi::FunctionInternal::disp_more ( std::ostream & stream ) const

inlinevirtualinherited

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

Reimplemented in casadi::SXFunction, casadi::Switch, casadi::Nlpsol, and casadi::MXFunction.

Definition at line 940 of file function_internal.hpp.

940 {}

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

◆ 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 3244 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 3220 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 3252 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 3224 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 1857 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::Rootfinder::eval	(	const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w,
		void *	mem
	)		const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 283 of file rootfinder.cpp.

                                                   {
     // Reset the solver, prepare for solution
     setup(mem, arg, res, iw, w);
  
     // Solve the NLP
     int ret = solve(mem);
     auto m = static_cast<RootfinderMemory*>(mem);
     if (error_on_fail_ && !m->success)
       casadi_error("rootfinder process failed. "
                    "Set 'error_on_fail' option to false to ignore this error.");
  
     return ret;
   }

References casadi::ProtoFunction::error_on_fail_, casadi::FunctionInternal::setup(), and casadi::Rootfinder::solve().

◆ 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 2026 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 430 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 830 of file function_internal.cpp.

                                                    {
     casadi_int dump_id = (dump_in_ || dump_out_ || dump_) ? get_dump_id() : 0;
     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<ProtoFunctionMemory*>(mem);
  
     // Avoid memory corruption
     for (casadi_int i=0;i<n_in_;++i) {
       casadi_assert(arg[i]==0 || 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]==0 || 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();
     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 426 of file function_internal.hpp.

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

◆ eval_mx()

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

virtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 2241 of file function_internal.cpp.

                                                                               {
  
     always_inline = always_inline || always_inline_;
     never_inline = never_inline || never_inline_;
  
     // The code below creates a call node, to inline, wrap in an MXFunction
     if (always_inline) {
       casadi_assert(!never_inline, "Inconsistent options for " + str(name_));
       return wrap().call(arg, res, true);
     }
  
     // Create a call-node
     res = Call::create(self(), arg);
   }

References casadi::FunctionInternal::always_inline_, casadi::Function::call(), casadi::Call::create(), casadi::ProtoFunction::name_, casadi::FunctionInternal::never_inline_, casadi::str(), and casadi::FunctionInternal::wrap().

Referenced by casadi::FunctionInternal::call_gen(), casadi::MXFunction::eval_mx(), and casadi::SXFunction::eval_mx().

◆ eval_sx()

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

virtualinherited

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

Reimplemented in casadi::SXFunction, casadi::Switch, casadi::MXFunction, casadi::MapSum, and casadi::Map.

Definition at line 2030 of file function_internal.cpp.

                                                  {
  
     always_inline = always_inline || always_inline_;
     never_inline = never_inline || never_inline_;
  
     casadi_assert(!always_inline, "'eval_sx' not defined for " + class_name() +
     " in combination with always_inline true");
  
     return CallSX::eval_sx(self(), arg, res);
   }

References casadi::FunctionInternal::always_inline_, casadi::SharedObjectInternal::class_name(), casadi::CallSX::eval_sx(), and casadi::FunctionInternal::never_inline_.

Referenced by casadi::MXFunction::eval_sx(), and casadi::SXFunction::eval_sx().

◆ expand()

void casadi::OracleFunction::expand ( )

inherited

Definition at line 455 of file oracle_function.cpp.

                             {
   oracle_ = oracle_.expand();
 }

References casadi::Function::expand(), and casadi::OracleFunction::oracle_.

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

◆ export_code()

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

virtualinherited

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

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, and casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >.

Definition at line 2201 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ factory()

Function casadi::FunctionInternal::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

virtualinherited

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >, casadi::FmuFunction, and casadi::External.

Definition at line 3613 of file function_internal.cpp.

                                   {
     return wrap().factory(name, s_in, s_out, aux, opts);
   }

References casadi::Function::factory(), and casadi::FunctionInternal::wrap().

Referenced by casadi::Function::factory(), casadi::External::factory(), and casadi::FmuFunction::factory().

◆ finalize()

void casadi::OracleFunction::finalize ( )

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 122 of file oracle_function.cpp.

                               {
   if (post_expand_) {
     for (auto&& e : all_functions_) {
       Function& fcn = e.second.f;
       fcn = fcn.expand();
     }
   }
  
   // Allocate space for (parallel) evaluations
   // Lifted from set_function as max_num_threads_ is not known yet in that method
   for (auto&& e : all_functions_) {
     Function& fcn = e.second.f;
     // Compute strides for multi threading
     size_t sz_arg, sz_res, sz_iw, sz_w;
     fcn.sz_work(sz_arg, sz_res, sz_iw, sz_w);
     stride_arg_ = std::max(stride_arg_, sz_arg);
     stride_res_ = std::max(stride_res_, sz_res);
     stride_iw_ = std::max(stride_iw_, sz_iw);
     stride_w_ = std::max(stride_w_, sz_w);
     bool persistent = false;
     alloc(fcn, persistent, max_num_threads_);
   }
  
   // Set corresponding monitors
   for (const std::string& fname : monitor_) {
     auto it = all_functions_.find(fname);
     if (it==all_functions_.end()) {
       casadi_warning("Ignoring monitor '" + fname + "'."
                       " Available functions: " + join(get_function()) + ".");
     } else {
       if (it->second.monitored) casadi_warning("Duplicate monitor " + fname);
       it->second.monitored = true;
     }
   }
  
   // Check specific options
   for (auto&& i : specific_options_) {
     if (all_functions_.find(i.first)==all_functions_.end())
       casadi_warning("Ignoring specific_options entry '" + i.first+"'."
                       " Available functions: " + join(get_function()) + ".");
   }
  
   // Recursive call
   FunctionInternal::finalize();
 }

References casadi::OracleFunction::all_functions_, casadi::FunctionInternal::alloc(), casadi::Function::expand(), casadi::FunctionInternal::finalize(), casadi::OracleFunction::get_function(), casadi::join(), casadi::OracleFunction::max_num_threads_, casadi::OracleFunction::monitor_, casadi::OracleFunction::post_expand_, casadi::OracleFunction::specific_options_, casadi::OracleFunction::stride_arg_, casadi::OracleFunction::stride_iw_, casadi::OracleFunction::stride_res_, casadi::OracleFunction::stride_w_, casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), casadi::FunctionInternal::sz_w(), and casadi::Function::sz_work().

◆ find()

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

inlinevirtualinherited

Reimplemented in casadi::BSplineInterpolant, casadi::SXFunction, casadi::Switch, and casadi::MXFunction.

Definition at line 371 of file function_internal.hpp.

371 {}

Referenced by casadi::FunctionInternal::add_embedded(), casadi::MX::cse(), casadi::FunctionInternal::from_compact(), and casadi::FunctionInternal::to_compact().

◆ 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 3772 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 2079 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_);
       opts = combine(opts, generate_options("forward"));
       if (!enable_forward_) opts = fd_options_;
       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 {
         // 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 633 of file function_internal.hpp.

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

References casadi::str().

◆ free_mem()

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

inlineoverridevirtual

Reimplemented from casadi::OracleFunction.

Definition at line 101 of file fast_newton.hpp.

101 { delete static_cast<FastNewtonMemory*>(mem);}

◆ free_mx()

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

virtualinherited

Reimplemented in casadi::MXFunction.

Definition at line 3293 of file function_internal.cpp.

                                                 {
     casadi_error("'free_mx' only defined for 'MXFunction'");
   }

◆ free_sx()

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

virtualinherited

Reimplemented in casadi::SXFunction.

Definition at line 3297 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 1844 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 1496 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 2909 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::OracleFunction::generate_dependencies	(	const std::string &	fname,
		const Dict &	opts
	)		const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 428 of file oracle_function.cpp.

                             {
   CodeGenerator gen(fname, opts);
   gen.add(oracle_);
   for (auto&& e : all_functions_) {
     if (e.second.jit) gen.add(e.second.f);
   }
   return gen.generate();
 }

References casadi::CodeGenerator::add(), casadi::OracleFunction::all_functions_, casadi::CodeGenerator::generate(), and casadi::OracleFunction::oracle_.

Referenced by casadi::OracleFunction::jit_dependencies().

◆ 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 731 of file function_internal.cpp.

                                                                                      {
     // Set up output stream
     std::ofstream of;
     Filesystem::open(of, fname);
     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::open().

◆ generate_lifted()

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

virtualinherited

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

Reimplemented in casadi::MXFunction.

Definition at line 3301 of file function_internal.cpp.

                                                                     {
     casadi_error("'generate_lifted' only defined for 'MXFunction'");
   }

◆ generate_options()

Dict casadi::FunctionInternal::generate_options ( const std::string & target ) const

overridevirtualinherited

Reimplemented from casadi::ProtoFunction.

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 382 of file function_internal.cpp.

                                                                        {
     Dict opts = ProtoFunction::generate_options(target);
     opts["jac_penalty"] = jac_penalty_;
     opts["user_data"] = user_data_;
     opts["inputs_check"] = inputs_check_;
     if (target!="tmp") opts["jit"] = jit_;
     opts["jit_cleanup"] = jit_cleanup_;
     opts["jit_serialize"] = jit_serialize_;
     opts["compiler"] = compiler_plugin_;
     opts["jit_options"] = jit_options_;
     opts["jit_name"] = jit_base_name_;
     opts["jit_temp_suffix"] = jit_temp_suffix_;
     opts["ad_weight"] = ad_weight_;
     opts["ad_weight_sp"] = ad_weight_sp_;
     opts["always_inline"] = always_inline_;
     opts["never_inline"] = never_inline_;
     opts["max_num_dir"] = max_num_dir_;
     if (target=="clone" || target=="tmp") {
       opts["enable_forward"] = enable_forward_op_;
       opts["enable_reverse"] = enable_reverse_op_;
       opts["enable_jacobian"] = enable_jacobian_op_;
       opts["enable_fd"] = enable_fd_op_;
       opts["reverse_options"] = reverse_options_;
       opts["forward_options"] = forward_options_;
       opts["jacobian_options"] = jacobian_options_;
       opts["der_options"] = der_options_;
       opts["derivative_of"] = derivative_of_;
     }
     opts["fd_options"] = fd_options_;
     opts["fd_method"] = fd_method_;
     opts["print_in"] = print_in_;
     opts["print_out"] = print_out_;
     opts["max_io"] = max_io_;
     opts["dump_in"] = dump_in_;
     opts["dump_out"] = dump_out_;
     opts["dump_dir"] = dump_dir_;
     opts["dump_format"] = dump_format_;
     opts["dump"] = dump_;
     return opts;
   }

Referenced by casadi::FunctionInternal::forward(), casadi::MXFunction::generate_options(), casadi::SXFunction::generate_options(), casadi::BlazingSplineFunction::get_jacobian(), and casadi::FunctionInternal::reverse().

◆ generate_out()

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

inherited

Definition at line 747 of file function_internal.cpp.

                                                                                 {
     // Set up output stream
     std::ofstream of;
     Filesystem::open(of, fname);
     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::open().

◆ 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 1094 of file function_internal.hpp.

                                       {
       return eps;
     }

References casadi::eps.

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

◆ get_default_in()

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

inlinevirtualinherited

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

Reimplemented in casadi::SXFunction, casadi::Nlpsol, casadi::MXFunction, casadi::MapSum, casadi::Map, casadi::FiniteDiff, casadi::Conic, and casadi::External.

Definition at line 1058 of file function_internal.hpp.

                                                         {
       return 0;
     }

Referenced by casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::convert_arg(), and casadi::External::get_default_in().

◆ 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 1111 of file function_internal.hpp.

1111 { 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 1116 of file function_internal.hpp.

1116 { return true; }

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

◆ get_forward()

Function casadi::Rootfinder::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_1oi

Reimplemented from casadi::FunctionInternal.

Definition at line 315 of file rootfinder.cpp.

                                         {
     // Symbolic expression for the input
     std::vector<MX> arg = mx_in(), res = mx_out();
     std::vector<std::vector<MX>> fseed = fwd_seed<MX>(nfwd), fsens;
     arg[iin_] = MX::sym(arg[iin_].name(), Sparsity(arg[iin_].size()));
     for (auto&& e : fseed) e[iin_] = MX::sym(e[iin_].name(), e[iin_].size());
     ad_forward(arg, res, fseed, fsens, false, false);
  
     // Construct return function
     arg.insert(arg.end(), res.begin(), res.end());
     std::vector<MX> v(nfwd);
     for (casadi_int i=0; i<n_in_; ++i) {
       for (casadi_int d=0; d<nfwd; ++d) v[d] = fseed[d][i];
       arg.push_back(horzcat(v));
     }
     res.clear();
     for (casadi_int i=0; i<n_out_; ++i) {
       for (casadi_int d=0; d<nfwd; ++d) v[d] = fsens[d][i];
       res.push_back(ensure_stacked(horzcat(v), sparsity_out(i), nfwd));
     }
  
     Dict options = opts;
     options["allow_duplicate_io_names"] = true;
  
     return Function(name, arg, res, inames, onames, options);
   }

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

◆ get_free()

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

virtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 936 of file function_internal.cpp.

                                                         {
     casadi_assert_dev(!has_free());
     return std::vector<std::string>();
   }

References casadi::FunctionInternal::has_free().

◆ get_function() [1/2]

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

overridevirtualinherited

-1 Indicates irregularity

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

Reimplemented from casadi::FunctionInternal.

Definition at line 531 of file oracle_function.cpp.

                                                         {
   std::vector<std::string> ret;
   ret.reserve(all_functions_.size());
   for (auto&& e : all_functions_) {
     ret.push_back(e.first);
   }
   return ret;
 }

References casadi::OracleFunction::all_functions_.

Referenced by casadi::Rootfinder::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::OracleFunction::calc_function(), casadi::OracleFunction::calc_sp_forward(), casadi::OracleFunction::calc_sp_reverse(), codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::codegen_declarations(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::MadnlpInterface::codegen_declarations(), codegen_declarations(), casadi::Feasiblesqpmethod::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), casadi::FixedStepIntegrator::create_advanced(), casadi::OracleFunction::create_forward(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::OracleFunction::finalize(), casadi::Nlpsol::get_forward(), casadi::OracleFunction::get_function(), casadi::AlpaqaProblem::get_hess_L_num_nonzeros(), casadi::AlpaqaProblem::get_hess_ψ_num_nonzeros(), casadi::Nlpsol::get_reverse(), casadi::FixedStepIntegrator::init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::Blocksqp::init(), casadi::BonminInterface::init(), casadi::FatropInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), casadi::SLEQPInterface::init(), casadi::SundialsInterface::init(), init(), casadi::Feasiblesqpmethod::init(), casadi::Sqpmethod::init(), casadi::OracleFunction::monitored(), casadi::FatropInterface::set_fatrop_prob(), casadi::IpoptInterface::set_ipopt_prob(), casadi::MadnlpInterface::set_madnlp_prob(), casadi::SundialsInterface::set_work(), casadi::Collocation::setup_step(), casadi::RungeKutta::setup_step(), casadi::Integrator::sp_jac_dae(), and casadi::Integrator::sp_jac_rdae().

◆ get_function() [2/2]

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 540 of file oracle_function.cpp.

                                                                         {
   auto it = all_functions_.find(name);
   casadi_assert(it!=all_functions_.end(),
     "No function \"" + name + "\" in " + name_ + ". " +
     "Available functions: " + join(get_function()) + ".");
   return it->second.f;
 }

References casadi::OracleFunction::all_functions_, casadi::OracleFunction::get_function(), casadi::join(), and casadi::ProtoFunction::name_.

◆ 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 1787 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 1132 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 1472 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 1237 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::FunctionInternal::get_jacobian	(	const std::string &	name,
		const std::vector< std::string > &	inames,
		const std::vector< std::string > &	onames,
		const Dict &	opts
	)		const

virtualinherited

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

Reimplemented in casadi::LinearInterpolantJac, casadi::LinearInterpolant, casadi::BSplineInterpolant, casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >, casadi::JitFunction, casadi::FmuFunction, casadi::External, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

Definition at line 2298 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

Referenced by casadi::External::get_jacobian(), casadi::BSplineInterpolant::get_jacobian(), casadi::LinearInterpolantJac::get_jacobian(), and casadi::FunctionInternal::jacobian().

◆ 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 1065 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 1072 of file function_internal.hpp.

                                                     {
       return -inf;
     }

References casadi::inf.

◆ get_n_in()

size_t casadi::Rootfinder::get_n_in ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 71 of file rootfinder_impl.hpp.

71 { return oracle_.n_in();}

casadi::Function::n_in

casadi_int n_in() const

Get the number of function inputs.

Definition: function.cpp:819

◆ get_n_out()

size_t casadi::Rootfinder::get_n_out ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 72 of file rootfinder_impl.hpp.

72 { return oracle_.n_out();}

casadi::Function::n_out

casadi_int n_out() const

Get the number of function outputs.

Definition: function.cpp:823

◆ get_name_in()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 72 of file rootfinder.cpp.

                                                 {
     if (i==iin_) return oracle_.name_in(i) + "0";
     return oracle_.name_in(i);
   }

References casadi::Rootfinder::iin_, casadi::Function::name_in(), and casadi::OracleFunction::oracle_.

◆ get_name_out()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 77 of file rootfinder.cpp.

                                                  {
     if (i==iout_) return oracle_.name_in(iin_);
     return oracle_.name_out(i);
   }

References casadi::Rootfinder::iin_, casadi::Rootfinder::iout_, casadi::Function::name_in(), casadi::Function::name_out(), and casadi::OracleFunction::oracle_.

◆ get_nominal_in()

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

inlinevirtualinherited

Reimplemented in casadi::FmuFunction.

Definition at line 1076 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 1080 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::FastNewton::get_options ( ) const

inlineoverridevirtual

Reimplemented from casadi::Rootfinder.

Definition at line 85 of file fast_newton.hpp.

85 { return options_;}

casadi::FastNewton::options_

static const Options options_

Options.

Definition: fast_newton.hpp:84

◆ 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 1927 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 1087 of file function_internal.hpp.

                                       {
       return eps;
     }

References casadi::eps.

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

◆ get_reverse()

Function casadi::Rootfinder::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_1oj

Reimplemented from casadi::FunctionInternal.

Definition at line 346 of file rootfinder.cpp.

                                         {
     // Symbolic expression for the input
     std::vector<MX> arg = mx_in();
     arg[iin_] = MX::sym(arg[iin_].name() + "_guess",
                         Sparsity(arg[iin_].size()));
     std::vector<MX> res = mx_out();
     std::vector<std::vector<MX> > aseed = symbolicAdjSeed(nadj, res), asens;
     ad_reverse(arg, res, aseed, asens, false, false);
  
     // Construct return function
     arg.insert(arg.end(), res.begin(), res.end());
     std::vector<MX> v(nadj);
     for (casadi_int i=0; i<n_out_; ++i) {
       for (casadi_int d=0; d<nadj; ++d) v[d] = aseed[d][i];
       arg.push_back(horzcat(v));
     }
     res.clear();
     for (casadi_int i=0; i<n_in_; ++i) {
       for (casadi_int d=0; d<nadj; ++d) v[d] = asens[d][i];
       res.push_back(ensure_stacked(horzcat(v), sparsity_in(i), nadj));
     }
  
     Dict options = opts;
     options["allow_duplicate_io_names"] = true;
     return Function(name, arg, res, inames, onames, options);
   }

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

◆ get_sparsity_in()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 79 of file rootfinder_impl.hpp.

79 { return oracle_.sparsity_in(i);}

casadi::Function::sparsity_in

const Sparsity & sparsity_in(casadi_int ind) const

Get sparsity of a given input.

Definition: function.cpp:1015

◆ get_sparsity_out()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 82 of file rootfinder.cpp.

                                                     {
     if (i==iout_) return oracle_.sparsity_in(iin_);
     return oracle_.sparsity_out(i);
   }

References casadi::Rootfinder::iin_, casadi::Rootfinder::iout_, casadi::OracleFunction::oracle_, casadi::Function::sparsity_in(), and casadi::Function::sparsity_out().

◆ get_stats()

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

overridevirtual

Reimplemented from casadi::Rootfinder.

Definition at line 246 of file fast_newton.cpp.

                                             {
     Dict stats = Rootfinder::get_stats(mem);
     auto m = static_cast<FastNewtonMemory*>(mem);
     stats["return_status"] = return_code(m->return_status);
     stats["iter_count"] = m->iter;
     return stats;
   }

References casadi::Rootfinder::get_stats(), and casadi::return_code().

◆ getAdaptorSolverName()

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

inlinevirtualinherited

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

Definition at line 304 of file function_internal.hpp.

304 { 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;
   }

◆ getPlugin()

PluginInterface< Rootfinder >::Plugin & casadi::PluginInterface< Rootfinder >::getPlugin ( const std::string & pname )

staticinherited

Definition at line 102 of file plugin_interface.hpp.

                                                             {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Check if the solver has been loaded
     auto it=Derived::solvers_.find(pname);
  
     // Load the solver if needed
     if (it==Derived::solvers_.end()) {
       load_plugin(pname, true, false);
       it=Derived::solvers_.find(pname);
     }
     casadi_assert_dev(it!=Derived::solvers_.end());
     return it->second;
   }

◆ has_codegen()

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

inlinevirtualinherited

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

Reimplemented in casadi::LinearInterpolantJac, casadi::LinearInterpolant, casadi::BSplineInterpolant, casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >, casadi::Switch, casadi::MapSum, casadi::Map, casadi::JitFunction, casadi::FiniteDiff, and casadi::BlazingSplineFunction.

Definition at line 909 of file function_internal.hpp.

909 { return false;}

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

◆ has_derivative()

bool casadi::FunctionInternal::has_derivative ( ) const

inherited

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

Definition at line 2905 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::FunctionInternal::jacobian(), and casadi::FunctionInternal::reverse().

◆ 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 419 of file function_internal.hpp.

419 { return false;}

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

◆ has_forward()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 148 of file rootfinder_impl.hpp.

148 { return true;}

◆ has_free()

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

inlinevirtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 738 of file function_internal.hpp.

738 { return false;}

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

◆ has_function()

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 556 of file oracle_function.cpp.

                                                               {
   return all_functions_.find(fname) != all_functions_.end();
 }

References casadi::OracleFunction::all_functions_.

Referenced by casadi::OracleFunction::create_forward(), casadi::FixedStepIntegrator::init(), casadi::BonminInterface::init(), casadi::FatropInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), casadi::SLEQPInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Sqpmethod::init(), casadi::OracleFunction::set_function(), and casadi::Integrator::trigger_event().

◆ 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 628 of file function_internal.hpp.

628 { return false;}

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

◆ has_jacobian()

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

inlinevirtualinherited

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

Reimplemented in casadi::LinearInterpolantJac, casadi::LinearInterpolant, casadi::BSplineInterpolant, casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >, casadi::JitFunction, casadi::FmuFunction, casadi::External, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

Definition at line 615 of file function_internal.hpp.

615 { return false;}

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

◆ has_memory()

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

inherited

Definition at line 3581 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 920 of file function_internal.cpp.

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

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

◆ has_plugin()

bool casadi::PluginInterface< Rootfinder >::has_plugin	(	const std::string &	pname,
		bool	verbose = `false`
	)

staticinherited

Definition at line 76 of file plugin_interface.hpp.

                                                                                 {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Quick return if available
     if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
       return true;
     }
  
     // Try loading the plugin
     try {
       (void)load_plugin(pname, false, false);
       return true;
     } catch (CasadiException& ex) {
       if (verbose) {
         casadi_warning(ex.what());
       }
       return false;
     }
   }

◆ has_reverse()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 159 of file rootfinder_impl.hpp.

159 { return true;}

◆ has_spfwd()

bool casadi::Rootfinder::has_spfwd ( ) const

inlineoverridevirtualinherited

Is the class able to propagate seeds through the algorithm?

Reimplemented from casadi::FunctionInternal.

Definition at line 135 of file rootfinder_impl.hpp.

135 { return true;}

◆ has_sprev()

bool casadi::Rootfinder::has_sprev ( ) const

inlineoverridevirtualinherited

Is the class able to propagate seeds through the algorithm?

Reimplemented from casadi::FunctionInternal.

Definition at line 136 of file rootfinder_impl.hpp.

136 { 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 994 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 1121 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 1133 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, and casadi::Map.

Definition at line 2941 of file function_internal.cpp.

                                     {
     return Dict();
   }

Referenced by casadi::MXFunction::export_code_body(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::Blocksqp::filterLineSearch(), casadi::Blocksqp::fullstep(), 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::FastNewton::init ( const Dict & opts )

overridevirtual

Reimplemented from casadi::Rootfinder.

Definition at line 71 of file fast_newton.cpp.

                                         {
  
     // Call the base class initializer
     Rootfinder::init(opts);
  
     // Default options
     max_iter_ = 1000;
     abstol_ = 1e-12;
     abstolStep_ = 1e-12;
  
     // Read options
     for (auto&& op : opts) {
       if (op.first=="max_iter") {
         max_iter_ = op.second;
       } else if (op.first=="abstol") {
         abstol_ = op.second;
       } else if (op.first=="abstolStep") {
         abstolStep_ = op.second;
       }
     }
  
     casadi_assert(oracle_.n_in()>0,
                           "Newton: the supplied f must have at least one input.");
     casadi_assert(!linsol_.is_null(),
                           "Newton::init: linear_solver must be supplied");
  
     jac_g_x_ = get_function("jac_g_x");
  
     // Symbolic factorization
     sp_jac_.qr_sparse(sp_v_, sp_r_, prinv_, pc_);
  
     // Allocate memory
     alloc_w(n_, true); // x
     alloc_w(n_, true); // F
     alloc_w(sp_jac_.nnz(), true); // J
  
     alloc_w(sp_jac_.size1() + sp_jac_.size2(), true); // w
     alloc_w(sp_v_.nnz(), true); // v
     alloc_w(sp_r_.nnz(), true); // r
     alloc_w(sp_jac_.size2(), true); // beta
  
   }

References abstol_, abstolStep_, casadi::FunctionInternal::alloc_w(), casadi::OracleFunction::get_function(), casadi::Rootfinder::init(), casadi::GenericShared< Shared, Internal >::is_null(), jac_g_x_, casadi::Rootfinder::linsol_, max_iter_, casadi::Rootfinder::n_, casadi::Function::n_in(), casadi::Sparsity::nnz(), casadi::OracleFunction::oracle_, pc_, prinv_, casadi::Sparsity::qr_sparse(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::Rootfinder::sp_jac_, sp_r_, and sp_v_.

◆ init_mem()

int casadi::FastNewton::init_mem ( void * mem ) const

overridevirtual

Reimplemented from casadi::Rootfinder.

Definition at line 225 of file fast_newton.cpp.

                                           {
     if (Rootfinder::init_mem(mem)) return 1;
     auto m = static_cast<FastNewtonMemory*>(mem);
     m->return_status = 0;
     m->iter = 0;
     return 0;
   }

References casadi::Rootfinder::init_mem(), and casadi::FastNewtonMemory::return_status.

◆ 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++;
     }

◆ instantiate()

Rootfinder * casadi::PluginInterface< Rootfinder >::instantiate	(	const std::string &	fname,
		const std::string &	pname,
		Problem	problem
	)

staticinherited

Definition at line 106 of file plugin_interface.hpp.

                                                        {
  
     // Assert the plugin exists (needed for adaptors)
     if (!has_plugin(pname, true)) {
       casadi_error("Plugin '" + pname + "' is not found.");
     }
     return getPlugin(pname).creator(fname, problem);
   }

◆ 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 3318 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_id()

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

virtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 3310 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_input()

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

virtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 3314 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_MX()

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

virtualinherited

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

Reimplemented in casadi::MXFunction.

Definition at line 3326 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_output()

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

virtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 3322 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ 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 3330 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ is_a()

bool casadi::FunctionInternal::is_a	(	const std::string &	type,
		bool	recursive
	)		const

virtualinherited

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

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >, casadi::SXFunction, casadi::Nlpsol, casadi::MXFunction, casadi::ThreadMap, casadi::OmpMap, casadi::Map, and casadi::Conic.

Definition at line 3284 of file function_internal.cpp.

                                                                          {
     return type == "FunctionInternal";
   }

Referenced by casadi::Conic::is_a(), casadi::Map::is_a(), casadi::Nlpsol::is_a(), and casadi::XFunction< DerivedType, MatType, NodeType >::is_a().

◆ jac_is_symm()

bool casadi::FunctionInternal::jac_is_symm	(	casadi_int	oind,
		casadi_int	iind
	)		const

virtualinherited

Definition at line 1774 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 1862 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 2257 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()

void casadi::OracleFunction::jit_dependencies ( const std::string & fname )

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 438 of file oracle_function.cpp.

                                                             {
   if (compiler_.is_null()) {
     if (verbose_) casadi_message("compiling to "+ fname+"'.");
     // JIT dependent functions
     compiler_ = Importer(generate_dependencies(fname, Dict()),
                         compiler_plugin_, jit_options_);
   }
   // Replace the Oracle functions with generated functions
   for (auto&& e : all_functions_) {
     if (verbose_) casadi_message("loading '" + e.second.f.name() + "' from '" + fname + "'.");
     if (e.second.jit) {
       e.second.f_original = e.second.f;
       e.second.f = external(e.second.f.name(), compiler_);
     }
   }
 }

References casadi::OracleFunction::all_functions_, casadi::FunctionInternal::compiler_, casadi::FunctionInternal::compiler_plugin_, casadi::external(), casadi::OracleFunction::generate_dependencies(), casadi::GenericShared< Shared, Internal >::is_null(), casadi::FunctionInternal::jit_options_, and casadi::ProtoFunction::verbose_.

◆ join_results()

void casadi::OracleFunction::join_results ( OracleMemory * m ) const

inherited

Definition at line 168 of file oracle_function.cpp.

                                                        {
   // Combine runtime statistics
   // Note: probably not correct to simply add wall times
   for (int i = 0; i < max_num_threads_; ++i) {
     auto* ml = m->thread_local_mem[i];
     for (auto&& s : ml->fstats) {
       m->fstats.at(s.first).join(s.second);
     }
   }
 }

References casadi::ProtoFunctionMemory::fstats, casadi::OracleFunction::max_num_threads_, and casadi::OracleMemory::thread_local_mem.

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

◆ load_library()

handle_t casadi::PluginInterface< Rootfinder >::load_library	(	const std::string &	libname,
		std::string &	resultpath,
		bool	global
	)

staticinherited

Definition at line 92 of file plugin_interface.hpp.

                                         {
  
 #ifndef WITH_DL
     casadi_error("WITH_DL option needed for dynamic loading");
 #else // WITH_DL
  
     // Get the name of the shared library
     std::string lib = SHARED_LIBRARY_PREFIX + libname + SHARED_LIBRARY_SUFFIX;
  
     // Build up search paths;
     std::vector<std::string> search_paths = get_search_paths();
     return open_shared_library(lib, search_paths, resultpath,
       "PluginInterface::load_plugin", global);
  
 #endif // WITH_DL
   }

◆ load_plugin()

PluginInterface< Rootfinder >::Plugin casadi::PluginInterface< Rootfinder >::load_plugin	(	const std::string &	pname,
		bool	register_plugin = `true`,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 88 of file plugin_interface.hpp.

                                                {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Issue warning and quick return if already loaded
     if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
       casadi_warning("PluginInterface: Solver " + pname + " is already in use. Ignored.");
       return Plugin();
     }
  
     // Logger singletons are lazily instantiated on first uout()/uerr() calls
     // This instantation may lead to a data race with potential instatiations in plugin
     // To be safe, trigger instantatin before any plugin loading
     uout();
     uerr();
  
 #ifndef WITH_DL
     casadi_error("WITH_DL option needed for dynamic loading");
 #else // WITH_DL
     // Retrieve the registration function
     RegFcn reg;
  
     // Load the dll
     std::string regName = "casadi_register_" + Derived::infix_ + "_" + pname;
  
     std::string searchpath;
     handle_t handle = load_library("casadi_" + Derived::infix_ + "_" + pname, searchpath,
       false);
  
 #ifdef _WIN32
  
 #if __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
 #endif
     reg = reinterpret_cast<RegFcn>(GetProcAddress(handle, TEXT(regName.c_str())));
 #if __GNUC__
 #pragma GCC diagnostic pop
 #endif
  
 #else // _WIN32
     // Reset error
     dlerror();
  
     // Load creator
     reg = reinterpret_cast<RegFcn>(dlsym(handle, regName.c_str()));
 #endif // _WIN32
     casadi_assert(reg!=nullptr,
       "PluginInterface::load_plugin: no \"" + regName + "\" found in " + searchpath + ".");
  
     // Create a temporary struct
     Plugin plugin = pluginFromRegFcn(reg);
     // Register the plugin
     if (register_plugin) {
       registerPlugin(plugin, false);
     }
  
     return plugin;
  
 #endif // WITH_DL
   }

◆ local_init_mem()

int casadi::OracleFunction::local_init_mem ( void * mem ) const

inherited

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

Definition at line 465 of file oracle_function.cpp.

                                                   {
   if (ProtoFunction::init_mem(mem)) return 1;
   if (!mem) return 1;
   auto m = static_cast<LocalOracleMemory*>(mem);
  
   // Create statistics
   for (auto&& e : all_functions_) {
     m->add_stat(e.first);
   }
  
   return 0;
 }

References casadi::ProtoFunctionMemory::add_stat(), casadi::OracleFunction::all_functions_, and casadi::ProtoFunction::init_mem().

Referenced by casadi::OracleFunction::init_mem().

◆ 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 1007 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 3339 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 1722 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 casadi::MXFunction::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 1732 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 casadi::MXFunction::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 3574 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 3288 of file function_internal.cpp.

                                                             {
     return;
   }

◆ monitored()

bool casadi::OracleFunction::monitored ( const std::string & name ) const

virtualinherited

Definition at line 548 of file oracle_function.cpp.

                                                           {
   auto it = all_functions_.find(name);
   casadi_assert(it!=all_functions_.end(),
     "No function \"" + name + "\" in " + name_+ ". " +
     "Available functions: " + join(get_function()) + ".");
   return it->second.monitored;
 }

References casadi::OracleFunction::all_functions_, casadi::OracleFunction::get_function(), casadi::join(), and casadi::ProtoFunction::name_.

Referenced by casadi::OracleFunction::calc_function().

◆ mx_in() [1/2]

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

virtualinherited

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

Reimplemented in casadi::MXFunction.

Definition at line 3268 of file function_internal.cpp.

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

References casadi::FunctionInternal::n_in_.

Referenced by casadi::Nlpsol::get_forward(), casadi::LinearInterpolantJac::get_jacobian(), casadi::Nlpsol::get_reverse(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

◆ mx_in() [2/2]

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

virtualinherited

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

Reimplemented in casadi::MXFunction.

Definition at line 3260 of file function_internal.cpp.

                                                        {
     return MX::sym(name_in_.at(ind), sparsity_in(ind));
   }

References casadi::FunctionInternal::name_in_, casadi::FunctionInternal::sparsity_in(), and casadi::GenericMatrix< MX >::sym().

◆ 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 3276 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 3264 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::FunctionInternal::n_instructions ( ) const

virtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 3306 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ n_nodes()

casadi_int casadi::FunctionInternal::n_nodes ( ) const

virtualinherited

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

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 3334 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ 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 2217 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 969 of file function_internal.hpp.

969 { return sparsity_in(ind).nnz(); }

◆ 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 2223 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 971 of file function_internal.hpp.

971 { 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 2229 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 979 of file function_internal.hpp.

979 { 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 2235 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 980 of file function_internal.hpp.

980 { 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 3429 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_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 3399 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 3447 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_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 3414 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().

◆ oracle()

const Function& casadi::OracleFunction::oracle ( ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 147 of file oracle_function.hpp.

147 { return oracle_;}

Referenced by casadi::OracleFunction::create_function(), casadi::AmplInterface::init(), and casadi::Scpgen::init().

◆ plugin_deserialize()

Deserialize casadi::PluginInterface< Rootfinder >::plugin_deserialize ( const std::string & pname )

staticinherited

Definition at line 82 of file plugin_interface.hpp.

                                                                                  {
     Deserialize m = getPlugin(pname).deserialize;
     casadi_assert(m, "Plugin \"" + pname + "\" does not support deserialize");
     return m;
   }

◆ plugin_name()

const char* casadi::FastNewton::plugin_name ( ) const

inlineoverridevirtual

Implements casadi::PluginInterface< Rootfinder >.

Definition at line 72 of file fast_newton.hpp.

72 { return "fast_newton";}

◆ plugin_options()

const Options & casadi::PluginInterface< Rootfinder >::plugin_options ( const std::string & pname )

staticinherited

Definition at line 79 of file plugin_interface.hpp.

                                                                                 {
     const Options *op = getPlugin(pname).options;
     casadi_assert(op!=nullptr, "Plugin \"" + pname + "\" does not support options");
     return *op;
   }

◆ pluginFromRegFcn()

PluginInterface< Rootfinder >::Plugin casadi::PluginInterface< Rootfinder >::pluginFromRegFcn ( RegFcn regfcn )

staticinherited

Definition at line 85 of file plugin_interface.hpp.

                                                               {
     // Create a temporary struct
     Plugin plugin;
  
     // Set the fields
     int flag = regfcn(&plugin);
     casadi_assert(flag==0, "Registration of plugin failed.");
  
     return plugin;
   }

◆ print()

void casadi::ProtoFunction::print	(	const char *	fmt,
			...
	)		const

inherited

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

Definition at line 3813 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_dimensions()

void casadi::FunctionInternal::print_dimensions ( std::ostream & stream ) const

inherited

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

Definition at line 899 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 804 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]) {
         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::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 916 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 912 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 817 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]) {
         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::Matrix< double >::print_default(), and casadi::FunctionInternal::sparsity_out_.

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

◆ 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 3733 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 1594 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 1634 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 1487 of file function_internal.hpp.

                                                              {
     for (auto i=v.begin(); i!=v.end(); ++i) {
       if (!i->is_zero()) return false;
     }
     return true;
   }

Referenced by casadi::MXFunction::ad_forward(), and casadi::MXFunction::ad_reverse().

◆ registerPlugin() [1/2]

void casadi::PluginInterface< Rootfinder >::registerPlugin	(	const Plugin &	plugin,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 96 of file plugin_interface.hpp.

                                                                                      {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Check if the solver name is in use
     typename std::map<std::string, Plugin>::iterator it=Derived::solvers_.find(plugin.name);
     casadi_assert(it==Derived::solvers_.end(),
       "Solver " + str(plugin.name) + " is already in use");
  
     // Add to list of solvers
     Derived::solvers_[plugin.name] = plugin;
   }

◆ registerPlugin() [2/2]

void casadi::PluginInterface< Rootfinder >::registerPlugin	(	RegFcn	regfcn,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 99 of file plugin_interface.hpp.

                                                                               {
     registerPlugin(pluginFromRegFcn(regfcn), needs_lock);
   }

◆ release()

void casadi::ProtoFunction::release ( int mem ) const

inherited

Definition at line 3606 of file function_internal.cpp.

                                            {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
     unused_.push(mem);
   }

◆ 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 1767 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 1791 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 casadi::MXFunction::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 1783 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 casadi::MXFunction::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 1775 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().

◆ 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 2140 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 657 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 348 of file function_internal.hpp.

348 { return shared_from_this<Function>();}

◆ serialize()

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

inherited

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

Definition at line 4090 of file function_internal.cpp.

                                                           {
     serialize_type(s);
     serialize_body(s);
   }

References casadi::ProtoFunction::serialize_body(), and casadi::ProtoFunction::serialize_type().

◆ serialize_base_function()

std::string casadi::Rootfinder::serialize_base_function ( ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Definition at line 236 of file rootfinder_impl.hpp.

236 { return "Rootfinder"; }

◆ serialize_body()

void casadi::FastNewton::serialize_body ( SerializingStream & s ) const

overridevirtual

Reimplemented from casadi::Rootfinder.

Definition at line 267 of file fast_newton.cpp.

                                                             {
     Rootfinder::serialize_body(s);
     s.version("Newton", 1);
     s.pack("Newton::max_iter", max_iter_);
     s.pack("Newton::abstol", abstol_);
     s.pack("Newton::abstolStep", abstolStep_);
     s.pack("Newton::jac_g_x", jac_g_x_);
     s.pack("Newton::sp_v", sp_v_);
     s.pack("Newton::sp_r", sp_r_);
     s.pack("Newton::prinv", prinv_);
     s.pack("Newton::pc", pc_);
   }

References abstol_, abstolStep_, jac_g_x_, max_iter_, casadi::SerializingStream::pack(), pc_, prinv_, casadi::Rootfinder::serialize_body(), sp_r_, sp_v_, and casadi::SerializingStream::version().

◆ serialize_type()

void casadi::Rootfinder::serialize_type ( SerializingStream & s ) const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 587 of file rootfinder.cpp.

                                                             {
     OracleFunction::serialize_type(s);
     PluginInterface<Rootfinder>::serialize_type(s);
   }

References casadi::PluginInterface< Derived >::serialize_type(), and casadi::FunctionInternal::serialize_type().

◆ set_function() [1/2]

void casadi::OracleFunction::set_function ( const Function & fcn )

inlineinherited

Register the function for evaluation and statistics gathering

Definition at line 183 of file oracle_function.hpp.

183 { set_function(fcn, fcn.name()); }

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

Referenced by casadi::OracleFunction::set_function().

◆ set_function() [2/2]

void casadi::OracleFunction::set_function	(	const Function &	fcn,
		const std::string &	fname,
		bool	jit = `false`
	)

inherited

Register the function for evaluation and statistics gathering

Definition at line 286 of file oracle_function.cpp.

                                                                     {
   casadi_assert(!has_function(fname), "Duplicate function " + fname);
   RegFun& r = all_functions_[fname];
   r.f = fcn;
   r.jit = jit;
 }

References casadi::OracleFunction::all_functions_, casadi::OracleFunction::RegFun::f, casadi::OracleFunction::has_function(), and casadi::OracleFunction::RegFun::jit.

Referenced by casadi::OracleFunction::create_forward(), casadi::OracleFunction::create_function(), casadi::Integrator::init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::Rootfinder::init(), casadi::BonminInterface::init(), casadi::IpoptInterface::init(), casadi::SundialsInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Newton::init(), casadi::Sqpmethod::init(), casadi::Collocation::setup_step(), and casadi::RungeKutta::setup_step().

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

void casadi::OracleFunction::set_temp	(	void *	mem,
		const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w
	)		const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 505 of file oracle_function.cpp.

                                                            {
  
   auto m = static_cast<OracleMemory*>(mem);
   m->arg = arg;
   m->res = res;
   m->iw = iw;
   m->w = w;
   m->d_oracle.arg = arg;
   m->d_oracle.res = res;
   m->d_oracle.iw = iw;
   m->d_oracle.w = w;
   for (int i = 0; i < max_num_threads_; ++i) {
     auto* ml = m->thread_local_mem[i];
     for (auto&& s : ml->fstats) s.second.reset();
     ml->arg = arg;
     ml->res = res;
     ml->iw = iw;
     ml->w = w;
     arg += stride_arg_;
     res += stride_res_;
     iw += stride_iw_;
     w += stride_w_;
   }
 }

References casadi::OracleMemory::arg, casadi::OracleFunction::max_num_threads_, casadi::OracleFunction::stride_arg_, casadi::OracleFunction::stride_iw_, casadi::OracleFunction::stride_res_, and casadi::OracleFunction::stride_w_.

◆ set_work()

void casadi::FastNewton::set_work	(	void *	mem,
		const double **&	arg,
		double **&	res,
		casadi_int *&	iw,
		double *&	w
	)		const

overridevirtual

Reimplemented from casadi::Rootfinder.

Definition at line 114 of file fast_newton.cpp.

                                                           {
      Rootfinder::set_work(mem, arg, res, iw, w);
      auto m = static_cast<FastNewtonMemory*>(mem);
      casadi_newton_mem<double>* M = &(m->M);
  
      M->n = n_;
      M->abstol = abstol_;
      M->abstol_step = abstolStep_;
  
      M->x = w; w += n_;
      M->g = w; w += n_;
      M->jac_g_x = w; w += sp_jac_.nnz();
  
      M->sp_a = sp_jac_;
      M->sp_v = sp_v_;
      M->sp_r = sp_r_;
      M->prinv = get_ptr(prinv_);
      M->pc = get_ptr(pc_);
  
      M->lin_w = w; w+= sp_jac_.size1()+sp_jac_.size2();
      M->lin_v = w; w+= sp_v_.nnz();
      M->lin_r = w; w+= sp_r_.nnz();
      M->lin_beta = w; w+= sp_jac_.size2();
  
   }

References abstol_, abstolStep_, casadi::get_ptr(), casadi::Rootfinder::n_, casadi::Sparsity::nnz(), pc_, prinv_, casadi::Rootfinder::set_work(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::Rootfinder::sp_jac_, sp_r_, and sp_v_.

◆ 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 3465 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(), casadi::MXFunction::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;
     }

◆ shortname()

static std::string casadi::Rootfinder::shortname ( )

inlinestaticinherited

Definition at line 209 of file rootfinder_impl.hpp.

209 { return "rootfinder";}

◆ 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 2329 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(), and casadi::External::codegen_declarations().

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

◆ 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 988 of file function_internal.hpp.

988 { return sparsity_in(ind).size1(); }

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 990 of file function_internal.hpp.

990 { 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 989 of file function_internal.hpp.

989 { return sparsity_in(ind).size2(); }

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 991 of file function_internal.hpp.

991 { 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 992 of file function_internal.hpp.

                                                                   {
       return sparsity_in(ind).size();
     }

Referenced by casadi::Rootfinder::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::MXFunction::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 995 of file function_internal.hpp.

                                                                    {
       return sparsity_out(ind).size();
     }

Referenced by casadi::MXFunction::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::FunctionInternal::slice	(	const std::string &	name,
		const std::vector< casadi_int > &	order_in,
		const std::vector< casadi_int > &	order_out,
		const Dict &	opts
	)		const

virtualinherited

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

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, and casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >.

Definition at line 3658 of file function_internal.cpp.

                                                                         {
     return wrap().slice(name, order_in, order_out, opts);
   }

References casadi::Function::slice(), and casadi::FunctionInternal::wrap().

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

◆ solve()

int casadi::FastNewton::solve ( void * mem ) const

overridevirtual

Implements casadi::Rootfinder.

Definition at line 141 of file fast_newton.cpp.

                                        {
     auto m = static_cast<FastNewtonMemory*>(mem);
     casadi_newton_mem<double>* M = &(m->M);
  
     // Get the initial guess
     casadi_copy(m->iarg[iin_], n_, M->x);
  
     for (m->iter=0; m->iter<max_iter_; ++m->iter) {
        /* (re)calculate f and J */
        // Use x to evaluate J
        for (casadi_int i=0;i<n_in_;++i) m->arg[i] = m->iarg[i];
        m->arg[iin_] = M->x;
        for (casadi_int i=0;i<n_out_;++i) m->res[i+1] = m->ires[i];
        m->res[0] = M->jac_g_x;
        m->res[1+iout_] = M->g;
        jac_g_x_(m->arg, m->res, m->iw, m->w);
  
        m->return_status = casadi_newton(M);
        if (m->return_status) break;
     }
     // Get the solution
     casadi_copy(M->x, n_, m->ires[iout_]);
  
     m->success = m->return_status>0;
     if (m->return_status==0) m->unified_return_status = SOLVER_RET_LIMITED;
  
     return 0;
   }

References casadi::casadi_copy(), casadi::casadi_newton(), casadi::Rootfinder::iin_, casadi::Rootfinder::iout_, jac_g_x_, max_iter_, casadi::Rootfinder::n_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, and casadi::SOLVER_RET_LIMITED.

◆ sp_forward()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 377 of file rootfinder.cpp.

                                                                                            {
     bvec_t* tmp1 = w; w += n_;
     bvec_t* tmp2 = w; w += n_;
  
     // Propagate dependencies through the function
     const bvec_t** arg1 = arg+n_in_;
     std::copy(arg, arg+n_in_, arg1);
     arg1[iin_] = nullptr;
     bvec_t** res1 = res+n_out_;
     std::fill_n(res1, n_out_, static_cast<bvec_t*>(nullptr));
     res1[iout_] = tmp1;
     oracle_(arg1, res1, iw, w, 0);
  
     // "Solve" in order to propagate to z
     std::fill_n(tmp2, n_, 0);
     sp_jac_.spsolve(tmp2, tmp1, false);
     if (res[iout_]) std::copy(tmp2, tmp2+n_, res[iout_]);
  
     // Propagate to auxiliary outputs
     if (n_out_>1) {
       arg1[iin_] = tmp2;
       std::copy(res, res+n_out_, res1);
       res1[iout_] = nullptr;
       oracle_(arg1, res1, iw, w, 0);
     }
     return 0;
   }

References casadi::Rootfinder::iin_, casadi::Rootfinder::iout_, casadi::Rootfinder::n_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::OracleFunction::oracle_, casadi::Rootfinder::sp_jac_, and casadi::Sparsity::spsolve().

◆ 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 2773 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::Rootfinder::sp_reverse	(	bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem
	)		const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 406 of file rootfinder.cpp.

                                                   {
     bvec_t* tmp1 = w; w += n_;
     bvec_t* tmp2 = w; w += n_;
  
     // Get & clear seed corresponding to implicitly defined variable
     if (res[iout_]) {
       std::copy(res[iout_], res[iout_]+n_, tmp1);
       std::fill_n(res[iout_], n_, 0);
     } else {
       std::fill_n(tmp1, n_, 0);
     }
  
     // Propagate dependencies from auxiliary outputs to z
     bvec_t** res1 = res+n_out_;
     std::copy(res, res+n_out_, res1);
     res1[iout_] = nullptr;
     bvec_t** arg1 = arg+n_in_;
     std::copy(arg, arg+n_in_, arg1);
     arg1[iin_] = tmp1;
     if (n_out_>1) {
       if (oracle_.rev(arg1, res1, iw, w, 0)) return 1;
     }
  
     // "Solve" in order to get seed
     std::fill_n(tmp2, n_, 0);
     sp_jac_.spsolve(tmp2, tmp1, true);
  
     // Propagate dependencies through the function
     for (casadi_int i=0; i<n_out_; ++i) res1[i] = nullptr;
     res1[iout_] = tmp2;
     arg1[iin_] = nullptr; // just a guess
     if (oracle_.rev(arg1, res1, iw, w, 0)) return 1;
     return 0;
   }

References casadi::Rootfinder::iin_, casadi::Rootfinder::iout_, casadi::Rootfinder::n_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::OracleFunction::oracle_, casadi::Function::rev(), casadi::Rootfinder::sp_jac_, and casadi::Sparsity::spsolve().

◆ sp_weight()

double casadi::FunctionInternal::sp_weight ( ) const

virtualinherited

sparsity propagation

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

Definition at line 3201 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(), casadi::MXFunction::sp_forward(), casadi::SXFunction::sp_forward(), casadi::MXFunction::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 1005 of file function_internal.hpp.

1005 { 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 3801 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 3869 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().

◆ 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 3228 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 3212 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 3236 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 3216 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::FunctionInternal::symbolic_output ( const std::vector< MX > & arg ) const

virtualinherited

Reimplemented in casadi::MXFunction.

Definition at line 1066 of file function_internal.cpp.

                                                                                 {
     return self()(arg);
   }

Referenced by casadi::MXFunction::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 1512 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 1167 of file function_internal.hpp.

1167 { return sz_arg_per_ + sz_arg_tmp_;}

◆ sz_iw()

size_t casadi::FunctionInternal::sz_iw ( ) const

inlineinherited

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

Definition at line 1177 of file function_internal.hpp.

1177 { 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 1172 of file function_internal.hpp.

1172 { return sz_res_per_ + sz_res_tmp_;}

◆ sz_w()

size_t casadi::FunctionInternal::sz_w ( ) const

inlineinherited

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

Definition at line 1182 of file function_internal.hpp.

1182 { 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 2821 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 1837 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 999 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 1003 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().

◆ uses_output()

bool casadi::Rootfinder::uses_output ( ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 142 of file rootfinder_impl.hpp.

142 {return true;}

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

                                                                                   {
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
   }

◆ which_depends()

std::vector< bool > casadi::FunctionInternal::which_depends	(	const std::string &	s_in,
		const std::vector< std::string > &	s_out,
		casadi_int	order,
		bool	tr = `false`
	)		const

virtualinherited

Parameters

[in]	s_in	Input name
[in]	s_out	Output name(s)
[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_k9

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, and casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >.

Definition at line 3644 of file function_internal.cpp.

                                        {
     Function f = shared_from_this<Function>();
     f = f.wrap();
     return f.which_depends(s_in, s_out, order, tr);
   }

References casadi::Function::which_depends(), and casadi::Function::wrap().

◆ wrap()

Function casadi::FunctionInternal::wrap ( ) const

inherited

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

Definition at line 1044 of file function_internal.cpp.

                                         {
     Function f;
     std::string fname = "wrap_" + name_;
     if (!incache(fname, 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(fname, arg, res, name_in_, name_out_, opts);
       // Save in cache
       tocache_if_missing(f);
     }
     return f;
   }

Referenced by casadi::FunctionInternal::eval_mx(), casadi::FunctionInternal::factory(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::reverse(), casadi::FunctionInternal::slice(), and casadi::Function::wrap().

◆ wrap_as_needed()

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

inherited

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

Definition at line 1026 of file function_internal.cpp.

                                                                   {
     if (opts.empty()) return shared_from_this<Function>();
     std::string fname = "wrap_" + name_;
     // 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(fname, 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().

Member Data Documentation

◆ abstol_

double casadi::FastNewton::abstol_

protected

Definition at line 133 of file fast_newton.hpp.

Referenced by codegen_body(), FastNewton(), init(), serialize_body(), and set_work().

◆ abstolStep_

double casadi::FastNewton::abstolStep_

protected

Definition at line 136 of file fast_newton.hpp.

Referenced by codegen_body(), FastNewton(), init(), serialize_body(), and set_work().

◆ ad_weight_

double casadi::FunctionInternal::ad_weight_

inherited

Definition at line 1359 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 1359 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().

◆ all_functions_

std::map<std::string, RegFun> casadi::OracleFunction::all_functions_

protectedinherited

Definition at line 104 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::generate_dependencies(), casadi::OracleFunction::get_function(), casadi::OracleFunction::has_function(), casadi::OracleFunction::init_mem(), casadi::OracleFunction::jit_dependencies(), casadi::OracleFunction::local_init_mem(), casadi::OracleFunction::monitored(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_function().

◆ always_inline_

bool casadi::FunctionInternal::always_inline_

inherited

Definition at line 1258 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::eval_mx(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::FunctionInternal::eval_sx(), casadi::MXFunction::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 1330 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 1327 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 1307 of file function_internal.hpp.

Referenced by casadi::GenericExternal::any_symbol_found(), casadi::External::codegen_checkout(), casadi::External::codegen_declarations(), casadi::External::codegen_mem_type(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::GenericExternal::init_external(), and casadi::FunctionBuffer::operator=().

◆ common_options_

Dict casadi::OracleFunction::common_options_

protectedinherited

Definition at line 86 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::create_function(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), and casadi::OracleFunction::serialize_body().

◆ compiler_

Importer casadi::FunctionInternal::compiler_

inherited

Definition at line 1348 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::Scpgen::init(), casadi::OracleFunction::jit_dependencies(), and casadi::FunctionInternal::serialize_body().

◆ compiler_plugin_

std::string casadi::FunctionInternal::compiler_plugin_

inherited

Definition at line 1347 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 1396 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ der_options_

Dict casadi::FunctionInternal::der_options_

inherited

Definition at line 1393 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 1341 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},
    {"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}
  }

Definition at line 1447 of file function_internal.hpp.

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

◆ dump_

bool casadi::FunctionInternal::dump_

inherited

Definition at line 1384 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 1402 of file function_internal.hpp.

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

◆ dump_dir_

std::string casadi::FunctionInternal::dump_dir_

inherited

Definition at line 1387 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_format_

std::string casadi::FunctionInternal::dump_format_

inherited

Definition at line 1390 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_in_

bool casadi::FunctionInternal::dump_in_

inherited

Definition at line 1384 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), 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 1384 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_fd_

bool casadi::FunctionInternal::enable_fd_

inherited

Definition at line 1355 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 1356 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 1355 of file function_internal.hpp.

Referenced by casadi::MXFunction::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 1356 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 1355 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 1356 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 1355 of file function_internal.hpp.

Referenced by casadi::MXFunction::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 1356 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

◆ eval_

eval_t casadi::FunctionInternal::eval_

inherited

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

Definition at line 1302 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 1374 of file function_internal.hpp.

Referenced by 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 1368 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 1371 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 1393 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().

◆ has_refcount_

bool casadi::FunctionInternal::has_refcount_

inherited

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

Definition at line 1322 of file function_internal.hpp.

Referenced by casadi::CodeGenerator::add_dependency(), casadi::FunctionInternal::FunctionInternal(), casadi::Call::has_refcount(), casadi::External::init(), casadi::MXFunction::init(), casadi::OsqpInterface::OsqpInterface(), and casadi::FunctionInternal::serialize_body().

◆ iin_

casadi_int casadi::Rootfinder::iin_

inherited

◆ infix_

const std::string casadi::Rootfinder::infix_ = "rootfinder"

staticinherited

Definition at line 212 of file rootfinder_impl.hpp.

◆ inputs_check_

bool casadi::FunctionInternal::inputs_check_

inherited

Definition at line 1365 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().

◆ iout_

casadi_int casadi::Rootfinder::iout_

inherited

Definition at line 193 of file rootfinder_impl.hpp.

◆ is_diff_in_

std::vector<bool> casadi::FunctionInternal::is_diff_in_

inherited

Definition at line 1264 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwd_seed(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::MapSum::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::wrap().

◆ is_diff_out_

std::vector<bool> casadi::FunctionInternal::is_diff_out_

inherited

Definition at line 1264 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::MapSum::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::serialize_body(), casadi::FunctionInternal::symbolicAdjSeed(), and casadi::FunctionInternal::wrap().

◆ jac_g_x_

Function casadi::FastNewton::jac_g_x_

protected

Definition at line 139 of file fast_newton.hpp.

Referenced by FastNewton(), init(), serialize_body(), and solve().

◆ jac_penalty_

double casadi::FunctionInternal::jac_penalty_

inherited

Definition at line 1352 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 1333 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 1393 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 1275 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::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 1292 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 1280 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_name_

std::string casadi::FunctionInternal::jit_name_

inherited

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

Definition at line 1290 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 1349 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(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_serialize_

std::string casadi::FunctionInternal::jit_serialize_

inherited

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

Definition at line 1285 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 1297 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().

◆ linsol_

Linsol casadi::Rootfinder::linsol_

inherited

Definition at line 186 of file rootfinder_impl.hpp.

Referenced by casadi::Rootfinder::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::Rootfinder::init(), init(), casadi::Newton::init(), casadi::KinsolInterface::psetup(), casadi::KinsolInterface::psolve(), casadi::Rootfinder::Rootfinder(), casadi::Rootfinder::serialize_body(), and casadi::Newton::solve().

◆ max_io_

casadi_int casadi::FunctionInternal::max_io_

inherited

Definition at line 1381 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ max_iter_

casadi_int casadi::FastNewton::max_iter_

protected

Definition at line 130 of file fast_newton.hpp.

Referenced by codegen_body(), FastNewton(), init(), serialize_body(), and solve().

◆ max_num_dir_

casadi_int casadi::FunctionInternal::max_num_dir_

inherited

Definition at line 1362 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().

◆ max_num_threads_

int casadi::OracleFunction::max_num_threads_

protectedinherited

Definition at line 93 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::calc_function(), casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::KnitroInterface::init(), casadi::OracleFunction::init_mem(), casadi::OracleFunction::join_results(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ meta_doc

const std::string casadi::FastNewton::meta_doc

static

Initial value:

=
      "\n"
"\n"
"\n"
"Implements simple newton iterations to solve an implicit function.\n"
"\n"
"Extra doc: https://github.com/casadi/casadi/wiki/L_237 \n"
"\n"
"\n"
">List of available options\n"
"\n"
"+------------+-----------+-------------------------------------------------+\n"
"|     Id     |   Type    |                   Description                   |\n"
"+============+===========+=================================================+\n"
"| abstol     | OT_DOUBLE | Stopping criterion tolerance on ||g||__inf)     |\n"
"+------------+-----------+-------------------------------------------------+\n"
"| abstolStep | OT_DOUBLE | Stopping criterion tolerance on step size       |\n"
"+------------+-----------+-------------------------------------------------+\n"
"| max_iter   | OT_INT    | Maximum number of Newton iterations to perform  |\n"
"|            |           | before returning.                               |\n"
"+------------+-----------+-------------------------------------------------+\n"
"\n"
"\n"
"\n"
"\n"

Definition at line 111 of file fast_newton.hpp.

Referenced by casadi::casadi_register_rootfinder_fast_newton().

◆ monitor_

std::vector<std::string> casadi::OracleFunction::monitor_

protectedinherited

Definition at line 107 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), and casadi::OracleFunction::serialize_body().

◆ n_

casadi_int casadi::Rootfinder::n_

inherited

◆ n_in_

size_t casadi::FunctionInternal::n_in_

inherited

Definition at line 1261 of file function_internal.hpp.

◆ n_out_

size_t casadi::FunctionInternal::n_out_

inherited

Definition at line 1261 of file function_internal.hpp.

◆ name_

std::string casadi::ProtoFunction::name_

inherited

Definition at line 246 of file function_internal.hpp.

◆ name_in_

std::vector<std::string> casadi::FunctionInternal::name_in_

inherited

Definition at line 1270 of file function_internal.hpp.

◆ name_out_

std::vector<std::string> casadi::FunctionInternal::name_out_

inherited

Definition at line 1270 of file function_internal.hpp.

◆ never_inline_

bool casadi::FunctionInternal::never_inline_

inherited

Definition at line 1258 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::eval_mx(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::FunctionInternal::eval_sx(), casadi::MXFunction::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::FastNewton::options_

static

Initial value:

= {{&Rootfinder::options_},
     {{"abstol",
       {OT_DOUBLE,
        "Stopping criterion tolerance on ||g||__inf)"}},
      {"abstolStep",
       {OT_DOUBLE,
        "Stopping criterion tolerance on step size"}},
      {"max_iter",
       {OT_INT,
        "Maximum number of Newton iterations to perform before returning."}}
     }
  }

Definition at line 84 of file fast_newton.hpp.

Referenced by casadi::casadi_register_rootfinder_fast_newton().

◆ oracle_

Function casadi::OracleFunction::oracle_

protectedinherited

Definition at line 83 of file oracle_function.hpp.

Referenced by casadi::Rootfinder::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::Integrator::augmented_dae(), casadi::OracleFunction::create_function(), casadi::Nlpsol::disp_more(), casadi::OracleFunction::expand(), casadi::KinsolInterface::func(), casadi::OracleFunction::generate_dependencies(), casadi::Integrator::get_forward_dae(), casadi::KinsolInterface::get_jtimes(), casadi::Rootfinder::get_name_in(), casadi::Rootfinder::get_name_out(), casadi::Nlpsol::get_sparsity_in(), casadi::Nlpsol::get_sparsity_out(), casadi::Rootfinder::get_sparsity_out(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::OracleFunction::init(), casadi::Rootfinder::init(), casadi::AlpaqaInterface::init(), casadi::Blocksqp::init(), casadi::BonminInterface::init(), casadi::IpoptInterface::init(), casadi::KnitroInterface::init(), init(), casadi::ImplicitToNlp::init(), casadi::Newton::init(), casadi::Nlpsol::kkt(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), casadi::ImplicitToNlp::set_work(), casadi::KinsolInterface::solve(), casadi::ImplicitToNlp::solve(), casadi::Rootfinder::sp_forward(), and casadi::Rootfinder::sp_reverse().

◆ pc_

std::vector<casadi_int> casadi::FastNewton::pc_

protected

Definition at line 145 of file fast_newton.hpp.

Referenced by codegen_body(), FastNewton(), init(), serialize_body(), and set_work().

◆ post_expand_

bool casadi::OracleFunction::post_expand_

protectedinherited

Definition at line 114 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), and casadi::OracleFunction::OracleFunction().

◆ print_in_

bool casadi::FunctionInternal::print_in_

inherited

Definition at line 1377 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ print_out_

bool casadi::FunctionInternal::print_out_

inherited

Definition at line 1378 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), 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 252 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().

◆ prinv_

std::vector<casadi_int> casadi::FastNewton::prinv_

protected

Definition at line 144 of file fast_newton.hpp.

Referenced by codegen_body(), FastNewton(), init(), serialize_body(), and set_work().

◆ record_time_

bool casadi::ProtoFunction::record_time_

inherited

Definition at line 255 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().

◆ regularity_check_

bool casadi::ProtoFunction::regularity_check_

inherited

Definition at line 258 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 1312 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(), and casadi::FunctionBuffer::~FunctionBuffer().

◆ reverse_options_

Dict casadi::FunctionInternal::reverse_options_

inherited

Definition at line 1393 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().

◆ show_eval_warnings_

bool casadi::OracleFunction::show_eval_warnings_

protectedinherited

Definition at line 90 of file oracle_function.hpp.

◆ solvers_

std::map< std::string, Rootfinder::Plugin > casadi::Rootfinder::solvers_

staticinherited

Definition at line 202 of file rootfinder_impl.hpp.

◆ sp_jac_

Sparsity casadi::Rootfinder::sp_jac_

inherited

Definition at line 187 of file rootfinder_impl.hpp.

Referenced by casadi::KinsolInterface::bjac(), codegen_body(), casadi::KinsolInterface::djac(), casadi::Rootfinder::init(), casadi::KinsolInterface::init(), init(), casadi::Newton::init(), casadi::Rootfinder::Rootfinder(), casadi::Rootfinder::serialize_body(), casadi::KinsolInterface::set_work(), set_work(), casadi::Newton::set_work(), casadi::Rootfinder::sp_forward(), and casadi::Rootfinder::sp_reverse().

◆ sp_r_

Sparsity casadi::FastNewton::sp_r_

protected

Definition at line 143 of file fast_newton.hpp.

Referenced by codegen_body(), FastNewton(), init(), serialize_body(), and set_work().

◆ sp_v_

Sparsity casadi::FastNewton::sp_v_

protected

Definition at line 142 of file fast_newton.hpp.

Referenced by codegen_body(), FastNewton(), init(), serialize_body(), and set_work().

◆ sparsity_in_

std::vector<Sparsity> casadi::FunctionInternal::sparsity_in_

inherited

Definition at line 1267 of file function_internal.hpp.

◆ sparsity_out_

std::vector<Sparsity> casadi::FunctionInternal::sparsity_out_

inherited

◆ specific_options_

Dict casadi::OracleFunction::specific_options_

protectedinherited

Definition at line 87 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::create_function(), casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), and casadi::OracleFunction::serialize_body().

◆ stats_

Dict casadi::FunctionInternal::stats_

inherited

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

Definition at line 1317 of file function_internal.hpp.

◆ stride_arg_

size_t casadi::OracleFunction::stride_arg_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ stride_iw_

size_t casadi::OracleFunction::stride_iw_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ stride_res_

size_t casadi::OracleFunction::stride_res_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ stride_w_

size_t casadi::OracleFunction::stride_w_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ u_c_

std::vector<casadi_int> casadi::Rootfinder::u_c_

inherited

Definition at line 190 of file rootfinder_impl.hpp.

Referenced by casadi::Rootfinder::init(), casadi::KinsolInterface::init_mem(), casadi::Rootfinder::Rootfinder(), casadi::Rootfinder::serialize_body(), and casadi::ImplicitToNlp::solve().

◆ user_data_

void* casadi::FunctionInternal::user_data_

inherited

Definition at line 1344 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 249 of file function_internal.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

Protected Attributes

Member Typedef Documentation

◆ Creator

◆ RegFcn

◆ weak_ref_type

Constructor & Destructor Documentation

◆ FastNewton() [1/2]

◆ ~FastNewton()

◆ FastNewton() [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()

◆ cache()

◆ calc_function()

◆ calc_sp_forward()

◆ calc_sp_reverse()

◆ call()

◆ call_forward() [1/2]

◆ call_forward() [2/2]

◆ call_gen() [1/2]

◆ call_gen() [2/2]

◆ call_reverse() [1/2]

◆ call_reverse() [2/2]

◆ change_option()

◆ check_arg()

◆ check_mat()

◆ check_mem_count()

◆ check_res()

◆ checkout()

◆ class_name()

◆ clear_mem()

◆ codegen()

◆ codegen_alloc_mem()

◆ codegen_body()

◆ codegen_body_enter()

◆ codegen_body_exit()

◆ codegen_checkout()

◆ codegen_declarations()

◆ codegen_decref()

◆ codegen_free_mem()

◆ codegen_incref()

◆ codegen_init_mem()

◆ codegen_mem()

◆ codegen_mem_type()

◆ codegen_meta()

◆ codegen_name()

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

◆ create_forward()

◆ create_function() [1/3]

◆ create_function() [2/3]

◆ create_function() [3/3]

◆ create_oracle()

◆ creator()