casadi::FixedStepIntegrator Class Reference

#include <integrator_impl.hpp>

Detailed Description

List of available options

Id	Type	Description	Used in
ad_weight	OT_DOUBLE	Weighting factor for derivative calculation.When there is an option of either using forward or reverse mode directional derivatives, the condition ad_weight*nf<=(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
augmented_options	OT_DICT	Options to be passed down to the augmented integrator, if one is constructed	casadi::Integrator
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
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
event_tol	OT_DOUBLE	Termination tolerance for the event iteration	casadi::Integrator
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
grid	OT_DOUBLEVECTOR	[DEPRECATED] Time grid	casadi::Integrator
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_options	OT_DICT	Options to be passed to a Jacobian constructor	casadi::FunctionInternal
jit	OT_BOOL	Use just-in-time compiler to speed up the evaluation	casadi::FunctionInternal
jit_cleanup	OT_BOOL	Cleanup up the temporary source file that jit creates. Default: true	casadi::FunctionInternal
jit_name	OT_STRING	The file name used to write out code. The actual file names used depend on 'jit_temp_suffix' and include extensions. Default: 'jit_tmp'	casadi::FunctionInternal
jit_options	OT_DICT	Options to be passed to the jit compiler.	casadi::FunctionInternal
jit_serialize	OT_STRING	Specify behaviour when serializing a jitted function: SOURCE|link|embed.	casadi::FunctionInternal
jit_temp_suffix	OT_BOOL	Use a temporary (seemingly random) filename suffix for generated code and libraries. This is desired for thread-safety. This behaviour may defeat caching compiler wrappers. Default: true	casadi::FunctionInternal
max_event_iter	OT_INT	Maximum number of iterations to zero in on a single event	casadi::Integrator
max_events	OT_INT	Maximum total number of events	casadi::Integrator
max_io	OT_INT	Acceptable number of inputs and outputs. Warn if exceeded.	casadi::FunctionInternal
max_num_dir	OT_INT	Specify the maximum number of directions for derivative functions. Overrules the builtin optimized_num_dir.	casadi::FunctionInternal
monitor	OT_STRINGVECTOR	Set of user problem functions to be monitored	casadi::OracleFunction
nadj	OT_INT	Number of adjoint sensitivities to be calculated [0]	casadi::Integrator
never_inline	OT_BOOL	Forbid inlining.	casadi::FunctionInternal
nfwd	OT_INT	Number of forward sensitivities to be calculated [0]	casadi::Integrator
number_of_finite_elements	OT_INT	Target number of finite elements. The actual number may be higher to accommodate all output times	casadi::FixedStepIntegrator
output_scheme	OT_STRINGVECTOR	Deprecated option (ignored)	casadi::FunctionInternal
output_t0	OT_BOOL	[DEPRECATED] Output the state at the initial time	casadi::Integrator
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_stats	OT_BOOL	Print out statistics after integration	casadi::Integrator
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
rootfinder	OT_STRING	An implicit function solver	casadi::FixedStepIntegrator
rootfinder_options	OT_DICT	Options to be passed to the NLP Solver	casadi::FixedStepIntegrator
show_eval_warnings	OT_BOOL	Show warnings generated from function evaluations [true]	casadi::OracleFunction
simplify	OT_BOOL	Implement as MX Function (codegeneratable/serializable) default: false	casadi::FixedStepIntegrator
simplify_options	OT_DICT	Any options to pass to simplified form Function constructor	casadi::FixedStepIntegrator
specific_options	OT_DICT	Options for specific auto-generated functions, overwriting the defaults from common_options. Nested dictionary.	casadi::OracleFunction
t0	OT_DOUBLE	[DEPRECATED] Beginning of the time horizon	casadi::Integrator
tf	OT_DOUBLE	[DEPRECATED] End of the time horizon	casadi::Integrator
transition	OT_FUNCTION	Function to be called a zero-crossing events	casadi::Integrator
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 566 of file integrator_impl.hpp.

Inheritance diagram for casadi::FixedStepIntegrator:

Collaboration diagram for casadi::FixedStepIntegrator:

Public Types
typedef Integrator *(*	Creator) (const std::string &name, const Function &oracle, double t0, const std::vector< double > &tout)
using	weak_ref_type = WeakRefInternal
typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	FixedStepIntegrator (const std::string &name, const Function &dae, double t0, const std::vector< double > &tout)
	Constructor. More...
	~FixedStepIntegrator () override
	Destructor. More...
void	init (const Dict &opts) override
	Initialize stage. More...
void	set_work (void *mem, const double **&arg, double **&res, casadi_int *&iw, double *&w) const override
	Set the (persistent) work vectors. More...
Function	create_advanced (const Dict &opts) override
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...
virtual void	setup_step ()=0
	Setup step functions. More...
void	reset (IntegratorMemory *mem, bool first_call) const override
	Reset the forward solver at the start or after an event. More...
int	advance_noevent (IntegratorMemory *mem) const override
	Advance solution in time. More...
void	resetB (IntegratorMemory *mem) const override
	Reset the backward problem and take time to tf. More...
void	impulseB (IntegratorMemory *mem, const double *adj_x, const double *adj_z, const double *adj_q) const override
	Introduce an impulse into the backwards integration at the current time. More...
void	retreat (IntegratorMemory *mem, const double *u, double *adj_x, double *adj_p, double *adj_u) const override
	Retreat solution in time. More...
void	stepF (FixedStepMemory *m, double t, double h, const double *x0, const double *v0, double *xf, double *vf, double *qf) const
	Take integrator step forward. More...
void	stepB (FixedStepMemory *m, double t, double h, const double *x0, const double *xf, const double *vf, const double *adj_xf, const double *rv0, double *adj_x0, double *adj_p, double *adj_u) const
	Take integrator step backward. More...
void	serialize_body (SerializingStream &s) const override
	Serialize an object without type information. More...
virtual MX	algebraic_state_init (const MX &x0, const MX &z0) const
virtual MX	algebraic_state_output (const MX &Z) const
void	set_q (IntegratorMemory *m, const double *q) const
void	set_x (IntegratorMemory *m, const double *x) const
void	set_z (IntegratorMemory *m, const double *z) const
void	set_p (IntegratorMemory *m, const double *p) const
void	set_u (IntegratorMemory *m, const double *u) const
void	get_q (IntegratorMemory *m, double *q) const
void	get_x (IntegratorMemory *m, double *x) const
void	get_z (IntegratorMemory *m, double *z) const
casadi_int	next_stop (casadi_int k, const double *u) const
	Find next stop time. More...
int	calc_edot (IntegratorMemory *m) const
	Linearize the zero crossing function. More...
int	predict_events (IntegratorMemory *m) const
	Predict next event time. More...
int	trigger_event (IntegratorMemory *m, casadi_int *ind) const
	Trigger an event. More...
int	advance (IntegratorMemory *m) const
	Advance solution in time, with events handling. More...
casadi_int	next_stopB (casadi_int k, const double *u) const
	Find next stop time. More...
int	eval (const double **arg, double **res, casadi_int *iw, double *w, void *mem) const override
	evaluate More...
virtual void	print_stats (IntegratorMemory *mem) const
	Print solver statistics. More...
int	fdae_sp_forward (SpForwardMem *m, const bvec_t *x, const bvec_t *p, const bvec_t *u, bvec_t *ode, bvec_t *alg) const
	Forward sparsity pattern propagation through DAE, forward problem. More...
int	fquad_sp_forward (SpForwardMem *m, const bvec_t *x, const bvec_t *z, const bvec_t *p, const bvec_t *u, bvec_t *quad) const
	Forward sparsity pattern propagation through quadratures, forward problem. More...
int	bdae_sp_forward (SpForwardMem *m, const bvec_t *x, const bvec_t *z, const bvec_t *p, const bvec_t *u, const bvec_t *adj_ode, const bvec_t *adj_quad, bvec_t *adj_x, bvec_t *adj_z) const
	Forward sparsity pattern propagation through DAE, backward problem. More...
int	bquad_sp_forward (SpForwardMem *m, const bvec_t *x, const bvec_t *z, const bvec_t *p, const bvec_t *u, const bvec_t *adj_ode, const bvec_t *adj_alg, const bvec_t *adj_quad, bvec_t *adj_p, bvec_t *adj_u) const
	Forward sparsity pattern propagation through quadratures, backward problem. 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	fdae_sp_reverse (SpReverseMem *m, bvec_t *x, bvec_t *p, bvec_t *u, bvec_t *ode, bvec_t *alg) const
	Reverse sparsity pattern propagation through DAE, forward problem. More...
int	fquad_sp_reverse (SpReverseMem *m, bvec_t *x, bvec_t *z, bvec_t *p, bvec_t *u, bvec_t *quad) const
	Reverse sparsity pattern propagation through quadratures, forward problem. More...
int	bdae_sp_reverse (SpReverseMem *m, bvec_t *x, bvec_t *z, bvec_t *p, bvec_t *u, bvec_t *adj_ode, bvec_t *adj_quad, bvec_t *adj_x, bvec_t *adj_z) const
	Reverse sparsity pattern propagation through DAE, backward problem. More...
int	bquad_sp_reverse (SpReverseMem *m, bvec_t *x, bvec_t *z, bvec_t *p, bvec_t *u, bvec_t *adj_ode, bvec_t *adj_alg, bvec_t *adj_quad, bvec_t *adj_p, bvec_t *adj_u) const
	Reverse sparsity pattern propagation through quadratures, backward problem. More...
int	sp_reverse (bvec_t **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const override
	Propagate sparsity backwards. More...
virtual Dict	getDerivativeOptions (bool fwd) const
	Set solver specific options to generated augmented integrators. More...
Sparsity	sp_jac_aug (const Sparsity &J, const Sparsity &J1) const
	Helper function, get augmented system Jacobian. More...
Sparsity	sp_jac_dae ()
	Create sparsity pattern of the extended Jacobian (forward problem) More...
Sparsity	sp_jac_rdae ()
	Create sparsity pattern of the extended Jacobian (backward problem) More...
casadi_int	nt () const
	Number of output times. 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...
Dict	get_stats (void *mem) const override
	Get all statistics. 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...
virtual bool	uses_output () const
	Do the derivative functions need nondifferentiated outputs? More...
std::string	diff_prefix (const std::string &prefix) const
	Determine prefix for differentiated functions. More...
virtual 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 void	codegen_declarations (CodeGenerator &g) const
	Generate code for the declarations of the C function. More...
virtual void	codegen_body (CodeGenerator &g) const
	Generate code for the function body. 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...
virtual std::string	class_name () const =0
	Readable name of the internal class. 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...
virtual const char *	plugin_name () const=0
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
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_forward (casadi_int nfwd) const override
	Generate a function that calculates nfwd forward derivatives. More...
Function	get_reverse (casadi_int nadj, const std::string &name, const std::vector< std::string > &inames, const std::vector< std::string > &onames, const Dict &opts) const override
	Generate a function that calculates nadj adjoint derivatives. More...
bool	has_reverse (casadi_int nadj) const override
	Generate a function that calculates nadj adjoint derivatives. More...
template<typename MatType >
Function	get_forward_dae (const std::string &name) const
	Generate the augmented DAE system. More...
Function	augmented_dae () const
	Generate the augmented DAE system. 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 bool	all_zero (const double *v, casadi_int n)
	Helper function: Vector has only zeros? More...
template<typename XType >
static Function	map2oracle (const std::string &name, const std::map< std::string, XType > &d)
	Convert dictionary to Problem. More...
static ProtoFunction *	deserialize (DeserializingStream &s)
	Deserialize into MX. More...
static bool	grid_in (casadi_int i)
	Is an input repeated for each grid point? More...
static bool	grid_out (casadi_int i)
	Is an output repeated for each grid point? More...
static casadi_int	adjmap_out (casadi_int i)
	Which output is used to calculate a given input in adjoint sensitivity analysis. 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 Integrator *	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	nk_target_
std::vector< casadi_int >	disc_
casadi_int	nv_
	Number of dependent variables in the discrete time integration. More...
casadi_int	nv1_
casadi_int	nrv_
casadi_int	nrv1_
Sparsity	sp_jac_dae_
	Sparsity pattern of the extended Jacobians. More...
Sparsity	sp_jac_rdae_
double	t0_
	Initial time. More...
std::vector< double >	tout_
	Output time grid. More...
casadi_int	nfwd_
	Number of sensitivities. More...
casadi_int	nadj_
Function	rdae_
	Backwards DAE function. More...
casadi_int	nx_
	Number of states for the forward integration. More...
casadi_int	nz_
casadi_int	nq_
casadi_int	nx1_
casadi_int	nz1_
casadi_int	nq1_
casadi_int	nrx_
	Number of states for the backward integration. More...
casadi_int	nrz_
casadi_int	nrq_
casadi_int	nuq_
casadi_int	nrx1_
casadi_int	nrz1_
casadi_int	nrq1_
casadi_int	nuq1_
casadi_int	np_
	Number of forward and backward parameters. More...
casadi_int	nrp_
casadi_int	np1_
casadi_int	nrp1_
casadi_int	nu_
	Number of controls. More...
casadi_int	nu1_
casadi_int	ne_
	Number of of zero-crossing functions. More...
casadi_int	ntmp_
	Length of the tmp1, tmp2 vectors. More...
std::vector< double >	nom_x_
std::vector< double >	nom_z_
Dict	augmented_options_
	Augmented user option. More...
Dict	opts_
	Copy of the options. More...
bool	print_stats_
	Options. More...
Function	transition_
	Function to be called at state events. More...
casadi_int	max_event_iter_
	Maximum number of event iterations for a single event. More...
casadi_int	max_events_
	Maximum total number of events during the simulation. More...
double	event_tol_
	Termination tolerance for the event iteration. More...
double	event_acceptable_tol_
	Acceptable tolerance for the event iteration. More...
bool	always_inline_
bool	never_inline_
size_t	n_in_
	Number of inputs and outputs. More...
size_t	n_out_
std::vector< bool >	is_diff_in_
	Are inputs and outputs differentiable? More...
std::vector< bool >	is_diff_out_
std::vector< Sparsity >	sparsity_in_
	Input and output sparsity. More...
std::vector< Sparsity >	sparsity_out_
std::vector< std::string >	name_in_
	Input and output scheme. More...
std::vector< std::string >	name_out_
bool	jit_
	Use just-in-time compiler. More...
bool	jit_cleanup_
	Cleanup jit source file. More...
std::string	jit_serialize_
	Serialize behaviour. More...
std::string	jit_name_
	Name if jit source file. More...
std::string	jit_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 std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...
static const std::string	infix_ = "integrator"
	Infix. More...
static std::map< std::string, ProtoFunction *(*)(DeserializingStream &)>	deserialize_map

Protected Member Functions
	FixedStepIntegrator (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
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...
enum	DaeOut { DAE_ODE , DAE_ALG , DAE_NUM_OUT }
	IO conventions for continuous time dynamics. More...
enum	QuadOut { QUAD_QUAD , QUAD_NUM_OUT }
	IO conventions for continuous time dynamics. More...
enum	BDynIn {   BDYN_T , BDYN_X , BDYN_Z , BDYN_P ,   BDYN_U , BDYN_OUT_ODE , BDYN_OUT_ALG , BDYN_OUT_QUAD ,   BDYN_OUT_ZERO , BDYN_ADJ_ODE , BDYN_ADJ_ALG , BDYN_ADJ_QUAD ,   BDYN_ADJ_ZERO , BDYN_NUM_IN }
	IO conventions for continuous time dynamics. More...
enum	BDynOut {   BDYN_ADJ_T , BDYN_ADJ_X , BDYN_ADJ_Z , BDYN_ADJ_P ,   BDYN_ADJ_U , BDYN_NUM_OUT }
	IO conventions for continuous time dynamics. More...
enum	DAEBOut { BDAE_ADJ_X , BDAE_ADJ_Z , BDAE_NUM_OUT }
	IO conventions for continuous time dynamics. More...
enum	QuadBOut { BQUAD_ADJ_P , BQUAD_ADJ_U , BQUAD_NUM_OUT }
	IO conventions for continuous time dynamics. More...
static std::vector< std::string >	dae_out ()
	IO conventions for continuous time dynamics. More...
static std::vector< std::string >	quad_out ()
	IO conventions for continuous time dynamics. More...
static std::string	bdyn_in (casadi_int i)
	IO conventions for continuous time dynamics. More...
static std::vector< std::string >	bdyn_in ()
	IO conventions for continuous time dynamics. More...
static std::string	bdyn_out (casadi_int i)
	IO conventions for continuous time dynamics. More...
static std::vector< std::string >	bdyn_out ()
	IO conventions for continuous time dynamics. More...
static std::vector< std::string >	bdae_out ()
	IO conventions for continuous time dynamics. More...
static std::vector< std::string >	bquad_out ()
	IO conventions for continuous time dynamics. More...

Member Typedef Documentation

Creator

typedef Integrator*(* casadi::Integrator::Creator) (const std::string &name, const Function &oracle, double t0, const std::vector< double > &tout)

inherited

Definition at line 442 of file integrator_impl.hpp.

RegFcn

typedef int(* casadi::PluginInterface< Integrator >::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.

Member Enumeration Documentation

BDynIn

enum casadi::Integrator::BDynIn

inherited

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

Enumerator
BDYN_T
BDYN_X
BDYN_Z
BDYN_P
BDYN_U
BDYN_OUT_ODE
BDYN_OUT_ALG
BDYN_OUT_QUAD
BDYN_OUT_ZERO
BDYN_ADJ_ODE
BDYN_ADJ_ALG
BDYN_ADJ_QUAD
BDYN_ADJ_ZERO
BDYN_NUM_IN

Definition at line 370 of file integrator_impl.hpp.

              { BDYN_T, BDYN_X, BDYN_Z, BDYN_P, BDYN_U,
    BDYN_OUT_ODE, BDYN_OUT_ALG, BDYN_OUT_QUAD, BDYN_OUT_ZERO,
    BDYN_ADJ_ODE, BDYN_ADJ_ALG, BDYN_ADJ_QUAD, BDYN_ADJ_ZERO, BDYN_NUM_IN};

BDynOut

enum casadi::Integrator::BDynOut

inherited

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

Enumerator
BDYN_ADJ_T
BDYN_ADJ_X
BDYN_ADJ_Z
BDYN_ADJ_P
BDYN_ADJ_U
BDYN_NUM_OUT

Definition at line 375 of file integrator_impl.hpp.

{ BDYN_ADJ_T, BDYN_ADJ_X, BDYN_ADJ_Z, BDYN_ADJ_P, BDYN_ADJ_U, BDYN_NUM_OUT};

DAEBOut

enum casadi::Integrator::DAEBOut

inherited

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

Enumerator
BDAE_ADJ_X
BDAE_ADJ_Z
BDAE_NUM_OUT

Definition at line 378 of file integrator_impl.hpp.

{ BDAE_ADJ_X, BDAE_ADJ_Z, BDAE_NUM_OUT};

DaeOut

enum casadi::Integrator::DaeOut

inherited

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

Enumerator
DAE_ODE
DAE_ALG
DAE_NUM_OUT

Definition at line 366 of file integrator_impl.hpp.

{ DAE_ODE, DAE_ALG, DAE_NUM_OUT};

QuadBOut

enum casadi::Integrator::QuadBOut

inherited

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

Enumerator
BQUAD_ADJ_P
BQUAD_ADJ_U
BQUAD_NUM_OUT

Definition at line 380 of file integrator_impl.hpp.

{ BQUAD_ADJ_P, BQUAD_ADJ_U, BQUAD_NUM_OUT};

QuadOut

enum casadi::Integrator::QuadOut

inherited

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

Enumerator
QUAD_QUAD
QUAD_NUM_OUT

Definition at line 368 of file integrator_impl.hpp.

{ QUAD_QUAD, QUAD_NUM_OUT};

Constructor & Destructor Documentation

FixedStepIntegrator() [1/2]

casadi::FixedStepIntegrator::FixedStepIntegrator ( const std::string &  name, const Function &  dae, double  t0, const std::vector< double > &  tout  )

explicit

Definition at line 1865 of file integrator.cpp.

                                              : Integrator(name, dae, t0, tout) {
 
  // Default options
  nk_target_ = 20;
}

References nk_target_.

~FixedStepIntegrator()

casadi::FixedStepIntegrator::~FixedStepIntegrator ( )

override

Definition at line 1872 of file integrator.cpp.

                                          {
  clear_mem();
}

References casadi::ProtoFunction::clear_mem().

FixedStepIntegrator() [2/2]

casadi::FixedStepIntegrator::FixedStepIntegrator ( DeserializingStream &  s )

explicitprotected

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

Definition at line 2492 of file integrator.cpp.

                                                                : Integrator(s) {
  s.version("FixedStepIntegrator", 3);
  s.unpack("FixedStepIntegrator::nk_target", nk_target_);
  s.unpack("FixedStepIntegrator::disc", disc_);
  s.unpack("FixedStepIntegrator::nv", nv_);
  s.unpack("FixedStepIntegrator::nv1", nv1_);
  s.unpack("FixedStepIntegrator::nrv", nrv_);
  s.unpack("FixedStepIntegrator::nrv1", nrv1_);
}

References disc_, nk_target_, nrv1_, nrv_, nv1_, nv_, casadi::DeserializingStream::unpack(), and casadi::DeserializingStream::version().

Member Function Documentation

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

adjmap_out()

casadi_int casadi::Integrator::adjmap_out ( casadi_int  i )

staticinherited

Definition at line 336 of file integrator.cpp.

                                              {
  switch (static_cast<IntegratorInput>(i)) {
    case INTEGRATOR_X0: return INTEGRATOR_ADJ_X0;
    case INTEGRATOR_Z0: return INTEGRATOR_ADJ_Z0;
    case INTEGRATOR_P: return INTEGRATOR_ADJ_P;
    case INTEGRATOR_U: return INTEGRATOR_ADJ_U;
    case INTEGRATOR_ADJ_XF: return INTEGRATOR_XF;
    case INTEGRATOR_ADJ_ZF: return INTEGRATOR_ZF;
    case INTEGRATOR_ADJ_QF: return INTEGRATOR_QF;
    default: break;
  }
  return -1;
}

References casadi::INTEGRATOR_ADJ_P, casadi::INTEGRATOR_ADJ_QF, casadi::INTEGRATOR_ADJ_U, casadi::INTEGRATOR_ADJ_X0, casadi::INTEGRATOR_ADJ_XF, casadi::INTEGRATOR_ADJ_Z0, casadi::INTEGRATOR_ADJ_ZF, casadi::INTEGRATOR_P, casadi::INTEGRATOR_QF, casadi::INTEGRATOR_U, casadi::INTEGRATOR_X0, casadi::INTEGRATOR_XF, casadi::INTEGRATOR_Z0, and casadi::INTEGRATOR_ZF.

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

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

advance()

int casadi::Integrator::advance ( IntegratorMemory *  m ) const

inherited

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

Definition at line 532 of file integrator.cpp.

                                                 {
  // Predict next event
  if (ne_ > 0 && m->t_next_out != m->t_start) {
    if (predict_events(m)) return 1;
  }
  // Event iterations
  m->event_iter = 0;
  while (true) {
    // Start a new event iteration
    m->event_iter++;
    // No event triggered
    m->event_index = -1;
    // Advance solution in time
    if (advance_noevent(m)) return 1;
    // Update current time
    m->t = m->t_next;
    m->t_next = m->t_next_out;
    // If no events or no interval, done
    if (ne_ == 0 || m->t_next_out == m->t_start) break;
    // Recalculate m->e and m->edot
    if (calc_edot(m)) return 1;
    // By default, let integrator continue to the next input step change
    m->t_stop = m->t_step;
    // Detect events
    for (casadi_int i = 0; i < ne_; ++i) {
      // Make sure that event was not already triggered
      if (m->event_triggered[i] || m->old_e[i] <= 0) continue;
      // Check if event was triggered or is projected to be triggered before next output time
      if (m->e[i] < 0 || (m->edot[i] < 0 && m->e[i] + (m->t_next_out - m->t) * m->edot[i] < 0)) {
        // Projected zero-crossing time
        double t_zero = m->t - m->e[i] / m->edot[i];
        // If t_zero is too small or m->edot[i] has the wrong sign, fall back to bisection
        if (t_zero <= m->t_start || (m->e[i] < 0 && m->edot[i] >= 0)) {
          t_zero = 0.5 * (m->t_start + m->t);
        }
        // Update t_next if earliest event so far
        if (t_zero < m->t_next) {
          m->event_index = i;
          m->t_next = t_zero;
          m->t_stop = std::max(m->t, m->t_next);
        }
      }
    }
    // If no events, done
    if (m->event_index < 0) break;
    // Distance to new time step
    double t_diff = std::fabs(m->t_next - m->t);
    // Check if converged
    if (t_diff < event_tol_) {
      if (verbose_) casadi_message("Event iteration converged, |dt| == " + str(t_diff));
      break;
    }
    // Maximum number of iterations reached?
    if (m->event_iter == max_event_iter_) {
      // Throw error?
      if (t_diff >= event_acceptable_tol_) {
        casadi_error("Maximum number of event iterations reached without convergence");
      }
      if (verbose_) casadi_message("Max event iterations, |dt| == " + str(t_diff));
      break;
    }
    // More iterations needed
    if (verbose_) casadi_message("Event iteration " + str(m->event_iter) + ", |dt| == "
      + str(t_diff));
  }
  // Successful return
  return 0;
}

References casadi::Integrator::advance_noevent(), casadi::Integrator::calc_edot(), casadi::IntegratorMemory::e, casadi::IntegratorMemory::edot, casadi::Integrator::event_acceptable_tol_, casadi::IntegratorMemory::event_index, casadi::IntegratorMemory::event_iter, casadi::Integrator::event_tol_, casadi::IntegratorMemory::event_triggered, casadi::Integrator::max_event_iter_, casadi::Integrator::ne_, casadi::IntegratorMemory::old_e, casadi::Integrator::predict_events(), casadi::str(), casadi::IntegratorMemory::t, casadi::IntegratorMemory::t_next, casadi::IntegratorMemory::t_next_out, casadi::IntegratorMemory::t_start, casadi::IntegratorMemory::t_step, casadi::IntegratorMemory::t_stop, and casadi::ProtoFunction::verbose_.

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

advance_noevent()

int casadi::FixedStepIntegrator::advance_noevent ( IntegratorMemory *  mem ) const

overridevirtual

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

Implements casadi::Integrator.

Definition at line 2041 of file integrator.cpp.

                                                                    {
  auto m = static_cast<FixedStepMemory*>(mem);
 
  // State at previous step
  double* x_prev = m->tmp1;
 
  // Number of finite elements and time steps
  casadi_int nj = disc_[m->k + 1] - disc_[m->k];
  double h = (m->t_next - m->t) / nj;
 
  // Take steps
  for (casadi_int j = 0; j < nj; ++j) {
    // Current time
    double t = m->t + j * h;
 
    // Update the previous step
    casadi_copy(m->x, nx_, x_prev);
    casadi_copy(m->v, nv_, m->v_prev);
    casadi_copy(m->q, nq_, m->q_prev);
 
    // Take step
    stepF(m, t, h, x_prev, m->v_prev, m->x, m->v, m->q);
    casadi_axpy(nq_, 1., m->q_prev, m->q);
 
    // Save state, if needed
    if (nrx_ > 0) {
      casadi_int tapeind = disc_[m->k] + j;
      casadi_copy(m->x, nx_, m->x_tape + nx_ * (tapeind + 1));
      casadi_copy(m->v, nv_, m->v_tape + nv_ * tapeind);
    }
  }
 
  // Save algebraic variables
  casadi_copy(m->v + nv_ - nz_, nz_, m->z);
 
  return 0;
}

References casadi::casadi_axpy(), casadi::casadi_copy(), disc_, casadi::Integrator::nq_, casadi::Integrator::nrx_, nv_, casadi::Integrator::nx_, casadi::Integrator::nz_, stepF(), and casadi::IntegratorMemory::tmp1.

algebraic_state_init()

virtual MX casadi::Integrator::algebraic_state_init ( const MX &  x0, const MX &  z0  ) const

inlinevirtualinherited

Reimplemented in casadi::Collocation.

Definition at line 162 of file integrator_impl.hpp.

{ return z0; }

Referenced by create_advanced().

algebraic_state_output()

virtual MX casadi::Integrator::algebraic_state_output ( const MX &  Z ) const

inlinevirtualinherited

Reimplemented in casadi::Collocation.

Definition at line 163 of file integrator_impl.hpp.

{ return Z; }

References casadi::Z.

Referenced by create_advanced().

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

all_zero()

bool casadi::Integrator::all_zero ( const double *  v, casadi_int  n  )

staticinherited

Definition at line 2736 of file integrator.cpp.

                                                       {
  // Quick return if trivially zero
  if (v == 0 || n == 0) return true;
  // Loop over entries
  for (casadi_int i = 0; i < n; ++i) {
    if (v[i] != 0.) return false;
  }
  // All zero if reached here
  return true;
}

Referenced by casadi::Integrator::eval(), and casadi::IdasInterface::z_impulseB().

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

Referenced by casadi::FunctionInternal::alloc(), casadi::BlazingSplineFunction::init(), casadi::External::init(), casadi::FmuFunction::init(), casadi::Integrator::init(), casadi::Interpolant::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::GurobiInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), casadi::OoqpInterface::init(), casadi::SlicotDple::init(), casadi::SlicotExpm::init(), casadi::SundialsInterface::init(), casadi::BSplineInterpolant::init(), casadi::Feasiblesqpmethod::init(), casadi::Ipqp::init(), casadi::LinearInterpolant::init(), casadi::LinearInterpolantJac::init(), casadi::Qrqp::init(), and casadi::Sqpmethod::init().

alloc_mem()

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

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 599 of file integrator_impl.hpp.

{ return new FixedStepMemory();}

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

Referenced by casadi::FunctionInternal::alloc(), casadi::BlazingSplineFunction::init(), casadi::External::init(), casadi::FiniteDiff::init(), casadi::FmuFunction::init(), casadi::Integrator::init(), init(), casadi::Interpolant::init(), casadi::JitFunction::init(), casadi::Map::init(), casadi::OmpMap::init(), casadi::ThreadMap::init(), casadi::MapSum::init(), casadi::MXFunction::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::Switch::init(), casadi::SXFunction::init(), casadi::Blocksqp::init(), casadi::BonminInterface::init(), casadi::CbcInterface::init(), casadi::ClarabelInterface::init(), casadi::ClpInterface::init(), casadi::CplexInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::GurobiInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::IpoptInterface::init(), casadi::KnitroInterface::init(), casadi::MadnlpInterface::init(), casadi::OoqpInterface::init(), casadi::OsqpInterface::init(), casadi::ProxqpInterface::init(), casadi::QpoasesInterface::init(), casadi::SLEQPInterface::init(), casadi::SlicotDple::init(), casadi::SlicotExpm::init(), casadi::SnoptInterface::init(), casadi::CvodesInterface::init(), casadi::IdasInterface::init(), casadi::KinsolInterface::init(), casadi::SundialsInterface::init(), casadi::SuperscsInterface::init(), casadi::WorhpInterface::init(), casadi::BSplineInterpolant::init(), casadi::FastNewton::init(), casadi::Feasiblesqpmethod::init(), casadi::ImplicitToNlp::init(), casadi::Ipqp::init(), casadi::LinearInterpolant::init(), casadi::LinearInterpolantJac::init(), casadi::Newton::init(), casadi::QpToNlp::init(), casadi::Qrqp::init(), casadi::Qrsqp::init(), casadi::Scpgen::init(), and casadi::Sqpmethod::init().

augmented_dae()

Function casadi::Integrator::augmented_dae ( ) const

inherited

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

Definition at line 919 of file integrator.cpp.

                                         {
  // If no sensitivities, augmented oracle is the oracle itself
  if (nfwd_ == 0) return oracle_;
  // Name of augmented DAE
  std::string aug_name = "fsens" + str(nfwd_) + "_" + oracle_.name();
  // Use function in cache, if available
  Function ret;
  // if (incache(aug_name, ret)) return ret;  // caching disabled while implementing #3047
  // Create new augmented oracle
  try {
    if (oracle_.is_a("SXFunction")) {
      ret = get_forward_dae<SX>(aug_name);
    } else {
      ret = get_forward_dae<MX>(aug_name);
    }
  } catch (std::exception& e) {
    casadi_error("Failed to generate augmented DAE for " + name_ + ":\n" + e.what());
  }
  // Save to Function cache and return
  // tocache(ret);  // caching disabled while implementing #3047
  return ret;
}

References casadi::Function::is_a(), casadi::Function::name(), casadi::ProtoFunction::name_, casadi::Integrator::nfwd_, casadi::OracleFunction::oracle_, and casadi::str().

Referenced by casadi::Integrator::get_forward(), and casadi::Integrator::get_reverse().

bdae_out()

static std::vector<std::string> casadi::Integrator::bdae_out ( )

inlinestaticinherited

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

Definition at line 379 of file integrator_impl.hpp.

{ return {"adj_x", "adj_z"}; }

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

bdae_sp_forward()

int casadi::Integrator::bdae_sp_forward ( SpForwardMem *  m, const bvec_t *  x, const bvec_t *  z, const bvec_t *  p, const bvec_t *  u, const bvec_t *  adj_ode, const bvec_t *  adj_quad, bvec_t *  adj_x, bvec_t *  adj_z  ) const

inherited

Definition at line 1053 of file integrator.cpp.

                                        {
  // Evaluate nondifferentiated
  m->arg[BDYN_T] = nullptr;  // t
  m->arg[BDYN_X] = x;  // x
  m->arg[BDYN_Z] = z;  // z
  m->arg[BDYN_P] = p;  // p
  m->arg[BDYN_U] = u;  // u
  m->arg[BDYN_OUT_ODE] = nullptr;  // out_ode
  m->arg[BDYN_OUT_ALG] = nullptr;  // out_alg
  m->arg[BDYN_OUT_QUAD] = nullptr;  // out_quad
  m->arg[BDYN_OUT_ZERO] = nullptr;  // out_zero
  m->arg[BDYN_ADJ_ODE] = adj_ode;  // adj_ode
  m->arg[BDYN_ADJ_ALG] = nullptr;  // adj_alg
  m->arg[BDYN_ADJ_QUAD] = adj_quad;  // adj_quad
  m->arg[BDYN_ADJ_ZERO] = nullptr;  // adj_zero
  m->res[BDAE_ADJ_X] = adj_x;  // adj_x
  m->res[BDAE_ADJ_Z] = adj_z;  // adj_z
  if (calc_sp_forward("daeB", m->arg, m->res, m->iw, m->w)) return 1;
  // Evaluate sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->arg[BDYN_NUM_IN + BDAE_ADJ_X] = adj_x;  // out:adj_x
    m->arg[BDYN_NUM_IN + BDAE_ADJ_Z] = adj_z;  // out:adj_z
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_T] = nullptr;  // fwd:t
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_Z] = z + (i + 1) * nz1_;  // fwd:z
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_U] = u + (i + 1) * nu1_;  // fwd:u
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_ODE] = nullptr;  // fwd:out_ode
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_ALG] = nullptr;  // fwd:out_alg
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_QUAD] = nullptr;  // fwd:out_quad
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_ZERO] = nullptr;  // fwd:out_zero
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_ODE]
      = adj_ode + (i + 1) * nrx1_ * nadj_;  // fwd:adj_ode
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_ALG] = nullptr;  // fwd:adj_alg
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_QUAD]
      = adj_quad + (i + 1) * nrz1_ * nadj_;  // fwd:adj_quad
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_ZERO] = nullptr;  // fwd:adj_zero
    m->res[BDAE_ADJ_X] = adj_x + (i + 1) * nrx1_ * nadj_;  // fwd:adj_x
    m->res[BDAE_ADJ_Z] = adj_z + (i + 1) * nrz1_ * nadj_;  // fwd:adj_z
    if (calc_sp_forward(forward_name("daeB", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  return 0;
}

References casadi::SpForwardMem::arg, casadi::Integrator::BDAE_ADJ_X, casadi::Integrator::BDAE_ADJ_Z, casadi::Integrator::BDAE_NUM_OUT, casadi::Integrator::BDYN_ADJ_ALG, casadi::Integrator::BDYN_ADJ_ODE, casadi::Integrator::BDYN_ADJ_QUAD, casadi::Integrator::BDYN_ADJ_ZERO, casadi::Integrator::BDYN_NUM_IN, casadi::Integrator::BDYN_OUT_ALG, casadi::Integrator::BDYN_OUT_ODE, casadi::Integrator::BDYN_OUT_QUAD, casadi::Integrator::BDYN_OUT_ZERO, casadi::Integrator::BDYN_P, casadi::Integrator::BDYN_T, casadi::Integrator::BDYN_U, casadi::Integrator::BDYN_X, casadi::Integrator::BDYN_Z, casadi::OracleFunction::calc_sp_forward(), casadi::FunctionInternal::forward_name(), casadi::SpForwardMem::iw, casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nrx1_, casadi::Integrator::nrz1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::SpForwardMem::res, and casadi::SpForwardMem::w.

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

bdae_sp_reverse()

int casadi::Integrator::bdae_sp_reverse ( SpReverseMem *  m, bvec_t *  x, bvec_t *  z, bvec_t *  p, bvec_t *  u, bvec_t *  adj_ode, bvec_t *  adj_quad, bvec_t *  adj_x, bvec_t *  adj_z  ) const

inherited

Definition at line 1317 of file integrator.cpp.

                                        {
  // Nondifferentiated inputs
  m->arg[BDYN_T] = nullptr;  // t
  m->arg[BDYN_X] = x;  // x
  m->arg[BDYN_Z] = z;  // z
  m->arg[BDYN_P] = p;  // p
  m->arg[BDYN_U] = u;  // u
  m->arg[BDYN_OUT_ODE] = nullptr;  // out_ode
  m->arg[BDYN_OUT_ALG] = nullptr;  // out_alg
  m->arg[BDYN_OUT_QUAD] = nullptr;  // out_quad
  m->arg[BDYN_OUT_ZERO] = nullptr;  // out_zero
  m->arg[BDYN_ADJ_ODE] = adj_ode;  // adj_ode
  m->arg[BDYN_ADJ_ALG] = nullptr;  // adj_alg
  m->arg[BDYN_ADJ_QUAD] = adj_quad;  // adj_quad
  m->arg[BDYN_ADJ_ZERO] = nullptr;  // adj_zero
  // Propagate through sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->res[BDAE_ADJ_X] = adj_x + (i + 1) * nrx1_ * nadj_;  // fwd:adj_x
    m->res[BDAE_ADJ_Z] = adj_z + (i + 1) * nrz1_ * nadj_;  // fwd:adj_z
    m->arg[BDYN_NUM_IN + BDAE_ADJ_X] = adj_x;  // out:adj_x
    m->arg[BDYN_NUM_IN + BDAE_ADJ_Z] = adj_z;  // out:adj_z
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_T] = nullptr;  // fwd:t
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_Z] = z + (i + 1) * nz1_;  // fwd:z
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_U] = u + (i + 1) * nu1_;  // fwd:u
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_ODE] = nullptr;  // fwd:out_ode
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_ALG] = nullptr;  // fwd:out_alg
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_QUAD] = nullptr;  // fwd:out_quad
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_OUT_ZERO] = nullptr;  // fwd:out_zero
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_ODE] =
      adj_ode + (i + 1) * nrx1_ * nadj_;  // fwd:adj_ode
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_ALG] = nullptr;  // fwd:adj_alg
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_QUAD] =
      adj_quad + (i + 1) * nrz1_ * nadj_;  // fwd:adj_quad
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_ZERO] = nullptr;  // fwd:adj_zero
    if (calc_sp_reverse(forward_name("daeB", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  // Propagate through nondifferentiated
  m->res[BDAE_ADJ_X] = adj_x;  // adj_x
  m->res[BDAE_ADJ_Z] = adj_z;  // adj_z
  if (calc_sp_reverse("daeB", m->arg, m->res, m->iw, m->w)) return 1;
  return 0;
}

References casadi::SpReverseMem::arg, casadi::Integrator::BDAE_ADJ_X, casadi::Integrator::BDAE_ADJ_Z, casadi::Integrator::BDAE_NUM_OUT, casadi::Integrator::BDYN_ADJ_ALG, casadi::Integrator::BDYN_ADJ_ODE, casadi::Integrator::BDYN_ADJ_QUAD, casadi::Integrator::BDYN_ADJ_ZERO, casadi::Integrator::BDYN_NUM_IN, casadi::Integrator::BDYN_OUT_ALG, casadi::Integrator::BDYN_OUT_ODE, casadi::Integrator::BDYN_OUT_QUAD, casadi::Integrator::BDYN_OUT_ZERO, casadi::Integrator::BDYN_P, casadi::Integrator::BDYN_T, casadi::Integrator::BDYN_U, casadi::Integrator::BDYN_X, casadi::Integrator::BDYN_Z, casadi::OracleFunction::calc_sp_reverse(), casadi::FunctionInternal::forward_name(), casadi::SpReverseMem::iw, casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nrx1_, casadi::Integrator::nrz1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::SpReverseMem::res, and casadi::SpReverseMem::w.

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

bdyn_in() [1/2]

std::vector< std::string > casadi::Integrator::bdyn_in ( )

staticinherited

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

Definition at line 96 of file integrator.cpp.

                                         {
  std::vector<std::string> ret(BDYN_NUM_IN);
  for (casadi_int i = 0; i < BDYN_NUM_IN; ++i)
    ret[i] = bdyn_in(i);
  return ret;
}

References casadi::Integrator::BDYN_NUM_IN.

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

bdyn_in() [2/2]

std::string casadi::Integrator::bdyn_in ( casadi_int  i )

staticinherited

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

Definition at line 76 of file integrator.cpp.

                                          {
  switch (i) {
    case BDYN_T: return "t";
    case BDYN_X: return "x";
    case BDYN_Z: return "z";
    case BDYN_P: return "p";
    case BDYN_U: return "u";
    case BDYN_OUT_ODE: return "out_ode";
    case BDYN_OUT_ALG: return "out_alg";
    case BDYN_OUT_QUAD: return "out_quad";
    case BDYN_OUT_ZERO: return "out_zero";
    case BDYN_ADJ_ODE: return "adj_ode";
    case BDYN_ADJ_ALG: return "adj_alg";
    case BDYN_ADJ_QUAD: return "adj_quad";
    case BDYN_ADJ_ZERO: return "adj_zero";
  default: break;
  }
  return "";
}

References casadi::Integrator::BDYN_ADJ_ALG, casadi::Integrator::BDYN_ADJ_ODE, casadi::Integrator::BDYN_ADJ_QUAD, casadi::Integrator::BDYN_ADJ_ZERO, casadi::Integrator::BDYN_OUT_ALG, casadi::Integrator::BDYN_OUT_ODE, casadi::Integrator::BDYN_OUT_QUAD, casadi::Integrator::BDYN_OUT_ZERO, casadi::Integrator::BDYN_P, casadi::Integrator::BDYN_T, casadi::Integrator::BDYN_U, casadi::Integrator::BDYN_X, and casadi::Integrator::BDYN_Z.

bdyn_out() [1/2]

std::vector< std::string > casadi::Integrator::bdyn_out ( )

staticinherited

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

Definition at line 115 of file integrator.cpp.

                                          {
  std::vector<std::string> ret(BDYN_NUM_OUT);
  for (casadi_int i = 0; i < BDYN_NUM_OUT; ++i)
    ret[i] = bdyn_out(i);
  return ret;
}

References casadi::Integrator::BDYN_NUM_OUT.

bdyn_out() [2/2]

std::string casadi::Integrator::bdyn_out ( casadi_int  i )

staticinherited

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

Definition at line 103 of file integrator.cpp.

                                           {
  switch (i) {
    case BDYN_ADJ_T: return "adj_t";
    case BDYN_ADJ_X: return "adj_x";
    case BDYN_ADJ_Z: return "adj_z";
    case BDYN_ADJ_P: return "adj_p";
    case BDYN_ADJ_U: return "adj_u";
  default: break;
  }
  return "";
}

References casadi::Integrator::BDYN_ADJ_P, casadi::Integrator::BDYN_ADJ_T, casadi::Integrator::BDYN_ADJ_U, casadi::Integrator::BDYN_ADJ_X, and casadi::Integrator::BDYN_ADJ_Z.

bquad_out()

static std::vector<std::string> casadi::Integrator::bquad_out ( )

inlinestaticinherited

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

Definition at line 381 of file integrator_impl.hpp.

{ return {"adj_p", "adj_u"}; }

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

bquad_sp_forward()

int casadi::Integrator::bquad_sp_forward ( SpForwardMem *  m, const bvec_t *  x, const bvec_t *  z, const bvec_t *  p, const bvec_t *  u, const bvec_t *  adj_ode, const bvec_t *  adj_alg, const bvec_t *  adj_quad, bvec_t *  adj_p, bvec_t *  adj_u  ) const

inherited

Definition at line 1099 of file integrator.cpp.

                                        {
  // Evaluate nondifferentiated
  m->arg[BDYN_T] = nullptr;  // t
  m->arg[BDYN_X] = x;  // x
  m->arg[BDYN_Z] = z;  // z
  m->arg[BDYN_P] = p;  // p
  m->arg[BDYN_U] = u;  // u
  m->arg[BDYN_OUT_ODE] = nullptr;  // out_ode
  m->arg[BDYN_OUT_ALG] = nullptr;  // out_alg
  m->arg[BDYN_OUT_QUAD] = nullptr;  // out_quad
  m->arg[BDYN_OUT_ZERO] = nullptr;  // out_zero
  m->arg[BDYN_ADJ_ODE] = adj_ode;  // adj_ode
  m->arg[BDYN_ADJ_ALG] = adj_alg;  // adj_alg
  m->arg[BDYN_ADJ_QUAD] = adj_quad;  // adj_quad
  m->arg[BDYN_ADJ_ZERO] = nullptr;  // adj_zero
  m->res[BQUAD_ADJ_P] = adj_p;  // adj_p
  m->res[BQUAD_ADJ_U] = adj_u;  // adj_u
  if (calc_sp_forward("quadB", m->arg, m->res, m->iw, m->w)) return 1;
  // Evaluate sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->arg[BDYN_NUM_IN + BQUAD_ADJ_P] = adj_p;  // out:adj_p
    m->arg[BDYN_NUM_IN + BQUAD_ADJ_U] = adj_u;  // out:adj_u
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_T] = nullptr;  // fwd:t
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_Z] = z + (i + 1) * nz1_;  // fwd:z
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_U] = u + (i + 1) * nu1_;  // fwd:u
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_ODE] = nullptr;  // fwd:out_ode
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_ALG] = nullptr;  // fwd:out_alg
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_QUAD] = nullptr;  // fwd:out_quad
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_ZERO] = nullptr;  // fwd:out_zero
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_ODE] =
      adj_ode + (i + 1) * nrx1_ * nadj_;  // fwd:adj_ode
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_ALG] =
      adj_alg + (i + 1) * nrz1_ * nadj_;  // fwd:adj_alg
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_QUAD] =
      adj_quad + (i + 1) * nrp1_ * nadj_;  // fwd:adj_quad
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_ZERO] = nullptr;  // fwd:adj_zero
    m->res[BQUAD_ADJ_P] = adj_p ? adj_p + (i + 1) * nrq1_ * nadj_ : 0;  // fwd:adj_p
    m->res[BQUAD_ADJ_U] = adj_u ? adj_u + (i + 1) * nuq1_ * nadj_: 0;  // fwd:adj_u
    if (calc_sp_forward(forward_name("quadB", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  return 0;
}

References casadi::SpForwardMem::arg, casadi::Integrator::BDYN_ADJ_ALG, casadi::Integrator::BDYN_ADJ_ODE, casadi::Integrator::BDYN_ADJ_QUAD, casadi::Integrator::BDYN_ADJ_ZERO, casadi::Integrator::BDYN_NUM_IN, casadi::Integrator::BDYN_OUT_ALG, casadi::Integrator::BDYN_OUT_ODE, casadi::Integrator::BDYN_OUT_QUAD, casadi::Integrator::BDYN_OUT_ZERO, casadi::Integrator::BDYN_P, casadi::Integrator::BDYN_T, casadi::Integrator::BDYN_U, casadi::Integrator::BDYN_X, casadi::Integrator::BDYN_Z, casadi::Integrator::BQUAD_ADJ_P, casadi::Integrator::BQUAD_ADJ_U, casadi::Integrator::BQUAD_NUM_OUT, casadi::OracleFunction::calc_sp_forward(), casadi::FunctionInternal::forward_name(), casadi::SpForwardMem::iw, casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nrp1_, casadi::Integrator::nrq1_, casadi::Integrator::nrx1_, casadi::Integrator::nrz1_, casadi::Integrator::nu1_, casadi::Integrator::nuq1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::SpForwardMem::res, and casadi::SpForwardMem::w.

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

bquad_sp_reverse()

int casadi::Integrator::bquad_sp_reverse ( SpReverseMem *  m, bvec_t *  x, bvec_t *  z, bvec_t *  p, bvec_t *  u, bvec_t *  adj_ode, bvec_t *  adj_alg, bvec_t *  adj_quad, bvec_t *  adj_p, bvec_t *  adj_u  ) const

inherited

Definition at line 1364 of file integrator.cpp.

                                        {
  // Nondifferentiated inputs
  m->arg[BDYN_T] = nullptr;  // t
  m->arg[BDYN_X] = x;  // x
  m->arg[BDYN_Z] = z;  // z
  m->arg[BDYN_P] = p;  // p
  m->arg[BDYN_U] = u;  // u
  m->arg[BDYN_OUT_ODE] = adj_ode;  // out_ode
  m->arg[BDYN_OUT_ALG] = adj_alg;  // out_alg
  m->arg[BDYN_OUT_QUAD] = adj_quad;  // out_quad
  m->arg[BDYN_OUT_ZERO] = nullptr;  // out_zero
  m->arg[BDYN_ADJ_ODE] = adj_ode;  // adj_ode
  m->arg[BDYN_ADJ_ALG] = adj_alg;  // adj_alg
  m->arg[BDYN_ADJ_QUAD] = adj_quad;  // adj_quad
  m->arg[BDYN_ADJ_ZERO] = nullptr;  // adj_zero
  // Propagate through sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->res[BQUAD_ADJ_P] = adj_p ? adj_p + (i + 1) * nrq1_ * nadj_ : 0;  // fwd:adj_p
    m->res[BQUAD_ADJ_U] = adj_u ? adj_u + (i + 1) * nuq1_ * nadj_ : 0;  // fwd:adj_u
    m->arg[BDYN_NUM_IN + BQUAD_ADJ_P] = adj_p;  // out:adj_p
    m->arg[BDYN_NUM_IN + BQUAD_ADJ_U] = adj_u;  // out:adj_u
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_T] = nullptr;  // fwd:t
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_Z] = z + (i + 1) * nz1_;  // fwd:z
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_U] = u + (i + 1) * nu1_;  // fwd:u
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_ODE] = nullptr;  // fwd:out_ode
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_ALG] = nullptr;  // fwd:out_alg
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_QUAD] = nullptr;  // fwd:out_quad
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_OUT_ZERO] = nullptr;  // fwd:out_zero
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_ODE] =
      adj_ode + (i + 1) * nrx1_ * nadj_;  // fwd:adj_ode
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_ALG] =
      adj_alg + (i + 1) * nrz1_ * nadj_;  // fwd:adj_alg
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_QUAD] =
      adj_quad + (i + 1) * nrp1_ * nadj_;  // fwd:adj_quad
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_ZERO] = nullptr;  // fwd:adj_zero
    if (calc_sp_reverse(forward_name("quadB", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  // Propagate through nondifferentiated
  m->res[BQUAD_ADJ_P] = adj_p;  // adj_p
  m->res[BQUAD_ADJ_U] = adj_u;  // adj_u
  if (calc_sp_reverse("quadB", m->arg, m->res, m->iw, m->w)) return 1;
  return 0;
}

References casadi::SpReverseMem::arg, casadi::Integrator::BDYN_ADJ_ALG, casadi::Integrator::BDYN_ADJ_ODE, casadi::Integrator::BDYN_ADJ_QUAD, casadi::Integrator::BDYN_ADJ_ZERO, casadi::Integrator::BDYN_NUM_IN, casadi::Integrator::BDYN_OUT_ALG, casadi::Integrator::BDYN_OUT_ODE, casadi::Integrator::BDYN_OUT_QUAD, casadi::Integrator::BDYN_OUT_ZERO, casadi::Integrator::BDYN_P, casadi::Integrator::BDYN_T, casadi::Integrator::BDYN_U, casadi::Integrator::BDYN_X, casadi::Integrator::BDYN_Z, casadi::Integrator::BQUAD_ADJ_P, casadi::Integrator::BQUAD_ADJ_U, casadi::Integrator::BQUAD_NUM_OUT, casadi::OracleFunction::calc_sp_reverse(), casadi::FunctionInternal::forward_name(), casadi::SpReverseMem::iw, casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nrp1_, casadi::Integrator::nrq1_, casadi::Integrator::nrx1_, casadi::Integrator::nrz1_, casadi::Integrator::nu1_, casadi::Integrator::nuq1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::SpReverseMem::res, and casadi::SpReverseMem::w.

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

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

int casadi::Integrator::calc_edot ( IntegratorMemory *  m ) const

inherited

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

Definition at line 2564 of file integrator.cpp.

                                                   {
  // Evaluate the DAE and zero crossing function
  m->arg[DYN_T] = &m->t;  // t
  m->arg[DYN_X] = m->x;  // x
  m->arg[DYN_Z] = m->z;  // z
  m->arg[DYN_P] = m->p;  // p
  m->arg[DYN_U] = m->u;  // u
  m->res[DYN_ODE] = m->xdot;  // ode
  m->res[DYN_ALG] = m->tmp1 + nx_;  // alg
  m->res[DYN_QUAD] = nullptr;  // quad
  m->res[DYN_ZERO] = m->e;  // zero
  if (calc_function(m, "dae")) return 1;
  // Calculate de_dt using by forward mode AD applied to zero crossing function
  // Note: Currently ignoring dependency propagation via algebraic equations
  double dt_dt = 1;
  m->arg[DYN_NUM_IN + DYN_ODE] = m->xdot;  // out:ode
  m->arg[DYN_NUM_IN + DYN_ALG] = m->tmp1 + nx_;  // out:alg
  m->arg[DYN_NUM_IN + DYN_QUAD] = nullptr;  // out:quad
  m->arg[DYN_NUM_IN + DYN_ZERO] = m->e;  // out:zero
  m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_T] = &dt_dt;  // fwd:t
  m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_X] = m->xdot;  // fwd:x
  m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_Z] = nullptr;  // fwd:z
  m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_P] = nullptr;  // fwd:p
  m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_U] = nullptr;  // fwd:u
  m->res[DYN_ODE] = nullptr;  // fwd:ode
  m->res[DYN_ALG] = nullptr;  // fwd:alg
  m->res[DYN_QUAD] = nullptr;  // fwd:quad
  m->res[DYN_ZERO] = m->edot;  // fwd:zero
  if (calc_function(m, forward_name("dae", 1))) return 1;
  // Success
  return 0;
}

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::DYN_ALG, casadi::DYN_NUM_IN, casadi::DYN_NUM_OUT, casadi::DYN_ODE, casadi::DYN_P, casadi::DYN_QUAD, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::DYN_ZERO, casadi::IntegratorMemory::e, casadi::IntegratorMemory::edot, casadi::FunctionInternal::forward_name(), casadi::Integrator::nx_, casadi::IntegratorMemory::p, casadi::OracleMemory::res, casadi::IntegratorMemory::t, casadi::IntegratorMemory::tmp1, casadi::IntegratorMemory::u, casadi::IntegratorMemory::x, casadi::IntegratorMemory::xdot, and casadi::IntegratorMemory::z.

Referenced by casadi::Integrator::advance(), casadi::Integrator::predict_events(), and casadi::Integrator::trigger_event().

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.

Referenced by casadi::KinsolInterface::bjac(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_daeF(), casadi::Integrator::calc_edot(), casadi::calc_function(), casadi::SundialsInterface::calc_jacF(), casadi::SundialsInterface::calc_jtimesF(), casadi::SundialsInterface::calc_quadB(), casadi::SundialsInterface::calc_quadF(), casadi::casadi_func_cons_jac(), casadi::casadi_func_cons_val(), casadi::casadi_func_hess_prod(), casadi::casadi_func_obj_grad(), casadi::casadi_func_obj_val(), casadi::KinsolInterface::djac(), casadi::Nlpsol::eval(), casadi::AlpaqaProblem::eval_f(), casadi::BonminUserClass::eval_f(), casadi::IpoptUserClass::eval_f(), casadi::AlpaqaProblem::eval_f_grad_f(), casadi::AlpaqaProblem::eval_g(), casadi::BonminUserClass::eval_g(), casadi::IpoptUserClass::eval_g(), casadi::BonminUserClass::eval_grad_f(), casadi::IpoptUserClass::eval_grad_f(), casadi::AlpaqaProblem::eval_grad_L(), casadi::BonminUserClass::eval_h(), casadi::IpoptUserClass::eval_h(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_L_prod(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::AlpaqaProblem::eval_hess_ψ_prod(), casadi::AlpaqaProblem::eval_jac_g(), casadi::BonminUserClass::eval_jac_g(), casadi::IpoptUserClass::eval_jac_g(), casadi::AlpaqaProblem::eval_ψ(), casadi::AlpaqaProblem::eval_ψ_grad_ψ(), casadi::Blocksqp::evaluate(), casadi::Feasiblesqpmethod::feasibility_iterations(), casadi::KinsolInterface::psetup(), casadi::KnitroInterface::solve(), casadi::SnoptInterface::solve(), casadi::WorhpInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Newton::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), stepB(), stepF(), casadi::Integrator::trigger_event(), and casadi::SnoptInterface::userfun().

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

References casadi::SharedObjectInternal::class_name(), casadi::FunctionInternal::enable_fd_, casadi::FunctionInternal::enable_forward_, casadi::FunctionInternal::forward(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::has_forward(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::replace_fseed(), casadi::FunctionInternal::size2_out(), and casadi::FunctionInternal::size_out().

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

References casadi::ProtoFunction::error_on_fail_, casadi::FunctionInternal::eval_gen(), casadi::get_ptr(), casadi::ProtoFunction::memory(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::project_arg(), casadi::FunctionInternal::size2_in(), casadi::FunctionInternal::sparsity_out(), casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), casadi::FunctionInternal::sz_w(), and casadi::GenericMatrix< Matrix< Scalar > >::zeros().

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

References casadi::FunctionInternal::adjViaJac(), casadi::SharedObjectInternal::class_name(), casadi::FunctionInternal::enable_reverse_, casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::has_reverse(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::matching_res(), casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::replace_aseed(), casadi::FunctionInternal::reverse(), casadi::FunctionInternal::size2_in(), casadi::FunctionInternal::size_in(), and casadi::T.

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.

{ }

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

virtual std::string casadi::SharedObjectInternal::class_name ( ) const

pure virtualinherited

Implemented in casadi::SymbolicQr, casadi::Sqpmethod, casadi::ShellCompiler, casadi::Scpgen, casadi::RungeKutta, casadi::Qrsqp, casadi::Qrqp, casadi::QpToNlp, casadi::Newton, casadi::Lsqr, casadi::LinsolTridiag, casadi::LinsolQr, casadi::LinsolLdl, casadi::LinearInterpolantJac, casadi::LinearInterpolant, casadi::Ipqp, casadi::ImplicitToNlp, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::Collocation, casadi::BSplineInterpolant, casadi::WorhpInterface, casadi::TinyXmlInterface, casadi::SuperscsInterface, casadi::KinsolInterface, casadi::IdasInterface, casadi::CvodesInterface, casadi::SqicInterface, casadi::SnoptInterface, casadi::SlicotExpm, casadi::SlicotDple, casadi::SLEQPInterface, casadi::QpoasesInterface, casadi::ProxqpInterface, casadi::OsqpInterface, casadi::OoqpInterface, casadi::MumpsInterface, casadi::MadnlpInterface, casadi::LapackQr, casadi::LapackLu, casadi::KnitroInterface, casadi::IpoptInterface, casadi::Ma27Interface, casadi::HpmpcInterface, casadi::HpipmInterface, casadi::HighsInterface, casadi::GurobiInterface, casadi::FatropInterface, casadi::FatropConicInterface, casadi::DaqpInterface, casadi::CsparseInterface, casadi::CSparseCholeskyInterface, casadi::CplexInterface, casadi::ClpInterface, casadi::ClarabelInterface, casadi::ClangCompiler, casadi::CbcInterface, casadi::BonminInterface, casadi::Blocksqp, casadi::AmplInterface, casadi::AlpaqaInterface, casadi::SXFunction, casadi::Switch, casadi::SparsityInternal, casadi::WeakRefInternal, casadi::ZipMemResource, casadi::ZipResource, casadi::DirResource, casadi::OptiNode, casadi::Nlpsol, casadi::MXNode, casadi::MXFunction, casadi::MapSum, casadi::ThreadMap, casadi::OmpMap, casadi::Map, casadi::JitFunction, casadi::Interpolant, casadi::DllLibrary, casadi::ImporterInternal, casadi::GenericTypeInternal< ID, T >, casadi::FmuFunction, casadi::Fmu3, casadi::Fmu2, casadi::Smoothing, casadi::CentralDiff, casadi::BackwardDiff, casadi::ForwardDiff, casadi::External, casadi::DaeBuilderInternal, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::codegen_body(), casadi::ProtoFunction::construct(), casadi::FmuInternal::deserialize(), casadi::ResourceInternal::deserialize(), casadi::FmuInternal::disp(), casadi::FunctionInternal::disp(), casadi::LinsolInternal::disp(), casadi::XmlFileInternal::dump(), casadi::FunctionInternal::eval(), casadi::FunctionInternal::eval_dm(), casadi::FunctionInternal::eval_sx(), casadi::FunctionInternal::export_code(), casadi::LinsolInternal::generate(), casadi::FunctionInternal::generate_dependencies(), casadi::Conic::generateNativeCode(), casadi::FmuInternal::get_adjoint_derivative(), casadi::FunctionInternal::get_forward(), casadi::FunctionInternal::get_function(), casadi::FunctionInternal::get_jacobian(), casadi::FunctionInternal::get_reverse(), casadi::FiniteDiff::init(), casadi::FunctionInternal::instruction_constant(), casadi::FunctionInternal::instruction_id(), casadi::FunctionInternal::instruction_input(), casadi::FunctionInternal::instruction_MX(), casadi::FunctionInternal::instruction_output(), casadi::FunctionInternal::instructions_sx(), casadi::LinsolInternal::linsol_eval_sx(), casadi::FunctionInternal::n_instructions(), casadi::FunctionInternal::n_nodes(), casadi::LinsolInternal::neig(), casadi::LinsolInternal::nfact(), casadi::FunctionInternal::oracle(), casadi::XmlFileInternal::parse(), casadi::LinsolInternal::rank(), casadi::FmuInternal::serialize_type(), casadi::ResourceInternal::serialize_type(), and casadi::LinsolInternal::solve().

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

Referenced by casadi::AlpaqaInterface::~AlpaqaInterface(), casadi::AmplInterface::~AmplInterface(), casadi::BlazingSplineFunction::~BlazingSplineFunction(), casadi::Blocksqp::~Blocksqp(), casadi::BonminInterface::~BonminInterface(), casadi::BSplineInterpolant::~BSplineInterpolant(), casadi::CallbackInternal::~CallbackInternal(), casadi::CbcInterface::~CbcInterface(), casadi::ClarabelInterface::~ClarabelInterface(), casadi::ClpInterface::~ClpInterface(), casadi::CplexInterface::~CplexInterface(), casadi::CsparseInterface::~CsparseInterface(), casadi::CvodesInterface::~CvodesInterface(), casadi::DaqpInterface::~DaqpInterface(), casadi::External::~External(), casadi::FastNewton::~FastNewton(), casadi::FatropConicInterface::~FatropConicInterface(), casadi::FatropInterface::~FatropInterface(), casadi::Feasiblesqpmethod::~Feasiblesqpmethod(), casadi::FiniteDiff::~FiniteDiff(), ~FixedStepIntegrator(), casadi::FmuFunction::~FmuFunction(), casadi::GurobiInterface::~GurobiInterface(), casadi::HighsInterface::~HighsInterface(), casadi::HpipmInterface::~HpipmInterface(), casadi::HpmpcInterface::~HpmpcInterface(), casadi::IdasInterface::~IdasInterface(), casadi::ImplicitToNlp::~ImplicitToNlp(), casadi::IpoptInterface::~IpoptInterface(), casadi::Ipqp::~Ipqp(), casadi::JitFunction::~JitFunction(), casadi::KinsolInterface::~KinsolInterface(), casadi::KnitroInterface::~KnitroInterface(), casadi::LapackLu::~LapackLu(), casadi::LapackQr::~LapackQr(), casadi::LinearInterpolant::~LinearInterpolant(), casadi::LinearInterpolantJac::~LinearInterpolantJac(), casadi::LinsolLdl::~LinsolLdl(), casadi::LinsolQr::~LinsolQr(), casadi::LinsolTridiag::~LinsolTridiag(), casadi::Lsqr::~Lsqr(), casadi::Ma27Interface::~Ma27Interface(), casadi::MadnlpInterface::~MadnlpInterface(), casadi::Map::~Map(), casadi::MapSum::~MapSum(), casadi::MumpsInterface::~MumpsInterface(), casadi::MXFunction::~MXFunction(), casadi::Newton::~Newton(), casadi::Nlpsol::~Nlpsol(), casadi::OmpMap::~OmpMap(), casadi::OoqpInterface::~OoqpInterface(), casadi::OsqpInterface::~OsqpInterface(), casadi::ProxqpInterface::~ProxqpInterface(), casadi::QpoasesInterface::~QpoasesInterface(), casadi::QpToNlp::~QpToNlp(), casadi::Qrqp::~Qrqp(), casadi::Qrsqp::~Qrsqp(), casadi::Scpgen::~Scpgen(), casadi::SLEQPInterface::~SLEQPInterface(), casadi::SlicotDple::~SlicotDple(), casadi::SlicotExpm::~SlicotExpm(), casadi::SnoptInterface::~SnoptInterface(), casadi::Sqpmethod::~Sqpmethod(), casadi::SuperscsInterface::~SuperscsInterface(), casadi::Switch::~Switch(), casadi::SXFunction::~SXFunction(), casadi::SymbolicQr::~SymbolicQr(), casadi::ThreadMap::~ThreadMap(), and casadi::WorhpInterface::~WorhpInterface().

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::FunctionInternal::codegen_body ( CodeGenerator &  g ) const

virtualinherited

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

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >, casadi::Sqpmethod, casadi::Qrqp, casadi::LinearInterpolantJac, casadi::LinearInterpolant, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::BSplineInterpolant, casadi::OsqpInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HpipmInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, casadi::SXFunction, casadi::Switch, casadi::MXFunction, casadi::MapSum, casadi::ThreadMap, casadi::OmpMap, casadi::Map, casadi::JitFunction, casadi::FiniteDiff, casadi::External, and casadi::BlazingSplineFunction.

Definition at line 2742 of file function_internal.cpp.

                                                            {
    casadi_warning("The function \"" + name_ + "\", which is of type \""
                   + class_name() + "\" cannot be code generated. The generation "
                   "will proceed, but compilation of the code will not be possible.");
    g << "#error Code generation not supported for " << class_name() << "\n";
  }

References casadi::SharedObjectInternal::class_name(), and casadi::ProtoFunction::name_.

Referenced by casadi::FunctionInternal::codegen(), and casadi::BSplineInterpolant::codegen_body().

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.

                                                               {
  }

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::FunctionInternal::codegen_declarations ( CodeGenerator &  g ) const

virtualinherited

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

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >, casadi::Sqpmethod, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::BSplineInterpolant, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::FatropInterface, casadi::SXFunction, casadi::Switch, casadi::Nlpsol, casadi::MXFunction, casadi::MapSum, casadi::Map, casadi::FiniteDiff, and casadi::External.

Definition at line 2738 of file function_internal.cpp.

                                                                    {
    // Nothing to declare
  }

Referenced by casadi::CodeGenerator::add_dependency(), and casadi::BSplineInterpolant::codegen_declarations().

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.

{}

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.

{}

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.

{}

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

Referenced by casadi::ClarabelInterface::codegen_body(), casadi::DaqpInterface::codegen_body(), casadi::FatropInterface::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::IpoptInterface::codegen_body(), casadi::MadnlpInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::ClarabelInterface::codegen_free_mem(), casadi::DaqpInterface::codegen_free_mem(), casadi::FatropInterface::codegen_free_mem(), casadi::HighsInterface::codegen_free_mem(), casadi::IpoptInterface::codegen_free_mem(), casadi::MadnlpInterface::codegen_free_mem(), casadi::OsqpInterface::codegen_free_mem(), casadi::ClarabelInterface::codegen_init_mem(), casadi::DaqpInterface::codegen_init_mem(), casadi::FatropInterface::codegen_init_mem(), casadi::HighsInterface::codegen_init_mem(), casadi::IpoptInterface::codegen_init_mem(), casadi::MadnlpInterface::codegen_init_mem(), and casadi::OsqpInterface::codegen_init_mem().

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.

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

References casadi::all(), casadi::CodeGenerator::array(), casadi::CodeGenerator::body, casadi::FunctionInternal::codegen_decref(), casadi::FunctionInternal::codegen_incref(), casadi::FunctionInternal::codegen_mem_type(), casadi::FunctionInternal::codegen_name(), casadi::FunctionInternal::codegen_sparsities(), casadi::FunctionInternal::codegen_sz_arg(), casadi::FunctionInternal::codegen_sz_iw(), casadi::FunctionInternal::codegen_sz_res(), casadi::FunctionInternal::codegen_sz_w(), casadi::CodeGenerator::constant(), casadi::CodeGenerator::declare(), casadi::CodeGenerator::flush(), casadi::CodeGenerator::from_mex(), casadi::FunctionInternal::get_default_in(), casadi::CodeGenerator::header, casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::is_diff_out_, casadi::CodeGenerator::main, casadi::CodeGenerator::mex, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::CodeGenerator::printf(), casadi::CodeGenerator::res(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::FunctionInternal::sparsity_in_, casadi::FunctionInternal::sparsity_out_, casadi::str(), casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), casadi::FunctionInternal::sz_w(), casadi::CodeGenerator::to_mex(), casadi::CodeGenerator::with_header, and casadi::CodeGenerator::with_mem.

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

Function casadi::FixedStepIntegrator::create_advanced ( const Dict &  opts )

overridevirtual

Helper for a more powerful 'integrator' factory

Reimplemented from casadi::Integrator.

Definition at line 1892 of file integrator.cpp.

                                                              {
  Function temp = Function::create(this, opts);
 
  // Check if we need to simplify
  bool simplify = false;
  auto it = opts.find("simplify");
  if (it != opts.end()) simplify = it->second;
 
  if (simplify && nrx_==0 && nt()==1) {
    // Retrieve explicit simulation step (one finite element)
    Function F = get_function("step");
 
    MX z0 = MX::sym("z0", sparsity_in(INTEGRATOR_Z0));
 
    // Create symbols
    std::vector<MX> F_in = F.mx_in();
 
    // Prepare return Function inputs
    std::vector<MX> intg_in(INTEGRATOR_NUM_IN);
    intg_in[INTEGRATOR_X0] = F_in[STEP_X0];
    intg_in[INTEGRATOR_Z0] = z0;
    intg_in[INTEGRATOR_P] = F_in[STEP_P];
    intg_in[INTEGRATOR_U] = F_in[STEP_U];
    F_in[STEP_V0] = algebraic_state_init(intg_in[INTEGRATOR_X0], z0);
 
    // Number of finite elements and time steps
    double h = (tout_.back() - t0_)/static_cast<double>(disc_.back());
 
    // Prepare return Function outputs
    std::vector<MX> intg_out(INTEGRATOR_NUM_OUT);
    F_in[STEP_T] = t0_;
    F_in[STEP_H] = h;
 
    std::vector<MX> F_out;
    // Loop over finite elements
    for (casadi_int k=0; k<disc_.back(); ++k) {
      F_out = F(F_in);
 
      F_in[STEP_X0] = F_out[STEP_XF];
      F_in[STEP_V0] = F_out[STEP_VF];
      intg_out[INTEGRATOR_QF] = k==0? F_out[STEP_QF] : intg_out[INTEGRATOR_QF]+F_out[STEP_QF];
      F_in[STEP_T] += h;
    }
 
    intg_out[INTEGRATOR_XF] = F_out[STEP_XF];
 
    // If-clause needed because rk abuses STEP_VF output for intermediate state output
    if (nz_) {
      intg_out[INTEGRATOR_ZF] = algebraic_state_output(F_out[STEP_VF]);
    }
 
    // Extract options for Function constructor
    Dict sopts;
    sopts["print_time"] = print_time_;
    auto it = opts.find("simplify_options");
    if (it!=opts.end()) update_dict(sopts, it->second);
 
    return Function(temp.name(), intg_in, intg_out, integrator_in(), integrator_out(), sopts);
  } else {
    return temp;
  }
}

References casadi::Integrator::algebraic_state_init(), casadi::Integrator::algebraic_state_output(), casadi::Function::create(), disc_, casadi::FunctionInternal::Function, casadi::OracleFunction::get_function(), casadi::integrator_in(), casadi::INTEGRATOR_NUM_IN, casadi::INTEGRATOR_NUM_OUT, casadi::integrator_out(), casadi::INTEGRATOR_P, casadi::INTEGRATOR_QF, casadi::INTEGRATOR_U, casadi::INTEGRATOR_X0, casadi::INTEGRATOR_XF, casadi::INTEGRATOR_Z0, casadi::INTEGRATOR_ZF, casadi::Function::mx_in(), casadi::Function::name(), casadi::Integrator::nrx_, casadi::Integrator::nt(), casadi::Integrator::nz_, casadi::ProtoFunction::print_time_, casadi::simplify(), casadi::FunctionInternal::sparsity_in(), casadi::STEP_H, casadi::STEP_P, casadi::STEP_QF, casadi::STEP_T, casadi::STEP_U, casadi::STEP_V0, casadi::STEP_VF, casadi::STEP_X0, casadi::STEP_XF, casadi::GenericMatrix< MX >::sym(), casadi::Integrator::t0_, casadi::Integrator::tout_, and casadi::update_dict().

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

Referenced by casadi::OracleFunction::create_function(), casadi::Integrator::init(), casadi::Nlpsol::init(), casadi::AlpaqaInterface::init(), casadi::Blocksqp::init(), casadi::BonminInterface::init(), casadi::FatropInterface::init(), casadi::IpoptInterface::init(), casadi::KnitroInterface::init(), casadi::MadnlpInterface::init(), casadi::SLEQPInterface::init(), casadi::SnoptInterface::init(), casadi::SundialsInterface::init(), casadi::WorhpInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Qrsqp::init(), and casadi::Sqpmethod::init().

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

dae_out()

static std::vector<std::string> casadi::Integrator::dae_out ( )

inlinestaticinherited

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

Definition at line 367 of file integrator_impl.hpp.

{ return {"ode", "alg"}; }

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

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

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

staticinherited

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

Definition at line 2424 of file integrator.cpp.

                                                             {
  return PluginInterface<Integrator>::deserialize(s);
}

References casadi::PluginInterface< Derived >::deserialize().

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.

{}

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::Integrator::eval ( const double **  arg, double **  res, casadi_int *  iw, double *  w, void *  mem  ) const

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 354 of file integrator.cpp.

                                                {
  auto m = static_cast<IntegratorMemory*>(mem);
 
  // Read inputs
  const double* x0 = arg[INTEGRATOR_X0];
  const double* z0 = arg[INTEGRATOR_Z0];
  const double* p = arg[INTEGRATOR_P];
  const double* u = arg[INTEGRATOR_U];
  const double* adj_xf = arg[INTEGRATOR_ADJ_XF];
  const double* rz0 = arg[INTEGRATOR_ADJ_ZF];
  const double* rp = arg[INTEGRATOR_ADJ_QF];
  arg += INTEGRATOR_NUM_IN;
 
  // Read outputs
  double* x = res[INTEGRATOR_XF];
  double* z = res[INTEGRATOR_ZF];
  double* q = res[INTEGRATOR_QF];
  double* adj_x = res[INTEGRATOR_ADJ_X0];
  double* adj_p = res[INTEGRATOR_ADJ_P];
  double* adj_u = res[INTEGRATOR_ADJ_U];
  res += INTEGRATOR_NUM_OUT;
 
  // Setup memory object
  setup(m, arg, res, iw, w);
 
  // Pass initial state, parameters
  set_q(m, 0);
  set_x(m, x0);
  set_z(m, z0);
  set_p(m, p);
 
  // Reset number of events
  m->num_events = 0;
 
  // Is this the first call to reset?
  bool first_call = true;
 
  // Take time to t0
  m->t = t0_;
 
  // Ensure that control is updated at the first iteration
  casadi_int k_stop = -1;
 
  // Do we need to reset the solver?
  m->reset_solver = false;
 
  // Integrate forward
  for (m->k = 0; m->k < nt(); ++m->k) {
    // Start of the current interval
    m->t_start = m->t;
    // Next output time
    m->t_next_out = tout_[m->k];
    // By default, integrate until the next output time
    m->t_next = m->t_next_out;
    // Handle changes in control input
    if (m->k > k_stop) {
      // Pass new controls
      set_u(m, u);
      // Detect next stopping time
      k_stop = next_stop(m->k, u);
      m->t_stop = m->t_step = tout_[k_stop];
      // Need to reset solver
      m->reset_solver = true;
    }
    // Mark all events as not triggered
    std::fill_n(m->event_triggered, ne_, 0);
    // Keep integrating until we reach the next output time
    do {
      // Reset the solver
      if (m->reset_solver) {
        reset(m, first_call);
        m->reset_solver = false;
        first_call = false;
      }
      // Advance solution
      if (verbose_) {
        casadi_message("Interval " + str(m->k) + ": Integrating forward from "
          + str(m->t) + " to " + str(m->t_next) + ", t_stop = " + str(m->t_stop));
      }
      if (advance(m)) return 1;
      // Trigger all event, if any
      if (m->event_index >= 0) {
        // Clear list of triggered events
        std::fill_n(m->event_triggered, ne_, 0);
        // Trigger the specific event and any chained events
        while (m->event_index >= 0) {
          // Trigger event, get any chained event
          if (trigger_event(m, &m->event_index)) return 1;
          // Solver needs to be reset
          m->reset_solver = true;
        }
        // Move past event
        m->t_start = m->t;
        m->t_stop = m->t_step;
        m->t_next = m->t_next_out;
      }
    } while (m->t != m->t_next);
    // Get solution
    get_x(m, x);
    get_z(m, z);
    get_q(m, q);
    if (x) x += nx_;
    if (z) z += nz_;
    if (q) q += nq_;
    if (u) u += nu_;
  }
 
  // Backwards integration, if needed
  if (nrx_ > 0) {
    // Take adj_xf, rz0, rp past the last grid point
    if (adj_xf) adj_xf += nrx_ * nt();
    if (rz0) rz0 += nrz_ * nt();
    if (rp) rp += nrp_ * nt();
    if (adj_u) adj_u += nuq_ * nt();
    // Next stop time due to step change in input
    k_stop = nt();
    // Reset the solver
    resetB(m);
    // Any adjoint seed so far?
    bool any_impulse = false;
    // Integrate backward
    for (m->k = nt(); m->k-- > 0; ) {
      m->t = tout_[m->k];
      // Add impulse to backwards integration
      if (adj_xf) adj_xf -= nrx_;
      if (rz0) rz0 -= nrz_;
      if (rp) rp -= nrp_;
      if (adj_u) adj_u -= nuq_;
      if (u) u -= nu_;
      if (!all_zero(adj_xf, nrx_) || !all_zero(rz0, nrz_) || !all_zero(rp, nrp_)) {
        if (verbose_) casadi_message("Impulse from adjoint seeds at output time " + str(m->k));
        impulseB(m, adj_xf, rz0, rp);
        any_impulse = true;
      }
      // Next output time, or beginning
      casadi_int k_next = m->k - 1;
      m->t_next = k_next < 0 ? t0_ : tout_[k_next];
      // Update integrator stopping time
      if (k_next < k_stop) k_stop = next_stopB(m->k, u);
      m->t_stop = k_stop < 0 ? t0_ : tout_[k_stop];
      // Proceed to the previous time point or t0
      if (any_impulse) {
        if (verbose_) casadi_message("Integrating backward from output time " + str(m->k)
          + ": t_next = " + str(m->t_next) + ", t_stop = " + str(m->t_stop));
        if (m->k > 0) {
          retreat(m, u, 0, 0, adj_u);
        } else {
          retreat(m, u, adj_x, adj_p, adj_u);
        }
      } else {
        if (verbose_) casadi_message("No adjoint seeds from output time " + str(m->k)
          + ": t_next = " + str(m->t_next) + ", t_stop = " + str(m->t_stop));
        casadi_clear(adj_u, nuq_);
        if (m->k == 0) {
          casadi_clear(adj_x, nrx_);
          casadi_clear(adj_p, nrq_);
        }
      }
    }
    // adj_u should contain the contribution from the grid point, not cumulative
    if (adj_u) {
      for (m->k = 0; m->k < nt() - 1; ++m->k) {
        casadi_axpy(nuq_, -1., adj_u + nuq_, adj_u);
        adj_u += nuq_;
      }
    }
  }
 
  // Collect oracle statistics
  join_results(m);
 
  // Print integrator statistics
  if (print_stats_) print_stats(m);
 
  return 0;
}

References casadi::Integrator::advance(), casadi::Integrator::all_zero(), casadi::casadi_axpy(), casadi::casadi_clear(), casadi::Integrator::get_q(), casadi::Integrator::get_x(), casadi::Integrator::get_z(), casadi::Integrator::impulseB(), casadi::INTEGRATOR_ADJ_P, casadi::INTEGRATOR_ADJ_QF, casadi::INTEGRATOR_ADJ_U, casadi::INTEGRATOR_ADJ_X0, casadi::INTEGRATOR_ADJ_XF, casadi::INTEGRATOR_ADJ_ZF, casadi::INTEGRATOR_NUM_IN, casadi::INTEGRATOR_NUM_OUT, casadi::INTEGRATOR_P, casadi::INTEGRATOR_QF, casadi::INTEGRATOR_U, casadi::INTEGRATOR_X0, casadi::INTEGRATOR_XF, casadi::INTEGRATOR_Z0, casadi::INTEGRATOR_ZF, casadi::OracleFunction::join_results(), casadi::Integrator::ne_, casadi::Integrator::next_stop(), casadi::Integrator::next_stopB(), casadi::Integrator::nq_, casadi::Integrator::nrp_, casadi::Integrator::nrq_, casadi::Integrator::nrx_, casadi::Integrator::nrz_, casadi::Integrator::nt(), casadi::Integrator::nu_, casadi::Integrator::nuq_, casadi::Integrator::nx_, casadi::Integrator::nz_, casadi::Integrator::print_stats(), casadi::Integrator::print_stats_, casadi::Integrator::reset(), casadi::Integrator::resetB(), casadi::Integrator::retreat(), casadi::Integrator::set_p(), casadi::Integrator::set_q(), casadi::Integrator::set_u(), casadi::Integrator::set_x(), casadi::Integrator::set_z(), casadi::FunctionInternal::setup(), casadi::str(), casadi::Integrator::t0_, casadi::Integrator::tout_, casadi::Integrator::trigger_event(), and casadi::ProtoFunction::verbose_.

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

References casadi::FunctionInternal::checkout_, casadi::FunctionInternal::dump_, casadi::FunctionInternal::dump_in_, casadi::FunctionInternal::dump_out_, casadi::FunctionInternal::eval(), casadi::FunctionInternal::eval_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_in_, casadi::FunctionInternal::print_out(), casadi::FunctionInternal::print_out_, casadi::ProtoFunction::print_time(), casadi::ProtoFunction::regularity_check_, casadi::FunctionInternal::release_, casadi::FunctionInternal::sparsity_out(), casadi::FunctionMemory::stats_available, casadi::str(), casadi::FunctionInternal::sz_w(), and casadi::uout().

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

fdae_sp_forward()

int casadi::Integrator::fdae_sp_forward ( SpForwardMem *  m, const bvec_t *  x, const bvec_t *  p, const bvec_t *  u, bvec_t *  ode, bvec_t *  alg  ) const

inherited

Definition at line 1002 of file integrator.cpp.

                                                                      {
  // Evaluate nondifferentiated
  m->arg[DYN_T] = nullptr;  // t
  m->arg[DYN_X] = x;  // x
  m->arg[DYN_Z] = nullptr;  // z
  m->arg[DYN_P] = p;  // p
  m->arg[DYN_U] = u;  // u
  m->res[DAE_ODE] = ode;  // ode
  m->res[DAE_ALG] = alg;  // alg
  if (calc_sp_forward("daeF", m->arg, m->res, m->iw, m->w)) return 1;
  // Evaluate sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->arg[DYN_NUM_IN + DAE_ODE] = ode;  // out:ode
    m->arg[DYN_NUM_IN + DAE_ALG] = alg;  // out:alg
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_T] = nullptr;  // fwd:t
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_Z] = nullptr;  // fwd:z
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_U] = u + (i + 1) * nu1_;  // fwd:u
    m->res[DAE_ODE] = ode + (i + 1) * nx1_;  // fwd:ode
    m->res[DAE_ALG] = alg + (i + 1) * nz1_;  // fwd:alg
    if (calc_sp_forward(forward_name("daeF", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  return 0;
}

References casadi::SpForwardMem::arg, casadi::OracleFunction::calc_sp_forward(), casadi::Integrator::DAE_ALG, casadi::Integrator::DAE_NUM_OUT, casadi::Integrator::DAE_ODE, casadi::DYN_NUM_IN, casadi::DYN_P, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::FunctionInternal::forward_name(), casadi::SpForwardMem::iw, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::SpForwardMem::res, and casadi::SpForwardMem::w.

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

fdae_sp_reverse()

int casadi::Integrator::fdae_sp_reverse ( SpReverseMem *  m, bvec_t *  x, bvec_t *  p, bvec_t *  u, bvec_t *  ode, bvec_t *  alg  ) const

inherited

Definition at line 1264 of file integrator.cpp.

                                                          {
  // Nondifferentiated inputs
  m->arg[DYN_T] = nullptr;  // t
  m->arg[DYN_X] = x;  // x
  m->arg[DYN_Z] = nullptr;  // z
  m->arg[DYN_P] = p;  // p
  m->arg[DYN_U] = u;  // u
  // Propagate through sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->res[DAE_ODE] = ode + (i + 1) * nx1_;  // fwd:ode
    m->res[DAE_ALG] = alg + (i + 1) * nz1_;  // fwd:alg
    m->arg[DYN_NUM_IN + DAE_ODE] = ode;  // out:ode
    m->arg[DYN_NUM_IN + DAE_ALG] = alg;  // out:alg
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_T] = nullptr;  // fwd:t
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_Z] = nullptr;  // fwd:z
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_U] = u + (i + 1) * nu1_;  // fwd:u
    if (calc_sp_reverse(forward_name("daeF", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  // Propagate through nondifferentiated
  m->res[DAE_ODE] = ode;  // ode
  m->res[DAE_ALG] = alg;  // alg
  if (calc_sp_reverse("daeF", m->arg, m->res, m->iw, m->w)) return 1;
  return 0;
}

References casadi::SpReverseMem::arg, casadi::OracleFunction::calc_sp_reverse(), casadi::Integrator::DAE_ALG, casadi::Integrator::DAE_NUM_OUT, casadi::Integrator::DAE_ODE, casadi::DYN_NUM_IN, casadi::DYN_P, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::FunctionInternal::forward_name(), casadi::SpReverseMem::iw, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::SpReverseMem::res, and casadi::SpReverseMem::w.

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

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.

{}

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

References casadi::Function::assert_size_in(), casadi::Function::assert_sparsity_out(), casadi::combine(), casadi::Function::create(), casadi::FunctionInternal::der_options_, casadi::FunctionInternal::diff_prefix(), casadi::FunctionInternal::enable_fd_, casadi::FunctionInternal::enable_forward_, casadi::FunctionInternal::fd_method_, casadi::FunctionInternal::fd_options_, casadi::Function::forward(), casadi::FunctionInternal::forward_name(), casadi::FunctionInternal::forward_options_, casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::get_forward(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::incache(), casadi::Function::n_in(), casadi::FunctionInternal::n_in_, casadi::Function::n_out(), casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::size1_in(), casadi::FunctionInternal::size1_out(), casadi::FunctionInternal::size2_in(), casadi::FunctionInternal::size2_out(), casadi::FunctionInternal::sparsity_out(), casadi::FunctionInternal::tocache_if_missing(), and casadi::FunctionInternal::wrap().

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

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_daeF(), casadi::Integrator::calc_edot(), casadi::SundialsInterface::calc_jtimesF(), casadi::SundialsInterface::calc_quadB(), casadi::SundialsInterface::calc_quadF(), casadi::OracleFunction::create_forward(), casadi::Integrator::fdae_sp_forward(), casadi::Integrator::fdae_sp_reverse(), casadi::FunctionInternal::forward(), casadi::Integrator::fquad_sp_forward(), casadi::Integrator::fquad_sp_reverse(), casadi::Integrator::sp_jac_dae(), casadi::Integrator::sp_jac_rdae(), stepB(), stepF(), and casadi::Integrator::trigger_event().

fquad_sp_forward()

int casadi::Integrator::fquad_sp_forward ( SpForwardMem *  m, const bvec_t *  x, const bvec_t *  z, const bvec_t *  p, const bvec_t *  u, bvec_t *  quad  ) const

inherited

Definition at line 1029 of file integrator.cpp.

                                                          {
  // Evaluate nondifferentiated
  m->arg[DYN_T] = nullptr;  // t
  m->arg[DYN_X] = x;  // x
  m->arg[DYN_Z] = z;  // z
  m->arg[DYN_P] = p;  // p
  m->arg[DYN_U] = u;  // u
  m->res[QUAD_QUAD] = quad;  // quad
  if (calc_sp_forward("quadF", m->arg, m->res, m->iw, m->w)) return 1;
  // Evaluate sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->arg[DYN_NUM_IN + QUAD_QUAD] = quad;  // out:quad
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_T] = nullptr;  // fwd:t
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_Z] = z + (i + 1) * nz1_;  // fwd:z
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_U] = u + (i + 1) * nu1_;  // fwd:u
    m->res[QUAD_QUAD] = quad + (i + 1) * nq1_;  // fwd:quad
    if (calc_sp_forward(forward_name("quadF", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  return 0;
}

References casadi::SpForwardMem::arg, casadi::OracleFunction::calc_sp_forward(), casadi::DYN_NUM_IN, casadi::DYN_P, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::FunctionInternal::forward_name(), casadi::SpForwardMem::iw, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nq1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::Integrator::QUAD_NUM_OUT, casadi::Integrator::QUAD_QUAD, casadi::SpForwardMem::res, and casadi::SpForwardMem::w.

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

fquad_sp_reverse()

int casadi::Integrator::fquad_sp_reverse ( SpReverseMem *  m, bvec_t *  x, bvec_t *  z, bvec_t *  p, bvec_t *  u, bvec_t *  quad  ) const

inherited

Definition at line 1292 of file integrator.cpp.

                                              {
  // Nondifferentiated inputs
  m->arg[DYN_T] = nullptr;  // t
  m->arg[DYN_X] = x;  // x
  m->arg[DYN_Z] = z;  // z
  m->arg[DYN_P] = p;  // p
  m->arg[DYN_U] = u;  // u
  // Propagate through sensitivities
  for (casadi_int i = 0; i < nfwd_; ++i) {
    m->res[QUAD_QUAD] = quad + (i + 1) * nq1_;  // fwd:quad
    m->arg[DYN_NUM_IN + QUAD_QUAD] = quad;  // out:quad
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_T] = nullptr;  // fwd:t
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_X] = x + (i + 1) * nx1_;  // fwd:x
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_Z] = z + (i + 1) * nz1_;  // fwd:z
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_P] = p + (i + 1) * np1_;  // fwd:p
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_U] = u + (i + 1) * nu1_;  // fwd:u
    if (calc_sp_reverse(forward_name("quadF", 1), m->arg, m->res, m->iw, m->w)) return 1;
  }
  // Propagate through nondifferentiated
  m->res[QUAD_QUAD] = quad;  // quad
  if (calc_sp_reverse("quadF", m->arg, m->res, m->iw, m->w)) return 1;
  return 0;
}

References casadi::SpReverseMem::arg, casadi::OracleFunction::calc_sp_reverse(), casadi::DYN_NUM_IN, casadi::DYN_P, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::FunctionInternal::forward_name(), casadi::SpReverseMem::iw, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nq1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::Integrator::QUAD_NUM_OUT, casadi::Integrator::QUAD_QUAD, casadi::SpReverseMem::res, and casadi::SpReverseMem::w.

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

free_mem()

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

inlineoverridevirtual

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

Reimplemented from casadi::FunctionInternal.

Definition at line 609 of file integrator_impl.hpp.

{ delete static_cast<FixedStepMemory*>(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;
  }

References casadi::FunctionInternal::ad_weight_, casadi::FunctionInternal::ad_weight_sp_, casadi::FunctionInternal::always_inline_, casadi::FunctionInternal::compiler_plugin_, casadi::FunctionInternal::der_options_, casadi::FunctionInternal::derivative_of_, casadi::FunctionInternal::dump_, casadi::FunctionInternal::dump_dir_, casadi::FunctionInternal::dump_format_, casadi::FunctionInternal::dump_in_, casadi::FunctionInternal::dump_out_, casadi::FunctionInternal::enable_fd_op_, casadi::FunctionInternal::enable_forward_op_, casadi::FunctionInternal::enable_jacobian_op_, casadi::FunctionInternal::enable_reverse_op_, casadi::FunctionInternal::fd_method_, casadi::FunctionInternal::fd_options_, casadi::FunctionInternal::forward_options_, casadi::ProtoFunction::generate_options(), casadi::FunctionInternal::inputs_check_, casadi::FunctionInternal::jac_penalty_, casadi::FunctionInternal::jacobian_options_, casadi::FunctionInternal::jit_, casadi::FunctionInternal::jit_base_name_, casadi::FunctionInternal::jit_cleanup_, casadi::FunctionInternal::jit_options_, casadi::FunctionInternal::jit_serialize_, casadi::FunctionInternal::jit_temp_suffix_, casadi::FunctionInternal::max_io_, casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::never_inline_, casadi::FunctionInternal::print_in_, casadi::FunctionInternal::print_out_, casadi::FunctionInternal::reverse_options_, and casadi::FunctionInternal::user_data_.

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.

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

{ return true; }

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

get_forward()

Function casadi::Integrator::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_1m7

Reimplemented from casadi::FunctionInternal.

Definition at line 1558 of file integrator.cpp.

                            {
  if (verbose_) casadi_message(name_ + "::get_forward");
 
  // Integrator options
  Dict aug_opts = getDerivativeOptions(true);
  for (auto&& i : augmented_options_) {
    aug_opts[i.first] = i.second;
  }
 
  // Get current DAE, with any existing sensitivity equations augmented
  Function this_dae = augmented_dae();
 
  // Create integrator for augmented DAE
  std::string aug_prefix = "fsens" + str(nfwd) + "_";
  aug_opts["derivative_of"] = self();
  aug_opts["nfwd"] = nfwd;
  aug_opts["nadj"] = nadj_;
  Function aug_int = integrator(aug_prefix + name_, plugin_name(),
    this_dae, t0_, tout_, aug_opts);
 
  // All inputs of the return function
  std::vector<MX> ret_in;
  ret_in.reserve(INTEGRATOR_NUM_IN + INTEGRATOR_NUM_OUT + INTEGRATOR_NUM_IN);
 
  // Add nondifferentiated inputs to ret_in
  for (casadi_int i = 0; i < INTEGRATOR_NUM_IN; ++i) {
    ret_in.push_back(MX::sym(integrator_in(i), sparsity_in(i)));
  }
 
  // Add nondifferentiated outputs (unused) to ret_in
  for (casadi_int i = 0; i < INTEGRATOR_NUM_OUT; ++i) {
    ret_in.push_back(MX::sym("out_" + integrator_out(i), Sparsity(size_out(i))));
  }
 
  // Create symbolic expressions for augmented problem, add forward seeds to ret_in
  std::vector<std::vector<MX>> aug_in(INTEGRATOR_NUM_IN);
  std::vector<MX> v(nfwd);
  for (casadi_int i = 0; i < INTEGRATOR_NUM_IN; ++i) {
    for (casadi_int d = 0; d < nfwd; ++d) {
      v[d] = MX::sym("fwd" + str(d) + "_" + integrator_in(i), sparsity_in(i));
      aug_in[i].push_back(v[d]);
    }
    ret_in.push_back(horzcat(v));
  }
 
  // Call the augmented integrator
  std::vector<MX> integrator_in(INTEGRATOR_NUM_IN);
  for (casadi_int i = 0; i < INTEGRATOR_NUM_IN; ++i) {
    if (size1_in(i) > 0 && grid_in(i) && nt() > 1) {
      // Split nondifferentiated input by grid point
      std::vector<MX> ret_in_split = horzsplit_n(ret_in[i], nt());
      // Split augmented input by grid point
      std::vector<std::vector<MX>> aug_in_split(nfwd);
      for (casadi_int d = 0; d < nfwd; ++d) {
        aug_in_split[d] = horzsplit_n(aug_in[i][d], nt());
      }
      // Reorder columns
      v.clear();
      for (casadi_int k = 0; k < nt(); ++k) {
        v.push_back(ret_in_split.at(k));
        for (casadi_int d = 0; d < nfwd; ++d) {
          v.push_back(aug_in_split[d].at(k));
        }
      }
    } else {
      // No reordering necessary
      v = aug_in[i];
      v.insert(v.begin(), ret_in[i]);
    }
    // Flatten all elements
    for (MX& e : v) e = vec(e);
    integrator_in[i] = horzcat(v);
  }
  std::vector<MX> integrator_out = aug_int(integrator_in);
 
  // Collect forward sensitivites
  std::vector<MX> ret_out;
  ret_out.reserve(INTEGRATOR_NUM_OUT);
  for (casadi_int i = 0; i < INTEGRATOR_NUM_OUT; ++i) {
    // Split return by grid points and sensitivities
    casadi_int n_grid = grid_out(i) ? nt() : 1;
    std::vector<casadi_int> offset = {0};
    for (casadi_int k = 0; k < n_grid; ++k) {
      for (casadi_int d = 0; d <= nfwd; ++d) {
        offset.push_back(offset.back() + size2_out(i) / n_grid);
      }
    }
    std::vector<MX> integrator_out_split = horzsplit(
      reshape(integrator_out[i], size1_out(i), offset.back()), offset);
    // Collect sensitivity blocks in the right order
    std::vector<MX> ret_out_split;
    ret_out_split.reserve(n_grid * nfwd);
    for (casadi_int d = 0; d < nfwd; ++d) {
      for (casadi_int k = 0; k < n_grid; ++k) {
        ret_out_split.push_back(integrator_out_split.at((nfwd + 1) * k + d + 1));
      }
    }
    ret_out.push_back(horzcat(ret_out_split));
  }
 
  Dict options = opts;
  options["allow_duplicate_io_names"] = true;
 
  // Create derivative function and return
  return Function(name, ret_in, ret_out, inames, onames, options);
}

References casadi::Integrator::augmented_dae(), casadi::Integrator::augmented_options_, casadi::FunctionInternal::Function, casadi::Integrator::getDerivativeOptions(), casadi::Integrator::grid_in(), casadi::Integrator::grid_out(), casadi::integrator(), casadi::integrator_in(), casadi::INTEGRATOR_NUM_IN, casadi::INTEGRATOR_NUM_OUT, casadi::integrator_out(), casadi::Integrator::nadj_, casadi::ProtoFunction::name_, casadi::Integrator::nt(), casadi::PluginInterface< Integrator >::plugin_name(), casadi::FunctionInternal::size1_in(), casadi::FunctionInternal::size1_out(), casadi::FunctionInternal::size2_out(), casadi::FunctionInternal::size_out(), casadi::FunctionInternal::sparsity_in(), casadi::str(), casadi::GenericMatrix< MX >::sym(), casadi::Integrator::t0_, casadi::Integrator::tout_, and casadi::ProtoFunction::verbose_.

get_forward_dae()

template<typename MatType >

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

inherited

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

Definition at line 943 of file integrator.cpp.

                                                                {
  if (verbose_) casadi_message(name_ + "::get_forward_dae");
 
  // Events not implemented
  casadi_assert(ne_ == 0, "Event support not implemented for Integrator::augmented_dae");
 
  // Get input and output expressions
  std::vector<MatType> arg = MatType::get_input(oracle_);
  std::vector<MatType> res = oracle_(arg);
 
  // Symbolic expression for augmented DAE
  std::vector<std::vector<MatType>> aug_in(DYN_NUM_IN);
  for (casadi_int i = 0; i < DYN_NUM_IN; ++i) aug_in[i].push_back(arg.at(i));
  std::vector<std::vector<MatType>> aug_out(DYN_NUM_OUT);
  for (casadi_int i = 0; i < DYN_NUM_OUT; ++i) aug_out[i].push_back(res.at(i));
 
  // Zero of time dimension
  MatType zero_t = MatType::zeros(oracle_.sparsity_in(DYN_T));
 
  // Augment aug_in with forward sensitivity seeds
  std::vector<std::vector<MatType>> seed(nfwd_, std::vector<MatType>(DYN_NUM_IN));
  for (casadi_int d = 0; d < nfwd_; ++d) {
    // Create expressions for augmented states
    std::string pref = "aug" + str(d) + "_";
    for (casadi_int i = 0; i < DYN_NUM_IN; ++i) {
      if (i == DYN_T) {
        seed[d][i] = zero_t;
      } else {
        seed[d][i] = MatType::sym(pref + dyn_in(i), oracle_.sparsity_in(i));
      }
    }
    // Save to augmented function inputs
    for (casadi_int i = 0; i < DYN_NUM_IN; ++i) {
      if (i != DYN_T) aug_in[i].push_back(seed[d][i]);
    }
  }
 
  // Calculate directional derivatives
  std::vector<std::vector<MatType>> sens;
  bool always_inline = oracle_.is_a("SXFunction") || oracle_.is_a("MXFunction");
  oracle_->call_forward(arg, res, seed, sens, always_inline, false);
 
  // Augment aug_out with forward sensitivity equations
  casadi_assert_dev(sens.size() == nfwd_);
  for (casadi_int d = 0; d < nfwd_; ++d) {
    casadi_assert_dev(sens[d].size() == DYN_NUM_OUT);
    for (casadi_int i = 0; i < DYN_NUM_OUT; ++i) {
      aug_out[i].push_back(project(sens[d][i], oracle_.sparsity_out(i)));
    }
  }
 
  // Concatenate arrays
  for (casadi_int i = 0; i < DYN_NUM_IN; ++i) arg.at(i) = vertcat(aug_in[i]);
  for (casadi_int i = 0; i < DYN_NUM_OUT; ++i) res.at(i) = vertcat(aug_out[i]);
 
  // Convert to oracle function and return
  return Function(name, arg, res, dyn_in(), dyn_out());
}

References casadi::FunctionInternal::call_forward(), casadi::dyn_in(), casadi::DYN_NUM_IN, casadi::DYN_NUM_OUT, casadi::dyn_out(), casadi::DYN_T, casadi::FunctionInternal::Function, casadi::Function::is_a(), casadi::ProtoFunction::name_, casadi::Integrator::ne_, casadi::Integrator::nfwd_, casadi::OracleFunction::oracle_, casadi::Function::sparsity_in(), casadi::Function::sparsity_out(), casadi::str(), and casadi::ProtoFunction::verbose_.

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(), casadi::FastNewton::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(), casadi::FastNewton::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), 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(), 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(), casadi::FastNewton::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();
    }
  }

References casadi::bvec_size, casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FunctionInternal::has_spfwd(), casadi::FunctionInternal::has_sprev(), casadi::GlobalOptions::hierarchical_sparsity, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::nz_in(), casadi::FunctionInternal::nz_out(), casadi::FunctionInternal::sp_weight(), and casadi::FunctionInternal::sparsity_out_.

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

References casadi::bvec_size, casadi::Sparsity::density(), casadi::get_ptr(), casadi::ProtoFunction::memory(), casadi::Sparsity::nnz(), casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::nz_in(), casadi::FunctionInternal::nz_out(), casadi::Sparsity::size(), casadi::str(), casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), casadi::FunctionInternal::sz_w(), casadi::Sparsity::triplet(), and casadi::ProtoFunction::verbose_.

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

References casadi::bvec_or(), casadi::bvec_size, casadi::bvec_toggle(), casadi::Sparsity::colind(), casadi::D, casadi::Sparsity::dense(), casadi::Sparsity::density(), casadi::diff(), casadi::Sparsity::dim(), casadi::Sparsity::get_nz(), casadi::get_ptr(), casadi::lookupvector(), casadi::ProtoFunction::memory(), casadi::Sparsity::nnz(), casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::nz_in(), casadi::FunctionInternal::nz_out(), casadi::range(), casadi::Sparsity::row(), casadi::Sparsity::size(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::FunctionInternal::sp_weight(), casadi::Matrix< Scalar >::sparsity(), casadi::str(), casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), casadi::FunctionInternal::sz_w(), casadi::Sparsity::T(), casadi::Sparsity::triplet(), casadi::Matrix< casadi_int >::triplet(), casadi::Sparsity::uni_coloring(), and casadi::ProtoFunction::verbose_.

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

References casadi::bvec_or(), casadi::bvec_size, casadi::bvec_toggle(), casadi::Sparsity::colind(), casadi::D, casadi::Sparsity::dense(), casadi::Sparsity::density(), casadi::diff(), casadi::Sparsity::dim(), casadi::Sparsity::get_nz(), casadi::get_ptr(), casadi::FunctionInternal::has_spfwd(), casadi::lookupvector(), casadi::Sparsity::nnz(), casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::range(), casadi::Sparsity::row(), casadi::Sparsity::size(), casadi::Matrix< Scalar >::sparsity(), casadi::Sparsity::star_coloring(), casadi::str(), casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), casadi::FunctionInternal::sz_w(), casadi::Sparsity::T(), casadi::Sparsity::triplet(), casadi::Matrix< casadi_int >::triplet(), and casadi::ProtoFunction::verbose_.

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::Integrator::get_n_in ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 115 of file integrator_impl.hpp.

{ return INTEGRATOR_NUM_IN;}

References casadi::INTEGRATOR_NUM_IN.

get_n_out()

size_t casadi::Integrator::get_n_out ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 116 of file integrator_impl.hpp.

{ return INTEGRATOR_NUM_OUT;}

References casadi::INTEGRATOR_NUM_OUT.

get_name_in()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 131 of file integrator_impl.hpp.

{ return integrator_in(i);}

References casadi::integrator_in().

get_name_out()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 132 of file integrator_impl.hpp.

{ return integrator_out(i);}

References casadi::integrator_out().

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::FixedStepIntegrator::get_options ( ) const

inlineoverridevirtual

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

Reimplemented from casadi::Integrator.

Reimplemented in casadi::Collocation, and casadi::ImplicitFixedStepIntegrator.

Definition at line 581 of file integrator_impl.hpp.

{ return options_;}

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

void casadi::Integrator::get_q ( IntegratorMemory *  m, double *  q  ) const

inherited

Definition at line 2533 of file integrator.cpp.

                                                           {
  casadi_copy(m->q, nq_, q);
}

References casadi::casadi_copy(), casadi::Integrator::nq_, and casadi::IntegratorMemory::q.

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

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::Integrator::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_1m8

Reimplemented from casadi::FunctionInternal.

Definition at line 1668 of file integrator.cpp.

                            {
  if (verbose_) casadi_message(name_ + "::get_reverse");
 
  // Events not implemented
  casadi_assert(ne_ == 0, "Event support not implemented for  Integrator::get_reverse");
 
  // Integrator options
  Dict aug_opts = getDerivativeOptions(false);
  for (auto&& i : augmented_options_) {
    aug_opts[i.first] = i.second;
  }
 
  // Get the current oracle, augmented with any existing forward sensitivity equations
  Function this_dae = augmented_dae();
 
  // Create integrator for augmented DAE
  std::string aug_prefix = "asens" + str(nadj) + "_";
  aug_opts["derivative_of"] = self();
  if (nrx_ == 0) {
    // Add backward problem
    aug_opts["nadj"] = nadj;
    aug_opts["nfwd"] = 0;
  } else {
    // Reformulate as forward-over-reverse
    aug_opts["nfwd"] = nadj;
    aug_opts["nadj"] = nadj_;
  }
  Function aug_int = integrator(aug_prefix + name_, plugin_name(),
    this_dae, t0_, tout_, aug_opts);
 
  // All inputs of the return function
  std::vector<MX> ret_in;
  ret_in.reserve(INTEGRATOR_NUM_IN + INTEGRATOR_NUM_OUT + INTEGRATOR_NUM_IN);
 
  // Add nondifferentiated inputs to ret_in
  for (casadi_int i = 0; i < INTEGRATOR_NUM_IN; ++i) {
    ret_in.push_back(MX::sym(integrator_in(i), sparsity_in(i)));
  }
 
  // Add nondifferentiated outputs (unused) to ret_in
  for (casadi_int i = 0; i < INTEGRATOR_NUM_OUT; ++i) {
    ret_in.push_back(MX::sym("out_" + integrator_out(i), Sparsity(size_out(i))));
  }
 
  // Create symbolic expressions for augmented problem, add adjoint seeds to ret_in
  std::vector<std::vector<MX>> aug_in(INTEGRATOR_NUM_OUT);
  std::vector<MX> v(nadj);
  for (casadi_int i = 0; i < INTEGRATOR_NUM_OUT; ++i) {
    for (casadi_int d=0; d<nadj; ++d) {
      v[d] = MX::sym("adj" + str(d) + "_" + integrator_out(i), sparsity_out(i));
      aug_in[i].push_back(v[d]);
    }
    ret_in.push_back(horzcat(v));
  }
 
  // Call the augmented integrator
  std::vector<MX> integrator_in(INTEGRATOR_NUM_IN);
  for (casadi_int i = 0; i < INTEGRATOR_NUM_IN; ++i) {
    // Output index contributing to adjoint seeds
    casadi_int j = adjmap_out(i);
    // Number of grid points for this integrator input
    casadi_int n_grid = grid_in(i) ? nt() : 1;
    // Split input and seeds by grid points, if necessary
    std::vector<MX> ret_in_split;
    std::vector<std::vector<MX>> aug_in_split(nadj);
    if (size1_in(i) > 0 && grid_in(i) && n_grid > 1) {
      // Split nondifferentiated input by grid point
      ret_in_split = horzsplit_n(ret_in[i], nt());
      // Split augmented input by grid point
      for (casadi_int d = 0; d < nadj; ++d) {
        aug_in_split[d] = horzsplit_n(aug_in[j][d], nt());
      }
    } else {
      // No reordering necessary
      ret_in_split = {ret_in[i]};
      for (casadi_int d = 0; d < nadj; ++d) aug_in_split[d] = {aug_in[j][d]};
    }
    // Vectorize all inputs to allow concatenation (unlike forward sensitivities,
    // number of rows for sensitivities may be different from original inputs)
    for (auto&& e : ret_in_split) e = vec(e);
    for (auto&& e1 : aug_in_split) {
      for (auto&& e2 : e1) e2 = vec(e2);
    }
    // Assemble input argument
    v.clear();
    for (casadi_int k = 0; k < ret_in_split.size(); ++k) {
      v.push_back(ret_in_split.at(k));
      for (casadi_int d = 0; d < nadj; ++d) {
        v.push_back(aug_in_split[d].at(k));
      }
    }
    integrator_in[i] = reshape(vertcat(v), aug_int.size_in(i));
  }
  std::vector<MX> integrator_out = aug_int(integrator_in);
 
  // Collect adjoint sensitivites
  std::vector<MX> ret_out;
  ret_out.reserve(INTEGRATOR_NUM_IN);
  for (casadi_int i = 0; i < INTEGRATOR_NUM_IN; ++i) {
    casadi_int j = adjmap_out(i);
    // Split return by grid points and sensitivities
    casadi_int n_grid = grid_out(j) ? nt() : 1;
    std::vector<casadi_int> offset = {0};
    for (casadi_int k = 0; k < n_grid; ++k) {
      offset.push_back(offset.back() + numel_out(j) / n_grid);
      for (casadi_int d = 0; d < nadj; ++d) {
        offset.push_back(offset.back() + numel_in(i) / n_grid);
      }
    }
    std::vector<MX> integrator_out_split = vertsplit(vec(integrator_out[j]), offset);
    // Collect sensitivity blocks in the right order
    std::vector<MX> ret_out_split;
    ret_out_split.reserve(n_grid * nadj);
    for (casadi_int d = 0; d < nadj; ++d) {
      for (casadi_int k = 0; k < n_grid; ++k) {
        ret_out_split.push_back(reshape(integrator_out_split.at((nadj + 1) * k + d + 1),
          size1_in(i), size2_in(i) / n_grid));
      }
    }
    ret_out.push_back(horzcat(ret_out_split));
  }
 
  Dict options = opts;
  options["allow_duplicate_io_names"] = true;
 
  // Create derivative function and return
  return Function(name, ret_in, ret_out, inames, onames, options);
}

References casadi::Integrator::adjmap_out(), casadi::Integrator::augmented_dae(), casadi::Integrator::augmented_options_, casadi::FunctionInternal::Function, casadi::Integrator::getDerivativeOptions(), casadi::Integrator::grid_in(), casadi::Integrator::grid_out(), casadi::integrator(), casadi::integrator_in(), casadi::INTEGRATOR_NUM_IN, casadi::INTEGRATOR_NUM_OUT, casadi::integrator_out(), casadi::Integrator::nadj_, casadi::ProtoFunction::name_, casadi::Integrator::ne_, casadi::Integrator::nrx_, casadi::Integrator::nt(), casadi::FunctionInternal::numel_in(), casadi::FunctionInternal::numel_out(), casadi::PluginInterface< Integrator >::plugin_name(), casadi::FunctionInternal::size1_in(), casadi::FunctionInternal::size2_in(), casadi::Function::size_in(), casadi::FunctionInternal::size_out(), casadi::FunctionInternal::sparsity_in(), casadi::FunctionInternal::sparsity_out(), casadi::str(), casadi::GenericMatrix< MX >::sym(), casadi::Integrator::t0_, casadi::Integrator::tout_, and casadi::ProtoFunction::verbose_.

get_sparsity_in()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 284 of file integrator.cpp.

                                                 {
  switch (static_cast<IntegratorInput>(i)) {
  case INTEGRATOR_X0: return Sparsity::dense(nx1_, 1 + nfwd_);
  case INTEGRATOR_Z0: return Sparsity::dense(nz1_, 1 + nfwd_);
  case INTEGRATOR_P: return Sparsity::dense(np1_, 1 + nfwd_);
  case INTEGRATOR_U: return Sparsity::dense(nu1_, nt() * (1 + nfwd_));
  case INTEGRATOR_ADJ_XF: return Sparsity::dense(nrx1_, nadj_ * (1 + nfwd_) * nt());
  case INTEGRATOR_ADJ_ZF: return Sparsity::dense(nrz1_, nadj_ * (1 + nfwd_) * nt());
  case INTEGRATOR_ADJ_QF: return Sparsity::dense(nrp1_, nadj_ * (1 + nfwd_) * nt());
  case INTEGRATOR_NUM_IN: break;
  }
  return Sparsity();
}

References casadi::Sparsity::dense(), casadi::INTEGRATOR_ADJ_QF, casadi::INTEGRATOR_ADJ_XF, casadi::INTEGRATOR_ADJ_ZF, casadi::INTEGRATOR_NUM_IN, casadi::INTEGRATOR_P, casadi::INTEGRATOR_U, casadi::INTEGRATOR_X0, casadi::INTEGRATOR_Z0, casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nrp1_, casadi::Integrator::nrx1_, casadi::Integrator::nrz1_, casadi::Integrator::nt(), casadi::Integrator::nu1_, casadi::Integrator::nx1_, and casadi::Integrator::nz1_.

get_sparsity_out()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 298 of file integrator.cpp.

                                                  {
  switch (static_cast<IntegratorOutput>(i)) {
  case INTEGRATOR_XF: return Sparsity::dense(nx1_, nt() * (1 + nfwd_));
  case INTEGRATOR_ZF: return Sparsity::dense(nz1_, nt() * (1 + nfwd_));
  case INTEGRATOR_QF: return Sparsity::dense(nq1_, nt() * (1 + nfwd_));
  case INTEGRATOR_ADJ_X0: return Sparsity::dense(nrx1_, nadj_ * (1 + nfwd_));
  case INTEGRATOR_ADJ_Z0: return Sparsity(nrz1_, nadj_ * (1 + nfwd_));  // always zero
  case INTEGRATOR_ADJ_P: return Sparsity::dense(nrq1_, nadj_ * (1 + nfwd_));
  case INTEGRATOR_ADJ_U: return Sparsity::dense(nuq1_, nadj_ * (1 + nfwd_) * nt());
  case INTEGRATOR_NUM_OUT: break;
  }
  return Sparsity();
}

References casadi::Sparsity::dense(), casadi::INTEGRATOR_ADJ_P, casadi::INTEGRATOR_ADJ_U, casadi::INTEGRATOR_ADJ_X0, casadi::INTEGRATOR_ADJ_Z0, casadi::INTEGRATOR_NUM_OUT, casadi::INTEGRATOR_QF, casadi::INTEGRATOR_XF, casadi::INTEGRATOR_ZF, casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::nq1_, casadi::Integrator::nrq1_, casadi::Integrator::nrx1_, casadi::Integrator::nrz1_, casadi::Integrator::nt(), casadi::Integrator::nuq1_, casadi::Integrator::nx1_, and casadi::Integrator::nz1_.

get_stats()

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Reimplemented in casadi::Sqpmethod, casadi::Scpgen, casadi::Qrsqp, casadi::Newton, casadi::ImplicitToNlp, casadi::Feasiblesqpmethod, casadi::FastNewton, casadi::WorhpInterface, casadi::SundialsInterface, casadi::SnoptInterface, casadi::SLEQPInterface, casadi::MadnlpInterface, casadi::KnitroInterface, casadi::IpoptInterface, casadi::FatropInterface, casadi::BonminInterface, casadi::AlpaqaInterface, and casadi::Rootfinder.

Definition at line 459 of file oracle_function.cpp.

                                              {
  Dict stats = FunctionInternal::get_stats(mem);
  //auto m = static_cast<OracleMemory*>(mem);
  return stats;
}

References casadi::FunctionInternal::get_stats().

Referenced by casadi::Nlpsol::get_stats(), casadi::Rootfinder::get_stats(), and casadi::SundialsInterface::get_stats().

get_x()

void casadi::Integrator::get_x ( IntegratorMemory *  m, double *  x  ) const

inherited

Definition at line 2537 of file integrator.cpp.

                                                           {
  casadi_copy(m->x, nx_, x);
}

References casadi::casadi_copy(), casadi::Integrator::nx_, and casadi::IntegratorMemory::x.

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

get_z()

void casadi::Integrator::get_z ( IntegratorMemory *  m, double *  z  ) const

inherited

Definition at line 2541 of file integrator.cpp.

                                                           {
  casadi_copy(m->z, nz_, z);
}

References casadi::casadi_copy(), casadi::Integrator::nz_, and casadi::IntegratorMemory::z.

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

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.

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

getDerivativeOptions()

Dict casadi::Integrator::getDerivativeOptions ( bool  fwd ) const

virtualinherited

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

Definition at line 1800 of file integrator.cpp.

                                                    {
  // Copy all options
  return opts_;
}

References casadi::Integrator::opts_.

Referenced by casadi::Integrator::get_forward(), and casadi::Integrator::get_reverse().

getPlugin()

PluginInterface< Integrator >::Plugin & casadi::PluginInterface< Integrator >::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;
  }

grid_in()

bool casadi::Integrator::grid_in ( casadi_int  i )

staticinherited

Definition at line 312 of file integrator.cpp.

                                     {
  switch (static_cast<IntegratorInput>(i)) {
    case INTEGRATOR_U:
    case INTEGRATOR_ADJ_XF:
    case INTEGRATOR_ADJ_ZF:
    case INTEGRATOR_ADJ_QF:
      return true;
    default: break;
  }
  return false;
}

References casadi::INTEGRATOR_ADJ_QF, casadi::INTEGRATOR_ADJ_XF, casadi::INTEGRATOR_ADJ_ZF, and casadi::INTEGRATOR_U.

Referenced by casadi::Integrator::get_forward(), and casadi::Integrator::get_reverse().

grid_out()

bool casadi::Integrator::grid_out ( casadi_int  i )

staticinherited

Definition at line 324 of file integrator.cpp.

                                      {
  switch (static_cast<IntegratorOutput>(i)) {
    case INTEGRATOR_XF:
    case INTEGRATOR_ZF:
    case INTEGRATOR_QF:
    case INTEGRATOR_ADJ_U:
      return true;
    default: break;
  }
  return false;
}

References casadi::INTEGRATOR_ADJ_U, casadi::INTEGRATOR_QF, casadi::INTEGRATOR_XF, and casadi::INTEGRATOR_ZF.

Referenced by casadi::Integrator::get_forward(), and casadi::Integrator::get_reverse().

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.

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

{ return false;}

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

has_forward()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 317 of file integrator_impl.hpp.

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

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

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

{ 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< Integrator >::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::Integrator::has_reverse ( casadi_int  nadj ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 328 of file integrator_impl.hpp.

{ return ne_ == 0;}

has_spfwd()

bool casadi::Integrator::has_spfwd ( ) const

inlineoverridevirtualinherited

Is the class able to propagate seeds through the algorithm?

Reimplemented from casadi::FunctionInternal.

Definition at line 305 of file integrator_impl.hpp.

{ return true;}

has_sprev()

bool casadi::Integrator::has_sprev ( ) const

inlineoverridevirtualinherited

Is the class able to propagate seeds through the algorithm?

Reimplemented from casadi::FunctionInternal.

Definition at line 306 of file integrator_impl.hpp.

{ return true;}

impulseB()

void casadi::FixedStepIntegrator::impulseB ( IntegratorMemory *  mem, const double *  adj_x, const double *  adj_z, const double *  adj_q  ) const

overridevirtual

Implements casadi::Integrator.

Definition at line 2239 of file integrator.cpp.

                                                                         {
  auto m = static_cast<FixedStepMemory*>(mem);
  // Add impulse to backward parameters
  casadi_axpy(nrp_, 1., adj_q, m->adj_q);
 
  // Add impulse to state
  casadi_axpy(nrx_, 1., adj_x, m->adj_x);
 
  // Add impulse to backwards dependent variables
  casadi_axpy(nrz_, 1., adj_z, m->rv + nrv_ - nrz_);
}

References casadi::casadi_axpy(), casadi::Integrator::nrp_, nrv_, casadi::Integrator::nrx_, and casadi::Integrator::nrz_.

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::FixedStepIntegrator::init ( const Dict &  opts )

overridevirtual

Reimplemented from casadi::Integrator.

Reimplemented in casadi::RungeKutta, casadi::Collocation, and casadi::ImplicitFixedStepIntegrator.

Definition at line 1955 of file integrator.cpp.

                                               {
  // Call the base class init
  Integrator::init(opts);
 
  // Read options
  for (auto&& op : opts) {
    if (op.first=="number_of_finite_elements") {
      nk_target_ = op.second;
    }
  }
 
  // Consistency check
  casadi_assert(nk_target_ > 0, "Number of finite elements must be strictly positive");
 
  // Target interval length
  double h_target = (tout_.back() - t0_) / nk_target_;
 
  // Number of finite elements for each control interval and in total
  disc_.reserve(1 + nt());
  disc_.push_back(0);
  double t_cur = t0_;
  for (double t_next : tout_) {
    disc_.push_back(disc_.back() + std::ceil((t_next - t_cur) / h_target));
    t_cur = t_next;
  }
 
  // Setup discrete time dynamics
  setup_step();
 
  // Get discrete time dimensions
  const Function& F = get_function(has_function("step") ? "step" : "implicit_step");
  nv1_ = F.nnz_out(STEP_VF);
  nrv1_ = nv1_ * nadj_;
  nv_ = nv1_ * (1 + nfwd_);
  nrv_ = nrv1_ * (1 + nfwd_);
 
  // Work vectors, forward problem
  alloc_w(nv_, true); // v
  alloc_w(nv_, true); // v_prev
  alloc_w(nq_, true); // q_prev
 
  // Work vectors, backward problem
  alloc_w(nrv_, true); // rv
  alloc_w(nuq_, true); // adj_u
  alloc_w(nrq_, true); // adj_p_prev
  alloc_w(nuq_, true); // adj_u_prev
 
  // Allocate tape if backward states are present
  if (nrx_ > 0) {
    alloc_w((disc_.back() + 1) * nx_, true); // x_tape
    alloc_w(disc_.back() * nv_, true); // v_tape
  }
}

References casadi::FunctionInternal::alloc_w(), disc_, casadi::OracleFunction::get_function(), casadi::OracleFunction::has_function(), casadi::Integrator::init(), casadi::Integrator::nadj_, casadi::Integrator::nfwd_, nk_target_, casadi::Function::nnz_out(), casadi::Integrator::nq_, casadi::Integrator::nrq_, nrv1_, nrv_, casadi::Integrator::nrx_, casadi::Integrator::nt(), casadi::Integrator::nuq_, nv1_, nv_, casadi::Integrator::nx_, setup_step(), casadi::STEP_VF, casadi::Integrator::t0_, and casadi::Integrator::tout_.

Referenced by casadi::ImplicitFixedStepIntegrator::init(), and casadi::RungeKutta::init().

init_mem()

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

overridevirtual

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

Reimplemented from casadi::Integrator.

Definition at line 2034 of file integrator.cpp.

                                                 {
  if (Integrator::init_mem(mem)) return 1;
  // auto m = static_cast<FixedStepMemory*>(mem);
 
  return 0;
}

References casadi::Integrator::init_mem().

initSingleton()

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

inlineprotectedinherited

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                         {
      casadi_assert_dev(static_cast<Internal*>(this)->count==0);
      static_cast<Internal*>(this)->count++;
    }

instantiate()

Integrator * casadi::PluginInterface< Integrator >::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;
  }

References casadi::Sparsity::dense(), casadi::FunctionInternal::from_compact(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::has_jac_sparsity(), casadi::FunctionInternal::has_spfwd(), casadi::FunctionInternal::has_sprev(), casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::is_diff_out_, casadi::GenericShared< Shared, Internal >::is_null(), casadi::Sparsity::is_symmetric(), casadi::FunctionInternal::jac_sparsity_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::Sparsity::size1(), casadi::Sparsity::size2(), casadi::Sparsity::T(), and casadi::FunctionInternal::to_compact().

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

References casadi::combine(), casadi::FunctionInternal::der_options_, casadi::FunctionInternal::enable_jacobian_, casadi::FunctionInternal::get_jacobian(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::has_jacobian(), casadi::FunctionInternal::incache(), casadi::Function::jacobian(), casadi::FunctionInternal::jacobian_options_, casadi::Function::n_in(), casadi::FunctionInternal::n_in_, casadi::Function::n_out(), casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::str(), casadi::FunctionInternal::tocache_if_missing(), and casadi::FunctionInternal::wrap().

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< Integrator >::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< Integrator >::Plugin casadi::PluginInterface< Integrator >::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().

map2oracle()

template<typename XType >

Function casadi::Integrator::map2oracle ( const std::string &  name, const std::map< std::string, XType > &  d  )

staticinherited

Definition at line 2309 of file integrator.cpp.

                                       {
  std::vector<XType> de_in(DYN_NUM_IN), de_out(DYN_NUM_OUT);
  for (auto&& i : d) {
    if (i.first=="t") {
      de_in[DYN_T]=i.second;
    } else if (i.first=="x") {
      de_in[DYN_X]=i.second;
    } else if (i.first=="z") {
      de_in[DYN_Z]=i.second;
    } else if (i.first=="p") {
      de_in[DYN_P]=i.second;
    } else if (i.first=="u") {
      de_in[DYN_U]=i.second;
    } else if (i.first=="ode") {
      de_out[DYN_ODE]=i.second;
    } else if (i.first=="alg") {
      de_out[DYN_ALG]=i.second;
    } else if (i.first=="quad") {
      de_out[DYN_QUAD]=i.second;
    } else if (i.first=="zero") {
      de_out[DYN_ZERO]=i.second;
    } else {
      casadi_error("No such field: " + i.first);
    }
  }
 
  // Consistency checks, input sparsities
  for (casadi_int i = 0; i < DYN_NUM_IN; ++i) {
    const Sparsity& sp = de_in[i].sparsity();
    if (i == DYN_T) {
      casadi_assert(sp.is_empty() || sp.is_scalar(), "DAE time variable must be empty or scalar. "
        "Got dimension " + str(sp.size()));
    } else {
      casadi_assert(sp.is_empty() || sp.is_vector(), "DAE inputs must be empty or vectors. "
        + dyn_in(i) + " has dimension " + str(sp.size()) + ".");
    }
    casadi_assert(sp.is_dense(), "DAE inputs must be dense . "
      + dyn_in(i) + " is sparse.");
    // Convert row vectors to column vectors
    de_in[i] = vec(de_in[i]);
  }
 
  // Consistency checks, output sparsities
  for (casadi_int i = 0; i < DYN_NUM_OUT; ++i) {
    const Sparsity& sp = de_out[i].sparsity();
    casadi_assert(sp.is_empty() || sp.is_vector(), "DAE outputs must be empty or vectors. "
      + dyn_out(i) + " has dimension " + str(sp.size()));
    // Make sure dense and vector
    de_out[i] = vec(densify(de_out[i]));
  }
 
  // Construct
  return Function(name, de_in, de_out, dyn_in(), dyn_out());
}

References casadi::DYN_ALG, casadi::dyn_in(), casadi::DYN_NUM_IN, casadi::DYN_NUM_OUT, casadi::DYN_ODE, casadi::dyn_out(), casadi::DYN_P, casadi::DYN_QUAD, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::DYN_ZERO, casadi::FunctionInternal::Function, casadi::Sparsity::is_dense(), casadi::Sparsity::is_empty(), casadi::Sparsity::is_scalar(), casadi::Sparsity::is_vector(), casadi::Sparsity::size(), and casadi::str().

Referenced by casadi::integrator().

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

next_stop()

casadi_int casadi::Integrator::next_stop ( casadi_int  k, const double *  u  ) const

inherited

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

Definition at line 2545 of file integrator.cpp.

                                                                    {
  // Integrate till the end if no input signals
  if (nu_ == 0 || u == 0) return nt() - 1;
  // Find the next discontinuity, if any
  for (; k + 1 < nt(); ++k) {
    // Next control value
    const double *u_next = u + nu_;
    // Check if there is any change in input from k to k + 1
    for (casadi_int i = 0; i < nu_; ++i) {
      // Step change detected: stop integration at k
      if (u[i] != u_next[i]) return k;
    }
    // Shift u
    u = u_next;
  }
  // No step changes detected
  return k;
}

References casadi::Integrator::nt(), and casadi::Integrator::nu_.

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

next_stopB()

casadi_int casadi::Integrator::next_stopB ( casadi_int  k, const double *  u  ) const

inherited

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

Definition at line 2717 of file integrator.cpp.

                                                                     {
  // Integrate till the beginning if no input signals
  if (nu_ == 0 || u == 0) return -1;
  // Find the next discontinuity, if any
  for (; k-- > 0; ) {
    // Next control value
    const double *u_next = u - nu_;
    // Check if there is any change in input from k to k + 1
    for (casadi_int i = 0; i < nu_; ++i) {
      // Step change detected: stop integration at k
      if (u[i] != u_next[i]) return k;
    }
    // Shift u
    u = u_next;
  }
  // No step changes detected
  return k;
}

References casadi::Integrator::nu_.

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

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

Referenced by casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_gen(), casadi::JitFunction::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::eval_gen(), casadi::CallbackInternal::finalize(), casadi::FunctionInternal::from_compact(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::generate_in(), casadi::FunctionInternal::get_jac_sparsity(), casadi::Expm::get_jac_sparsity(), casadi::FmuFunction::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::JitFunction::init(), casadi::Nlpsol::init(), casadi::CbcInterface::init(), casadi::ClpInterface::init(), casadi::CplexInterface::init(), casadi::OoqpInterface::init(), casadi::ProxqpInterface::init(), casadi::QpoasesInterface::init(), casadi::ImplicitToNlp::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::nz_in(), casadi::ImplicitToNlp::set_work(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::OoqpInterface::solve(), casadi::ProxqpInterface::solve(), casadi::QpToNlp::solve(), casadi::KinsolInterface::solve(), casadi::FunctionInternal::sp_forward(), and casadi::FunctionInternal::sp_reverse().

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.

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

Referenced by casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_gen(), casadi::Nlpsol::check_inputs(), casadi::JitFunction::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::eval_gen(), casadi::SXFunction::eval_mx(), casadi::Switch::eval_sx(), casadi::CallbackInternal::finalize(), casadi::FunctionInternal::from_compact(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::generate_out(), casadi::FunctionInternal::get_jac_sparsity(), casadi::Expm::get_jac_sparsity(), casadi::FmuFunction::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::JitFunction::init(), casadi::Nlpsol::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::nz_out(), casadi::KinsolInterface::solve(), casadi::FunctionInternal::sp_forward(), and casadi::FunctionInternal::sp_reverse().

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.

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

nt()

casadi_int casadi::Integrator::nt ( ) const

inlineinherited

Definition at line 360 of file integrator_impl.hpp.

{ return tout_.size();}

Referenced by create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::get_sparsity_out(), casadi::IdasInterface::impulseB(), init(), casadi::Integrator::next_stop(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

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.

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

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.

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

{ return oracle_;}

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

plugin_deserialize()

Deserialize casadi::PluginInterface< Integrator >::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()

virtual const char* casadi::PluginInterface< Integrator >::plugin_name ( ) const

pure virtualinherited

Implemented in casadi::RungeKutta, casadi::Collocation, casadi::IdasInterface, and casadi::CvodesInterface.

plugin_options()

const Options & casadi::PluginInterface< Integrator >::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< Integrator >::Plugin casadi::PluginInterface< Integrator >::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;
  }

predict_events()

int casadi::Integrator::predict_events ( IntegratorMemory *  m ) const

inherited

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

Definition at line 2597 of file integrator.cpp.

                                                        {
  // Event time same as stopping time, by default
  double t_event = m->t_stop;
  casadi_int event_index = -1;
  // Calculate m->e and m->edot
  if (calc_edot(m)) return 1;
  // Save the values of the zero-crossing functions
  casadi_copy(m->e, ne_, m->old_e);
  // Find the next event, if any
  for (casadi_int i = 0; i < ne_; ++i) {
    if (!m->event_triggered[i]) {
      // Check if zero crossing function is positive and moving in the negative direction
      if (m->e[i] > 0 && m->edot[i] < 0) {
        // Projected zero-crossing time
        double t = m->t - m->e[i] / m->edot[i];
        // Save if earlier than current t_event
        if (t < t_event) {
          t_event = t;
          event_index = i;
        }
      }
    }
  }
  // Zero crossing projected
  if (event_index >= 0) {
    // Print progress
    if (verbose_) casadi_message("Projected zero crossing for index " + str(event_index)
      + " at t = " + str(t_event));
    // Update t_stop and t_next accordingly
    m->t_stop = t_event;
    m->t_next = std::min(m->t_next, t_event);
  }
  return 0;
}

References casadi::Integrator::calc_edot(), casadi::casadi_copy(), casadi::IntegratorMemory::e, casadi::IntegratorMemory::edot, casadi::IntegratorMemory::event_triggered, casadi::Integrator::ne_, casadi::IntegratorMemory::old_e, casadi::str(), casadi::IntegratorMemory::t, casadi::IntegratorMemory::t_next, casadi::IntegratorMemory::t_stop, and casadi::ProtoFunction::verbose_.

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

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

Referenced by casadi::Feasiblesqpmethod::anderson_acc_step_update(), casadi::Nlpsol::callback(), casadi::Blocksqp::convertHessian(), casadi::FmuFunction::eval_task(), casadi::Feasiblesqpmethod::feasibility_iterations(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::Blocksqp::fullstep(), casadi::Blocksqp::init(), casadi::Feasiblesqpmethod::init(), casadi::Ipqp::init(), casadi::Qrqp::init(), casadi::Qrsqp::init(), casadi::Sqpmethod::init(), casadi::LinsolQr::nfact(), casadi::Feasiblesqpmethod::print_iteration(), casadi::Qrsqp::print_iteration(), casadi::Sqpmethod::print_iteration(), casadi::SundialsInterface::print_stats(), casadi::ProtoFunction::print_time(), casadi::Blocksqp::printInfo(), casadi::Blocksqp::printProgress(), casadi::Blocksqp::run(), casadi::Blocksqp::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_ela_QP(), casadi::Feasiblesqpmethod::solve_LP(), casadi::Feasiblesqpmethod::solve_QP(), casadi::Qrsqp::solve_QP(), casadi::Sqpmethod::solve_QP(), and casadi::Blocksqp::solveQP().

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

virtual void casadi::Integrator::print_stats ( IntegratorMemory *  mem ) const

inlinevirtualinherited

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

Reimplemented in casadi::SundialsInterface.

Definition at line 254 of file integrator_impl.hpp.

{}

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

print_time()

void casadi::ProtoFunction::print_time ( const std::map< std::string, FStats > &  fstats ) const

inherited

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

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

quad_out()

static std::vector<std::string> casadi::Integrator::quad_out ( )

inlinestaticinherited

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

Definition at line 369 of file integrator_impl.hpp.

{ return {"quad"}; }

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

registerPlugin() [1/2]

void casadi::PluginInterface< Integrator >::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< Integrator >::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().

reset()

void casadi::FixedStepIntegrator::reset ( IntegratorMemory *  mem, bool  first_call  ) const

overridevirtual

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

Reimplemented from casadi::Integrator.

Reimplemented in casadi::Collocation.

Definition at line 2206 of file integrator.cpp.

                                                                            {
  auto m = static_cast<FixedStepMemory*>(mem);
 
  // Reset the base classes
  Integrator::reset(mem, first_call);
 
  // Only reset once
  if (first_call) {
    // Get consistent initial conditions
    casadi_fill(m->v, nv_, std::numeric_limits<double>::quiet_NaN());
 
    // Add the first element in the tape
    if (nrx_ > 0) {
      casadi_copy(m->x, nx_, m->x_tape);
    }
  }
}

References casadi::casadi_copy(), casadi::casadi_fill(), casadi::Integrator::nrx_, nv_, casadi::Integrator::nx_, and casadi::Integrator::reset().

Referenced by casadi::Collocation::reset().

resetB()

void casadi::FixedStepIntegrator::resetB ( IntegratorMemory *  mem ) const

overridevirtual

Implements casadi::Integrator.

Definition at line 2224 of file integrator.cpp.

                                                            {
  auto m = static_cast<FixedStepMemory*>(mem);
 
  // Clear adjoint seeds
  casadi_clear(m->adj_q, nrp_);
  casadi_clear(m->adj_x, nrx_);
 
  // Reset summation states
  casadi_clear(m->adj_p, nrq_);
  casadi_clear(m->adj_u, nuq_);
 
  // Update backwards dependent variables
  casadi_clear(m->rv, nrv_);
}

References casadi::casadi_clear(), casadi::Integrator::nrp_, casadi::Integrator::nrq_, nrv_, casadi::Integrator::nrx_, and casadi::Integrator::nuq_.

retreat()

void casadi::FixedStepIntegrator::retreat ( IntegratorMemory *  mem, const double *  u, double *  adj_x, double *  adj_p, double *  adj_u  ) const

overridevirtual

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

Implements casadi::Integrator.

Definition at line 2079 of file integrator.cpp.

                                                       {
  auto m = static_cast<FixedStepMemory*>(mem);
 
  // Set controls
  casadi_copy(u, nu_, m->u);
 
  // Number of finite elements and time steps
  casadi_int nj = disc_[m->k + 1] - disc_[m->k];
  double h = (m->t - m->t_next) / nj;
 
  // Take steps
  for (casadi_int j = nj; j-- > 0; ) {
    // Current time
    double t = m->t_next + j * h;
 
    // Update the previous step
    casadi_copy(m->adj_x, nrx_, m->tmp1);
    casadi_copy(m->adj_p, nrq_, m->adj_p_prev);
    casadi_copy(m->adj_u, nuq_, m->adj_u_prev);
 
    // Take step
    casadi_int tapeind = disc_[m->k] + j;
    stepB(m, t, h,
      m->x_tape + nx_ * tapeind, m->x_tape + nx_ * (tapeind + 1),
      m->v_tape + nv_ * tapeind,
      m->tmp1, m->rv, m->adj_x, m->adj_p, m->adj_u);
    casadi_clear(m->rv, nrv_);
    casadi_axpy(nrq_, 1., m->adj_p_prev, m->adj_p);
    casadi_axpy(nuq_, 1., m->adj_u_prev, m->adj_u);
  }
 
  // Return to user
  casadi_copy(m->adj_x, nrx_, adj_x);
  casadi_copy(m->adj_p, nrq_, adj_p);
  casadi_copy(m->adj_u, nuq_, adj_u);
}

References casadi::casadi_axpy(), casadi::casadi_clear(), casadi::casadi_copy(), disc_, casadi::Integrator::nrq_, nrv_, casadi::Integrator::nrx_, casadi::Integrator::nu_, casadi::Integrator::nuq_, nv_, casadi::Integrator::nx_, and stepB().

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

References casadi::Function::assert_size_in(), casadi::Function::assert_sparsity_out(), casadi::combine(), casadi::FunctionInternal::der_options_, casadi::FunctionInternal::diff_prefix(), casadi::FunctionInternal::enable_reverse_, casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::get_reverse(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::incache(), casadi::Function::n_in(), casadi::FunctionInternal::n_in_, casadi::Function::n_out(), casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::Function::reverse(), casadi::FunctionInternal::reverse_name(), casadi::FunctionInternal::reverse_options_, casadi::FunctionInternal::size1_in(), casadi::FunctionInternal::size1_out(), casadi::FunctionInternal::size2_in(), casadi::FunctionInternal::size2_out(), casadi::FunctionInternal::sparsity_in(), casadi::FunctionInternal::tocache_if_missing(), and casadi::FunctionInternal::wrap().

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

{ 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::Integrator::serialize_base_function ( ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Definition at line 479 of file integrator_impl.hpp.

{ return "Integrator"; }

serialize_body()

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

overridevirtual

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

Reimplemented from casadi::Integrator.

Reimplemented in casadi::RungeKutta, casadi::Collocation, and casadi::ImplicitFixedStepIntegrator.

Definition at line 2480 of file integrator.cpp.

                                                                   {
  Integrator::serialize_body(s);
 
  s.version("FixedStepIntegrator", 3);
  s.pack("FixedStepIntegrator::nk_target", nk_target_);
  s.pack("FixedStepIntegrator::disc", disc_);
  s.pack("FixedStepIntegrator::nv", nv_);
  s.pack("FixedStepIntegrator::nv1", nv1_);
  s.pack("FixedStepIntegrator::nrv", nrv_);
  s.pack("FixedStepIntegrator::nrv1", nrv1_);
}

References disc_, nk_target_, nrv1_, nrv_, nv1_, nv_, casadi::SerializingStream::pack(), casadi::Integrator::serialize_body(), and casadi::SerializingStream::version().

Referenced by casadi::ImplicitFixedStepIntegrator::serialize_body(), and casadi::RungeKutta::serialize_body().

serialize_type()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 2419 of file integrator.cpp.

                                                          {
  OracleFunction::serialize_type(s);
  PluginInterface<Integrator>::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.

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

void casadi::Integrator::set_p ( IntegratorMemory *  m, const double *  p  ) const

inherited

Definition at line 2525 of file integrator.cpp.

                                                                 {
  casadi_copy(p, np_, m->p);
}

References casadi::casadi_copy(), casadi::Integrator::np_, and casadi::IntegratorMemory::p.

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

set_q()

void casadi::Integrator::set_q ( IntegratorMemory *  m, const double *  q  ) const

inherited

Definition at line 2513 of file integrator.cpp.

                                                                 {
  casadi_copy(q, nq_, m->q);
}

References casadi::casadi_copy(), casadi::Integrator::nq_, and casadi::IntegratorMemory::q.

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

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

void casadi::Integrator::set_u ( IntegratorMemory *  m, const double *  u  ) const

inherited

Definition at line 2529 of file integrator.cpp.

                                                                 {
  casadi_copy(u, nu_, m->u);
}

References casadi::casadi_copy(), casadi::Integrator::nu_, and casadi::IntegratorMemory::u.

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

set_work()

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

overridevirtual

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

Reimplemented from casadi::Integrator.

Definition at line 2009 of file integrator.cpp.

                                       {
  auto m = static_cast<FixedStepMemory*>(mem);
 
  // Set work in base classes
  Integrator::set_work(mem, arg, res, iw, w);
 
  // Work vectors, forward problem
  m->v = w; w += nv_;
  m->v_prev = w; w += nv_;
  m->q_prev = w; w += nq_;
 
  // Work vectors, backward problem
  m->rv = w; w += nrv_;
  m->adj_u = w; w += nuq_;
  m->adj_p_prev = w; w += nrq_;
  m->adj_u_prev = w; w += nuq_;
 
  // Allocate tape if backward states are present
  if (nrx_ > 0) {
    m->x_tape = w; w += (disc_.back() + 1) * nx_;
    m->v_tape = w; w += disc_.back() * nv_;
  }
}

References disc_, casadi::Integrator::nq_, casadi::Integrator::nrq_, nrv_, casadi::Integrator::nrx_, casadi::Integrator::nuq_, nv_, casadi::Integrator::nx_, and casadi::Integrator::set_work().

set_x()

void casadi::Integrator::set_x ( IntegratorMemory *  m, const double *  x  ) const

inherited

Definition at line 2517 of file integrator.cpp.

                                                                 {
  casadi_copy(x, nx_, m->x);
}

References casadi::casadi_copy(), casadi::Integrator::nx_, and casadi::IntegratorMemory::x.

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

set_z()

void casadi::Integrator::set_z ( IntegratorMemory *  m, const double *  z  ) const

inherited

Definition at line 2521 of file integrator.cpp.

                                                                 {
  casadi_copy(z, nz_, m->z);
}

References casadi::casadi_copy(), casadi::Integrator::nz_, and casadi::IntegratorMemory::z.

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

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

setup_step()

virtual void casadi::FixedStepIntegrator::setup_step ( )

pure virtual

Implemented in casadi::RungeKutta, and casadi::Collocation.

Referenced by init().

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

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.

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

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

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

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

sp_forward()

int casadi::Integrator::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_1m5

Reimplemented from casadi::FunctionInternal.

Definition at line 1147 of file integrator.cpp.

                                                {
  if (verbose_) casadi_message(name_ + "::sp_forward");
 
  // Inputs
  const bvec_t* x0 = arg[INTEGRATOR_X0];
  const bvec_t* p = arg[INTEGRATOR_P];
  const bvec_t* u = arg[INTEGRATOR_U];
  const bvec_t* adj_xf = arg[INTEGRATOR_ADJ_XF];
  const bvec_t* adj_qf = arg[INTEGRATOR_ADJ_QF];
  arg += n_in_;
 
  // Outputs
  bvec_t* xf = res[INTEGRATOR_XF];
  bvec_t* zf = res[INTEGRATOR_ZF];
  bvec_t* qf = res[INTEGRATOR_QF];
  bvec_t* adj_x0 = res[INTEGRATOR_ADJ_X0];
  bvec_t* adj_p0 = res[INTEGRATOR_ADJ_P];
  bvec_t* adj_u = res[INTEGRATOR_ADJ_U];
  res += n_out_;
 
  // Work vectors
  bvec_t *x = w; w += nx_;
 
  bvec_t *adj_x = w; w += nrx_;
  bvec_t *adj_z = w; w += nrz_;
  bvec_t *adj_p = w; w += nrq_;
 
  bvec_t *tmp1 = w; w += nx_ + nz_;
  bvec_t *tmp2 = w; w += nrx_;
 
  // Memory struct for function calls below
  SpForwardMem m = {arg, res, iw, w};
 
  // Copy initial guess to x
  std::copy_n(x0, nx_, x);
 
  // Propagate forward
  for (casadi_int k = 0; k < nt(); ++k) {
    // Propagate through DAE function
    if (fdae_sp_forward(&m, x, p, u, tmp1, tmp1 + nx_)) return 1;
    for (casadi_int i = 0; i < nx_; ++i) tmp1[i] |= x[i];
 
    // "Solve" in order to resolve interdependencies (cf. Rootfinder)
    std::copy_n(tmp1, nx_ + nx_, w);
    std::fill_n(tmp1, nx_ + nz_, 0);
    sp_jac_dae_.spsolve(tmp1, w, false);
 
    // Get xf and zf
    if (xf) std::copy_n(tmp1, nx_, xf);
    if (zf) std::copy_n(tmp1 + nx_, nz_, zf);
 
    // Propagate to quadratures
    if (nq_ > 0 && qf) {
      if (fquad_sp_forward(&m, tmp1, tmp1 + nx_, p, u, qf)) return 1;
    }
 
    // Shift time
    std::copy_n(tmp1, nx_, x);
    if (xf) xf += nx_;
    if (zf) zf += nz_;
    if (qf) qf += nq_;
    if (u) u += nu_;
  }
 
  if (nrx_ > 0) {
    // Clear tmp2, adj_p0
    std::fill_n(tmp2, nrx_, 0);
    if (adj_p0) std::fill_n(adj_p0, nrq_, 0);
 
    // Take adj_xf, rp, adj_u past the last grid point
    if (adj_xf) adj_xf += nrx_ * nt();
    if (adj_qf) adj_qf += nrp_ * nt();
    if (adj_u) adj_u += nuq_ * nt();
 
    // Integrate backward
    for (casadi_int k = nt(); k-- > 0; ) {
      // Shift time
      if (adj_xf) adj_xf -= nrx_;
      if (adj_qf) adj_qf -= nrp_;
      if (adj_u) adj_u -= nuq_;
      if (u) u -= nu_;
 
      // Add impulse from adj_xf
      if (adj_xf) {
        for (casadi_int i = 0; i < nrx_; ++i) tmp2[i] |= adj_xf[i];
      }
 
      // Propagate through DAE function
      if (bdae_sp_forward(&m, tmp1, tmp1 + nx_, p, u, tmp2, adj_qf, adj_x, adj_z)) return 1;
      for (casadi_int i = 0; i < nrx_; ++i) adj_x[i] |= tmp2[i];
 
      // "Solve" in order to resolve interdependencies (cf. Rootfinder)
      std::copy_n(adj_x, nrx_ + nrz_, w);
      std::fill_n(adj_x, nrx_ + nrz_, 0);
      sp_jac_rdae_.spsolve(adj_x, w, false);
 
      // Propagate to quadratures
      if ((nrq_ > 0 && adj_p0) || (nuq_ > 0 && adj_u)) {
        if (bquad_sp_forward(&m, tmp1, tmp1 + nx_, p, u, adj_x, adj_z, adj_qf, adj_p, adj_u))
          return 1;
        // Sum contributions to adj_p0
        if (adj_p0) {
          for (casadi_int i = 0; i < nrq_; ++i) adj_p0[i] |= adj_p[i];
        }
      }
 
      // Update tmp2
      std::copy_n(adj_x, nx_, tmp2);
    }
 
    // Get adj_x0 at initial time
    if (adj_x0) std::copy_n(adj_x, nrx_, adj_x0);
  }
  return 0;
}

References casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::fdae_sp_forward(), casadi::Integrator::fquad_sp_forward(), casadi::INTEGRATOR_ADJ_P, casadi::INTEGRATOR_ADJ_QF, casadi::INTEGRATOR_ADJ_U, casadi::INTEGRATOR_ADJ_X0, casadi::INTEGRATOR_ADJ_XF, casadi::INTEGRATOR_P, casadi::INTEGRATOR_QF, casadi::INTEGRATOR_U, casadi::INTEGRATOR_X0, casadi::INTEGRATOR_XF, casadi::INTEGRATOR_ZF, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::Integrator::nq_, casadi::Integrator::nrp_, casadi::Integrator::nrq_, casadi::Integrator::nrx_, casadi::Integrator::nrz_, casadi::Integrator::nt(), casadi::Integrator::nu_, casadi::Integrator::nuq_, casadi::Integrator::nx_, casadi::Integrator::nz_, casadi::Integrator::sp_jac_dae_, casadi::Integrator::sp_jac_rdae_, casadi::Sparsity::spsolve(), and casadi::ProtoFunction::verbose_.

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

Sparsity casadi::Integrator::sp_jac_aug ( const Sparsity &  J, const Sparsity &  J1  ) const

inherited

Definition at line 1805 of file integrator.cpp.

                                                                           {
  // Row 1, column 2 in the augmented Jacobian
  Sparsity J12(J.size1(), nfwd_ * J.size2());
  // Row 2, column 1 in the augmented Jacobian
  Sparsity J21 = vertcat(std::vector<Sparsity>(nfwd_, J1));
  // Row 2, column 2 in the augmented Jacobian
  Sparsity J22 = diagcat(std::vector<Sparsity>(nfwd_, J));
  // Form block matrix
  return blockcat(J, J12, J21, J22);
}

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

Referenced by casadi::Integrator::sp_jac_dae(), and casadi::Integrator::sp_jac_rdae().

sp_jac_dae()

Sparsity casadi::Integrator::sp_jac_dae ( )

inherited

Definition at line 1817 of file integrator.cpp.

                                {
  // Get the functions
  const Function& F = get_function("daeF");
  // Sparsity pattern for nonaugmented system
  Sparsity J_xx = F.jac_sparsity(DAE_ODE, DYN_X) + Sparsity::diag(nx1_);
  Sparsity J_xz = F.jac_sparsity(DAE_ODE, DYN_Z);
  Sparsity J_zx = F.jac_sparsity(DAE_ALG, DYN_X);
  Sparsity J_zz = F.jac_sparsity(DAE_ALG, DYN_Z);
  // Augment with sensitivity equations
  if (nfwd_ > 0) {
    const Function& fwd_F = get_function(forward_name("daeF", 1));
    J_xx = sp_jac_aug(J_xx, fwd_F.jac_sparsity(DAE_ODE, DYN_X));
    J_xz = sp_jac_aug(J_xz, fwd_F.jac_sparsity(DAE_ODE, DYN_Z));
    J_zx = sp_jac_aug(J_zx, fwd_F.jac_sparsity(DAE_ALG, DYN_X));
    J_zz = sp_jac_aug(J_zz, fwd_F.jac_sparsity(DAE_ALG, DYN_Z));
  }
  // Assemble the block matrix
  return blockcat(J_xx, J_xz, J_zx, J_zz);
}

References casadi::Integrator::DAE_ALG, casadi::Integrator::DAE_ODE, casadi::Sparsity::diag(), casadi::DYN_X, casadi::DYN_Z, casadi::FunctionInternal::forward_name(), casadi::OracleFunction::get_function(), casadi::Function::jac_sparsity(), casadi::Integrator::nfwd_, casadi::Integrator::nx1_, and casadi::Integrator::sp_jac_aug().

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

sp_jac_rdae()

Sparsity casadi::Integrator::sp_jac_rdae ( )

inherited

Definition at line 1837 of file integrator.cpp.

                                 {
  // Get the functions
  const Function& G = get_function("daeB");
  // Sparsity pattern for nonaugmented system
  Sparsity J_xx = G.jac_sparsity(BDAE_ADJ_X, BDYN_ADJ_ODE) + Sparsity::diag(nrx1_ * nadj_);
  Sparsity J_xz = G.jac_sparsity(BDAE_ADJ_X, BDYN_ADJ_ALG);
  Sparsity J_zx = G.jac_sparsity(BDAE_ADJ_Z, BDYN_ADJ_ODE);
  Sparsity J_zz = G.jac_sparsity(BDAE_ADJ_Z, BDYN_ADJ_ALG);
  // Augment with sensitivity equations
  if (nfwd_ > 0) {
    const Function& fwd_G = get_function(forward_name("daeB", 1));
    J_xx = sp_jac_aug(J_xx, fwd_G.jac_sparsity(BDAE_ADJ_X, BDYN_ADJ_ODE));
    J_xz = sp_jac_aug(J_xz, fwd_G.jac_sparsity(BDAE_ADJ_X, BDYN_ADJ_ALG));
    J_zx = sp_jac_aug(J_zx, fwd_G.jac_sparsity(BDAE_ADJ_Z, BDYN_ADJ_ODE));
    J_zz = sp_jac_aug(J_zz, fwd_G.jac_sparsity(BDAE_ADJ_Z, BDYN_ADJ_ALG));
  }
  // Assemble the block matrix
  return blockcat(J_xx, J_xz, J_zx, J_zz);
}

References casadi::Integrator::BDAE_ADJ_X, casadi::Integrator::BDAE_ADJ_Z, casadi::Integrator::BDYN_ADJ_ALG, casadi::Integrator::BDYN_ADJ_ODE, casadi::Sparsity::diag(), casadi::FunctionInternal::forward_name(), casadi::OracleFunction::get_function(), casadi::Function::jac_sparsity(), casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::nrx1_, and casadi::Integrator::sp_jac_aug().

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

sp_reverse()

int casadi::Integrator::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_1m6

Reimplemented from casadi::FunctionInternal.

Definition at line 1412 of file integrator.cpp.

                                                {
  if (verbose_) casadi_message(name_ + "::sp_reverse");
 
  // Inputs
  bvec_t* x0 = arg[INTEGRATOR_X0];
  bvec_t* p = arg[INTEGRATOR_P];
  bvec_t* u = arg[INTEGRATOR_U];
  bvec_t* adj_xf = arg[INTEGRATOR_ADJ_XF];
  bvec_t* adj_qf = arg[INTEGRATOR_ADJ_QF];
  arg += n_in_;
 
  // Outputs
  bvec_t* xf = res[INTEGRATOR_XF];
  bvec_t* zf = res[INTEGRATOR_ZF];
  bvec_t* qf = res[INTEGRATOR_QF];
  bvec_t* adj_x0 = res[INTEGRATOR_ADJ_X0];
  bvec_t* adj_p0 = res[INTEGRATOR_ADJ_P];
  bvec_t* adj_u = res[INTEGRATOR_ADJ_U];
  res += n_out_;
 
  // Work vectors
  bvec_t *x = w; w += nx_;
 
  bvec_t *adj_x = w; w += nrx_;
  bvec_t *adj_z = w; w += nrz_;
  bvec_t *adj_p = w; w += nrq_;
 
  bvec_t *tmp1 = w; w += nx_ + nz_;
  bvec_t *tmp2 = w; w += nrx_;
 
  // Memory struct for function calls below
  SpReverseMem m = {arg, res, iw, w};
 
  // Clear state vector
  std::fill_n(tmp1, nx_ + nz_, 0);
 
  if (nrx_ > 0) {
    // Propagate from adj_x0 initial time
    if (adj_x0) {
      std::copy_n(adj_x0, nrx_, adj_x);
      std::fill_n(adj_x0, nrx_, 0);
    } else {
      std::fill_n(adj_x, nrx_, 0);
    }
    // Reset adj_z
    std::fill_n(adj_z, nrz_, 0);
 
    // Save adj_p0: See note below
    if (adj_p0) std::copy_n(adj_p0, nrq_, adj_p);
 
    // Step backwards through backward problem
    for (casadi_int k = 0; k < nt(); ++k) {
      // Restore adj_p0: See note below
      if (adj_p0) std::copy_n(adj_p, nrq_, adj_p0);
 
      // Add impulse from adj_xf
      if (adj_xf) {
        for (casadi_int i = 0; i < nrx_; ++i) adj_x[i] |= adj_xf[i];
        std::fill_n(adj_xf, nrx_, 0);
      }
 
      // Get dependencies from backward quadratures
      if ((nrq_ > 0 && adj_p0) || (nuq_ > 0 && adj_u)) {
        if (bquad_sp_reverse(&m, tmp1, tmp1 + nx_, p, u, adj_x, adj_z, adj_qf, adj_p0, adj_u))
          return 1;
      }
 
      // Propagate interdependencies
      std::fill_n(w, nrx_ + nrz_, 0);
      sp_jac_rdae_.spsolve(w, adj_x, true);
      std::copy_n(w, nrx_ + nrz_, adj_x);
 
      // Direct dependency tmp2 -> adj_x
      std::copy_n(adj_x, nrx_, tmp2);
 
      // Indirect dependency via g
      if (bdae_sp_reverse(&m, tmp1, tmp1 + nx_, p, u, tmp2, adj_qf, adj_x, adj_z)) return 1;
 
      // Update adj_x, adj_z
      std::copy_n(tmp2, nrx_, adj_x);
      std::fill_n(adj_z, nrz_, 0);
 
      // Shift time
      if (adj_xf) adj_xf += nrx_;
      if (adj_qf) adj_qf += nrp_;
      if (adj_u) adj_u += nuq_;
      if (u) u += nu_;
    }
  } else {
    // Take u past the last grid point
    if (u) u += nu_ * nt();
  }
 
  // Take xf, zf, qf past the last grid point
  if (xf) xf += nx_ * nt();
  if (zf) zf += nz_ * nt();
  if (qf) qf += nq_ * nt();
 
  // Step backwards through forward problem
  for (casadi_int k = nt(); k-- > 0; ) {
    // Shift time
    if (xf) xf -= nx_;
    if (zf) zf -= nz_;
    if (qf) qf -= nq_;
    if (u) u -= nu_;
 
    // Add impulse from outputs
    if (xf) {
      for (casadi_int i = 0; i < nx_; ++i) tmp1[i] |= xf[i];
      std::fill_n(xf, nx_, 0);
    }
    if (zf) {
      for (casadi_int i = 0; i < nz_; ++i) tmp1[nx_ + i] |= zf[i];
      std::fill_n(zf, nz_, 0);
    }
 
    // Get dependencies from forward quadratures, if any
    if (nq_ > 0 && qf) {
      if (fquad_sp_reverse(&m, tmp1, tmp1 + nx_, p, u, qf)) return 1;
    }
 
    // Propagate interdependencies
    std::fill_n(w, nx_ + nz_, 0);
    sp_jac_dae_.spsolve(w, tmp1, true);
    std::copy_n(w, nx_ + nz_, tmp1);
 
    // Direct dependency ode -> x
    std::copy_n(tmp1, nx_, x);
 
    // Indirect dependency through f
    if (fdae_sp_reverse(&m, x, p, u, tmp1, tmp1 + nx_)) return 1;
 
    // Update x, z
    std::copy_n(x, nx_, tmp1);
    std::fill_n(tmp1 + nx_, nz_, 0);
  }
 
  // Direct dependency x0 -> x
  if (x0) {
    for (casadi_int i = 0; i < nx_; ++i) x0[i] |= x[i];
  }
 
  return 0;
}

References casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_reverse(), casadi::Integrator::fdae_sp_reverse(), casadi::Integrator::fquad_sp_reverse(), casadi::INTEGRATOR_ADJ_P, casadi::INTEGRATOR_ADJ_QF, casadi::INTEGRATOR_ADJ_U, casadi::INTEGRATOR_ADJ_X0, casadi::INTEGRATOR_ADJ_XF, casadi::INTEGRATOR_P, casadi::INTEGRATOR_QF, casadi::INTEGRATOR_U, casadi::INTEGRATOR_X0, casadi::INTEGRATOR_XF, casadi::INTEGRATOR_ZF, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::Integrator::nq_, casadi::Integrator::nrp_, casadi::Integrator::nrq_, casadi::Integrator::nrx_, casadi::Integrator::nrz_, casadi::Integrator::nt(), casadi::Integrator::nu_, casadi::Integrator::nuq_, casadi::Integrator::nx_, casadi::Integrator::nz_, casadi::Integrator::sp_jac_dae_, casadi::Integrator::sp_jac_rdae_, casadi::Sparsity::spsolve(), and casadi::ProtoFunction::verbose_.

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

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

Definition at line 1004 of file function_internal.hpp.

{ return sparsity_in_.at(ind); }

Referenced by casadi::FunctionInternal::check_arg(), create_advanced(), casadi::FunctionInternal::dm_in(), casadi::FunctionInternal::from_compact(), casadi::FunctionInternal::fwd_seed(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::JitFunction::JitFunction(), casadi::FunctionInternal::mx_in(), casadi::FunctionInternal::project_arg(), casadi::FunctionInternal::replace_arg(), casadi::FunctionInternal::reverse(), casadi::HpipmInterface::set_hpipm_prob(), casadi::FunctionInternal::sx_in(), and casadi::FunctionInternal::to_compact().

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.

{ return sparsity_out_.at(ind); }

Referenced by casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::check_res(), casadi::FunctionInternal::dm_out(), casadi::FmuFunction::eval(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::from_compact(), casadi::Integrator::get_reverse(), casadi::FmuFunction::init(), casadi::JitFunction::JitFunction(), casadi::FunctionInternal::mx_out(), casadi::FunctionInternal::replace_res(), casadi::FunctionInternal::sx_out(), and casadi::FunctionInternal::to_compact().

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

stepB()

void casadi::FixedStepIntegrator::stepB	(	FixedStepMemory *	m,
		double	t,
		double	h,
		const double *	x0,
		const double *	xf,
		const double *	vf,
		const double *	adj_xf,
		const double *	rv0,
		double *	adj_x0,
		double *	adj_p,
		double *	adj_u
	)		const

Definition at line 2150 of file integrator.cpp.

                                                        {
  // Evaluate nondifferentiated
  std::fill(m->arg, m->arg + BSTEP_NUM_IN, nullptr);
  m->arg[BSTEP_T] = &t;  // t
  m->arg[BSTEP_H] = &h;  // h
  m->arg[BSTEP_X0] = x0;  // x0
  m->arg[BSTEP_V0] = nullptr;  // v0
  m->arg[BSTEP_P] = m->p;  // p
  m->arg[BSTEP_U] = m->u;  // u
  m->arg[BSTEP_OUT_XF] = xf;  // out:xf
  m->arg[BSTEP_OUT_VF] = vf;  // out:vf
  m->arg[BSTEP_OUT_QF] = nullptr;  // out:qf
  m->arg[BSTEP_ADJ_XF] = adj_xf;  // adj:xf
  m->arg[BSTEP_ADJ_VF] = rv0;  // adj:vf
  m->arg[BSTEP_ADJ_QF] = m->adj_q;  // adj:qf
  std::fill(m->res, m->res + BSTEP_NUM_OUT, nullptr);
  m->res[BSTEP_ADJ_T] = nullptr;  // adj:t
  m->res[BSTEP_ADJ_H] = nullptr;  // adj:h
  m->res[BSTEP_ADJ_X0] = adj_x0;  // adj:x0
  m->res[BSTEP_ADJ_V0] = nullptr;  // adj:v0
  m->res[BSTEP_ADJ_P] = adj_p;  // adj:p
  m->res[BSTEP_ADJ_U] = adj_u;  // adj:u
  calc_function(m, reverse_name("step", nadj_));
  // Evaluate sensitivities
  if (nfwd_ > 0) {
    m->arg[BSTEP_NUM_IN + BSTEP_ADJ_T] = nullptr;  // out:adj:t
    m->arg[BSTEP_NUM_IN + BSTEP_ADJ_H] = nullptr;  // out:adj:h
    m->arg[BSTEP_NUM_IN + BSTEP_ADJ_X0] = adj_x0;  // out:adj:x0
    m->arg[BSTEP_NUM_IN + BSTEP_ADJ_V0] = nullptr;  // out:adj:v0
    m->arg[BSTEP_NUM_IN + BSTEP_ADJ_P] = adj_p;  // out:adj:p
    m->arg[BSTEP_NUM_IN + BSTEP_ADJ_U] = adj_u;  // out:adj:u
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_T] = nullptr;  // fwd:t
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_H] = nullptr;  // fwd:h
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_X0] = x0 + nx1_;  // fwd:x0
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_V0] = nullptr;  // fwd:v0
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_P] = m->p + np1_;  // fwd:p
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_U] = m->u + nu1_;  // fwd:u
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_OUT_XF] = xf + nx1_;  // fwd:out:xf
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_OUT_VF] = vf + nv1_;  // fwd:out:vf
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_OUT_QF] = nullptr;  // fwd:out:qf
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_ADJ_XF] = adj_xf + nrx1_ * nadj_;  // fwd:adj:xf
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_ADJ_VF] = rv0 + nrv1_;  // fwd:adj:vf
    m->arg[BSTEP_NUM_IN + BSTEP_NUM_OUT + BSTEP_ADJ_QF] = m->adj_q + nrp1_ * nadj_;  // fwd:adj:qf
    m->res[BSTEP_ADJ_T] = nullptr;  // fwd:adj:t
    m->res[BSTEP_ADJ_H] = nullptr;  // fwd:adj:h
    m->res[BSTEP_ADJ_X0] = adj_x0 + nrx1_ * nadj_;  // fwd:adj_x0
    m->res[BSTEP_ADJ_V0] = nullptr;  // fwd:adj:v0
    m->res[BSTEP_ADJ_P] = adj_p + nrq1_ * nadj_;  // fwd:adj_p
    m->res[BSTEP_ADJ_U] = adj_u + nuq1_ * nadj_;  // fwd:adj_u
    calc_function(m, forward_name(reverse_name("step", nadj_), nfwd_));
  }
}

References casadi::IntegratorMemory::adj_q, casadi::OracleMemory::arg, casadi::BSTEP_ADJ_H, casadi::BSTEP_ADJ_P, casadi::BSTEP_ADJ_QF, casadi::BSTEP_ADJ_T, casadi::BSTEP_ADJ_U, casadi::BSTEP_ADJ_V0, casadi::BSTEP_ADJ_VF, casadi::BSTEP_ADJ_X0, casadi::BSTEP_ADJ_XF, casadi::BSTEP_H, casadi::BSTEP_NUM_IN, casadi::BSTEP_NUM_OUT, casadi::BSTEP_OUT_QF, casadi::BSTEP_OUT_VF, casadi::BSTEP_OUT_XF, casadi::BSTEP_P, casadi::BSTEP_T, casadi::BSTEP_U, casadi::BSTEP_V0, casadi::BSTEP_X0, casadi::OracleFunction::calc_function(), casadi::FunctionInternal::forward_name(), casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nrp1_, casadi::Integrator::nrq1_, nrv1_, casadi::Integrator::nrx1_, casadi::Integrator::nu1_, casadi::Integrator::nuq1_, nv1_, casadi::Integrator::nx1_, casadi::IntegratorMemory::p, casadi::OracleMemory::res, casadi::FunctionInternal::reverse_name(), and casadi::IntegratorMemory::u.

Referenced by retreat().

stepF()

void casadi::FixedStepIntegrator::stepF	(	FixedStepMemory *	m,
		double	t,
		double	h,
		const double *	x0,
		const double *	v0,
		double *	xf,
		double *	vf,
		double *	qf
	)		const

Definition at line 2117 of file integrator.cpp.

                                                                                  {
  // Evaluate nondifferentiated
  std::fill(m->arg, m->arg + STEP_NUM_IN, nullptr);
  m->arg[STEP_T] = &t;  // t
  m->arg[STEP_H] = &h;  // h
  m->arg[STEP_X0] = x0;  // x0
  m->arg[STEP_V0] = v0;  // v0
  m->arg[STEP_P] = m->p;  // p
  m->arg[STEP_U] = m->u;  // u
  std::fill(m->res, m->res + STEP_NUM_OUT, nullptr);
  m->res[STEP_XF] = xf;  // xf
  m->res[STEP_VF] = vf;  // vf
  m->res[STEP_QF] = qf;  // qf
  calc_function(m, "step");
  // Evaluate sensitivities
  if (nfwd_ > 0) {
    m->arg[STEP_NUM_IN + STEP_XF] = xf;  // out:xf
    m->arg[STEP_NUM_IN + STEP_VF] = vf;  // out:vf
    m->arg[STEP_NUM_IN + STEP_QF] = qf;  // out:qf
    m->arg[STEP_NUM_IN + STEP_NUM_OUT + STEP_T] = nullptr;  // fwd:t
    m->arg[STEP_NUM_IN + STEP_NUM_OUT + STEP_H] = nullptr;  // fwd:h
    m->arg[STEP_NUM_IN + STEP_NUM_OUT + STEP_X0] = x0 + nx1_;  // fwd:x0
    m->arg[STEP_NUM_IN + STEP_NUM_OUT + STEP_V0] = v0 + nv1_;  // fwd:v0
    m->arg[STEP_NUM_IN + STEP_NUM_OUT + STEP_P] = m->p + np1_;  // fwd:p
    m->arg[STEP_NUM_IN + STEP_NUM_OUT + STEP_U] = m->u + nu1_;  // fwd:u
    m->res[STEP_XF] = xf + nx1_;  // fwd:xf
    m->res[STEP_VF] = vf + nv1_;  // fwd:vf
    m->res[STEP_QF] = qf + nq1_;  // fwd:qf
    calc_function(m, forward_name("step", nfwd_));
  }
}

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::FunctionInternal::forward_name(), casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nq1_, casadi::Integrator::nu1_, nv1_, casadi::Integrator::nx1_, casadi::IntegratorMemory::p, casadi::OracleMemory::res, casadi::STEP_H, casadi::STEP_NUM_IN, casadi::STEP_NUM_OUT, casadi::STEP_P, casadi::STEP_QF, casadi::STEP_T, casadi::STEP_U, casadi::STEP_V0, casadi::STEP_VF, casadi::STEP_X0, casadi::STEP_XF, and casadi::IntegratorMemory::u.

Referenced by advance_noevent().

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.

{ return sz_arg_per_ + sz_arg_tmp_;}

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::alloc_arg(), casadi::FunctionInternal::call_gen(), casadi::OmpMap::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sz_arg(), casadi::OmpMap::eval(), casadi::MXFunction::eval_sx(), casadi::OracleFunction::finalize(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::External::init(), casadi::Nlpsol::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::Qrqp::init(), and casadi::FunctionInternal::sz_work().

sz_iw()

size_t casadi::FunctionInternal::sz_iw ( ) const

inlineinherited

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

Definition at line 1177 of file function_internal.hpp.

{ return sz_iw_per_ + sz_iw_tmp_;}

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::alloc_iw(), casadi::FunctionInternal::call_gen(), casadi::OmpMap::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sz_iw(), casadi::OmpMap::eval(), casadi::OracleFunction::finalize(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::External::init(), casadi::Nlpsol::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Qrqp::init(), casadi::Sqpmethod::init(), and casadi::FunctionInternal::sz_work().

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.

{ return sz_res_per_ + sz_res_tmp_;}

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::alloc_res(), casadi::FunctionInternal::call_gen(), casadi::OmpMap::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sz_res(), casadi::OmpMap::eval(), casadi::MXFunction::eval_sx(), casadi::OracleFunction::finalize(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::External::init(), casadi::Nlpsol::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::Qrqp::init(), and casadi::FunctionInternal::sz_work().

sz_w()

size_t casadi::FunctionInternal::sz_w ( ) const

inlineinherited

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

Definition at line 1182 of file function_internal.hpp.

{ return sz_w_per_ + sz_w_tmp_;}

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::alloc_w(), casadi::FunctionInternal::call_gen(), casadi::OmpMap::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sz_w(), casadi::SXFunction::codegen_sz_w(), casadi::OmpMap::eval(), casadi::FunctionInternal::eval_gen(), casadi::SXFunction::eval_mx(), casadi::OracleFunction::finalize(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::External::init(), casadi::MXFunction::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Qrqp::init(), casadi::Sqpmethod::init(), casadi::MXFunction::sp_reverse(), casadi::SXFunction::sp_reverse(), and casadi::FunctionInternal::sz_work().

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

trigger_event()

int casadi::Integrator::trigger_event ( IntegratorMemory *  m, casadi_int *  ind  ) const

inherited

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

Definition at line 2632 of file integrator.cpp.

                                                                        {
  // Throw an error if too many events are happening within a single control interval
  if (++m->num_events > max_events_) {
    casadi_error("At t = " + str(m->t) + ": Too many event iterations during interval "
      + str(m->k));
  }
  // Consistency checks
  if (*ind < 0 || m->event_triggered[*ind]) return 1;
  // Mark event as triggered
  m->event_triggered[*ind] = 1;
  // Print progress
  if (verbose_) casadi_message("Zero crossing for index " + str(*ind) + " at t = " + str(m->t));
  // The event time will be impacted by perturbations in x, z, u, p.
  // the perturbed time will be given by the following implicit function:
  //   e[ind](t, x + (t - t_event) * xdot, z + (t - t_event) * zdot, u, p) = 0
  // The sensitivities of t as a functions of fwd_x, fwd_z, fwd_u and fwd_p
  // are given by the implicit function theorem:
  //   de/dt(t, x, z, u, p) * fwd_t + de/dx * fwd_x + de/dz * fwd_z + de/du * fwd_u + de/dp * fwd_p
  //  <=> fwd_t = -fwd_e(fwd_x, fwd_z, fwd_u, fwd_p) / edot
  if (nfwd_ > 0) {
    m->arg[DYN_NUM_IN + DYN_ODE] = m->xdot;  // out:ode
    m->arg[DYN_NUM_IN + DYN_ALG] = nullptr;  // out:alg
    m->arg[DYN_NUM_IN + DYN_QUAD] = nullptr;  // out:quad
    m->arg[DYN_NUM_IN + DYN_ZERO] = m->e;  // out:zero
    m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_T] = nullptr;  // fwd:t
    m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_X] = m->x + nx1_;  // fwd:x
    m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_Z] = m->z + nz1_;  // fwd:z
    m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_P] = m->p + np1_;  // fwd:p
    m->arg[DYN_NUM_IN + DYN_NUM_OUT + DYN_U] = m->u + nu1_;  // fwd:u
    m->res[DYN_ODE] = nullptr;  // fwd:ode
    m->res[DYN_ALG] = nullptr;  // fwd:alg
    m->res[DYN_QUAD] = nullptr;  // fwd:quad
    m->res[DYN_ZERO] = m->tmp1;  // fwd:zero
    if (calc_function(m, forward_name("dae", nfwd_))) return 1;
    // Calculate sensitivity in t
    for (casadi_int i = 0; i < nfwd_; ++i) {
      m->tmp1[i] = -m->tmp1[*ind + ne_ * i] / m->edot[*ind];
    }
    // Propagate this sensitivity to the state vector
    for (casadi_int i = 0; i < nfwd_; ++i) {
       casadi_axpy(nx1_, m->tmp1[i], m->xdot, m->x + nx1_ * (1 + i));
    }
  }
  // Call event transition function, if any
  if (has_function("transition")) {
    // Evaluate to tmp2
    double index = *ind;  // function expects floating point values
    m->arg[EVENT_INDEX] = &index;  // index
    m->arg[EVENT_T] = &m->t;  // t
    m->arg[EVENT_X] = m->x;  // x
    m->arg[EVENT_Z] = m->z;  // z
    m->arg[EVENT_P] = m->p;  // p
    m->arg[EVENT_U] = m->u;  // u
    m->res[EVENT_POST_X] = m->tmp2;  // post_x
    m->res[EVENT_POST_Z] = m->tmp2 + nx_;  // post_z
    if (calc_function(m, "transition")) return 1;
    // Propagate forward sensitivities
    if (nfwd_ > 0) {
      // Propagate sensitivities through event transition
      m->arg[EVENT_NUM_IN + EVENT_POST_X] = m->tmp2;  // out:post_x
      m->arg[EVENT_NUM_IN + EVENT_POST_Z] = m->tmp2 + nx_;  // out:post_z
      m->arg[EVENT_NUM_IN + EVENT_NUM_OUT + EVENT_INDEX] = nullptr;  // fwd:index
      m->arg[EVENT_NUM_IN + EVENT_NUM_OUT + EVENT_T] = m->tmp1;  // fwd:t
      m->arg[EVENT_NUM_IN + EVENT_NUM_OUT + EVENT_X] = m->x + nx1_;  // fwd:x
      m->arg[EVENT_NUM_IN + EVENT_NUM_OUT + EVENT_Z] = m->z + nz1_;  // fwd:z
      m->arg[EVENT_NUM_IN + EVENT_NUM_OUT + EVENT_P] = m->p + np1_;  // fwd:p
      m->arg[EVENT_NUM_IN + EVENT_NUM_OUT + EVENT_U] = m->u + nu1_;  // fwd:u
      m->res[EVENT_POST_X] = m->tmp2 + nx1_;  // fwd:post_x
      m->res[EVENT_POST_Z] = m->tmp2 + nx_ + nz1_;  // fwd:post_z
      calc_function(m, forward_name("transition", nfwd_));
    }
  }
  // Update x, z
  casadi_copy(m->tmp2, nx_ + nz_, m->x);
  // Calculate m->xdot and m->zdot
  if (calc_edot(m)) return 1;
  // Propagate this sensitivity to the state vector
  for (casadi_int i = 0; i < nfwd_; ++i) {
     casadi_axpy(nx1_, -m->tmp1[i], m->xdot, m->x + nx1_ * (1 + i));
  }
  // TODO(@jaeandersson): Check if other events need to be triggered
  *ind = -1;  // for now, do not trigger other events
  return 0;
}

References casadi::OracleMemory::arg, casadi::Integrator::calc_edot(), casadi::OracleFunction::calc_function(), casadi::casadi_axpy(), casadi::casadi_copy(), casadi::DYN_ALG, casadi::DYN_NUM_IN, casadi::DYN_NUM_OUT, casadi::DYN_ODE, casadi::DYN_P, casadi::DYN_QUAD, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::DYN_ZERO, casadi::IntegratorMemory::e, casadi::IntegratorMemory::edot, casadi::EVENT_INDEX, casadi::EVENT_NUM_IN, casadi::EVENT_NUM_OUT, casadi::EVENT_P, casadi::EVENT_POST_X, casadi::EVENT_POST_Z, casadi::EVENT_T, casadi::IntegratorMemory::event_triggered, casadi::EVENT_U, casadi::EVENT_X, casadi::EVENT_Z, casadi::FunctionInternal::forward_name(), casadi::OracleFunction::has_function(), casadi::IntegratorMemory::k, casadi::Integrator::max_events_, casadi::Integrator::ne_, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nu1_, casadi::IntegratorMemory::num_events, casadi::Integrator::nx1_, casadi::Integrator::nx_, casadi::Integrator::nz1_, casadi::Integrator::nz_, casadi::IntegratorMemory::p, casadi::OracleMemory::res, casadi::str(), casadi::IntegratorMemory::t, casadi::IntegratorMemory::tmp1, casadi::IntegratorMemory::tmp2, casadi::IntegratorMemory::u, casadi::ProtoFunction::verbose_, casadi::IntegratorMemory::x, casadi::IntegratorMemory::xdot, and casadi::IntegratorMemory::z.

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

uses_output()

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

inlinevirtualinherited

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

Reimplemented in casadi::Rootfinder, casadi::Nlpsol, casadi::FiniteDiff, and casadi::CallbackInternal.

Definition at line 608 of file function_internal.hpp.

{return false;}

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

weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

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

Definition at line 67 of file generic_shared_internal.hpp.

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

References casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::derivative_of_, casadi::FunctionInternal::Function, casadi::FunctionInternal::incache(), casadi::FunctionInternal::is_diff_in_, casadi::FunctionInternal::is_diff_out_, casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::mx_in(), casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sp_weight(), and casadi::FunctionInternal::tocache_if_missing().

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

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

augmented_options_

Dict casadi::Integrator::augmented_options_

inherited

Definition at line 418 of file integrator_impl.hpp.

Referenced by casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::Integrator::init(), casadi::Integrator::Integrator(), and casadi::Integrator::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.

Referenced by casadi::FiniteDiff::codegen_body(), casadi::LinearInterpolantJac::codegen_body(), casadi::FiniteDiff::codegen_declarations(), casadi::FiniteDiff::eval(), casadi::LinearInterpolantJac::eval(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FiniteDiff::get_default_in(), casadi::CentralDiff::get_forward(), casadi::FunctionInternal::get_n_in(), casadi::FiniteDiff::get_n_in(), casadi::FunctionInternal::get_n_out(), casadi::FiniteDiff::get_n_out(), casadi::FunctionInternal::get_name_in(), casadi::FiniteDiff::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::FiniteDiff::get_name_out(), casadi::FunctionInternal::get_sparsity_in(), casadi::FiniteDiff::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::FiniteDiff::get_sparsity_out(), casadi::LinearInterpolantJac::has_parametric_grid(), casadi::LinearInterpolantJac::has_parametric_values(), casadi::FiniteDiff::init(), casadi::FunctionInternal::init(), casadi::SundialsInterface::init(), casadi::LinearInterpolantJac::init(), casadi::FunctionInternal::jac_is_symm(), casadi::BlazingSplineFunction::merge(), casadi::FunctionInternal::serialize_body(), casadi::LinearInterpolantJac::serialize_type(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

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

disc_

std::vector<casadi_int> casadi::FixedStepIntegrator::disc_

Definition at line 651 of file integrator_impl.hpp.

Referenced by advance_noevent(), create_advanced(), FixedStepIntegrator(), init(), retreat(), serialize_body(), and set_work().

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

Definition at line 261 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::call_gen(), casadi::ClarabelInterface::codegen_body(), casadi::DaqpInterface::codegen_body(), casadi::FatropInterface::codegen_body(), casadi::HighsInterface::codegen_body(), casadi::HpipmInterface::codegen_body(), casadi::IpoptInterface::codegen_body(), casadi::MadnlpInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Conic::Conic(), casadi::Conic::eval(), casadi::Nlpsol::eval(), casadi::Rootfinder::eval(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::Nlpsol::Nlpsol(), casadi::ProtoFunction::ProtoFunction(), casadi::Rootfinder::Rootfinder(), casadi::ProtoFunction::serialize_body(), and casadi::KinsolInterface::solve().

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

event_acceptable_tol_

double casadi::Integrator::event_acceptable_tol_

inherited

Definition at line 439 of file integrator_impl.hpp.

Referenced by casadi::Integrator::advance(), casadi::Integrator::init(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

event_tol_

double casadi::Integrator::event_tol_

inherited

Definition at line 436 of file integrator_impl.hpp.

Referenced by casadi::Integrator::advance(), casadi::Integrator::init(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

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

infix_

const std::string casadi::Integrator::infix_ = "integrator"

staticinherited

Definition at line 456 of file integrator_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().

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

max_event_iter_

casadi_int casadi::Integrator::max_event_iter_

inherited

Definition at line 430 of file integrator_impl.hpp.

Referenced by casadi::Integrator::advance(), casadi::Integrator::init(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

max_events_

casadi_int casadi::Integrator::max_events_

inherited

Definition at line 433 of file integrator_impl.hpp.

Referenced by casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), and casadi::Integrator::trigger_event().

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

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_in_

size_t casadi::FunctionInternal::n_in_

inherited

Definition at line 1261 of file function_internal.hpp.

Referenced by casadi::SXFunction::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::MXFunction::ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::FunctionInternal::all_scalar(), casadi::KinsolInterface::bjac(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::call_reverse(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::check_arg(), casadi::JitFunction::codegen_body(), casadi::Map::codegen_body(), casadi::OmpMap::codegen_body(), casadi::MapSum::codegen_body(), casadi::MXFunction::codegen_body(), casadi::Switch::codegen_body(), casadi::SXFunction::codegen_body(), casadi::FastNewton::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::convert_arg(), casadi::FunctionInternal::definition(), casadi::KinsolInterface::djac(), casadi::FunctionInternal::dm_in(), casadi::FunctionInternal::eval(), casadi::OmpMap::eval(), casadi::MXFunction::eval(), casadi::Switch::eval(), casadi::FunctionInternal::eval_gen(), casadi::Map::eval_gen(), casadi::MapSum::eval_gen(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::Switch::eval_sx(), casadi::SXFunction::export_code_body(), casadi::CallbackInternal::finalize(), casadi::FmuFunction::FmuFunction(), casadi::FunctionInternal::forward(), casadi::KinsolInterface::func(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwd_seed(), casadi::FunctionInternal::generate_in(), casadi::GenericExternal::get_jac_sparsity(), casadi::GenericExternal::has_jac_sparsity(), casadi::FunctionInternal::init(), casadi::MXFunction::init(), casadi::Switch::init(), casadi::SXFunction::init(), casadi::ImplicitToNlp::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::jacobian(), casadi::KinsolInterface::jtimes(), casadi::FunctionInternal::mapsum_mx(), casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::mx_in(), casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::numel_in(), casadi::FunctionInternal::nz_in(), casadi::FunctionInternal::print_dimensions(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::project_arg(), casadi::KinsolInterface::psetup(), casadi::FunctionInternal::reverse(), casadi::FmuFunction::serialize_body(), casadi::FunctionInternal::set_jac_sparsity(), casadi::Rootfinder::set_work(), casadi::QpToNlp::solve(), casadi::KinsolInterface::solve(), casadi::FastNewton::solve(), casadi::ImplicitToNlp::solve(), casadi::Newton::solve(), casadi::FunctionInternal::sp_forward(), casadi::Integrator::sp_forward(), casadi::MXFunction::sp_forward(), casadi::Rootfinder::sp_forward(), casadi::FunctionInternal::sp_reverse(), casadi::Integrator::sp_reverse(), casadi::Map::sp_reverse(), casadi::MapSum::sp_reverse(), casadi::MXFunction::sp_reverse(), casadi::Rootfinder::sp_reverse(), and casadi::FunctionInternal::sx_in().

n_out_

size_t casadi::FunctionInternal::n_out_

inherited

Definition at line 1261 of file function_internal.hpp.

Referenced by casadi::Rootfinder::ad_forward(), casadi::MXFunction::ad_forward(), casadi::SXFunction::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::FunctionInternal::all_scalar(), casadi::KinsolInterface::bjac(), casadi::FunctionInternal::call(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::call_reverse(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::check_res(), casadi::JitFunction::codegen_body(), casadi::Map::codegen_body(), casadi::OmpMap::codegen_body(), casadi::MapSum::codegen_body(), casadi::MXFunction::codegen_body(), casadi::Switch::codegen_body(), casadi::SXFunction::codegen_body(), casadi::FastNewton::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::convert_res(), casadi::FunctionInternal::definition(), casadi::KinsolInterface::djac(), casadi::FunctionInternal::dm_out(), casadi::FunctionInternal::eval(), casadi::OmpMap::eval(), casadi::MXFunction::eval(), casadi::Switch::eval(), casadi::FunctionInternal::eval_gen(), casadi::Map::eval_gen(), casadi::MapSum::eval_gen(), casadi::Switch::eval_sx(), casadi::CallbackInternal::finalize(), casadi::FmuFunction::FmuFunction(), casadi::FunctionInternal::forward(), casadi::KinsolInterface::func(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_out(), casadi::LinearInterpolantJac::get_jacobian(), casadi::FunctionInternal::init(), casadi::MapSum::init(), casadi::Nlpsol::init(), casadi::Switch::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::mapsum_mx(), casadi::FunctionInternal::matching_res(), casadi::FunctionInternal::mx_out(), casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::numel_out(), casadi::FunctionInternal::nz_out(), casadi::FunctionInternal::print_dimensions(), casadi::FunctionInternal::print_out(), casadi::KinsolInterface::psetup(), casadi::FunctionInternal::reverse(), casadi::FmuFunction::serialize_body(), casadi::FunctionInternal::set_jac_sparsity(), casadi::Rootfinder::set_work(), casadi::QpToNlp::solve(), casadi::KinsolInterface::solve(), casadi::FastNewton::solve(), casadi::ImplicitToNlp::solve(), casadi::Newton::solve(), casadi::FunctionInternal::sp_forward(), casadi::Integrator::sp_forward(), casadi::MXFunction::sp_forward(), casadi::Rootfinder::sp_forward(), casadi::FunctionInternal::sp_reverse(), casadi::Integrator::sp_reverse(), casadi::Map::sp_reverse(), casadi::MapSum::sp_reverse(), casadi::MXFunction::sp_reverse(), casadi::Rootfinder::sp_reverse(), and casadi::FunctionInternal::sx_out().

nadj_

casadi_int casadi::Integrator::nadj_

inherited

Definition at line 391 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_quadB(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::SundialsInterface::init(), casadi::IdasInterface::init_mem(), casadi::Integrator::Integrator(), casadi::IdasInterface::reset(), casadi::Integrator::serialize_body(), casadi::RungeKutta::setup_step(), casadi::IdasInterface::solve_transposed(), casadi::Integrator::sp_jac_rdae(), and stepB().

name_

std::string casadi::ProtoFunction::name_

inherited

Definition at line 246 of file function_internal.hpp.

Referenced by casadi::MXFunction::ad_forward(), casadi::SXFunction::ad_forward(), casadi::MXFunction::ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::Integrator::augmented_dae(), casadi::OracleFunction::calc_function(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::codegen_body(), casadi::External::codegen_body(), casadi::External::codegen_checkout(), casadi::External::codegen_declarations(), casadi::MXFunction::codegen_declarations(), casadi::SXFunction::codegen_declarations(), casadi::External::codegen_decref(), casadi::External::codegen_incref(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_name(), casadi::External::codegen_release(), casadi::FunctionInternal::codegen_sparsities(), casadi::ProtoFunction::construct(), casadi::OracleFunction::create_function(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::eval(), casadi::MXFunction::eval(), casadi::SXFunction::eval(), casadi::FunctionInternal::eval_mx(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::SXFunction::eval_sx(), casadi::FmuFunction::factory(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::Integrator::get_forward(), casadi::Integrator::get_forward_dae(), casadi::Map::get_function(), casadi::MapSum::get_function(), casadi::OracleFunction::get_function(), casadi::GenericExternal::get_jac_sparsity(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::get_n_in(), casadi::External::get_n_in(), casadi::FunctionInternal::get_n_out(), casadi::External::get_n_out(), casadi::FunctionInternal::get_name_in(), casadi::External::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::External::get_name_out(), casadi::FunctionInternal::get_partition(), casadi::Integrator::get_reverse(), casadi::FunctionInternal::get_sparsity_in(), casadi::GenericExternal::get_sparsity_in(), casadi::FunctionInternal::get_sparsity_out(), casadi::GenericExternal::get_sparsity_out(), casadi::FunctionInternal::get_stats(), casadi::External::has_forward(), casadi::GenericExternal::has_jac_sparsity(), casadi::External::has_jacobian(), casadi::External::has_reverse(), casadi::External::init(), casadi::FunctionInternal::init(), casadi::MXFunction::init(), casadi::SXFunction::init(), casadi::CvodesInterface::init(), casadi::IdasInterface::init(), casadi::External::init_external(), casadi::GenericExternal::init_external(), casadi::FunctionInternal::jac_is_symm(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::map(), casadi::OracleFunction::monitored(), casadi::MXFunction::print_arg(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_out(), casadi::MXFunction::print_res(), casadi::ProtoFunction::print_time(), casadi::ProtoFunction::ProtoFunction(), casadi::CvodesInterface::reset(), casadi::IdasInterface::reset(), casadi::IdasInterface::resetB(), casadi::FunctionInternal::reverse(), casadi::ProtoFunction::serialize_body(), casadi::GurobiInterface::solve(), casadi::SnoptInterface::solve(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

name_in_

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

inherited

Definition at line 1270 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::check_arg(), casadi::JitFunction::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::convert_arg(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::diff_prefix(), casadi::FunctionInternal::eval_gen(), casadi::FmuFunction::FmuFunction(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwd_seed(), casadi::FmuFunction::get_stats(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), casadi::JitFunction::JitFunction(), casadi::FunctionInternal::mx_in(), casadi::FunctionInternal::print_dimensions(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::reverse(), casadi::FunctionInternal::serialize_body(), casadi::FunctionInternal::signature_unrolled(), casadi::FunctionInternal::sx_in(), casadi::FunctionInternal::wrap(), casadi::FunctionInternal::wrap_as_needed(), and casadi::XFunction< DerivedType, MatType, NodeType >::XFunction().

name_out_

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

inherited

Definition at line 1270 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::check_res(), casadi::JitFunction::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::convert_res(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::diff_prefix(), casadi::FunctionInternal::eval_gen(), casadi::FmuFunction::FmuFunction(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), casadi::JitFunction::JitFunction(), casadi::FunctionInternal::mx_out(), casadi::FunctionInternal::print_dimensions(), casadi::FunctionInternal::print_out(), casadi::FunctionInternal::reverse(), casadi::FunctionInternal::serialize_body(), casadi::FunctionInternal::signature_unrolled(), casadi::FunctionInternal::sx_out(), casadi::FunctionInternal::wrap(), casadi::FunctionInternal::wrap_as_needed(), and casadi::XFunction< DerivedType, MatType, NodeType >::XFunction().

ne_

casadi_int casadi::Integrator::ne_

inherited

Definition at line 409 of file integrator_impl.hpp.

Referenced by casadi::Integrator::advance(), casadi::Integrator::eval(), casadi::Integrator::get_forward_dae(), casadi::Integrator::get_reverse(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::predict_events(), casadi::CvodesInterface::reset(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), and casadi::Integrator::trigger_event().

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

nfwd_

casadi_int casadi::Integrator::nfwd_

inherited

Definition at line 391 of file integrator_impl.hpp.

Referenced by casadi::Integrator::augmented_dae(), casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_daeF(), casadi::SundialsInterface::calc_jtimesF(), casadi::SundialsInterface::calc_quadB(), casadi::SundialsInterface::calc_quadF(), casadi::Integrator::fdae_sp_forward(), casadi::Integrator::fdae_sp_reverse(), casadi::Integrator::fquad_sp_forward(), casadi::Integrator::fquad_sp_reverse(), casadi::Integrator::get_forward_dae(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::SundialsInterface::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), casadi::RungeKutta::setup_step(), casadi::IdasInterface::solve_transposed(), casadi::Integrator::sp_jac_aug(), casadi::Integrator::sp_jac_dae(), casadi::Integrator::sp_jac_rdae(), stepB(), stepF(), and casadi::Integrator::trigger_event().

nk_target_

casadi_int casadi::FixedStepIntegrator::nk_target_

Definition at line 648 of file integrator_impl.hpp.

Referenced by FixedStepIntegrator(), init(), and serialize_body().

nom_x_

std::vector<double> casadi::Integrator::nom_x_

inherited

Definition at line 415 of file integrator_impl.hpp.

Referenced by casadi::Integrator::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

nom_z_

std::vector<double> casadi::Integrator::nom_z_

inherited

Definition at line 415 of file integrator_impl.hpp.

Referenced by casadi::Integrator::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

np1_

casadi_int casadi::Integrator::np1_

inherited

Definition at line 403 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_daeF(), casadi::SundialsInterface::calc_jtimesF(), casadi::SundialsInterface::calc_quadB(), casadi::SundialsInterface::calc_quadF(), casadi::Integrator::fdae_sp_forward(), casadi::Integrator::fdae_sp_reverse(), casadi::Integrator::fquad_sp_forward(), casadi::Integrator::fquad_sp_reverse(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), stepB(), stepF(), and casadi::Integrator::trigger_event().

np_

casadi_int casadi::Integrator::np_

inherited

Definition at line 403 of file integrator_impl.hpp.

Referenced by casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), casadi::Integrator::set_p(), and casadi::Integrator::set_work().

nq1_

casadi_int casadi::Integrator::nq1_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by casadi::IdasInterface::advance_noevent(), casadi::SundialsInterface::calc_quadF(), casadi::Integrator::fquad_sp_forward(), casadi::Integrator::fquad_sp_reverse(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), casadi::IdasInterface::init_mem(), casadi::Integrator::Integrator(), casadi::IdasInterface::reset(), casadi::Integrator::serialize_body(), casadi::Collocation::setup_step(), and stepF().

nq_

casadi_int casadi::Integrator::nq_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by advance_noevent(), casadi::CvodesInterface::advance_noevent(), casadi::IdasInterface::advance_noevent(), casadi::Integrator::eval(), casadi::Integrator::get_q(), casadi::Integrator::init(), init(), casadi::SundialsInterface::init(), casadi::CvodesInterface::init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::CvodesInterface::reset(), casadi::SundialsInterface::reset(), casadi::Integrator::serialize_body(), casadi::Integrator::set_q(), casadi::Integrator::set_work(), set_work(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

nrp1_

casadi_int casadi::Integrator::nrp1_

inherited

Definition at line 403 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_quadB(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), and stepB().

nrp_

casadi_int casadi::Integrator::nrp_

inherited

Definition at line 403 of file integrator_impl.hpp.

Referenced by casadi::Integrator::eval(), impulseB(), casadi::SundialsInterface::impulseB(), casadi::Integrator::init(), casadi::Integrator::Integrator(), resetB(), casadi::SundialsInterface::resetB(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

nrq1_

casadi_int casadi::Integrator::nrq1_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_quadB(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), and stepB().

nrq_

casadi_int casadi::Integrator::nrq_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::Integrator::eval(), casadi::IdasInterface::impulseB(), casadi::Integrator::init(), init(), casadi::SundialsInterface::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), resetB(), retreat(), casadi::CvodesInterface::retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), set_work(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

nrv1_

casadi_int casadi::FixedStepIntegrator::nrv1_

Definition at line 654 of file integrator_impl.hpp.

Referenced by FixedStepIntegrator(), init(), serialize_body(), and stepB().

nrv_

casadi_int casadi::FixedStepIntegrator::nrv_

Definition at line 654 of file integrator_impl.hpp.

Referenced by FixedStepIntegrator(), impulseB(), init(), resetB(), retreat(), serialize_body(), and set_work().

nrx1_

casadi_int casadi::Integrator::nrx1_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_quadB(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), casadi::IdasInterface::solve_transposed(), casadi::Integrator::sp_jac_rdae(), and stepB().

nrx_

casadi_int casadi::Integrator::nrx_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by advance_noevent(), casadi::CvodesInterface::advance_noevent(), casadi::IdasInterface::advance_noevent(), create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_reverse(), impulseB(), casadi::IdasInterface::impulseB(), casadi::SundialsInterface::impulseB(), casadi::Integrator::init(), init(), casadi::CvodesInterface::init(), casadi::CvodesInterface::init_mem(), casadi::IdasInterface::init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::SundialsInterface::print_stats(), reset(), casadi::CvodesInterface::reset(), resetB(), casadi::SundialsInterface::resetB(), retreat(), casadi::CvodesInterface::retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), set_work(), casadi::IdasInterface::solve_transposed(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), and casadi::IdasInterface::z_impulseB().

nrz1_

casadi_int casadi::Integrator::nrz1_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_quadB(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), and casadi::IdasInterface::solve_transposed().

nrz_

casadi_int casadi::Integrator::nrz_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::Integrator::eval(), impulseB(), casadi::IdasInterface::impulseB(), casadi::SundialsInterface::impulseB(), casadi::Integrator::init(), casadi::CvodesInterface::init(), casadi::RungeKutta::init(), casadi::IdasInterface::init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::SundialsInterface::resetB(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), casadi::IdasInterface::solve_transposed(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), and casadi::IdasInterface::z_impulseB().

ntmp_

casadi_int casadi::Integrator::ntmp_

inherited

Definition at line 412 of file integrator_impl.hpp.

Referenced by casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), and casadi::Integrator::set_work().

nu1_

casadi_int casadi::Integrator::nu1_

inherited

Definition at line 406 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_daeF(), casadi::SundialsInterface::calc_jtimesF(), casadi::SundialsInterface::calc_quadB(), casadi::SundialsInterface::calc_quadF(), casadi::Integrator::fdae_sp_forward(), casadi::Integrator::fdae_sp_reverse(), casadi::Integrator::fquad_sp_forward(), casadi::Integrator::fquad_sp_reverse(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), stepB(), stepF(), and casadi::Integrator::trigger_event().

nu_

casadi_int casadi::Integrator::nu_

inherited

Definition at line 406 of file integrator_impl.hpp.

Referenced by casadi::Integrator::eval(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::next_stop(), casadi::Integrator::next_stopB(), retreat(), casadi::CvodesInterface::retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::serialize_body(), casadi::Integrator::set_u(), casadi::Integrator::set_work(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

nuq1_

casadi_int casadi::Integrator::nuq1_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_quadB(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), and stepB().

nuq_

casadi_int casadi::Integrator::nuq_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::Integrator::eval(), casadi::IdasInterface::impulseB(), casadi::Integrator::init(), init(), casadi::SundialsInterface::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), resetB(), retreat(), casadi::CvodesInterface::retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::serialize_body(), set_work(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

nv1_

casadi_int casadi::FixedStepIntegrator::nv1_

Definition at line 654 of file integrator_impl.hpp.

Referenced by FixedStepIntegrator(), init(), serialize_body(), stepB(), and stepF().

nv_

casadi_int casadi::FixedStepIntegrator::nv_

Definition at line 654 of file integrator_impl.hpp.

Referenced by advance_noevent(), FixedStepIntegrator(), init(), reset(), retreat(), serialize_body(), and set_work().

nx1_

casadi_int casadi::Integrator::nx1_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_daeF(), casadi::SundialsInterface::calc_jtimesF(), casadi::SundialsInterface::calc_quadB(), casadi::SundialsInterface::calc_quadF(), casadi::Integrator::fdae_sp_forward(), casadi::Integrator::fdae_sp_reverse(), casadi::Integrator::fquad_sp_forward(), casadi::Integrator::fquad_sp_reverse(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), casadi::SundialsInterface::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::Collocation::reset(), casadi::Integrator::serialize_body(), casadi::Collocation::setup_step(), casadi::Integrator::sp_jac_dae(), stepB(), stepF(), and casadi::Integrator::trigger_event().

nx_

casadi_int casadi::Integrator::nx_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by advance_noevent(), casadi::CvodesInterface::advance_noevent(), casadi::IdasInterface::advance_noevent(), casadi::Integrator::calc_edot(), casadi::Integrator::eval(), casadi::Integrator::get_x(), casadi::Integrator::init(), init(), casadi::CvodesInterface::init(), casadi::IdasInterface::init(), casadi::SundialsInterface::init(), casadi::IdasInterface::init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), reset(), casadi::SundialsInterface::reset(), retreat(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), set_work(), casadi::Integrator::set_x(), casadi::IdasInterface::solve_transposed(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), casadi::Integrator::trigger_event(), and casadi::IdasInterface::z_impulseB().

nz1_

casadi_int casadi::Integrator::nz1_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by casadi::Integrator::bdae_sp_forward(), casadi::Integrator::bdae_sp_reverse(), casadi::Integrator::bquad_sp_forward(), casadi::Integrator::bquad_sp_reverse(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_daeF(), casadi::SundialsInterface::calc_jtimesF(), casadi::SundialsInterface::calc_quadB(), casadi::SundialsInterface::calc_quadF(), casadi::Integrator::fdae_sp_forward(), casadi::Integrator::fdae_sp_reverse(), casadi::Integrator::fquad_sp_forward(), casadi::Integrator::fquad_sp_reverse(), casadi::Integrator::get_sparsity_in(), casadi::Integrator::get_sparsity_out(), casadi::Integrator::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::Collocation::reset(), casadi::Integrator::serialize_body(), casadi::Collocation::setup_step(), and casadi::Integrator::trigger_event().

nz_

casadi_int casadi::Integrator::nz_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by advance_noevent(), casadi::IdasInterface::advance_noevent(), casadi::Collocation::algebraic_state_output(), create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_z(), casadi::Integrator::init(), casadi::CvodesInterface::init(), casadi::IdasInterface::init(), casadi::SundialsInterface::init(), casadi::RungeKutta::init(), casadi::IdasInterface::init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::SundialsInterface::reset(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), casadi::Integrator::set_z(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), and casadi::Integrator::trigger_event().

options_

const Options casadi::FixedStepIntegrator::options_

static

Initial value:

= {{&Integrator::options_},
    {{"number_of_finite_elements",
      {OT_INT,
      "Target number of finite elements. "
      "The actual number may be higher to accommodate all output times"}},
    {"simplify",
      {OT_BOOL,
      "Implement as MX Function (codegeneratable/serializable) default: false"}},
    {"simplify_options",
      {OT_DICT,
      "Any options to pass to simplified form Function constructor"}}
    }
}

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

Definition at line 580 of file integrator_impl.hpp.

Referenced by casadi::casadi_register_integrator_rk().

opts_

Dict casadi::Integrator::opts_

inherited

Definition at line 421 of file integrator_impl.hpp.

Referenced by casadi::Integrator::getDerivativeOptions(), casadi::Integrator::init(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

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(), casadi::FastNewton::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().

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_stats_

bool casadi::Integrator::print_stats_

inherited

Definition at line 424 of file integrator_impl.hpp.

Referenced by casadi::Integrator::eval(), casadi::Integrator::init(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

print_time_

bool casadi::ProtoFunction::print_time_

inherited

Definition at line 252 of file function_internal.hpp.

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

rdae_

Function casadi::Integrator::rdae_

inherited

Definition at line 394 of file integrator_impl.hpp.

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

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.

Referenced by casadi::OracleFunction::calc_function(), casadi::AlpaqaProblem::eval_f(), casadi::BonminUserClass::eval_f(), casadi::IpoptUserClass::eval_f(), casadi::AlpaqaProblem::eval_f_grad_f(), casadi::AlpaqaProblem::eval_g(), casadi::BonminUserClass::eval_g(), casadi::IpoptUserClass::eval_g(), casadi::BonminUserClass::eval_grad_f(), casadi::IpoptUserClass::eval_grad_f(), casadi::AlpaqaProblem::eval_grad_L(), casadi::BonminUserClass::eval_h(), casadi::IpoptUserClass::eval_h(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_L_prod(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::AlpaqaProblem::eval_hess_ψ_prod(), casadi::AlpaqaProblem::eval_jac_g(), casadi::BonminUserClass::eval_jac_g(), casadi::IpoptUserClass::eval_jac_g(), casadi::AlpaqaProblem::eval_ψ(), casadi::AlpaqaProblem::eval_ψ_grad_ψ(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), and casadi::OracleFunction::serialize_body().

solvers_

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

staticinherited

Definition at line 449 of file integrator_impl.hpp.

sp_jac_dae_

Sparsity casadi::Integrator::sp_jac_dae_

inherited

Definition at line 357 of file integrator_impl.hpp.

Referenced by casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

sp_jac_rdae_

Sparsity casadi::Integrator::sp_jac_rdae_

inherited

Definition at line 357 of file integrator_impl.hpp.

Referenced by casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::Integrator::serialize_body(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

sparsity_in_

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

inherited

Definition at line 1267 of file function_internal.hpp.

Referenced by casadi::SXFunction::ad_forward(), casadi::SXFunction::ad_reverse(), casadi::CodeGenerator::add(), casadi::FunctionInternal::all_scalar(), casadi::Switch::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sparsities(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::eval(), casadi::Switch::eval(), casadi::SXFunction::eval_mx(), casadi::Switch::eval_sx(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), casadi::Switch::init(), casadi::ImplicitToNlp::init(), casadi::JitFunction::JitFunction(), casadi::FunctionInternal::mapsum_mx(), casadi::FunctionInternal::print_dimensions(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::serialize_body(), and casadi::HpmpcInterface::solve().

sparsity_out_

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

inherited

Definition at line 1267 of file function_internal.hpp.

Referenced by casadi::SXFunction::ad_forward(), casadi::SXFunction::ad_reverse(), casadi::FunctionInternal::all_scalar(), casadi::Switch::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_sparsities(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::eval(), casadi::Switch::eval(), casadi::SXFunction::eval_mx(), casadi::Switch::eval_sx(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::init(), casadi::Nlpsol::init(), casadi::Switch::init(), casadi::JitFunction::JitFunction(), casadi::FunctionInternal::print_dimensions(), casadi::FunctionInternal::print_out(), and casadi::FunctionInternal::serialize_body().

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

t0_

double casadi::Integrator::t0_

inherited

Definition at line 385 of file integrator_impl.hpp.

Referenced by create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::IdasInterface::impulseB(), casadi::Integrator::init(), init(), casadi::Integrator::Integrator(), casadi::SundialsInterface::reset_stats(), and casadi::Integrator::serialize_body().

tout_

std::vector<double> casadi::Integrator::tout_

inherited

Definition at line 388 of file integrator_impl.hpp.

Referenced by create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::Integrator::init(), init(), casadi::IdasInterface::init(), casadi::Integrator::Integrator(), and casadi::Integrator::serialize_body().

transition_

Function casadi::Integrator::transition_

inherited

Definition at line 427 of file integrator_impl.hpp.

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

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.

Referenced by casadi::MXFunction::ad_forward(), casadi::SXFunction::ad_forward(), casadi::MXFunction::ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::Integrator::advance(), casadi::ProtoFunction::change_option(), casadi::BSplineInterpolant::construct_graph(), casadi::OracleFunction::create_function(), casadi::FmuFunction::eval(), casadi::Integrator::eval(), casadi::MXFunction::eval(), casadi::SXFunction::eval(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::SXFunction::eval_sx(), casadi::FmuFunction::factory(), casadi::FunctionInternal::finalize(), casadi::KinsolInterface::func(), casadi::ProtoFunction::generate_options(), casadi::FmuFunction::get_forward(), casadi::Integrator::get_forward(), casadi::Integrator::get_forward_dae(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FmuFunction::get_jacobian(), casadi::FunctionInternal::get_partition(), casadi::FmuFunction::get_reverse(), casadi::Integrator::get_reverse(), casadi::ProtoFunction::init(), casadi::FiniteDiff::init(), casadi::FmuFunction::init(), casadi::FunctionInternal::init(), casadi::MXFunction::init(), casadi::SXFunction::init(), casadi::Blocksqp::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), casadi::CvodesInterface::init(), casadi::IdasInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Scpgen::init(), casadi::Sqpmethod::init(), casadi::IpoptInterface::init_mem(), casadi::IdasInterface::init_mem(), casadi::SXFunction::instructions_sx(), casadi::BonminInterface::intermediate_callback(), casadi::OracleFunction::jit_dependencies(), casadi::CsparseInterface::nfact(), casadi::LapackLu::nfact(), casadi::LapackQr::nfact(), casadi::LinsolQr::nfact(), casadi::Integrator::predict_events(), casadi::ProtoFunction::ProtoFunction(), casadi::CvodesInterface::reset(), casadi::IdasInterface::reset(), casadi::IdasInterface::resetB(), casadi::ProtoFunction::serialize_body(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::HpipmInterface::solve(), casadi::QpoasesInterface::solve(), casadi::Ipqp::solve(), casadi::Qrqp::solve(), casadi::AlpaqaInterface::solve(), casadi::AmplInterface::solve(), casadi::SnoptInterface::solve(), casadi::KinsolInterface::solve(), casadi::WorhpInterface::solve(), casadi::Newton::solve(), casadi::Qrsqp::solve(), casadi::Scpgen::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_ela_QP(), casadi::Feasiblesqpmethod::solve_LP(), casadi::Feasiblesqpmethod::solve_QP(), casadi::Qrsqp::solve_QP(), casadi::Sqpmethod::solve_QP(), casadi::Integrator::sp_forward(), casadi::Integrator::sp_reverse(), and casadi::Integrator::trigger_event().

---

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

• integrator_impl.hpp
• integrator.cpp