casadi::CvodesInterface Class Reference

'cvodes' plugin for Integrator More...

#include <cvodes_interface.hpp>

Detailed Description

Interface to CVodes from the Sundials suite.

A call to evaluate will integrate to the end.

You can retrieve the entire state trajectory as follows, after the evaluate call: Call reset. Then call integrate(t_i) and getOuput for a series of times t_i.

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

List of available options

Id	Type	Description
abstol	OT_DOUBLE	Absolute tolerence for the IVP solution
always_recalculate_jacobian	OT_BOOL	Recalculate Jacobian before factorizations, even if Jacobian is current [default: true]
disable_internal_warnings	OT_BOOL	Disable SUNDIALS internal warning messages
fsens_all_at_once	OT_BOOL	Calculate all right hand sides of the sensitivity equations at once
fsens_err_con	OT_BOOL	include the forward sensitivities in all error controls
interpolation_type	OT_STRING	Type of interpolation for the adjoint sensitivities
linear_multistep_method	OT_STRING	Integrator scheme: BDF|adams
linear_solver	OT_STRING	A custom linear solver creator function [default: qr]
linear_solver_options	OT_DICT	Options to be passed to the linear solver
max_krylov	OT_INT	Maximum Krylov subspace size
max_multistep_order	OT_INT	Maximum order for the (variable-order) multistep method
max_num_steps	OT_INT	Maximum number of integrator steps
max_order	OT_DOUBLE	Maximum order
max_step_size	OT_DOUBLE	Max step size [default: 0/inf]
min_step_size	OT_DOUBLE	Min step size [default: 0/0.0]
newton_scheme	OT_STRING	Linear solver scheme in the Newton method: DIRECT|gmres|bcgstab|tfqmr
nonlin_conv_coeff	OT_DOUBLE	Coefficient in the nonlinear convergence test
nonlinear_solver_iteration	OT_STRING	Nonlinear solver type: NEWTON|functional
quad_err_con	OT_BOOL	Should the quadratures affect the step size control
reltol	OT_DOUBLE	Relative tolerence for the IVP solution
scale_abstol	OT_BOOL	Scale absolute tolerance by nominal value
second_order_correction	OT_BOOL	Second order correction in the augmented system Jacobian [true]
sensitivity_method	OT_STRING	Sensitivity method: SIMULTANEOUS|staggered
step0	OT_DOUBLE	initial step size [default: 0/estimated]
steps_per_checkpoint	OT_INT	Number of steps between two consecutive checkpoints
stop_at_end	OT_BOOL	[DEPRECATED] Stop the integrator at the end of the interval
use_preconditioner	OT_BOOL	Precondition the iterative solver [default: true]

Input scheme: casadi::IntegratorInput (INTEGRATOR_NUM_IN = 7)

Full name	Short	Description
INTEGRATOR_X0	x0	Differential state at the initial time.
INTEGRATOR_Z0	z0	Initial guess for the algebraic variable at the initial time.
INTEGRATOR_P	p	Parameters.
INTEGRATOR_U	u	Piecewise constant control, a new control interval starts at each output time.
INTEGRATOR_ADJ_XF	adj_xf	Adjoint seeds corresponding to the states at the output times.
INTEGRATOR_ADJ_ZF	adj_zf	Adjoint seeds corresponding to the algebraic variables at the output times.
INTEGRATOR_ADJ_QF	adj_qf	Adjoint seeds corresponding to the quadratures at the output times.

Output scheme: casadi::IntegratorOutput (INTEGRATOR_NUM_OUT = 7)

Full name	Short	Description
INTEGRATOR_XF	xf	Differential state at all output times.
INTEGRATOR_ZF	zf	Algebraic variable at all output times.
INTEGRATOR_QF	qf	Quadrature state at all output times.
INTEGRATOR_ADJ_X0	adj_x0	Adjoint sensitivities corresponding to the initial state.
INTEGRATOR_ADJ_Z0	adj_z0	Adjoint sensitivities corresponding to the algebraic variable guess.
INTEGRATOR_ADJ_P	adj_p	Adjoint sensitivities corresponding to the parameter vector.
INTEGRATOR_ADJ_U	adj_u	Adjoint sensitivities corresponding to the control vector.

List of available options

Id	Type	Description	Used in
abstol	OT_DOUBLE	Absolute tolerence for the IVP solution	casadi::SundialsInterface
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
always_recalculate_jacobian	OT_BOOL	Recalculate Jacobian before factorizations, even if Jacobian is current [default: true]	casadi::CvodesInterface
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
disable_internal_warnings	OT_BOOL	Disable SUNDIALS internal warning messages	casadi::SundialsInterface
dump	OT_BOOL	Dump function to file upon first evaluation. [false]	casadi::FunctionInternal
dump_dir	OT_STRING	Directory to dump inputs/outputs to. Make sure the directory exists [.]	casadi::FunctionInternal
dump_format	OT_STRING	Choose file format to dump matrices. See DM.from_file [mtx]	casadi::FunctionInternal
dump_in	OT_BOOL	Dump numerical values of inputs to file (readable with DM.from_file) [default: false] A counter is used to generate unique names. The counter may be reset using reset_dump_count.	casadi::FunctionInternal
dump_out	OT_BOOL	Dump numerical values of outputs to file (readable with DM.from_file) [default: false] A counter is used to generate unique names. The counter may be reset using reset_dump_count.	casadi::FunctionInternal
enable_fd	OT_BOOL	Enable derivative calculation by finite differencing. [default: false]]	casadi::FunctionInternal
enable_forward	OT_BOOL	Enable derivative calculation using generated functions for Jacobian-times-vector products - typically using forward mode AD - if available. [default: true]	casadi::FunctionInternal
enable_jacobian	OT_BOOL	Enable derivative calculation using generated functions for Jacobians of all differentiable outputs with respect to all differentiable inputs - if available. [default: true]	casadi::FunctionInternal
enable_reverse	OT_BOOL	Enable derivative calculation using generated functions for transposed Jacobian-times-vector products - typically using reverse mode AD - if available. [default: true]	casadi::FunctionInternal
error_on_fail	OT_BOOL	Throw exceptions when function evaluation fails (default true).	casadi::ProtoFunction
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
fsens_all_at_once	OT_BOOL	Calculate all right hand sides of the sensitivity equations at once	casadi::CvodesInterface
fsens_err_con	OT_BOOL	include the forward sensitivities in all error controls	casadi::SundialsInterface
gather_stats	OT_BOOL	Deprecated option (ignored): Statistics are now always collected.	casadi::FunctionInternal
grid	OT_DOUBLEVECTOR	[DEPRECATED] Time grid	casadi::Integrator
inputs_check	OT_BOOL	Throw exceptions when the numerical values of the inputs don't make sense	casadi::FunctionInternal
interpolation_type	OT_STRING	Type of interpolation for the adjoint sensitivities	casadi::SundialsInterface
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
linear_multistep_method	OT_STRING	Integrator scheme: BDF|adams	casadi::CvodesInterface
linear_solver	OT_STRING	A custom linear solver creator function [default: qr]	casadi::SundialsInterface
linear_solver_options	OT_DICT	Options to be passed to the linear solver	casadi::SundialsInterface
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_krylov	OT_INT	Maximum Krylov subspace size	casadi::SundialsInterface
max_multistep_order	OT_INT	Maximum order for the (variable-order) multistep method	casadi::SundialsInterface
max_num_dir	OT_INT	Specify the maximum number of directions for derivative functions. Overrules the builtin optimized_num_dir.	casadi::FunctionInternal
max_num_steps	OT_INT	Maximum number of integrator steps	casadi::SundialsInterface
max_order	OT_DOUBLE	Maximum order	casadi::SundialsInterface
max_step_size	OT_DOUBLE	Max step size [default: 0/inf]	casadi::SundialsInterface
min_step_size	OT_DOUBLE	Min step size [default: 0/0.0]	casadi::CvodesInterface
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
newton_scheme	OT_STRING	Linear solver scheme in the Newton method: DIRECT|gmres|bcgstab|tfqmr	casadi::SundialsInterface
nfwd	OT_INT	Number of forward sensitivities to be calculated [0]	casadi::Integrator
nonlin_conv_coeff	OT_DOUBLE	Coefficient in the nonlinear convergence test	casadi::SundialsInterface
nonlinear_solver_iteration	OT_STRING	Nonlinear solver type: NEWTON|functional	casadi::CvodesInterface
number_of_finite_elements	OT_INT	Target number of finite elements. The actual number may be higher to accommodate all output times	casadi::Integrator
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_canonical	OT_BOOL	When printing numerical matrices, use a format that is exact and reproducible in generated C code.	casadi::FunctionInternal
print_in	OT_BOOL	Print numerical values of inputs [default: false]	casadi::FunctionInternal
print_out	OT_BOOL	Print numerical values of outputs [default: false]	casadi::FunctionInternal
print_stats	OT_BOOL	Print out statistics after integration	casadi::Integrator
print_time	OT_BOOL	print information about execution time. Implies record_time.	casadi::ProtoFunction
quad_err_con	OT_BOOL	Should the quadratures affect the step size control	casadi::SundialsInterface
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
reltol	OT_DOUBLE	Relative tolerence for the IVP solution	casadi::SundialsInterface
reverse_options	OT_DICT	Options to be passed to a reverse mode constructor	casadi::FunctionInternal
rootfinder	OT_STRING	An implicit function solver	casadi::Integrator
rootfinder_options	OT_DICT	Options to be passed to the NLP Solver	casadi::Integrator
scale_abstol	OT_BOOL	Scale absolute tolerance by nominal value	casadi::SundialsInterface
second_order_correction	OT_BOOL	Second order correction in the augmented system Jacobian [true]	casadi::SundialsInterface
sensitivity_method	OT_STRING	Sensitivity method: SIMULTANEOUS|staggered	casadi::SundialsInterface
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::Integrator
simplify_options	OT_DICT	Any options to pass to simplified form Function constructor	casadi::Integrator
specific_options	OT_DICT	Options for specific auto-generated functions, overwriting the defaults from common_options. Nested dictionary.	casadi::OracleFunction
step0	OT_DOUBLE	initial step size [default: 0/estimated]	casadi::SundialsInterface
steps_per_checkpoint	OT_INT	Number of steps between two consecutive checkpoints	casadi::SundialsInterface
stop_at_end	OT_BOOL	[DEPRECATED] Stop the integrator at the end of the interval	casadi::SundialsInterface
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
use_preconditioner	OT_BOOL	Precondition the iterative solver [default: true]	casadi::SundialsInterface
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 87 of file cvodes_interface.hpp.

Inheritance diagram for casadi::CvodesInterface:

Collaboration diagram for casadi::CvodesInterface:

Public Types
enum	NewtonScheme { SD_DIRECT , SD_GMRES , SD_BCGSTAB , SD_TFQMR }
	Supported iterative solvers in Sundials. More...
enum	InterpType { SD_POLYNOMIAL , SD_HERMITE }
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)
enum	JtimesFIn {   JTIMESF_T , JTIMESF_X , JTIMESF_Z , JTIMESF_P ,   JTIMESF_U , JTIMESF_FWD_X , JTIMESF_FWD_Z , JTIMESF_NUM_IN }
	IO conventions for continuous time dynamics. More...
enum	JtimesFOut { JTIMESF_FWD_ODE , JTIMESF_FWD_ALG , JTIMESF_NUM_OUT }
	IO conventions for continuous time dynamics. More...
enum	JacFOut {   JACF_ODE_X , JACF_ALG_X , JACF_ODE_Z , JACF_ALG_Z ,   JACF_NUM_OUT }
	IO conventions for continuous time dynamics. More...

Public Member Functions
	CvodesInterface (const std::string &name, const Function &dae, double t0, const std::vector< double > &tout)
	Constructor. More...
	~CvodesInterface () override
	Destructor. More...
const char *	plugin_name () const override
std::string	class_name () const override
	Readable name of the internal class. More...
void	init (const Dict &opts) override
	Initialize stage. More...
void *	alloc_mem () const override
	Create memory block. More...
int	init_mem (void *mem) const override
	Initalize memory block. More...
void	free_mem (void *mem) const override
	Free memory block. More...
void	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	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	serialize_body (SerializingStream &s) const override
	Serialize an object without type information. More...
void	set_work (void *mem, const double **&arg, double **&res, casadi_int *&iw, double *&w) const override
	Set the (persistent) work vectors. More...
double	get_reltol () const override
	Get relative tolerance. More...
double	get_abstol () const override
	Get absolute tolerance. More...
int	calc_daeF (SundialsMemory *m, double t, const double *x, const double *z, double *ode, double *alg) const
int	calc_daeB (SundialsMemory *m, double t, const double *x, const double *z, const double *adj_ode, const double *adj_alg, const double *adj_quad, double *adj_x, double *adj_z) const
int	calc_quadF (SundialsMemory *m, double t, const double *x, const double *z, double *quad) const
int	calc_quadB (SundialsMemory *m, double t, const double *x, const double *z, const double *adj_ode, const double *adj_alg, double *adj_p, double *adj_u) const
int	calc_jtimesF (SundialsMemory *m, double t, const double *x, const double *z, const double *fwd_x, const double *fwd_z, double *fwd_ode, double *fwd_alg) const
int	calc_jacF (SundialsMemory *m, double t, const double *x, const double *z, double *jac_ode_x, double *jac_alg_x, double *jac_ode_z, double *jac_alg_z) const
Dict	get_stats (void *mem) const override
	Get all statistics. More...
void	print_stats (IntegratorMemory *mem) const override
	Print solver statistics. More...
void	resetB (IntegratorMemory *mem) const override
	Reset the backward problem and take time to tf. More...
void	reset_stats (SundialsMemory *m) const
	Reset stats. More...
void	save_offsets (SundialsMemory *m) const
	Save stats offsets before reset. More...
void	add_offsets (SundialsMemory *m) const
	Add stats offsets to stats. More...
virtual Function	create_advanced (const Dict &opts)
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...
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
void	find (std::map< FunctionInternal *, std::pair< Function, size_t > > &all_fun, casadi_int max_depth) const override
virtual bool	monitored (const std::string &name) const
bool	has_function (const std::string &fname) const override
std::string	generate_dependencies (const std::string &fname, const Dict &opts) const override
	Export / Generate C code for the generated functions. More...
void	jit_dependencies (const std::string &fname) override
	JIT for dependencies. More...
int	local_init_mem (void *mem) const
	Initalize memory block. More...
void	set_temp (void *mem, const double **arg, double **res, casadi_int *iw, double *w) const override
	Set the work vectors. More...
virtual void	codegen_body_enter (CodeGenerator &g) const
	Generate code for the function body. More...
virtual void	codegen_body_exit (CodeGenerator &g) const
	Generate code for the function body. More...
virtual std::string	getAdaptorSolverName () const
	Obtain solver name from Adaptor. More...
Dict	generate_options (const std::string &target) const override
	Reconstruct options dict. More...
void	change_option (const std::string &option_name, const GenericType &option_value) override
	Change option after object creation for debugging. More...
void	reset_dump_count ()
	Reset the counter used to name dump files. 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 *, std::pair< Function, size_t > > &all_fun, const Function &dep, 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 Function	simplify_passes (const std::vector< std::pair< std::string, casadi_int > > &tasks) const
	Apply an ordered list of simplify passes (used by transform) 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...
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	codegen_needs_mem () const
	Is thread-local memory object needed? More...
virtual bool	codegen_mem_is_opaque () const
	Is thread-local memory object managed by checkout/release. More...
virtual 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 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	eval_activity (const bvec_t **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const
	Propagate signal activity forward. More...
virtual int	sp_forward_block (const bvec_t **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem, casadi_int oind, casadi_int iind) const
	Propagate sparsity forward, specific block. More...
void	sz_work (size_t &sz_arg, size_t &sz_res, size_t &sz_iw, size_t &sz_w) const
	Get number of temporary variables needed. More...
size_t	sz_arg () const
	Get required length of arg field. More...
size_t	sz_res () const
	Get required length of res field. More...
size_t	sz_iw () const
	Get required length of iw field. More...
size_t	sz_w () const
	Get required length of w field. More...
void	alloc_arg (size_t sz_arg, bool persistent=false)
	Ensure required length of arg field. More...
void	alloc_res (size_t sz_res, bool persistent=false)
	Ensure required length of res field. More...
void	alloc_iw (size_t sz_iw, bool persistent=false)
	Ensure required length of iw field. More...
void	alloc_w (size_t sz_w, bool persistent=false)
	Ensure required length of w field. More...
void	alloc (const Function &f, bool persistent=false, int num_threads=1)
	Ensure work vectors long enough to evaluate function. More...
void	setup (void *mem, const double **arg, double **res, casadi_int *iw, double *w) const
	Set the (persistent and temporary) work vectors. More...
virtual Dict	info () const
Function	map (casadi_int n, const std::string &parallelization) const
	Generate/retrieve cached serial map. More...
void	generate_in (const std::string &fname, const double **arg) const
	Export an input file that can be passed to generate C code with a main. More...
void	generate_out (const std::string &fname, double **res) const
virtual bool	is_a (const std::string &type, bool recursive) const
	Check if the function is of a particular type. More...
virtual void	merge (const std::vector< MX > &arg, std::vector< MX > &subs_from, std::vector< MX > &subs_to) const
	List merge opportunitities. More...
template<typename MatType >
std::vector< std::vector< MatType > >	fwd_seed (casadi_int nfwd) const
	Symbolic expressions for the forward seeds. More...
template<typename MatType >
std::vector< std::vector< MatType > >	symbolicAdjSeed (casadi_int nadj, const std::vector< MatType > &v) const
	Symbolic expressions for the adjoint seeds. More...
void	print_in (std::ostream &stream, const double **arg, bool truncate) const
	Print inputs. More...
void	print_out (std::ostream &stream, double **res, bool truncate) const
	Print outputs. More...
void	construct (const Dict &opts)
	Construct. More...
void	print_options (std::ostream &stream) const
	Print list of options. More...
void	print_option (const std::string &name, std::ostream &stream) const
	Print all information there is to know about a certain option. More...
bool	has_option (const std::string &option_name) const
	Does a particular option exist. More...
int	checkout () const
	Checkout a memory object. More...
void	release (int mem) const
	Release a memory object. More...
void *	memory (int ind) const
	Memory objects. More...
bool	has_memory (int ind) const
	Check for existance of memory object. More...
virtual void	check_mem_count (casadi_int n) const
	Check for validatity of memory object count. More...
void	clear_mem ()
	Clear all memory (called from destructor) More...
void	print (const char *fmt,...) const
	C-style formatted printing during evaluation. More...
void	sprint (char *buf, size_t buf_sz, const char *fmt,...) const
	C-style formatted printing to string. More...
void	format_time (char *buffer, double time) const
	Format time in a fixed width 8 format. More...
void	print_time (const std::map< std::string, FStats > &fstats) const
	Print timing statistics. More...
void	serialize (SerializingStream &s) const
	Serialize an object. More...
casadi_int	getCount () const
	Get the reference count. More...
std::string	debug_repr (const SharedObjectInternal *) const
GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...
virtual void	deps_version_check (const std::string &stage) const
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...
Function	wrap (const std::string &name) const
	Wrap in an Function instance consisting of only one MX call. More...
Function	wrap () const
	Wrap in an Function instance consisting of only one MX call. More...
Function	wrap_as_needed (const std::string &name, const Dict &opts) const
	Wrap in an Function instance consisting of only one MX call. More...
Function	wrap_as_needed (const Dict &opts) const
	Wrap in an Function instance consisting of only one MX call. More...
casadi_int	nnz_in () const
	Number of input/output nonzeros. More...
casadi_int	nnz_in (casadi_int ind) const
	Number of input/output nonzeros. More...
casadi_int	nnz_out () const
	Number of input/output nonzeros. More...
casadi_int	nnz_out (casadi_int ind) const
	Number of input/output nonzeros. More...
casadi_int	numel_in () const
	Number of input/output elements. More...
casadi_int	numel_in (casadi_int ind) const
	Number of input/output elements. More...
casadi_int	numel_out (casadi_int ind) const
	Number of input/output elements. More...
casadi_int	numel_out () const
	Number of input/output elements. More...
casadi_int	size1_in (casadi_int ind) const
	Input/output dimensions. More...
casadi_int	size2_in (casadi_int ind) const
	Input/output dimensions. More...
casadi_int	size1_out (casadi_int ind) const
	Input/output dimensions. More...
casadi_int	size2_out (casadi_int ind) const
	Input/output dimensions. More...
std::pair< casadi_int, casadi_int >	size_in (casadi_int ind) const
	Input/output dimensions. More...
std::pair< casadi_int, casadi_int >	size_out (casadi_int ind) const
	Input/output dimensions. More...
const Sparsity &	sparsity_in (casadi_int ind) const
	Input/output sparsity. More...
const Sparsity &	sparsity_out (casadi_int ind) const
	Input/output sparsity. More...
bool	all_scalar () const
	Are all inputs and outputs scalar. More...
virtual bool	jac_is_symm (casadi_int oind, casadi_int iind) const
	Is a Jacobian block known to be symmetric a priori? More...
Sparsity	to_compact (casadi_int oind, casadi_int iind, const Sparsity &sp) const
	Convert to compact Jacobian sparsity pattern. More...
Sparsity	from_compact (casadi_int oind, casadi_int iind, const Sparsity &sp) const
	Convert from compact Jacobian sparsity pattern. More...
template<bool fwd>
Sparsity	get_jac_sparsity_gen (casadi_int oind, casadi_int iind) const
	Get the sparsity pattern via sparsity seed propagation. More...
Sparsity	get_jac_sparsity_hierarchical (casadi_int oind, casadi_int iind) const
	A flavor of get_jac_sparsity_gen that does hierarchical block structure recognition. More...
Sparsity	get_jac_sparsity_hierarchical_symm (casadi_int oind, casadi_int iind) const
virtual std::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 Integrator *	creator (const std::string &name, const Function &dae, double t0, const std::vector< double > &tout)
	Create a new integrator. More...
static CvodesMemory *	to_mem (void *mem)
	Cast to memory object. More...
static ProtoFunction *	deserialize (DeserializingStream &s)
	Deserialize into MX. More...
static void	printvar (const std::string &id, double v)
static void	printvar (const std::string &id, N_Vector v)
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 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...
static std::string	get_jit_directory (const Dict &jit_options)
	Get JIT directory from options. More...
template<typename MatType >
static bool	purgable (const std::vector< MatType > &seed)
	Can a derivative direction be skipped. More...
static std::string	string_from_UnifiedReturnStatus (UnifiedReturnStatus status)
static void	print_canonical (std::ostream &stream, const Sparsity &sp, const double *nz)
	Print canonical representation of a numeric matrix. More...
static void	print_canonical (std::ostream &stream, casadi_int sz, const double *nz)
	Print canonical representation of a numeric vector. More...
static void	print_canonical (std::ostream &stream, double a)
	Print canonical representation of a number. More...
static bool	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
Linsol	linsolF_
	Linear solver. More...
enum casadi::SundialsInterface::NewtonScheme	newton_scheme_
enum casadi::SundialsInterface::InterpType	interp_
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_directory_
std::string	jit_base_name_
bool	jit_temp_suffix_
	Use a temporary name. More...
eval_t	eval_
	Numerical evaluation redirected to a C function. More...
casadi_checkout_t	checkout_
	Checkout redirected to a C function. More...
casadi_release_t	release_
	Release redirected to a C function. More...
signal_t	incref_
	Incref/decref redirected to C functions. More...
signal_t	decref_
Dict	stats_
	Dict of statistics (resulting from evaluate) More...
bool	has_refcount_
	Reference counting in codegen? More...
bool	has_refcount_in_deps_
	Reference counting in dependent functions. More...
Dict	cache_init_
	Values to prepopulate the function cache with. More...
WeakCache< std::string, Function >	cache_
	Function cache. More...
std::vector< Sparsity >	jac_sparsity_ [2]
	Cache for sparsities of the Jacobian blocks. More...
Function	derivative_of_
	If the function is the derivative of another function. More...
void *	user_data_
	User-set field. More...
std::string	compiler_plugin_
	Just-in-time compiler. More...
Importer	compiler_
Dict	jit_options_
double	jac_penalty_
	Penalty factor for using a complete Jacobian to calculate directional derivatives. More...
bool	enable_forward_
bool	enable_reverse_
bool	enable_jacobian_
bool	enable_fd_
bool	enable_forward_op_
bool	enable_reverse_op_
bool	enable_jacobian_op_
bool	enable_fd_op_
double	ad_weight_
	Weighting factor for derivative calculation and sparsity pattern calculation. More...
double	ad_weight_sp_
casadi_int	max_num_dir_
	Maximum number of sensitivity directions. More...
bool	inputs_check_
	Errors are thrown if numerical values of inputs look bad. More...
Dict	fd_options_
double	fd_step_
std::string	fd_method_
bool	print_in_
bool	print_out_
bool	print_canonical_
casadi_int	max_io_
bool	dump_in_
bool	dump_out_
bool	dump_
std::string	dump_dir_
std::string	dump_format_
Dict	forward_options_
Dict	reverse_options_
Dict	jacobian_options_
Dict	der_options_
Function	custom_jacobian_
std::vector< Function >	registered_functions_
casadi_int	dump_count_
std::string	name_
	Name. More...
bool	verbose_
	Verbose printout. More...
bool	print_time_
bool	record_time_
bool	regularity_check_
	Errors are thrown when NaN is produced. More...
bool	error_on_fail_
	Throw an exception on failure? More...
double	abstol_
double	reltol_
casadi_int	max_num_steps_
bool	stop_at_end_
bool	quad_err_con_
casadi_int	steps_per_checkpoint_
bool	disable_internal_warnings_
casadi_int	max_multistep_order_
std::string	linear_solver_
Dict	linear_solver_options_
casadi_int	max_krylov_
bool	use_precon_
bool	second_order_correction_
double	step0_
double	max_step_size_
double	nonlin_conv_coeff_
casadi_int	max_order_
bool	scale_abstol_

Static Public Attributes
static const std::string	meta_doc
	A documentation string. More...
static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...
static const std::string	infix_ = "integrator"
	Infix. More...
static std::map< std::string, ProtoFunction *(*)(DeserializingStream &)>	deserialize_map

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

Static Protected Member Functions
static void	ehfun (int error_code, const char *module, const char *function, char *msg, void *user_data)
static int	rhsF (double t, N_Vector x, N_Vector xdot, void *user_data)
static int	rhsB (double t, N_Vector x, N_Vector xB, N_Vector xdotB, void *user_data)
static int	rhsQF (double t, N_Vector x, N_Vector qdot, void *user_data)
static int	rhsQB (double t, N_Vector x, N_Vector rx, N_Vector ruqdot, void *user_data)
static int	jtimesF (N_Vector v, N_Vector Jv, double t, N_Vector x, N_Vector xdot, void *user_data, N_Vector tmp)
static int	jtimesB (N_Vector vB, N_Vector JvB, double t, N_Vector x, N_Vector xB, N_Vector xdotB, void *user_data, N_Vector tmpB)
static int	psolveF (double t, N_Vector x, N_Vector xdot, N_Vector r, N_Vector z, double gamma, double delta, int lr, void *user_data, N_Vector tmp)
static int	psolveB (double t, N_Vector x, N_Vector xB, N_Vector xdotB, N_Vector rvecB, N_Vector zvecB, double gammaB, double deltaB, int lr, void *user_data, N_Vector tmpB)
static int	psetupF (double t, N_Vector x, N_Vector xdot, booleantype jok, booleantype *jcurPtr, double gamma, void *user_data, N_Vector tmp1, N_Vector tmp2, N_Vector tmp3)
static int	psetupB (double t, N_Vector x, N_Vector xB, N_Vector xdotB, booleantype jokB, booleantype *jcurPtrB, double gammaB, void *user_data, N_Vector tmp1B, N_Vector tmp2B, N_Vector tmp3B)
static int	lsetupF (CVodeMem cv_mem, int convfail, N_Vector x, N_Vector xdot, booleantype *jcurPtr, N_Vector vtemp1, N_Vector vtemp2, N_Vector vtemp3)
static int	lsolveF (CVodeMem cv_mem, N_Vector b, N_Vector weight, N_Vector x, N_Vector xdot)
static int	lsetupB (CVodeMem cv_mem, int convfail, N_Vector x, N_Vector xdot, booleantype *jcurPtr, N_Vector vtemp1, N_Vector vtemp2, N_Vector vtemp3)
static int	lsolveB (CVodeMem cv_mem, N_Vector b, N_Vector weight, N_Vector x, N_Vector xdot)
static void	cvodes_error (const char *module, int flag)

Protected Attributes
casadi_int	lmm_
casadi_int	iter_
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...
double	min_step_size_
	Options. More...
bool	always_recalculate_jacobian_
	Options. More...
const Options &	get_options () const override
	Options. 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...
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...

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

InterpType

enum casadi::SundialsInterface::InterpType

inherited

Enumerator
SD_POLYNOMIAL
SD_HERMITE

Definition at line 215 of file sundials_interface.hpp.

{SD_POLYNOMIAL, SD_HERMITE} interp_;

JacFOut

enum casadi::SundialsInterface::JacFOut

inherited

Enumerator
JACF_ODE_X
JACF_ALG_X
JACF_ODE_Z
JACF_ALG_Z
JACF_NUM_OUT

Definition at line 184 of file sundials_interface.hpp.

{JACF_ODE_X, JACF_ALG_X, JACF_ODE_Z, JACF_ALG_Z, JACF_NUM_OUT};

JtimesFIn

enum casadi::SundialsInterface::JtimesFIn

inherited

Enumerator
JTIMESF_T
JTIMESF_X
JTIMESF_Z
JTIMESF_P
JTIMESF_U
JTIMESF_FWD_X
JTIMESF_FWD_Z
JTIMESF_NUM_IN

Definition at line 181 of file sundials_interface.hpp.

                   { JTIMESF_T, JTIMESF_X, JTIMESF_Z, JTIMESF_P, JTIMESF_U, JTIMESF_FWD_X,
      JTIMESF_FWD_Z, JTIMESF_NUM_IN};

JtimesFOut

enum casadi::SundialsInterface::JtimesFOut

inherited

Enumerator
JTIMESF_FWD_ODE
JTIMESF_FWD_ALG
JTIMESF_NUM_OUT

Definition at line 183 of file sundials_interface.hpp.

{ JTIMESF_FWD_ODE, JTIMESF_FWD_ALG, JTIMESF_NUM_OUT};

NewtonScheme

enum casadi::SundialsInterface::NewtonScheme

inherited

Enumerator
SD_DIRECT
SD_GMRES
SD_BCGSTAB
SD_TFQMR

Definition at line 212 of file sundials_interface.hpp.

{SD_DIRECT, SD_GMRES, SD_BCGSTAB, SD_TFQMR} newton_scheme_;

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

CvodesInterface() [1/2]

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

Definition at line 51 of file cvodes_interface.cpp.

                                              : SundialsInterface(name, dae, t0, tout) {
}

~CvodesInterface()

casadi::CvodesInterface::~CvodesInterface ( )

override

Definition at line 55 of file cvodes_interface.cpp.

                                  {
  clear_mem();
}

References casadi::ProtoFunction::clear_mem().

CvodesInterface() [2/2]

casadi::CvodesInterface::CvodesInterface ( DeserializingStream &  s )

explicitprotected

Definition at line 759 of file cvodes_interface.cpp.

                                                       : SundialsInterface(s) {
  int version = s.version("CvodesInterface", 1, 3);
  s.unpack("CvodesInterface::lmm", lmm_);
  s.unpack("CvodesInterface::iter", iter_);
 
  if (version>=2) {
    s.unpack("CvodesInterface::min_step_size", min_step_size_);
  } else {
    min_step_size_ = 0;
  }
 
  if (version >= 3) {
    s.unpack("CvodesInterface::always_recalculate_jacobian", always_recalculate_jacobian_);
  }
}

References always_recalculate_jacobian_, iter_, lmm_, min_step_size_, 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 3464 of file function_internal.cpp.

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

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

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

add_embedded()

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

inherited

Definition at line 3906 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()] = std::make_pair(dep, all_fun.size());
      // Also add its dependencies
      if (max_depth > 0) dep->find(all_fun, max_depth - 1);
    }
  }

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

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

add_offsets()

void casadi::SundialsInterface::add_offsets ( SundialsMemory *  m ) const

inherited

Definition at line 374 of file sundials_interface.cpp.

                                                           {
  // Add stats offsets, backward problem
  m->nstepsB += m->nstepsB_off;
  m->nfevalsB += m->nfevalsB_off;
  m->nlinsetupsB += m->nlinsetupsB_off;
  m->netfailsB += m->netfailsB_off;
  m->nnitersB += m->nnitersB_off;
  m->nncfailsB += m->nncfailsB_off;
 
}

References casadi::SundialsMemory::netfailsB, casadi::SundialsMemory::netfailsB_off, casadi::SundialsMemory::nfevalsB, casadi::SundialsMemory::nfevalsB_off, casadi::SundialsMemory::nlinsetupsB, casadi::SundialsMemory::nlinsetupsB_off, casadi::SundialsMemory::nncfailsB, casadi::SundialsMemory::nncfailsB_off, casadi::SundialsMemory::nnitersB, casadi::SundialsMemory::nnitersB_off, casadi::SundialsMemory::nstepsB, and casadi::SundialsMemory::nstepsB_off.

Referenced by retreat(), and casadi::IdasInterface::retreat().

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 3197 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::CvodesInterface::advance_noevent ( IntegratorMemory *  mem ) const

overridevirtual

Implements casadi::Integrator.

Definition at line 259 of file cvodes_interface.cpp.

                                                                {
  auto m = to_mem(mem);
 
  // Do not integrate past change in input signals or past the end
  // The event handling may cause the stop time to become smaller than internal time reached,
  // in which case the stop time cannot be enforced
  if (m->t_stop >= m->tcur) {
    THROWING(CVodeSetStopTime, m->mem, m->t_stop);
  }
 
  // Integrate, unless already at desired time
  const double ttol = 1e-9;
  if (fabs(m->t - m->t_next) >= ttol) {
    // Integrate forward ...
    double tret = m->t;
    if (nrx_>0) {
      // ... with taping
      THROWING(CVodeF, m->mem, m->t_next, m->v_xz, &tret, CV_NORMAL, &m->ncheck);
    } else {
      // ... without taping
      THROWING(CVode, m->mem, m->t_next, m->v_xz, &tret, CV_NORMAL);
    }
 
    // Get quadratures
    if (nq_ > 0) {
      THROWING(CVodeGetQuad, m->mem, &tret, m->v_q);
    }
  }
 
  // Set function outputs
  casadi_copy(NV_DATA_S(m->v_xz), nx_, m->x);
  casadi_copy(NV_DATA_S(m->v_q), nq_, m->q);
 
  // Get stats
  THROWING(CVodeGetIntegratorStats, m->mem, &m->nsteps, &m->nfevals, &m->nlinsetups,
            &m->netfails, &m->qlast, &m->qcur, &m->hinused,
            &m->hlast, &m->hcur, &m->tcur);
  THROWING(CVodeGetNonlinSolvStats, m->mem, &m->nniters, &m->nncfails);
 
  return 0;
}

References casadi::casadi_copy(), casadi::Integrator::nq_, casadi::Integrator::nrx_, casadi::Integrator::nx_, and to_mem().

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 casadi::FixedStepIntegrator::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 casadi::FixedStepIntegrator::create_advanced().

all_scalar()

bool casadi::FunctionInternal::all_scalar ( ) const

inherited

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

Definition at line 3951 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 2757 of file integrator.cpp.

                                                       {
  // Quick return if trivially zero
  if (v == nullptr || 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 3145 of file function_internal.cpp.

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

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

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

alloc_arg()

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

inherited

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

Definition at line 3113 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::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::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 3129 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::MadmpecInterface::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::MosekInterface::init(), casadi::OoqpInterface::init(), casadi::SlicotDple::init(), casadi::SlicotExpm::init(), casadi::SundialsInterface::init(), casadi::XpressInterface::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::CvodesInterface::alloc_mem ( ) const

inlineoverridevirtual

Reimplemented from casadi::OracleFunction.

Definition at line 121 of file cvodes_interface.hpp.

{ return new CvodesMemory(*this);}

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 3121 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::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::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 3137 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(), casadi::FixedStepIntegrator::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::MadmpecInterface::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::MosekInterface::init(), casadi::OoqpInterface::init(), casadi::OsqpInterface::init(), casadi::PiqpInterface::init(), casadi::ProxqpInterface::init(), casadi::QpoasesInterface::init(), casadi::SLEQPInterface::init(), casadi::SlicotDple::init(), casadi::SlicotExpm::init(), casadi::SnoptInterface::init(), init(), casadi::IdasInterface::init(), casadi::KinsolInterface::init(), casadi::SundialsInterface::init(), casadi::SuperscsInterface::init(), casadi::WorhpInterface::init(), casadi::XpressInterface::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_ : nullptr;  // fwd:adj_p
    m->res[BQUAD_ADJ_U] = adj_u ? adj_u + (i + 1) * nuq1_ * nadj_: nullptr;  // 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_ : nullptr;  // fwd:adj_p
    m->res[BQUAD_ADJ_U] = adj_u ? adj_u + (i + 1) * nuq1_ * nadj_ : nullptr;  // 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 1105 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_daeB()

int casadi::SundialsInterface::calc_daeB ( SundialsMemory *  m, double  t, const double *  x, const double *  z, const double *  adj_ode, const double *  adj_alg, const double *  adj_quad, double *  adj_x, double *  adj_z  ) const

inherited

Definition at line 595 of file sundials_interface.cpp.

                                        {
  // Evaluate nondifferentiated
  m->arg[BDYN_T] = &t;  // t
  m->arg[BDYN_X] = x;  // x
  m->arg[BDYN_Z] = z;  // z
  m->arg[BDYN_P] = m->p;  // p
  m->arg[BDYN_U] = m->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[BDAE_ADJ_X] = adj_x;  // adj_x
  m->res[BDAE_ADJ_Z] = adj_z;  // adj_z
  // Issue #3353: zero-init when adj_* output is structurally empty
  const Function& daeB = get_function("daeB");
  if (adj_x && !daeB.nnz_out(BDAE_ADJ_X)) casadi_clear(adj_x, nrx1_ * nadj_);
  if (adj_z && !daeB.nnz_out(BDAE_ADJ_Z)) casadi_clear(adj_z, nrz1_ * nadj_);
  if (calc_function(m, "daeB")) return 1;
  // Evaluate sensitivities
  if (nfwd_ > 0) {
    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] = 0;  // fwd:t
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_X] = x ? x + nx1_ : x;  // fwd:x
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_Z] = z ? z + nz1_ : z;  // fwd:z
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_P] = m->p + np1_;  // fwd:p
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_U] = m->u + 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 ? adj_ode + nrx1_ * nadj_ : 0;  // fwd:adj_ode
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_ALG] =
      adj_alg ? adj_alg + nrz1_ * nadj_ : 0;  // fwd:adj_alg
    m->arg[BDYN_NUM_IN + BDAE_NUM_OUT + BDYN_ADJ_QUAD] =
      adj_quad ? adj_quad + nrp1_ * nadj_ : 0;  // 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 ? adj_x + nrx1_ * nadj_ : 0;  // fwd:adj_x
    m->res[BDAE_ADJ_Z] = adj_z ? adj_z + nrz1_ * nadj_ : 0;  // fwd:adj_z
    const Function& fwd_daeB = get_function(forward_name("daeB", nfwd_));
    if (adj_x && !fwd_daeB.nnz_out(BDAE_ADJ_X))
      casadi_clear(adj_x + nrx1_ * nadj_, nrx1_ * nadj_ * nfwd_);
    if (adj_z && !fwd_daeB.nnz_out(BDAE_ADJ_Z))
      casadi_clear(adj_z + nrz1_ * nadj_, nrz1_ * nadj_ * nfwd_);
    if (calc_function(m, forward_name("daeB", nfwd_))) return 1;
  }
  return 0;
}

References casadi::OracleMemory::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_function(), casadi::casadi_clear(), casadi::FunctionInternal::forward_name(), casadi::OracleFunction::get_function(), casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Function::nnz_out(), casadi::Integrator::np1_, casadi::Integrator::nrp1_, casadi::Integrator::nrx1_, casadi::Integrator::nrz1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::IntegratorMemory::p, casadi::OracleMemory::res, and casadi::IntegratorMemory::u.

Referenced by casadi::IdasInterface::solve_transposed(), and casadi::IdasInterface::z_impulseB().

calc_daeF()

int casadi::SundialsInterface::calc_daeF ( SundialsMemory *  m, double  t, const double *  x, const double *  z, double *  ode, double *  alg  ) const

inherited

Definition at line 568 of file sundials_interface.cpp.

                                    {
  // Evaluate nondifferentiated
  m->arg[DYN_T] = &t;  // t
  m->arg[DYN_X] = x;  // x
  m->arg[DYN_Z] = z;  // z
  m->arg[DYN_P] = m->p;  // p
  m->arg[DYN_U] = m->u;  // u
  m->res[DAE_ODE] = ode;  // ode
  m->res[DAE_ALG] = alg;  // alg
  if (calc_function(m, "daeF")) return 1;
  // Evaluate sensitivities
  if (nfwd_ > 0) {
    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] = 0;  // fwd:t
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_X] = x + nx1_;  // fwd:x
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_Z] = z ? z + nz1_ : 0;  // fwd:z
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_P] = m->p + np1_;  // fwd:p
    m->arg[DYN_NUM_IN + DAE_NUM_OUT + DYN_U] = m->u + nu1_;  // fwd:u
    m->res[DAE_ODE] = ode ? ode + nx1_ : 0;  // fwd:ode
    m->res[DAE_ALG] = alg ? alg + nz1_ : 0;  // fwd:alg
    if (calc_function(m, forward_name("daeF", nfwd_))) return 1;
  }
  return 0;
}

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), 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::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::IntegratorMemory::p, casadi::OracleMemory::res, and casadi::IntegratorMemory::u.

calc_edot()

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

inherited

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

Definition at line 2585 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(), casadi::FixedStepIntegrator::stepB(), casadi::FixedStepIntegrator::stepF(), casadi::Integrator::trigger_event(), and casadi::SnoptInterface::userfun().

calc_jacF()

int casadi::SundialsInterface::calc_jacF ( SundialsMemory *  m, double  t, const double *  x, const double *  z, double *  jac_ode_x, double *  jac_alg_x, double *  jac_ode_z, double *  jac_alg_z  ) const

inherited

Definition at line 760 of file sundials_interface.cpp.

                                                                                      {
  // Calculate Jacobian
  m->arg[DYN_T] = &t;
  m->arg[DYN_X] = x;
  m->arg[DYN_Z] = z;
  m->arg[DYN_P] = m->p;
  m->arg[DYN_U] = m->u;
  m->res[JACF_ODE_X] = jac_ode_x;
  m->res[JACF_ALG_X] = jac_alg_x;
  m->res[JACF_ODE_Z] = jac_ode_z;
  m->res[JACF_ALG_Z] = jac_alg_z;
  return calc_function(m, "jacF");
}

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::DYN_P, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::SundialsInterface::JACF_ALG_X, casadi::SundialsInterface::JACF_ALG_Z, casadi::SundialsInterface::JACF_ODE_X, casadi::SundialsInterface::JACF_ODE_Z, casadi::IntegratorMemory::p, casadi::OracleMemory::res, and casadi::IntegratorMemory::u.

calc_jtimesF()

int casadi::SundialsInterface::calc_jtimesF ( SundialsMemory *  m, double  t, const double *  x, const double *  z, const double *  fwd_x, const double *  fwd_z, double *  fwd_ode, double *  fwd_alg  ) const

inherited

Definition at line 728 of file sundials_interface.cpp.

                                                                                      {
  // Evaluate nondifferentiated
  m->arg[JTIMESF_T] = &t;  // t
  m->arg[JTIMESF_X] = x;  // x
  m->arg[JTIMESF_Z] = z;  // z
  m->arg[JTIMESF_P] = m->p;  // p
  m->arg[JTIMESF_U] = m->u;  // u
  m->arg[JTIMESF_FWD_X] = fwd_x;  // fwd:x
  m->arg[JTIMESF_FWD_Z] = fwd_z;  // fwd:z
  m->res[JTIMESF_FWD_ODE] = fwd_ode;  // fwd:ode
  m->res[JTIMESF_FWD_ALG] = fwd_alg;  // fwd:alg
  if (calc_function(m, "jtimesF")) return 1;
  // Evaluate sensitivities
  if (nfwd_ > 0) {
    m->arg[JTIMESF_NUM_IN + JTIMESF_FWD_ODE] = fwd_ode;  // out:fwd:ode
    m->arg[JTIMESF_NUM_IN + JTIMESF_FWD_ALG] = fwd_alg;  // out:fwd:alg
    m->arg[JTIMESF_NUM_IN + JTIMESF_NUM_OUT + JTIMESF_T] = 0;  // fwd:t
    m->arg[JTIMESF_NUM_IN + JTIMESF_NUM_OUT + JTIMESF_X] = x + nx1_;  // fwd:x
    m->arg[JTIMESF_NUM_IN + JTIMESF_NUM_OUT + JTIMESF_Z] = z + nz1_;  // fwd:z
    m->arg[JTIMESF_NUM_IN + JTIMESF_NUM_OUT + JTIMESF_P] = m->p + np1_;  // fwd:p
    m->arg[JTIMESF_NUM_IN + JTIMESF_NUM_OUT + JTIMESF_U] = m->u + nu1_;  // fwd:u
    m->arg[JTIMESF_NUM_IN + JTIMESF_NUM_OUT + JTIMESF_FWD_X] = fwd_x + nx1_;  // fwd:fwd:x
    m->arg[JTIMESF_NUM_IN + JTIMESF_NUM_OUT + JTIMESF_FWD_Z] = fwd_z + nz1_;  // fwd:fwd:z
    m->res[JTIMESF_FWD_ODE] = fwd_ode + nx1_;  // fwd:fwd:ode
    m->res[JTIMESF_FWD_ALG] = fwd_alg + nz1_;  // fwd:fwd:alg
    if (calc_function(m, forward_name("jtimesF", nfwd_))) return 1;
  }
  // Successful return
  return 0;
}

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::FunctionInternal::forward_name(), casadi::SundialsInterface::JTIMESF_FWD_ALG, casadi::SundialsInterface::JTIMESF_FWD_ODE, casadi::SundialsInterface::JTIMESF_FWD_X, casadi::SundialsInterface::JTIMESF_FWD_Z, casadi::SundialsInterface::JTIMESF_NUM_IN, casadi::SundialsInterface::JTIMESF_NUM_OUT, casadi::SundialsInterface::JTIMESF_P, casadi::SundialsInterface::JTIMESF_T, casadi::SundialsInterface::JTIMESF_U, casadi::SundialsInterface::JTIMESF_X, casadi::SundialsInterface::JTIMESF_Z, casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::IntegratorMemory::p, casadi::OracleMemory::res, and casadi::IntegratorMemory::u.

calc_quadB()

int casadi::SundialsInterface::calc_quadB ( SundialsMemory *  m, double  t, const double *  x, const double *  z, const double *  adj_ode, const double *  adj_alg, double *  adj_p, double *  adj_u  ) const

inherited

Definition at line 674 of file sundials_interface.cpp.

                                                                                      {
  // Evaluate nondifferentiated
  m->arg[BDYN_T] = &t;  // t
  m->arg[BDYN_X] = x;  // x
  m->arg[BDYN_Z] = z;  // z
  m->arg[BDYN_P] = m->p;  // p
  m->arg[BDYN_U] = m->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] = m->adj_q;  // 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
  // Issue #3353: zero-init when adj_* output is structurally empty
  const Function& quadB = get_function("quadB");
  if (adj_p && !quadB.nnz_out(BQUAD_ADJ_P)) casadi_clear(adj_p, nrq1_ * nadj_);
  if (adj_u && !quadB.nnz_out(BQUAD_ADJ_U)) casadi_clear(adj_u, nuq1_ * nadj_);
  if (calc_function(m, "quadB")) return 1;
  // Evaluate sensitivities
  if (nfwd_ > 0) {
    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] = 0;  // fwd:t
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_X] = x ? x + nx1_ : 0;  // fwd:x
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_Z] = z ? z + nz1_ : 0;  // fwd:z
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_P] = m->p + np1_;  // fwd:p
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_U] = m->u + 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 ? adj_ode + nrx1_ * nadj_ : 0;  // fwd:adj_ode
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_ALG] =
      adj_alg ? adj_alg + nrz1_ * nadj_ : 0;  // fwd:adj_alg
    m->arg[BDYN_NUM_IN + BQUAD_NUM_OUT + BDYN_ADJ_QUAD] = m->adj_q + 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 + nrq1_ * nadj_;  // fwd:adj_p
    m->res[BQUAD_ADJ_U] = adj_u + nuq1_ * nadj_;  // fwd:adj_u
    const Function& fwd_quadB = get_function(forward_name("quadB", nfwd_));
    if (adj_p && !fwd_quadB.nnz_out(BQUAD_ADJ_P))
      casadi_clear(adj_p + nrq1_ * nadj_, nrq1_ * nadj_ * nfwd_);
    if (adj_u && !fwd_quadB.nnz_out(BQUAD_ADJ_U))
      casadi_clear(adj_u + nuq1_ * nadj_, nuq1_ * nadj_ * nfwd_);
    if (calc_function(m, forward_name("quadB", nfwd_))) return 1;
  }
  return 0;
}

References casadi::IntegratorMemory::adj_q, casadi::OracleMemory::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_function(), casadi::casadi_clear(), casadi::FunctionInternal::forward_name(), casadi::OracleFunction::get_function(), casadi::Integrator::nadj_, casadi::Integrator::nfwd_, casadi::Function::nnz_out(), 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::IntegratorMemory::p, casadi::OracleMemory::res, and casadi::IntegratorMemory::u.

calc_quadF()

int casadi::SundialsInterface::calc_quadF ( SundialsMemory *  m, double  t, const double *  x, const double *  z, double *  quad  ) const

inherited

Definition at line 651 of file sundials_interface.cpp.

                        {
  m->arg[DYN_T] = &t;  // t
  m->arg[DYN_X] = x;  // x
  m->arg[DYN_Z] = z;  // z
  m->arg[DYN_P] = m->p;  // p
  m->arg[DYN_U] = m->u;  // u
  m->res[QUAD_QUAD] = quad;  // quad
  if (calc_function(m, "quadF")) return 1;
  // Evaluate sensitivities
  if (nfwd_ > 0) {
    m->arg[DYN_NUM_IN + QUAD_QUAD] = quad;  // out:quad
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_T] = 0;  // fwd:t
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_X] = x + nx1_;  // fwd:x
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_Z] = z ? z + nz1_ : 0;  // fwd:z
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_P] = m->p + np1_;  // fwd:p
    m->arg[DYN_NUM_IN + QUAD_NUM_OUT + DYN_U] = m->u + nu1_;  // fwd:u
    m->res[QUAD_QUAD] = quad ? quad + nq1_ : 0;  // fwd:quad
    if (calc_function(m, forward_name("quadF", nfwd_))) return 1;
  }
  return 0;
}

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::DYN_NUM_IN, casadi::DYN_P, casadi::DYN_T, casadi::DYN_U, casadi::DYN_X, casadi::DYN_Z, casadi::FunctionInternal::forward_name(), casadi::Integrator::nfwd_, casadi::Integrator::np1_, casadi::Integrator::nq1_, casadi::Integrator::nu1_, casadi::Integrator::nx1_, casadi::Integrator::nz1_, casadi::IntegratorMemory::p, casadi::Integrator::QUAD_NUM_OUT, casadi::Integrator::QUAD_QUAD, casadi::OracleMemory::res, and casadi::IntegratorMemory::u.

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

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

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 3438 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 4125 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 1719 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 3323 of file function_internal.cpp.

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

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 3451 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::SXFunction, and casadi::MXFunction.

Definition at line 443 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 == "print_canonical") {
      print_canonical_ = 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_canonical_, casadi::FunctionInternal::print_in_, casadi::FunctionInternal::print_out_, and casadi::GenericType::to_string().

Referenced by casadi::FmuFunction::change_option(), casadi::MXFunction::change_option(), and casadi::SXFunction::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 1766 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 3649 of file function_internal.cpp.

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

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

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

check_mem_count()

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

inlinevirtualinherited

Purpose if to allow more helpful error messages

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

Reimplemented in casadi::FmuFunction.

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

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

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

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

class_name()

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

inlineoverridevirtual

Implements casadi::SharedObjectInternal.

Definition at line 106 of file cvodes_interface.hpp.

{ return "CvodesInterface";}

clear_mem()

void casadi::ProtoFunction::clear_mem ( )

inherited

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

Definition at line 3746 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(), ~CvodesInterface(), casadi::DaqpInterface::~DaqpInterface(), casadi::External::~External(), casadi::FastNewton::~FastNewton(), casadi::FatropConicInterface::~FatropConicInterface(), casadi::FatropInterface::~FatropInterface(), casadi::Feasiblesqpmethod::~Feasiblesqpmethod(), casadi::FiniteDiff::~FiniteDiff(), casadi::FixedStepIntegrator::~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::MadmpecInterface::~MadmpecInterface(), casadi::MadnlpInterface::~MadnlpInterface(), casadi::Map::~Map(), casadi::MapSum::~MapSum(), casadi::MosekInterface::~MosekInterface(), casadi::MumpsInterface::~MumpsInterface(), casadi::MXFunction::~MXFunction(), casadi::Newton::~Newton(), casadi::Nlpsol::~Nlpsol(), casadi::OmpMap::~OmpMap(), casadi::OnnxFunction::~OnnxFunction(), casadi::OnnxRuntimeInterface::~OnnxRuntimeInterface(), casadi::OoqpInterface::~OoqpInterface(), casadi::OsqpInterface::~OsqpInterface(), casadi::PiqpInterface::~PiqpInterface(), 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(), casadi::UnoInterface::~UnoInterface(), casadi::WorhpInterface::~WorhpInterface(), and casadi::XpressInterface::~XpressInterface().

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

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

References casadi::CodeGenerator::auxiliaries, casadi::CodeGenerator::body, casadi::FunctionInternal::codegen_body(), casadi::FunctionInternal::codegen_name(), casadi::CodeGenerator::define_local_mutex(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::dump_in_, casadi::FunctionInternal::dump_out_, casadi::CodeGenerator::flush(), casadi::CodeGenerator::generate_dump(), casadi::CodeGenerator::generate_print(), casadi::CodeGenerator::local_mutex(), casadi::FunctionInternal::print_in_, casadi::FunctionInternal::print_out_, casadi::CodeGenerator::scope_enter(), casadi::CodeGenerator::scope_exit(), casadi::CodeGenerator::shorthand(), casadi::FunctionInternal::signature(), and casadi::CodeGenerator::thread_safe().

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

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

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

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

codegen_body()

void casadi::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::XpressInterface, casadi::UnoInterface, casadi::OsqpInterface, casadi::OnnxRuntimeInterface, casadi::MosekInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HpipmInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, casadi::MadmpecInterface, 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 3003 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 2605 of file function_internal.cpp.

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

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

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

codegen_declarations()

void casadi::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::UnoInterface, casadi::OnnxRuntimeInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::FatropInterface, casadi::MadmpecInterface, casadi::SXFunction, casadi::Switch, casadi::Nlpsol, casadi::MXFunction, casadi::MapSum, casadi::ThreadMap, casadi::Map, casadi::FiniteDiff, and casadi::External.

Definition at line 2999 of file function_internal.cpp.

                                                                    {
    // Nothing to declare
  }

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

codegen_decref()

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

virtualinherited

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

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

Definition at line 2551 of file function_internal.cpp.

                                                              {
 
    // Treat dependent functions
    std::set<void*> added;
    Function F = shared_from_this<Function>();
    for (const Function& f : F.find_functions(0)) {
      if (f->has_refcount_in_deps_) {
        std::string cg_name = f->codegen_name(g, false);
        auto i = added.insert(f.get());
        if (i.second) { // prevent duplicate calls
          std::string decref = g.shorthand(cg_name + "_decref");
          g << decref << "();\n";
        }
      }
    }
 
    if (has_refcount_) {
      std::string name = codegen_name(g, false);
      std::string ref_counter = g.shorthand(name + "_ref_counter");
      std::string mem_counter = g.shorthand(name + "_mem_counter");
      std::string free_mem = g.shorthand(name + "_free_mem");
      g << ref_counter << "--;\n";
      g << "if (" << ref_counter << "==0) {\n";
      if (codegen_needs_mem())  {
        g << "while (" << mem_counter << ">0) {\n";
        g << free_mem << "(--" << mem_counter << ");\n";
        g << "}\n";
      }
      if (g.thread_safe()) {
        Function F = shared_from_this<Function>();
        for (const auto& m : g.local_mutexes(F)) {
          std::string mtx = g.local_mutex(F, m);
          g << "#if CASADI_MUTEX_USE_STATIC_INIT == 0\n";
          g << "CASADI_MUTEX_DESTROY(&" << mtx << ");\n";
          g << "#endif\n";
        }
      }
      g << "}\n";
    }
  }

References casadi::FunctionInternal::codegen_name(), casadi::FunctionInternal::codegen_needs_mem(), casadi::Function::find_functions(), casadi::FunctionInternal::free_mem(), casadi::FunctionInternal::has_refcount_, casadi::CodeGenerator::local_mutex(), casadi::CodeGenerator::local_mutexes(), casadi::CodeGenerator::shorthand(), and casadi::CodeGenerator::thread_safe().

Referenced by casadi::CodeGenerator::add_dependency(), and casadi::MXFunction::codegen_decref().

codegen_free_mem()

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

inlinevirtualinherited

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

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

Definition at line 885 of file function_internal.hpp.

{}

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

codegen_incref()

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

virtualinherited

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

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

Definition at line 2518 of file function_internal.cpp.

                                                              {
    if (has_refcount_) {
      std::string name = codegen_name(g, false);
      std::string ref_counter = g.shorthand(name + "_ref_counter");
      g.auxiliaries << "static int " << ref_counter  << " = 0;\n";
 
      Function F = shared_from_this<Function>();
      if (g.thread_safe()) {
        for (const auto& m : g.local_mutexes(F)) {
          std::string mtx = g.local_mutex(F, m);
          g << "#if CASADI_MUTEX_USE_STATIC_INIT == 0\n";
          g << "if (" << ref_counter << "==0) CASADI_MUTEX_INIT(&" << mtx << ");\n";
          g << "#endif\n";
        }
      }
      g << ref_counter << "++;\n";
    }
 
    // Treat dependent functions
    std::set<void*> added;
    Function F = shared_from_this<Function>();
    for (const Function& f : F.find_functions(0)) {
      if (f->has_refcount_in_deps_) {
        std::string cg_name = f->codegen_name(g, false);
        auto i = added.insert(f.get());
        if (i.second) { // prevent duplicate calls
          std::string incref = g.shorthand(cg_name + "_incref");
          g << incref << "();\n";
        }
      }
    }
  }

References casadi::CodeGenerator::auxiliaries, casadi::FunctionInternal::codegen_name(), casadi::Function::find_functions(), casadi::FunctionInternal::has_refcount_, casadi::CodeGenerator::local_mutex(), casadi::CodeGenerator::local_mutexes(), casadi::CodeGenerator::shorthand(), and casadi::CodeGenerator::thread_safe().

Referenced by casadi::CodeGenerator::add_dependency(), and casadi::MXFunction::codegen_incref().

codegen_init_mem()

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

virtualinherited

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

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

Definition at line 2592 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 2993 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::MadmpecInterface::codegen_body(), 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::MosekInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::UnoInterface::codegen_body(), casadi::XpressInterface::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::MadmpecInterface::codegen_free_mem(), 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::MosekInterface::codegen_free_mem(), casadi::OsqpInterface::codegen_free_mem(), casadi::UnoInterface::codegen_free_mem(), casadi::XpressInterface::codegen_free_mem(), casadi::MadmpecInterface::codegen_init_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(), casadi::MosekInterface::codegen_init_mem(), casadi::OsqpInterface::codegen_init_mem(), casadi::UnoInterface::codegen_init_mem(), casadi::XpressInterface::codegen_init_mem(), and casadi::MadmpecInterface::codegen_options().

codegen_mem_is_opaque()

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

inlinevirtualinherited

without a need for alloc_mem, init_mem, free_mem?

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

Reimplemented in casadi::External.

Definition at line 932 of file function_internal.hpp.

{ return false; }

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

codegen_mem_type()

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

inlinevirtualinherited

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

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

Definition at line 920 of file function_internal.hpp.

{ return ""; }

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

codegen_meta()

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

inherited

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

Definition at line 2668 of file function_internal.cpp.

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

References casadi::all(), casadi::CodeGenerator::array(), casadi::CodeGenerator::body, casadi::ProtoFunction::checkout(), casadi::FunctionInternal::codegen_name(), casadi::FunctionInternal::codegen_needs_mem(), 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::FunctionInternal::has_refcount_in_deps_, 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::ProtoFunction::release(), casadi::CodeGenerator::res(), casadi::CodeGenerator::shorthand(), 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 2978 of file function_internal.cpp.

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

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

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

codegen_needs_mem()

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

inlinevirtualinherited

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

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

Definition at line 925 of file function_internal.hpp.

{ return false; }

Referenced by casadi::CodeGenerator::add_dependency(), casadi::FunctionInternal::codegen_alloc_mem(), casadi::OmpMap::codegen_body(), casadi::FunctionInternal::codegen_decref(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::finalize(), casadi::CodeGenerator::operator()(), and casadi::CodeGenerator::setup_callback().

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

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

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

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

codegen_sparsities()

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

inherited

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

Definition at line 2664 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 3100 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 3106 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 3103 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 3109 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 141 of file function_internal.cpp.

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

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

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

convert_arg() [1/2]

template<typename M >

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

inherited

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

Definition at line 1892 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 1880 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 1921 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 1909 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::Integrator::create_advanced ( const Dict &  opts )

virtualinherited

Helper for a more powerful 'integrator' factory

Reimplemented in casadi::FixedStepIntegrator.

Definition at line 350 of file integrator.cpp.

                                                     {
  return Function::create(this, opts);
}

References casadi::Function::create().

Referenced by casadi::integrator().

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(), casadi::UnoInterface::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::MadmpecInterface::init(), casadi::FatropInterface::init(), casadi::IpoptInterface::init(), casadi::KnitroInterface::init(), casadi::MadnlpInterface::init(), casadi::SLEQPInterface::init(), casadi::SnoptInterface::init(), casadi::SundialsInterface::init(), casadi::UnoInterface::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_.

creator()

static Integrator* casadi::CvodesInterface::creator ( const std::string &  name, const Function &  dae, double  t0, const std::vector< double > &  tout  )

inlinestatic

Definition at line 94 of file cvodes_interface.hpp.

                                                {
    return new CvodesInterface(name, dae, t0, tout);
  }

Referenced by casadi::casadi_register_integrator_cvodes().

cvodes_error()

void casadi::CvodesInterface::cvodes_error ( const char *  module, int  flag  )

staticprotected

Definition at line 391 of file cvodes_interface.cpp.

                                                               {
  // Successfull return or warning
  if (flag>=CV_SUCCESS) return;
  // Construct error message
  char* flagname = CVodeGetReturnFlagName(flag);
  std::stringstream ss;
  ss << module << " returned \"" << flagname << "\". Consult CVODES documentation.";
  free(flagname);  // NOLINT
  casadi_error(ss.str());
}

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

deps_version_check()

virtual void casadi::PluginInterface< Integrator >::deps_version_check ( const std::string &  stage ) const

inlinevirtualinherited

Definition at line 112 of file plugin_interface.hpp.

{}

deserialize()

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

inlinestatic

Definition at line 196 of file cvodes_interface.hpp.

{ return new CvodesInterface(s); }

Referenced by casadi::casadi_register_integrator_cvodes().

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

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

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

Referenced by casadi::FunctionInternal::forward(), casadi::OnnxFunction::has_forward(), casadi::OnnxFunction::has_reverse(), 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 1097 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 978 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 3518 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 3494 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 3526 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 3498 of file function_internal.cpp.

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

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

ehfun()

void casadi::CvodesInterface::ehfun ( int  error_code, const char *  module, const char *  function, char *  msg, void *  user_data  )

staticprotected

Definition at line 402 of file cvodes_interface.cpp.

                                {
  try {
    casadi_assert_dev(user_data);
    auto m = to_mem(user_data);
    auto& s = m->self;
    if (!s.disable_internal_warnings_) {
      uerr() << msg << std::endl;
    }
  } catch(std::exception& e) {
    uerr() << "ehfun failed: " << e.what() << std::endl;
  }
}

References to_mem(), and casadi::uerr().

Referenced by init_mem().

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 1938 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, nullptr);
  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, nullptr, nullptr, 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_activity()

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

virtualinherited

bvec bit set = active (possibly nonzero), clear = inactive (definitely zero). Unlike sp_forward (a dependency analysis), this respects multiplicative annihilation and nonzero constants. Default is the sound fallback: all active.

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

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

Definition at line 3015 of file function_internal.cpp.

                                                                                              {
    // Sound fallback: we cannot prove any output zero, so mark everything active
    for (casadi_int oind=0; oind<n_out_; ++oind) {
      if (res[oind]==nullptr) continue;
      std::fill_n(res[oind], nnz_out(oind), ~static_cast<bvec_t>(0));
    }
    return 0;
  }

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

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 2167 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 445 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 965 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]==nullptr || arg[i]+nnz_in(i)<=w || arg[i]>=w+sz_w(),
        "Memory corruption detected for input " + name_in_[i] + ".\n"+
        "arg[" + str(i) + "] " + str(arg[i]) + "-" + str(arg[i]+nnz_in(i)) +
        " intersects with w " + str(w)+"-"+str(w+sz_w())+".");
    }
    for (casadi_int i=0;i<n_out_;++i) {
      casadi_assert(res[i]==nullptr || res[i]+nnz_out(i)<=w || res[i]>=w+sz_w(),
        "Memory corruption detected for output " + name_out_[i]);
    }
    // Reset statistics
    for (auto&& s : m->fstats) s.second.reset();
    if (m->t_total) m->t_total->tic();
    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 441 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 2386 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_));
      wrap().call(arg, res, true);
      return;
    }
 
    // 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 2171 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::Nlpsol::init(), and 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 2346 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, casadi::External, and casadi::CallbackInternal.

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

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 548 of file oracle_function.cpp.

                                {
  // Call to base class
  FunctionInternal::find(all_fun, max_depth);
  for (auto&& e : all_functions_) {
    add_embedded(all_fun, e.second.f, max_depth);
  }
}

References casadi::FunctionInternal::add_embedded(), casadi::OracleFunction::all_functions_, and casadi::FunctionInternal::find().

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

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

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 648 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(), casadi::FixedStepIntegrator::stepB(), casadi::FixedStepIntegrator::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::CvodesInterface::free_mem ( void *  mem ) const

inlineoverridevirtual

Reimplemented from casadi::OracleFunction.

Definition at line 127 of file cvodes_interface.hpp.

{ delete static_cast<CvodesMemory*>(mem);}

free_mx()

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

virtualinherited

Reimplemented in casadi::MXFunction.

Definition at line 3566 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 3570 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 1985 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 1575 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 3181 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 794 of file function_internal.cpp.

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

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

generate_lifted()

void casadi::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 3574 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 389 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["print_canonical"] = print_canonical_;
    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_;
    if (target=="clone") {
      opts["is_diff_in"] = is_diff_in_;
      opts["is_diff_out"] = is_diff_out_;
    }
    if (target=="forward") {
      opts["is_diff_in"] = join(is_diff_in_, is_diff_out_, is_diff_in_);
      opts["is_diff_out"] = is_diff_out_;
    }
    if (target=="reverse") {
      opts["is_diff_in"] = join(is_diff_in_, is_diff_out_, is_diff_out_);
      opts["is_diff_out"] = is_diff_in_;
    }
    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::is_diff_in_, casadi::FunctionInternal::is_diff_out_, 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::join(), casadi::FunctionInternal::max_io_, casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::never_inline_, casadi::FunctionInternal::print_canonical_, casadi::FunctionInternal::print_in_, casadi::FunctionInternal::print_out_, casadi::FunctionInternal::reverse_options_, and casadi::FunctionInternal::user_data_.

Referenced by casadi::Function::expand(), 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 810 of file function_internal.cpp.

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

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

get_abstol()

double casadi::SundialsInterface::get_abstol ( ) const

inlineoverridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 120 of file sundials_interface.hpp.

{ return abstol_;}

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 1096 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 1149 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 1154 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 1071 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::SundialsInterface::calc_daeB(), casadi::OracleFunction::calc_function(), casadi::SundialsInterface::calc_quadB(), 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_declarations(), casadi::MadmpecInterface::codegen_declarations(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::MadnlpInterface::codegen_declarations(), casadi::UnoInterface::codegen_declarations(), casadi::FastNewton::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), casadi::Nlpsol::codegen_post_solve(), casadi::FixedStepIntegrator::create_advanced(), casadi::OracleFunction::create_forward(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_ψ(), casadi::OracleFunction::finalize(), casadi::Nlpsol::get_forward(), casadi::OracleFunction::get_function(), casadi::AlpaqaProblem::get_hess_L_num_nonzeros(), casadi::AlpaqaProblem::get_hess_ψ_num_nonzeros(), casadi::Nlpsol::get_reverse(), casadi::FixedStepIntegrator::init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::Blocksqp::init(), casadi::BonminInterface::init(), casadi::MadmpecInterface::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::MadmpecInterface::set_ccopt_prob(), 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(), casadi::Integrator::sp_jac_rdae(), and casadi::FixedStepIntegrator::stepB().

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 1928 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 1273 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 1613 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 1378 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::OnnxFunction, casadi::JitFunction, casadi::FmuFunction, casadi::External, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

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

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

staticinherited

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

Definition at line 710 of file function_internal.cpp.

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

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

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

get_max_in()

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

inlinevirtualinherited

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

Definition at line 1103 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 1110 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 1114 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 1118 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::CvodesInterface::get_options ( ) const

inlineoverridevirtual

Reimplemented from casadi::Integrator.

Definition at line 111 of file cvodes_interface.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 2068 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 2554 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()

double casadi::SundialsInterface::get_reltol ( ) const

inlineoverridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 117 of file sundials_interface.hpp.

{ return reltol_;}

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::SundialsInterface::get_stats ( void *  mem ) const

overridevirtualinherited

Reimplemented from casadi::OracleFunction.

Definition at line 430 of file sundials_interface.cpp.

                                                 {
  Dict stats = Integrator::get_stats(mem);
  auto m = static_cast<SundialsMemory*>(mem);
 
  // Counters, forward problem
  stats["nsteps"] = static_cast<casadi_int>(m->nsteps);
  stats["nfevals"] = static_cast<casadi_int>(m->nfevals);
  stats["nlinsetups"] = static_cast<casadi_int>(m->nlinsetups);
  stats["netfails"] = static_cast<casadi_int>(m->netfails);
  stats["qlast"] = m->qlast;
  stats["qcur"] = m->qcur;
  stats["hinused"] = m->hinused;
  stats["hlast"] = m->hlast;
  stats["hcur"] = m->hcur;
  stats["tcur"] = m->tcur;
  stats["nniters"] = static_cast<casadi_int>(m->nniters);
  stats["nncfails"] = static_cast<casadi_int>(m->nncfails);
 
  // Counters, backward problem
  stats["nstepsB"] = static_cast<casadi_int>(m->nstepsB);
  stats["nfevalsB"] = static_cast<casadi_int>(m->nfevalsB);
  stats["nlinsetupsB"] = static_cast<casadi_int>(m->nlinsetupsB);
  stats["netfailsB"] = static_cast<casadi_int>(m->netfailsB);
  stats["qlastB"] = m->qlastB;
  stats["qcurB"] = m->qcurB;
  stats["hinusedB"] = m->hinusedB;
  stats["hlastB"] = m->hlastB;
  stats["hcurB"] = m->hcurB;
  stats["tcurB"] = m->tcurB;
  stats["nnitersB"] = static_cast<casadi_int>(m->nnitersB);
  stats["nncfailsB"] = static_cast<casadi_int>(m->nncfailsB);
  return stats;
}

References casadi::OracleFunction::get_stats(), and casadi::SundialsMemory::qlast.

get_x()

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

inherited

Definition at line 2558 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 2562 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::OnnxRuntimeInterface, 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 942 of file function_internal.hpp.

{ return false;}

Referenced by casadi::External::External(), and 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 3177 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 434 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 753 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 565 of file oracle_function.cpp.

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

References casadi::OracleFunction::all_functions_.

Referenced by casadi::OracleFunction::create_forward(), casadi::FixedStepIntegrator::init(), casadi::BonminInterface::init(), casadi::MadmpecInterface::init(), casadi::FatropInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), casadi::SLEQPInterface::init(), casadi::UnoInterface::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 643 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::OnnxFunction, casadi::JitFunction, casadi::FmuFunction, casadi::External, casadi::CallbackInternal, and casadi::BlazingSplineFunction.

Definition at line 630 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 3854 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 1055 of file function_internal.cpp.

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

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::CvodesInterface::impulseB ( IntegratorMemory *  mem, const double *  adj_x, const double *  adj_z, const double *  adj_q  ) const

overridevirtual

Implements casadi::Integrator.

Definition at line 301 of file cvodes_interface.cpp.

                                                                         {
  auto m = to_mem(mem);
 
  // Call method in base class
  SundialsInterface::impulseB(mem, adj_x, adj_z, adj_q);
 
  if (m->first_callB) {
    // Create backward problem
    THROWING(CVodeCreateB, m->mem, lmm_, iter_, &m->whichB);
    THROWING(CVodeInitB, m->mem, m->whichB, rhsB, m->t, m->v_adj_xz);
    THROWING(CVodeSStolerancesB, m->mem, m->whichB, reltol_, abstol_);
    THROWING(CVodeSetUserDataB, m->mem, m->whichB, m);
    if (newton_scheme_==SD_DIRECT) {
      // Direct scheme
      CVodeMem cv_mem = static_cast<CVodeMem>(m->mem);
      CVadjMem ca_mem = cv_mem->cv_adj_mem;
      CVodeBMem cvB_mem = ca_mem->cvB_mem;
      cvB_mem->cv_lmem = m;
      cvB_mem->cv_mem->cv_lmem = m;
      cvB_mem->cv_mem->cv_lsetup = lsetupB;
      cvB_mem->cv_mem->cv_lsolve = lsolveB;
      cvB_mem->cv_mem->cv_setupNonNull = TRUE;
    } else {
      // Iterative scheme
      casadi_int pretype = use_precon_ ? PREC_LEFT : PREC_NONE;
      switch (newton_scheme_) {
      case SD_DIRECT: casadi_assert_dev(0);
      case SD_GMRES: THROWING(CVSpgmrB, m->mem, m->whichB, pretype, max_krylov_); break;
      case SD_BCGSTAB: THROWING(CVSpbcgB, m->mem, m->whichB, pretype, max_krylov_); break;
      case SD_TFQMR: THROWING(CVSptfqmrB, m->mem, m->whichB, pretype, max_krylov_); break;
      }
      THROWING(CVSpilsSetJacTimesVecFnB, m->mem, m->whichB, jtimesB);
      if (use_precon_) THROWING(CVSpilsSetPreconditionerB, m->mem, m->whichB, psetupB, psolveB);
    }
 
    // Quadratures for the backward problem
    THROWING(CVodeQuadInitB, m->mem, m->whichB, rhsQB, m->v_adj_pu);
    if (quad_err_con_) {
      THROWING(CVodeSetQuadErrConB, m->mem, m->whichB, true);
      THROWING(CVodeQuadSStolerancesB, m->mem, m->whichB, reltol_, abstol_);
    }
 
    // Mark initialized
    m->first_callB = false;
  } else {
    // Save solver stats offsets before reset
    save_offsets(m);
 
    // Reinitialize solver
    THROWING(CVodeReInitB, m->mem, m->whichB, m->t, m->v_adj_xz);
    THROWING(CVodeQuadReInitB, m->mem, m->whichB, m->v_adj_pu);
  }
}

References casadi::SundialsInterface::abstol_, casadi::SundialsInterface::impulseB(), iter_, jtimesB(), lmm_, lsetupB(), lsolveB(), casadi::SundialsInterface::max_krylov_, casadi::SundialsInterface::newton_scheme_, psetupB(), psolveB(), casadi::SundialsInterface::quad_err_con_, casadi::SundialsInterface::reltol_, rhsB(), rhsQB(), casadi::SundialsInterface::save_offsets(), casadi::SundialsInterface::SD_BCGSTAB, casadi::SundialsInterface::SD_DIRECT, casadi::SundialsInterface::SD_GMRES, casadi::SundialsInterface::SD_TFQMR, to_mem(), and casadi::SundialsInterface::use_precon_.

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 1129 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 1159 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 1171 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 3213 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::CvodesInterface::init ( const Dict &  opts )

overridevirtual

Reimplemented from casadi::Integrator.

Definition at line 79 of file cvodes_interface.cpp.

                                           {
  if (verbose_) casadi_message(name_ + "::init");
 
  // Initialize the base classes
  SundialsInterface::init(opts);
 
  // Default options
  std::string linear_multistep_method = "bdf";
  std::string nonlinear_solver_iteration = "newton";
  min_step_size_ = 0;
  always_recalculate_jacobian_ = true;
 
  // Read options
  for (auto&& op : opts) {
    if (op.first=="linear_multistep_method") {
      linear_multistep_method = op.second.to_string();
    } else if (op.first=="min_step_size") {
      min_step_size_ = op.second;
    } else if (op.first=="nonlinear_solver_iteration") {
      nonlinear_solver_iteration = op.second.to_string();
    } else if (op.first=="always_recalculate_jacobian") {
      always_recalculate_jacobian_ = op.second;
    }
  }
 
  // Algebraic variables not supported
  casadi_assert(nz_==0 && nrz_==0,
    "CVODES does not support algebraic variables");
 
  if (linear_multistep_method=="adams") {
    lmm_ = CV_ADAMS;
  } else if (linear_multistep_method=="bdf") {
    lmm_ = CV_BDF;
  } else {
    casadi_error("Unknown linear multistep method: " + linear_multistep_method);
  }
 
  if (nonlinear_solver_iteration=="newton") {
    iter_ = CV_NEWTON;
  } else if (nonlinear_solver_iteration=="functional") {
    iter_ = CV_FUNCTIONAL;
  } else {
    casadi_error("Unknown nonlinear solver iteration: " + nonlinear_solver_iteration);
  }
 
  // Misc
  alloc_w(nx_); // casadi_project
  alloc_w(nrx_); // casadi_project
}

References casadi::FunctionInternal::alloc_w(), always_recalculate_jacobian_, casadi::SundialsInterface::init(), iter_, lmm_, min_step_size_, casadi::ProtoFunction::name_, casadi::Integrator::nrx_, casadi::Integrator::nrz_, casadi::Integrator::nx_, casadi::Integrator::nz_, and casadi::ProtoFunction::verbose_.

init_mem()

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

overridevirtual

Reimplemented from casadi::Integrator.

Definition at line 129 of file cvodes_interface.cpp.

                                             {
  if (SundialsInterface::init_mem(mem)) return 1;
  auto m = to_mem(mem);
 
  // Create CVodes memory block
  m->mem = CVodeCreate(lmm_, iter_);
  casadi_assert(m->mem!=nullptr, "CVodeCreate: Creation failed");
 
  // Set error handler function
  THROWING(CVodeSetErrHandlerFn, m->mem, ehfun, m);
 
  // Set user data
  THROWING(CVodeSetUserData, m->mem, m);
 
  // Initialize CVodes
  double t0 = 0;
  THROWING(CVodeInit, m->mem, rhsF, t0, m->v_xz);
 
  // Set tolerances
  if (scale_abstol_) {
    THROWING(CVodeSVtolerances, m->mem, reltol_, m->abstolv);
  } else {
    THROWING(CVodeSStolerances, m->mem, reltol_, abstol_);
  }
 
  // Maximum number of steps
  THROWING(CVodeSetMaxNumSteps, m->mem, max_num_steps_);
 
  // Initial step size
  if (step0_!=0) THROWING(CVodeSetInitStep, m->mem, step0_);
 
  // Min step size
  if (min_step_size_!=0) THROWING(CVodeSetMinStep, m->mem, min_step_size_);
 
  // Max step size
  if (max_step_size_!=0) THROWING(CVodeSetMaxStep, m->mem, max_step_size_);
 
  // Maximum order of method
  if (max_order_) THROWING(CVodeSetMaxOrd, m->mem, max_order_);
 
  // Coeff. in the nonlinear convergence test
  if (nonlin_conv_coeff_!=0) THROWING(CVodeSetNonlinConvCoef, m->mem, nonlin_conv_coeff_);
 
  // attach a linear solver
  if (newton_scheme_==SD_DIRECT) {
    // Direct scheme
    CVodeMem cv_mem = static_cast<CVodeMem>(m->mem);
    cv_mem->cv_lmem   = m;
    cv_mem->cv_lsetup = lsetupF;
    cv_mem->cv_lsolve = lsolveF;
    cv_mem->cv_setupNonNull = TRUE;
  } else {
    // Iterative scheme
    casadi_int pretype = use_precon_ ? PREC_LEFT : PREC_NONE;
    switch (newton_scheme_) {
    case SD_DIRECT: casadi_assert_dev(0);
    case SD_GMRES: THROWING(CVSpgmr, m->mem, pretype, max_krylov_); break;
    case SD_BCGSTAB: THROWING(CVSpbcg, m->mem, pretype, max_krylov_); break;
    case SD_TFQMR: THROWING(CVSptfqmr, m->mem, pretype, max_krylov_); break;
    }
    THROWING(CVSpilsSetJacTimesVecFn, m->mem, jtimesF);
    if (use_precon_) THROWING(CVSpilsSetPreconditioner, m->mem, psetupF, psolveF);
  }
 
  // Quadrature equations
  if (nq_>0) {
    // Initialize quadratures in CVodes
    THROWING(CVodeQuadInit, m->mem, rhsQF, m->v_q);
 
    // Should the quadrature errors be used for step size control?
    if (quad_err_con_) {
      THROWING(CVodeSetQuadErrCon, m->mem, true);
 
      // Quadrature error tolerances
      // TODO(Joel): vector absolute tolerances
      THROWING(CVodeQuadSStolerances, m->mem, reltol_, abstol_);
    }
  }
 
  // Initialize adjoint sensitivities
  if (nrx_>0) {
    casadi_int interpType = interp_ == SD_HERMITE ? CV_HERMITE : CV_POLYNOMIAL;
    THROWING(CVodeAdjInit, m->mem, steps_per_checkpoint_, interpType);
  }
 
  m->first_callB = true;
  return 0;
}

References casadi::SundialsInterface::abstol_, ehfun(), casadi::SundialsInterface::init_mem(), casadi::SundialsInterface::interp_, iter_, jtimesF(), lmm_, lsetupF(), lsolveF(), casadi::SundialsInterface::max_krylov_, casadi::SundialsInterface::max_num_steps_, casadi::SundialsInterface::max_order_, casadi::SundialsInterface::max_step_size_, min_step_size_, casadi::SundialsInterface::newton_scheme_, casadi::SundialsInterface::nonlin_conv_coeff_, casadi::Integrator::nq_, casadi::Integrator::nrx_, psetupF(), psolveF(), casadi::SundialsInterface::quad_err_con_, casadi::SundialsInterface::reltol_, rhsF(), rhsQF(), casadi::SundialsInterface::scale_abstol_, casadi::SundialsInterface::SD_BCGSTAB, casadi::SundialsInterface::SD_DIRECT, casadi::SundialsInterface::SD_GMRES, casadi::SundialsInterface::SD_HERMITE, casadi::SundialsInterface::SD_TFQMR, casadi::SundialsInterface::step0_, casadi::SundialsInterface::steps_per_checkpoint_, to_mem(), and casadi::SundialsInterface::use_precon_.

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 3591 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 3583 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 3587 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 3599 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 3595 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 3603 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 3558 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 1915 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 2003 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 2403 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().

jtimesB()

int casadi::CvodesInterface::jtimesB ( N_Vector  vB, N_Vector  JvB, double  t, N_Vector  x, N_Vector  xB, N_Vector  xdotB, void *  user_data, N_Vector  tmpB  )

staticprotected

Definition at line 477 of file cvodes_interface.cpp.

                                                                 {
  try {
    auto m = to_mem(user_data);
    auto& s = m->self;
    // The function is linear so the Jacobian-times-vector function is the function itself
    if (s.calc_daeB(m, t, NV_DATA_S(x), nullptr, NV_DATA_S(v), nullptr, nullptr,
      NV_DATA_S(Jv), nullptr)) return 1;
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "jtimesB failed: " << e.what() << std::endl;
    return -1;
  }
}

References to_mem(), and casadi::uerr().

Referenced by impulseB().

jtimesF()

int casadi::CvodesInterface::jtimesF ( N_Vector  v, N_Vector  Jv, double  t, N_Vector  x, N_Vector  xdot, void *  user_data, N_Vector  tmp  )

staticprotected

Definition at line 463 of file cvodes_interface.cpp.

                                                  {
  try {
    auto m = to_mem(user_data);
    auto& s = m->self;
    if (s.calc_jtimesF(m, t, NV_DATA_S(x), nullptr, NV_DATA_S(v), nullptr,
      NV_DATA_S(Jv), nullptr)) return 1;
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "jtimesF failed: " << e.what() << std::endl;
    return -1;
  }
}

References to_mem(), and casadi::uerr().

Referenced by init_mem().

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 = std::string(CasadiMeta::shared_library_prefix()) + libname +
                      CasadiMeta::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().

lsetupB()

int casadi::CvodesInterface::lsetupB ( CVodeMem  cv_mem, int  convfail, N_Vector  x, N_Vector  xdot, booleantype *  jcurPtr, N_Vector  vtemp1, N_Vector  vtemp2, N_Vector  vtemp3  )

staticprotected

Definition at line 655 of file cvodes_interface.cpp.

                                                                             {
  try {
    auto m = to_mem(cv_mem->cv_lmem);
    CVadjMem ca_mem;
    //CVodeBMem cvB_mem;
 
    // Current time
    double t = cv_mem->cv_tn; // TODO(Joel): is this correct?
    double gamma = cv_mem->cv_gamma;
 
    cv_mem = static_cast<CVodeMem>(cv_mem->cv_user_data);
    ca_mem = cv_mem->cv_adj_mem;
    //cvB_mem = ca_mem->ca_bckpbCrt;
 
    // Get FORWARD solution from interpolation.
    int flag = ca_mem->ca_IMget(cv_mem, t, ca_mem->ca_ytmp, nullptr);
    if (flag != CV_SUCCESS) casadi_error("Could not interpolate forward states");
 
    // Call the preconditioner setup function (which sets up the linear solver)
    return psetupB(t, ca_mem->ca_ytmp, x, xdot, FALSE, jcurPtr,
      gamma, static_cast<void*>(m), vtemp1, vtemp2, vtemp3);
 
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "lsetupB failed: " << e.what() << std::endl;
    return -1;
  }
}

References psetupB(), to_mem(), and casadi::uerr().

Referenced by impulseB().

lsetupF()

int casadi::CvodesInterface::lsetupF ( CVodeMem  cv_mem, int  convfail, N_Vector  x, N_Vector  xdot, booleantype *  jcurPtr, N_Vector  vtemp1, N_Vector  vtemp2, N_Vector  vtemp3  )

staticprotected

Definition at line 640 of file cvodes_interface.cpp.

                                                                             {
  try {
    auto m = to_mem(cv_mem->cv_lmem);
 
    // Call the preconditioner setup function (which sets up the linear solver)
    return psetupF(cv_mem->cv_tn, x, xdot, FALSE, jcurPtr,
      cv_mem->cv_gamma, static_cast<void*>(m), vtemp1, vtemp2, vtemp3);
 
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "lsetup failed: " << e.what() << std::endl;
    return -1;
  }
}

References psetupF(), to_mem(), and casadi::uerr().

Referenced by init_mem().

lsolveB()

int casadi::CvodesInterface::lsolveB ( CVodeMem  cv_mem, N_Vector  b, N_Vector  weight, N_Vector  x, N_Vector  xdot  )

staticprotected

Definition at line 711 of file cvodes_interface.cpp.

                               {
  try {
    auto m = to_mem(cv_mem->cv_lmem);
    CVadjMem ca_mem;
    //CVodeBMem cvB_mem;
 
    // Current time
    double t = cv_mem->cv_tn; // TODO(Joel): is this correct?
    double gamma = cv_mem->cv_gamma;
 
    cv_mem = static_cast<CVodeMem>(cv_mem->cv_user_data);
 
    ca_mem = cv_mem->cv_adj_mem;
    //cvB_mem = ca_mem->ca_bckpbCrt;
 
    // Get FORWARD solution from interpolation.
    int flag = ca_mem->ca_IMget(cv_mem, t, ca_mem->ca_ytmp, nullptr);
    if (flag != CV_SUCCESS) casadi_error("Could not interpolate forward states");
 
    // Accuracy
    double delta = 0.0;
 
    // Left/right preconditioner
    int lr = 1;
 
    // Call the preconditioner solve function (which solves the linear system)
    return psolveB(t, ca_mem->ca_ytmp, x, xdot, b, b, gamma, delta, lr,
      static_cast<void*>(m), nullptr);
 
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "lsolveB failed: " << e.what() << std::endl;
    return -1;
  }
}

References psolveB(), to_mem(), and casadi::uerr().

Referenced by impulseB().

lsolveF()

int casadi::CvodesInterface::lsolveF ( CVodeMem  cv_mem, N_Vector  b, N_Vector  weight, N_Vector  x, N_Vector  xdot  )

staticprotected

Definition at line 684 of file cvodes_interface.cpp.

                               {
  try {
    auto m = to_mem(cv_mem->cv_lmem);
    //auto& s = m->self;
 
    // Current time
    double t = cv_mem->cv_tn;
 
    // Scaling factor before J
    double gamma = cv_mem->cv_gamma;
 
    // Accuracy
    double delta = 0.0;
 
    // Left/right preconditioner
    casadi_int lr = 1;
 
    // Call the preconditioner solve function (which solves the linear system)
    return psolveF(t, x, xdot, b, b, gamma, delta, lr, static_cast<void*>(m), nullptr);
 
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "lsolveF failed: " << e.what() << std::endl;
    return -1;
  }
}

References psolveF(), to_mem(), and casadi::uerr().

Referenced by 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 1142 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 2330 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 3612 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 1801 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 1811 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 3847 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 3562 of file function_internal.cpp.

                                                            {
     }

monitored()

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

virtualinherited

Definition at line 557 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 3542 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 3534 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 3550 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 3538 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 3579 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 3607 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 2566 of file integrator.cpp.

                                                                    {
  // Integrate till the end if no input signals
  if (nu_ == 0 || u == nullptr) 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 2738 of file integrator.cpp.

                                                                     {
  // Integrate till the beginning if no input signals
  if (nu_ == 0 || u == nullptr) 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 2362 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::PiqpInterface::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 1007 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 2368 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_activity(), 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 1009 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 casadi::FixedStepIntegrator::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(), casadi::FixedStepIntegrator::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 2374 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 1017 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 2380 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 1018 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 3702 of file function_internal.cpp.

                                                                          {
    // Disallow parallel inputs
    casadi_int npar = -1;
    if (!matching_arg(arg, npar)) {
      return nz_in(replace_arg(arg, npar));
    }
 
    std::vector<DM> arg2 = project_arg(arg, 1);
    std::vector<double> ret(nnz_in());
    casadi_int offset = 0;
    for (casadi_int i=0;i<n_in_;++i) {
      const double* e = arg2.at(i).ptr();
      std::copy(e, e+nnz_in(i), ret.begin()+offset);
      offset+= nnz_in(i);
    }
    return ret;
  }

References casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::project_arg(), and casadi::FunctionInternal::replace_arg().

Referenced by casadi::SXFunction::call_activity(), casadi::SXFunction::call_fwd(), casadi::SXFunction::call_rev(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical().

nz_in() [2/2]

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

inherited

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

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

                                                                           {
    // Disallow parallel inputs
    casadi_int npar = -1;
    if (!matching_res(res, npar)) {
      return nz_out(replace_res(res, npar));
    }
 
    std::vector<DM> res2 = project_res(res, 1);
    std::vector<double> ret(nnz_out());
    casadi_int offset = 0;
    for (casadi_int i=0;i<n_out_;++i) {
      const double* e = res2.at(i).ptr();
      std::copy(e, e+nnz_out(i), ret.begin()+offset);
      offset+= nnz_out(i);
    }
    return ret;
  }

References casadi::FunctionInternal::matching_res(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::project_res(), and casadi::FunctionInternal::replace_res().

Referenced by casadi::SXFunction::call_activity(), casadi::SXFunction::call_fwd(), casadi::SXFunction::call_rev(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical().

nz_out() [2/2]

std::vector< DM > casadi::FunctionInternal::nz_out ( const std::vector< double > &  res ) const

inherited

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

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

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

inlineoverridevirtual

Implements casadi::PluginInterface< Integrator >.

Definition at line 103 of file cvodes_interface.hpp.

{ return "cvodes";}

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 2618 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 4100 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_canonical() [1/3]

void casadi::FunctionInternal::print_canonical ( std::ostream &  stream, casadi_int  sz, const double *  nz  )

staticinherited

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

Definition at line 909 of file function_internal.cpp.

                                                                                            {
    StreamStateGuard backup(stream);
    normalized_setup(stream);
    if (nz) {
      stream << "[";
      for (casadi_int i=0; i<sz; ++i) {
        if (i>0) stream << ", ";
        normalized_out(stream, nz[i]);
      }
      stream << "]";
    } else {
      stream << "NULL";
    }
  }

References casadi::normalized_out(), and casadi::normalized_setup().

print_canonical() [2/3]

void casadi::FunctionInternal::print_canonical ( std::ostream &  stream, const Sparsity &  sp, const double *  nz  )

staticinherited

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

Definition at line 924 of file function_internal.cpp.

                                            {
    StreamStateGuard backup(stream);
    normalized_setup(stream);
    if (nz) {
      if (!sp.is_scalar(true)) {
        stream << sp.dim(false) << ": ";
        stream << "[";
      }
      for (casadi_int i=0; i<sp.nnz(); ++i) {
        if (i>0) stream << ", ";
        normalized_out(stream, nz[i]);
      }
      if (!sp.is_scalar(true)) {
        stream << "]";
        if (!sp.is_dense()) {
          stream << ", colind: [";
          for (casadi_int i=0; i<sp.size2()+1; ++i) {
            if (i>0) stream << ", ";
            stream << sp.colind()[i];
          }
          stream << "]";
          stream << ", row: [";
          for (casadi_int i=0; i<sp.nnz(); ++i) {
            if (i>0) stream << ", ";
            stream << sp.row()[i];
          }
          stream << "]";
        }
      }
    } else {
      stream << "NULL";
    }
  }

References casadi::Sparsity::colind(), casadi::Sparsity::dim(), casadi::Sparsity::is_dense(), casadi::Sparsity::is_scalar(), casadi::Sparsity::nnz(), casadi::normalized_out(), casadi::normalized_setup(), casadi::Sparsity::row(), and casadi::Sparsity::size2().

Referenced by casadi::Monitor::eval(), casadi::MXFunction::print_arg(), casadi::SXFunction::print_arg(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_out(), casadi::MXFunction::print_res(), and casadi::SXFunction::print_res().

print_canonical() [3/3]

void casadi::FunctionInternal::print_canonical ( std::ostream &  stream, double  a  )

staticinherited

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

Definition at line 959 of file function_internal.cpp.

                                                                     {
    StreamStateGuard backup(stream);
    normalized_setup(stream);
    normalized_out(stream, a);
  }

References casadi::normalized_out(), and casadi::normalized_setup().

print_dimensions()

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

inherited

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

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

                                                                                             {
    stream << "Function " << name_ << " (" << this << ")" << std::endl;
    for (casadi_int i=0; i<n_in_; ++i) {
      stream << "Input " << i << " (" << name_in_[i] << "): ";
      if (arg[i]) {
        if (print_canonical_) {
          print_canonical(stream, sparsity_in_[i], arg[i]);
        } else {
          DM::print_default(stream, sparsity_in_[i], arg[i], truncate);
        }
        stream << std::endl;
      } else {
        stream << "NULL" << std::endl;
      }
    }
  }

References casadi::FunctionInternal::n_in_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::print_canonical(), casadi::FunctionInternal::print_canonical_, casadi::Matrix< double >::print_default(), and casadi::FunctionInternal::sparsity_in_.

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

print_option()

void casadi::ProtoFunction::print_option ( const std::string &  name, std::ostream &  stream  ) const

inherited

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

Definition at line 1051 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 1047 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 892 of file function_internal.cpp.

                                                                                        {
    stream << "Function " << name_ << " (" << this << ")" << std::endl;
    for (casadi_int i=0; i<n_out_; ++i) {
      stream << "Output " << i << " (" << name_out_[i] << "): ";
      if (res[i]) {
        if (print_canonical_) {
          print_canonical(stream, sparsity_out_[i], res[i]);
        } else {
          DM::print_default(stream, sparsity_out_[i], res[i], truncate);
        }
        stream << std::endl;
      } else {
        stream << "NULL" << std::endl;
      }
    }
  }

References casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::print_canonical(), casadi::FunctionInternal::print_canonical_, casadi::Matrix< double >::print_default(), and casadi::FunctionInternal::sparsity_out_.

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

print_stats()

void casadi::SundialsInterface::print_stats ( IntegratorMemory *  mem ) const

overridevirtualinherited

Reimplemented from casadi::Integrator.

Definition at line 464 of file sundials_interface.cpp.

                                                               {
  auto m = to_mem(mem);
  print("FORWARD INTEGRATION:\n");
  print("Number of steps taken by SUNDIALS: %ld\n", m->nsteps);
  print("Number of calls to the user's f function: %ld\n", m->nfevals);
  print("Number of calls made to the linear solver setup function: %ld\n", m->nlinsetups);
  print("Number of error test failures: %ld\n", m->netfails);
  print("Method order used on the last internal step: %d\n", m->qlast);
  print("Method order to be used on the next internal step: %d\n", m->qcur);
  print("Actual value of initial step size: %g\n", m->hinused);
  print("Step size taken on the last internal step: %g\n", m->hlast);
  print("Step size to be attempted on the next internal step: %g\n", m->hcur);
  print("Current internal time reached: %g\n", m->tcur);
  print("Number of nonlinear iterations performed: %ld\n", m->nniters);
  print("Number of nonlinear convergence failures: %ld\n", m->nncfails);
  if (nrx_>0) {
    print("BACKWARD INTEGRATION:\n");
    print("Number of steps taken by SUNDIALS: %ld\n", m->nstepsB);
    print("Number of calls to the user's f function: %ld\n", m->nfevalsB);
    print("Number of calls made to the linear solver setup function: %ld\n", m->nlinsetupsB);
    print("Number of error test failures: %ld\n", m->netfailsB);
    print("Method order used on the last internal step: %d\n" , m->qlastB);
    print("Method order to be used on the next internal step: %d\n", m->qcurB);
    print("Actual value of initial step size: %g\n", m->hinusedB);
    print("Step size taken on the last internal step: %g\n", m->hlastB);
    print("Step size to be attempted on the next internal step: %g\n", m->hcurB);
    print("Current internal time reached: %g\n", m->tcurB);
    print("Number of nonlinear iterations performed: %ld\n", m->nnitersB);
    print("Number of nonlinear convergence failures: %ld\n", m->nncfailsB);
  }
  print("\n");
}

References casadi::Integrator::nrx_, casadi::ProtoFunction::print(), and casadi::SundialsInterface::to_mem().

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

printvar() [1/2]

static void casadi::SundialsInterface::printvar ( const std::string &  id, double  v  )

inlinestaticinherited

Definition at line 221 of file sundials_interface.hpp.

                                                        {
      uout() << id << " = " << v << std::endl;
    }

References casadi::uout().

printvar() [2/2]

static void casadi::SundialsInterface::printvar ( const std::string &  id, N_Vector  v  )

inlinestaticinherited

Definition at line 225 of file sundials_interface.hpp.

                                                          {
      std::vector<double> tmp(NV_DATA_S(v), NV_DATA_S(v)+NV_LENGTH_S(v));
      uout() << id << " = " << tmp << std::endl;
    }

References casadi::uout().

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

                                                                {
      return arg;
  }

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

psetupB()

int casadi::CvodesInterface::psetupB ( double  t, N_Vector  x, N_Vector  xB, N_Vector  xdotB, booleantype  jokB, booleantype *  jcurPtrB, double  gammaB, void *  user_data, N_Vector  tmp1B, N_Vector  tmp2B, N_Vector  tmp3B  )

staticprotected

Definition at line 624 of file cvodes_interface.cpp.

                                                                     {
  try {
    auto m = to_mem(user_data);
    // Store gamma for later
    m->gammaB = gammaB;
    // We use the same linear solver for the forward problem as for the backward problem
    return psetupF(t, x, nullptr, jokB, jcurPtrB, -gammaB, user_data, tmp1B, tmp2B, tmp3B);
 
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "psetupB failed: " << e.what() << std::endl;
    return -1;
  }
}

References psetupF(), to_mem(), and casadi::uerr().

Referenced by impulseB(), and lsetupB().

psetupF()

int casadi::CvodesInterface::psetupF ( double  t, N_Vector  x, N_Vector  xdot, booleantype  jok, booleantype *  jcurPtr, double  gamma, void *  user_data, N_Vector  tmp1, N_Vector  tmp2, N_Vector  tmp3  )

staticprotected

Definition at line 576 of file cvodes_interface.cpp.

                                                 {
  try {
    auto m = to_mem(user_data);
    auto& s = m->self;
    // Store gamma for later
    m->gamma = gamma;
 
    // Sparsity patterns
    const Sparsity& sp_jac_ode_x = s.get_function("jacF").sparsity_out(0);
    const Sparsity& sp_jacF = s.linsolF_.sparsity();
 
    // Calculate Jacobian, if necessary
    if (s.always_recalculate_jacobian_ || !jcurPtr || *jcurPtr == 0) {
      // Re(calculate) Jacobian
      if (s.calc_jacF(m, t, NV_DATA_S(x), nullptr,
        m->jac_ode_x, nullptr, nullptr, nullptr)) return 1;
 
      // Jacobian is now current
      if (jcurPtr) *jcurPtr = 1;
    }
 
    // Project to expected sparsity pattern (with diagonal)
    casadi_project(m->jac_ode_x, sp_jac_ode_x, m->jacF, sp_jacF, m->w);
 
    // Scale and shift diagonal
    const casadi_int *colind = sp_jacF.colind(), *row = sp_jacF.row();
    for (casadi_int c = 0; c < sp_jacF.size2(); ++c) {
      for (casadi_int k = colind[c]; k < colind[c + 1]; ++k) {
        casadi_int r = row[k];
        // Scale Jacobian
        m->jacF[k] *= -gamma;
        // Add contribution to diagonal
        if (r == c) m->jacF[k] += 1;
      }
    }
 
    // Prepare the solution of the linear system (e.g. factorize)
    if (s.linsolF_.nfact(m->jacF, m->mem_linsolF)) return 1;
 
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "psetup failed: " << e.what() << std::endl;
    return -1;
  }
}

References casadi::casadi_project(), casadi::Sparsity::colind(), casadi::Sparsity::row(), casadi::Sparsity::size2(), to_mem(), and casadi::uerr().

Referenced by init_mem(), lsetupF(), and psetupB().

psolveB()

int casadi::CvodesInterface::psolveB ( double  t, N_Vector  x, N_Vector  xB, N_Vector  xdotB, N_Vector  rvecB, N_Vector  zvecB, double  gammaB, double  deltaB, int  lr, void *  user_data, N_Vector  tmpB  )

staticprotected

Definition at line 533 of file cvodes_interface.cpp.

                                                                                          {
  try {
    auto m = to_mem(user_data);
    auto& s = m->self;
 
    // Get right-hand sides in m->tmp1
    double* v = NV_DATA_S(rvecB);
    casadi_copy(v, s.nrx_, m->tmp1);
 
    // Solve for undifferentiated right-hand-side, save to output
    if (s.linsolF_.solve(m->jacF, m->tmp1, s.nadj_, true, m->mem_linsolF)) return 1;
    v = NV_DATA_S(zvecB); // possibly different from rvecB
    casadi_copy(m->tmp1, s.nrx1_ * s.nadj_, v);
 
    // Sensitivity equations
    if (s.nfwd_ > 0) {
      // Second order correction
      if (s.second_order_correction_) {
        // The outputs will double as seeds for calc_daeB
        casadi_clear(v + s.nrx1_ * s.nadj_, s.nrx_ - s.nrx1_ * s.nadj_);
        if (s.calc_daeB(m, t, NV_DATA_S(x), nullptr, v, nullptr, nullptr, m->tmp2, nullptr))
          return 1;
        // Subtract m->tmp2 from m->tmp1, scaled with gammaB
        casadi_axpy(s.nrx_ - s.nrx1_ * s.nadj_, -m->gammaB, m->tmp2 + s.nrx1_ * s.nadj_,
          m->tmp1 + s.nrx1_ * s.nadj_);
      }
 
      // Solve for sensitivity right-hand-sides
      if (s.linsolF_.solve(m->jacF, m->tmp1 + s.nx1_, s.nadj_ * s.nfwd_,
        true, m->mem_linsolF)) return 1;
 
      // Save to output, reordered
      casadi_copy(m->tmp1 + s.nx1_, s.nx_ - s.nx1_, v + s.nx1_);
    }
 
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "psolveB failed: " << e.what() << std::endl;
    return -1;
  }
}

References casadi::casadi_axpy(), casadi::casadi_clear(), casadi::casadi_copy(), to_mem(), and casadi::uerr().

Referenced by impulseB(), and lsolveB().

psolveF()

int casadi::CvodesInterface::psolveF ( double  t, N_Vector  x, N_Vector  xdot, N_Vector  r, N_Vector  z, double  gamma, double  delta, int  lr, void *  user_data, N_Vector  tmp  )

staticprotected

Definition at line 492 of file cvodes_interface.cpp.

                                                                                   {
  try {
    auto m = to_mem(user_data);
    auto& s = m->self;
 
    // Get right-hand sides in m->tmp1
    double* v = NV_DATA_S(r);
    casadi_copy(v, s.nx_, m->tmp1);
 
    // Solve for undifferentiated right-hand-side, save to output
    if (s.linsolF_.solve(m->jacF, m->tmp1, 1, false, m->mem_linsolF)) return 1;
    v = NV_DATA_S(z); // possibly different from r
    casadi_copy(m->tmp1, s.nx1_, v);
 
    // Sensitivity equations
    if (s.nfwd_ > 0) {
      // Second order correction
      if (s.second_order_correction_) {
        // The outputs will double as seeds for jtimesF
        casadi_clear(v + s.nx1_, s.nx_ - s.nx1_);
        if (s.calc_jtimesF(m, t, NV_DATA_S(x), nullptr, v, nullptr, m->tmp2, nullptr)) return 1;
 
        // Subtract m->tmp2 from m->tmp1, scaled with -gamma
        casadi_axpy(s.nx_ - s.nx1_, m->gamma, m->tmp2 + s.nx1_, m->tmp1 + s.nx1_);
      }
 
      // Solve for sensitivity right-hand-sides
      if (s.linsolF_.solve(m->jacF, m->tmp1 + s.nx1_, s.nfwd_, false, m->mem_linsolF)) return 1;
 
      // Save to output, reordered
      casadi_copy(m->tmp1 + s.nx1_, s.nx_ - s.nx1_, v + s.nx1_);
    }
 
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "psolve failed: " << e.what() << std::endl;
    return -1;
  }
}

References casadi::casadi_axpy(), casadi::casadi_clear(), casadi::casadi_copy(), to_mem(), and casadi::uerr().

Referenced by init_mem(), and lsolveF().

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

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

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

replace_arg()

template<typename M >

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

inherited

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

Definition at line 1848 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 1872 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 1864 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 1856 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::CvodesInterface::reset ( IntegratorMemory *  mem, bool  first_call  ) const

overridevirtual

Reimplemented from casadi::Integrator.

Definition at line 231 of file cvodes_interface.cpp.

                                                                        {
  if (verbose_) casadi_message(name_ + "::reset");
  auto m = to_mem(mem);
 
  // Reset the base classes
  SundialsInterface::reset(mem, first_call);
 
  // Only reinitialize solver at first call or if event handling is required
  // May want to always enable this after more testing
  if (first_call || ne_ > 0) {
    // Re-initialize forward integration
    THROWING(CVodeReInit, m->mem, m->t, m->v_xz);
 
    // Re-initialize quadratures
    if (nq_ > 0) {
      THROWING(CVodeQuadReInit, m->mem, m->v_q);
    }
  }
 
  // How is this impacted by CVodeReInit?
  if (first_call) {
    // Re-initialize backward integration
    if (nrx_ > 0) {
      THROWING(CVodeAdjReInit, m->mem);
    }
  }
}

References casadi::ProtoFunction::name_, casadi::Integrator::ne_, casadi::Integrator::nq_, casadi::Integrator::nrx_, casadi::SundialsInterface::reset(), to_mem(), and casadi::ProtoFunction::verbose_.

reset_dump_count()

void casadi::FunctionInternal::reset_dump_count ( )

inherited

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

Definition at line 471 of file function_internal.cpp.

                                          {
    dump_count_ = 0;
  }

References casadi::FunctionInternal::dump_count_.

reset_stats()

void casadi::SundialsInterface::reset_stats ( SundialsMemory *  m ) const

inherited

Definition at line 346 of file sundials_interface.cpp.

                                                           {
  // Reset stats, forward problem
  m->nsteps = m->nfevals = m->nlinsetups = m->netfails = 0;
  m->qlast = m->qcur = -1;
  m->tcur = t0_;
  m->hinused = m->hlast = m->hcur = casadi::nan;
  m->nniters = m->nncfails = 0;
 
  // Reset stats, backward problem
  m->nstepsB = m->nfevalsB = m->nlinsetupsB = m->netfailsB = 0;
  m->qlastB = m->qcurB = -1;
  m->hinusedB = m->hlastB = m->hcurB = m->tcurB = casadi::nan;
  m->nnitersB = m->nncfailsB = 0;
 
  // Set offsets to zero
  save_offsets(m);
}

References casadi::SundialsMemory::hcur, casadi::SundialsMemory::hcurB, casadi::SundialsMemory::hinused, casadi::SundialsMemory::hinusedB, casadi::SundialsMemory::hlast, casadi::SundialsMemory::hlastB, casadi::nan, casadi::SundialsMemory::netfails, casadi::SundialsMemory::netfailsB, casadi::SundialsMemory::nfevals, casadi::SundialsMemory::nfevalsB, casadi::SundialsMemory::nlinsetups, casadi::SundialsMemory::nlinsetupsB, casadi::SundialsMemory::nncfails, casadi::SundialsMemory::nncfailsB, casadi::SundialsMemory::nniters, casadi::SundialsMemory::nnitersB, casadi::SundialsMemory::nsteps, casadi::SundialsMemory::nstepsB, casadi::SundialsMemory::qcur, casadi::SundialsMemory::qcurB, casadi::SundialsMemory::qlast, casadi::SundialsMemory::qlastB, casadi::SundialsInterface::save_offsets(), casadi::Integrator::t0_, casadi::SundialsMemory::tcur, and casadi::SundialsMemory::tcurB.

Referenced by casadi::SundialsInterface::init_mem(), and casadi::SundialsInterface::reset().

resetB()

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

overridevirtualinherited

Implements casadi::Integrator.

Definition at line 385 of file sundials_interface.cpp.

                                                          {
  auto m = static_cast<SundialsMemory*>(mem);
 
  // Clear seeds
  casadi_clear(m->adj_q, nrp_);
  casadi_clear(NV_DATA_S(m->v_adj_xz), nrx_ + nrz_);
 
  // Reset summation states
  N_VConst(0., m->v_adj_pu);
}

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

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

retreat()

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

overridevirtual

Implements casadi::Integrator.

Definition at line 356 of file cvodes_interface.cpp.

                                                       {
  auto m = to_mem(mem);
 
  // Set controls
  casadi_copy(u, nu_, m->u);
 
  // Integrate, unless already at desired time
  if (m->t_next < m->t) {
    THROWING(CVodeB, m->mem, m->t_next, CV_NORMAL);
    double tret;
    THROWING(CVodeGetB, m->mem, m->whichB, &tret, m->v_adj_xz);
    if (nrq_ > 0 || nuq_ > 0) {
      THROWING(CVodeGetQuadB, m->mem, m->whichB, &tret, m->v_adj_pu);
    }
  }
 
  // Save outputs
  casadi_copy(NV_DATA_S(m->v_adj_xz), nrx_, adj_x);
  casadi_copy(NV_DATA_S(m->v_adj_pu), nrq_, adj_p);
  casadi_copy(NV_DATA_S(m->v_adj_pu) + nrq_, nuq_, adj_u);
 
  // Get stats
  CVodeMem cv_mem = static_cast<CVodeMem>(m->mem);
  CVadjMem ca_mem = cv_mem->cv_adj_mem;
  CVodeBMem cvB_mem = ca_mem->cvB_mem;
  THROWING(CVodeGetIntegratorStats, cvB_mem->cv_mem, &m->nstepsB,
          &m->nfevalsB, &m->nlinsetupsB, &m->netfailsB, &m->qlastB,
          &m->qcurB, &m->hinusedB, &m->hlastB, &m->hcurB, &m->tcurB);
  THROWING(CVodeGetNonlinSolvStats, cvB_mem->cv_mem, &m->nnitersB, &m->nncfailsB);
 
  // Add offset corresponding to counters that were set to zero at reinitializations
  add_offsets(m);
}

References casadi::SundialsInterface::add_offsets(), casadi::casadi_copy(), casadi::Integrator::nrq_, casadi::Integrator::nrx_, casadi::Integrator::nu_, casadi::Integrator::nuq_, and to_mem().

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

                                                                         {
      return "adj" + str(nadj) + "_" + fcn;
    }

References casadi::str().

Referenced by casadi::FunctionInternal::reverse(), and casadi::FixedStepIntegrator::stepB().

rhsB()

int casadi::CvodesInterface::rhsB ( double  t, N_Vector  x, N_Vector  xB, N_Vector  xdotB, void *  user_data  )

staticprotected

Definition at line 429 of file cvodes_interface.cpp.

                                                                                            {
  try {
    casadi_assert_dev(user_data);
    auto m = to_mem(user_data);
    auto& s = m->self;
    if (s.calc_daeB(m, t, NV_DATA_S(x), nullptr, NV_DATA_S(rx), nullptr, m->adj_q,
      NV_DATA_S(rxdot), nullptr)) return 1;
    // Negate (note definition of g)
    casadi_scal(s.nrx_, -1., NV_DATA_S(rxdot));
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "rhsB failed: " << e.what() << std::endl;
    return -1;
  }
}

References casadi::casadi_scal(), to_mem(), and casadi::uerr().

Referenced by impulseB().

rhsF()

int casadi::CvodesInterface::rhsF ( double  t, N_Vector  x, N_Vector  xdot, void *  user_data  )

staticprotected

Definition at line 218 of file cvodes_interface.cpp.

                                                                              {
  try {
    casadi_assert_dev(user_data);
    auto m = to_mem(user_data);
    auto& s = m->self;
    if (s.calc_daeF(m, t, NV_DATA_S(x), nullptr, NV_DATA_S(xdot), nullptr)) return 1;
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "rhs failed: " << e.what() << std::endl;
    return -1;
  }
}

References to_mem(), and casadi::uerr().

Referenced by init_mem().

rhsQB()

int casadi::CvodesInterface::rhsQB ( double  t, N_Vector  x, N_Vector  rx, N_Vector  ruqdot, void *  user_data  )

staticprotected

Definition at line 445 of file cvodes_interface.cpp.

                                                                                              {
  try {
    casadi_assert_dev(user_data);
    auto m = to_mem(user_data);
    auto& s = m->self;
    if (s.calc_quadB(m, t, NV_DATA_S(x), nullptr, NV_DATA_S(rx), nullptr,
      NV_DATA_S(ruqdot), NV_DATA_S(ruqdot) + s.nrq_)) return 1;
 
    // Negate (note definition of g)
    casadi_scal((s.nrq_ + s.nuq_), -1., NV_DATA_S(ruqdot));
 
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "rhsQB failed: " << e.what() << std::endl;
    return -1;
  }
}

References casadi::casadi_scal(), to_mem(), and casadi::uerr().

Referenced by impulseB().

rhsQF()

int casadi::CvodesInterface::rhsQF ( double  t, N_Vector  x, N_Vector  qdot, void *  user_data  )

staticprotected

Definition at line 416 of file cvodes_interface.cpp.

                                                                               {
  try {
    auto m = to_mem(user_data);
    auto& s = m->self;
    if (s.calc_quadF(m, t, NV_DATA_S(x), nullptr, NV_DATA_S(qdot))) return 1;
 
    return 0;
  } catch(std::exception& e) { // non-recoverable error
    uerr() << "rhsQ failed: " << e.what() << std::endl;
    return -1;
  }
}

References to_mem(), and casadi::uerr().

Referenced by init_mem().

save_offsets()

void casadi::SundialsInterface::save_offsets ( SundialsMemory *  m ) const

inherited

Definition at line 364 of file sundials_interface.cpp.

                                                            {
  // Retrieve stats offset, backward problem
  m->nstepsB_off = m->nstepsB;
  m->nfevalsB_off = m->nfevalsB;
  m->nlinsetupsB_off = m->nlinsetupsB;
  m->netfailsB_off = m->netfailsB;
  m->nnitersB_off = m->nnitersB;
  m->nncfailsB_off = m->nncfailsB;
}

References casadi::SundialsMemory::netfailsB, casadi::SundialsMemory::netfailsB_off, casadi::SundialsMemory::nfevalsB, casadi::SundialsMemory::nfevalsB_off, casadi::SundialsMemory::nlinsetupsB, casadi::SundialsMemory::nlinsetupsB_off, casadi::SundialsMemory::nncfailsB, casadi::SundialsMemory::nncfailsB_off, casadi::SundialsMemory::nnitersB, casadi::SundialsMemory::nnitersB_off, casadi::SundialsMemory::nstepsB, and casadi::SundialsMemory::nstepsB_off.

Referenced by impulseB(), and casadi::SundialsInterface::reset_stats().

self()

Function casadi::FunctionInternal::self ( ) const

inlineinherited

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

Definition at line 353 of file function_internal.hpp.

{ return shared_from_this<Function>();}

Referenced by casadi::casadi_uno_term_cb_cpp().

serialize()

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

inherited

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

Definition at line 4393 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::CvodesInterface::serialize_body ( SerializingStream &  s ) const

overridevirtual

Reimplemented from casadi::Integrator.

Definition at line 775 of file cvodes_interface.cpp.

                                                               {
  SundialsInterface::serialize_body(s);
  s.version("CvodesInterface", 3);
 
  s.pack("CvodesInterface::lmm", lmm_);
  s.pack("CvodesInterface::iter", iter_);
  s.pack("CvodesInterface::min_step_size", min_step_size_);
  s.pack("CvodesInterface::always_recalculate_jacobian", always_recalculate_jacobian_);
}

References always_recalculate_jacobian_, iter_, lmm_, min_step_size_, casadi::SerializingStream::pack(), casadi::SundialsInterface::serialize_body(), and casadi::SerializingStream::version().

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 2440 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 3964 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 2546 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 2534 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 2550 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::SundialsInterface::set_work ( void *  mem, const double **&  arg, double **&  res, casadi_int *&  iw, double *&  w  ) const

overridevirtualinherited

Reimplemented from casadi::Integrator.

Definition at line 275 of file sundials_interface.cpp.

                                       {
  auto m = static_cast<SundialsMemory*>(mem);
 
  // Set work in base classes
  Integrator::set_work(mem, arg, res, iw, w);
 
  // Work vectors
  m->jacF = w; w += linsolF_.sparsity().nnz();
 
  // Work vectors
  const Function& jacF = get_function("jacF");
  m->jac_ode_x = w; w += jacF.nnz_out(JACF_ODE_X);
  m->jac_alg_x = w; w += jacF.nnz_out(JACF_ALG_X);
  m->jac_ode_z = w; w += jacF.nnz_out(JACF_ODE_Z);
  m->jac_alg_z = w; w += jacF.nnz_out(JACF_ALG_Z);
}

References casadi::OracleFunction::get_function(), casadi::SundialsInterface::JACF_ALG_X, casadi::SundialsInterface::JACF_ALG_Z, casadi::SundialsInterface::JACF_ODE_X, casadi::SundialsInterface::JACF_ODE_Z, casadi::SundialsInterface::linsolF_, casadi::Sparsity::nnz(), casadi::Function::nnz_out(), casadi::Integrator::set_work(), and casadi::Linsol::sparsity().

set_x()

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

inherited

Definition at line 2538 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 2542 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 3738 of file function_internal.cpp.

                                                                {
    set_work(mem, arg, res, iw, w);
    set_temp(mem, arg, res, iw, w);
    auto *m = static_cast<FunctionMemory*>(mem);
    m->stats_available = true;
  }

References casadi::FunctionInternal::set_temp(), casadi::FunctionInternal::set_work(), and casadi::FunctionMemory::stats_available.

Referenced by casadi::Conic::eval(), casadi::Nlpsol::eval(), casadi::CallbackInternal::eval(), casadi::FiniteDiff::eval(), casadi::FmuFunction::eval(), casadi::Integrator::eval(), casadi::Map::eval(), casadi::OmpMap::eval(), casadi::ThreadMap::eval(), casadi::MapSum::eval(), casadi::MXFunction::eval(), casadi::Rootfinder::eval(), casadi::Switch::eval(), casadi::SXFunction::eval(), casadi::SlicotDple::eval(), casadi::SlicotExpm::eval(), casadi::BSplineInterpolant::eval(), and casadi::LinearInterpolant::eval().

shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                         {
      casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
      B ret;
      ret.own(static_cast<Internal*>(this));
      return ret;
    }

shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                     {
      casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
      B ret;
      ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
      return ret;
    }

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

                                                                             {
    std::vector<std::string> args;
    for (auto e : name_in_) {
      args.push_back("const casadi_real* " + str(e));
    }
    for (auto e : name_out_) {
      args.push_back("casadi_real* " + str(e));
    }
    args.push_back("const casadi_real** arg");
    args.push_back("casadi_real** res");
    args.push_back("casadi_int* iw");
    args.push_back("casadi_real* w");
    args.push_back("int mem");
    return "int " + fname + "_unrolled(" + join(args, ", ") + ")";
  }

References casadi::join(), casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, and casadi::str().

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

simplify_passes()

Function casadi::FunctionInternal::simplify_passes ( const std::vector< std::pair< std::string, casadi_int > > &  tasks ) const

virtualinherited

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

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

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

Definition at line 3933 of file function_internal.cpp.

                                                                     {
    casadi_assert(tasks.empty(), "simplify passes not supported for " + class_name());
    return self();
  }

References casadi::SharedObjectInternal::class_name().

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

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 1026 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 1028 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 1027 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 1029 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 1030 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 1033 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 3945 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 3044 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 3475 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 1042 of file function_internal.hpp.

{ return sparsity_in_.at(ind); }

Referenced by casadi::FunctionInternal::check_arg(), casadi::FixedStepIntegrator::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 1043 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 4088 of file function_internal.cpp.

                                                                                 {
    // Variable number of arguments
    va_list args;
    va_start(args, fmt);
    // Print to buffer
    casadi_int n = vsnprintf(buf, buf_sz, fmt, args);
    // Cleanup
    va_end(args);
    // Throw error if failure
    casadi_assert(n>=0 && n<buf_sz, "Print failure while processing '" + std::string(fmt) + "'");
  }

Referenced by casadi::ProtoFunction::format_time(), and casadi::ProtoFunction::print_time().

string_from_UnifiedReturnStatus()

std::string casadi::FunctionInternal::string_from_UnifiedReturnStatus ( UnifiedReturnStatus  status )

staticinherited

Definition at line 4156 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 3502 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 3486 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 3510 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 3490 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 1207 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 1591 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 1215 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::ThreadMap::codegen_body(), casadi::ThreadMap::codegen_declarations(), 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::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::Qrqp::init(), and casadi::FunctionInternal::sz_work().

sz_iw()

size_t casadi::FunctionInternal::sz_iw ( ) const

inlineinherited

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

Definition at line 1225 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::ThreadMap::codegen_body(), casadi::ThreadMap::codegen_declarations(), 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::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::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 1220 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::ThreadMap::codegen_body(), casadi::ThreadMap::codegen_declarations(), 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::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::Qrqp::init(), and casadi::FunctionInternal::sz_work().

sz_w()

size_t casadi::FunctionInternal::sz_w ( ) const

inlineinherited

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

Definition at line 1230 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::ThreadMap::codegen_body(), casadi::ThreadMap::codegen_declarations(), 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::MadmpecInterface::init(), casadi::ClarabelInterface::init(), casadi::DaqpInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HighsInterface::init(), casadi::HpipmInterface::init(), casadi::MadnlpInterface::init(), casadi::MosekInterface::init(), casadi::XpressInterface::init(), casadi::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 3092 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 1978 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().

to_mem()

static CvodesMemory* casadi::CvodesInterface::to_mem ( void *  mem )

inlinestatic

Definition at line 144 of file cvodes_interface.hpp.

                                         {
    CvodesMemory* m = static_cast<CvodesMemory*>(mem);
    casadi_assert_dev(m);
    return m;
  }

Referenced by advance_noevent(), ehfun(), impulseB(), init_mem(), jtimesB(), jtimesF(), lsetupB(), lsetupF(), lsolveB(), lsolveF(), psetupB(), psetupF(), psolveB(), psolveF(), reset(), retreat(), rhsB(), rhsF(), rhsQB(), and rhsQF().

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 1134 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 1138 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 2653 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::OnnxFunction, casadi::Nlpsol, casadi::FiniteDiff, and casadi::CallbackInternal.

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

                                                                                  {
#ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
    auto* w = weak_ref_.load(std::memory_order_acquire);
    if (!w) {
      auto* nw = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
      GenericWeakRef<Shared, Internal>* expected = nullptr;
      if (weak_ref_.compare_exchange_strong(
            expected, nw, std::memory_order_release, std::memory_order_acquire)) {
        w = nw;
      } else {
        delete nw; // lost the race; another thread published first
        w = expected;
      }
    }
    return w;
#else
    if (weak_ref_==nullptr) {
      weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
    }
    return weak_ref_;
#endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  }

which_depends()

std::vector< bool > casadi::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 3925 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() [1/2]

Function casadi::FunctionInternal::wrap ( ) const

inherited

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

Definition at line 1182 of file function_internal.cpp.

                                        {
    return wrap("wrap_" + name_);
  }

References casadi::ProtoFunction::name_.

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

wrap() [2/2]

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

inherited

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

Definition at line 1186 of file function_internal.cpp.

                                                             {
    Function f;
    if (!incache(name, f)) {
      // Options
      Dict opts;
      opts["derivative_of"] = derivative_of_;
      opts["ad_weight"] = ad_weight();
      opts["ad_weight_sp"] = sp_weight();
      opts["max_num_dir"] = max_num_dir_;
      opts["is_diff_in"] = is_diff_in_;
      opts["is_diff_out"] = is_diff_out_;
      // Wrap the function
      std::vector<MX> arg = mx_in();
      std::vector<MX> res = self()(arg);
      f = Function(name, arg, res, name_in_, name_out_, opts);
      // Save in cache
      tocache_if_missing(f);
    }
    return f;
  }

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

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

wrap_as_needed() [1/2]

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

inherited

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

Definition at line 1161 of file function_internal.cpp.

                                                                  {
    return wrap_as_needed("wrap_" + name_, opts);
  }

References casadi::ProtoFunction::name_, and casadi::FunctionInternal::wrap_as_needed().

wrap_as_needed() [2/2]

Function casadi::FunctionInternal::wrap_as_needed ( const std::string &  name, const Dict &  opts  ) const

inherited

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

Definition at line 1165 of file function_internal.cpp.

                                                                                         {
    if (opts.empty() && name==name_) return shared_from_this<Function>();
    // Options
    Dict my_opts = opts;
    my_opts["derivative_of"] = derivative_of_;
    if (my_opts.find("ad_weight")==my_opts.end())
      my_opts["ad_weight"] = ad_weight();
    if (my_opts.find("ad_weight_sp")==my_opts.end())
      my_opts["ad_weight_sp"] = sp_weight();
    if (my_opts.find("max_num_dir")==my_opts.end())
      my_opts["max_num_dir"] = max_num_dir_;
    // Wrap the function
    std::vector<MX> arg = mx_in();
    std::vector<MX> res = self()(arg);
    return Function(name, arg, res, name_in_, name_out_, my_opts);
  }

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

Referenced by casadi::Function::wrap_as_needed(), and casadi::FunctionInternal::wrap_as_needed().

Member Data Documentation

abstol_

double casadi::SundialsInterface::abstol_

inherited

Options

Definition at line 189 of file sundials_interface.hpp.

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

ad_weight_

double casadi::FunctionInternal::ad_weight_

inherited

Definition at line 1417 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 1417 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::find(), 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 1306 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().

always_recalculate_jacobian_

bool casadi::CvodesInterface::always_recalculate_jacobian_

Definition at line 113 of file cvodes_interface.hpp.

Referenced by CvodesInterface(), init(), and 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 1388 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 1385 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 1355 of file function_internal.hpp.

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

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

Referenced by casadi::External::codegen_body(), casadi::External::codegen_declarations(), casadi::External::External(), casadi::External::factory(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::GenericExternal::get_jac_sparsity(), casadi::External::get_n_in(), casadi::External::get_n_out(), casadi::External::get_name_in(), casadi::External::get_name_out(), casadi::GenericExternal::get_sparsity_in(), casadi::GenericExternal::get_sparsity_out(), casadi::External::has_forward(), casadi::GenericExternal::has_jac_sparsity(), casadi::External::has_jacobian(), casadi::External::has_reverse(), casadi::External::init(), casadi::Scpgen::init(), casadi::External::init_external(), casadi::GenericExternal::init_external(), casadi::OracleFunction::jit_dependencies(), casadi::External::serialize_body(), and casadi::FunctionInternal::serialize_body().

compiler_plugin_

std::string casadi::FunctionInternal::compiler_plugin_

inherited

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

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

decref_

signal_t casadi::FunctionInternal::decref_

inherited

Definition at line 1365 of file function_internal.hpp.

Referenced by casadi::External::any_symbol_found(), casadi::External::codegen_declarations(), casadi::External::codegen_decref(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::External::init_external(), and casadi::FunctionInternal::~FunctionInternal().

der_options_

Dict casadi::FunctionInternal::der_options_

inherited

Definition at line 1454 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 1399 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},
    {"Onnx", OnnxFunction::deserialize}
  }

Definition at line 1511 of file function_internal.hpp.

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

disable_internal_warnings_

bool casadi::SundialsInterface::disable_internal_warnings_

inherited

Options

Definition at line 194 of file sundials_interface.hpp.

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

dump_

bool casadi::FunctionInternal::dump_

inherited

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

Referenced by casadi::FunctionInternal::FunctionInternal(), and casadi::FunctionInternal::reset_dump_count().

dump_dir_

std::string casadi::FunctionInternal::dump_dir_

inherited

Definition at line 1448 of file function_internal.hpp.

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

dump_format_

std::string casadi::FunctionInternal::dump_format_

inherited

Definition at line 1451 of file function_internal.hpp.

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

dump_in_

bool casadi::FunctionInternal::dump_in_

inherited

Definition at line 1445 of file function_internal.hpp.

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

dump_out_

bool casadi::FunctionInternal::dump_out_

inherited

Definition at line 1445 of file function_internal.hpp.

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

enable_fd_

bool casadi::FunctionInternal::enable_fd_

inherited

Definition at line 1413 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 1414 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 1413 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 1414 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 1413 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 1414 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 1413 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 1414 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::MadmpecInterface::codegen_body(), 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::MosekInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::UnoInterface::codegen_body(), casadi::XpressInterface::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 1350 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 1432 of file function_internal.hpp.

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

fd_options_

Dict casadi::FunctionInternal::fd_options_

inherited

Definition at line 1426 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 1429 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 1454 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 1375 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::codegen_decref(), casadi::FunctionInternal::codegen_incref(), casadi::DaqpInterface::DaqpInterface(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::External::init(), casadi::MXFunction::init(), and casadi::FunctionInternal::serialize_body().

has_refcount_in_deps_

bool casadi::FunctionInternal::has_refcount_in_deps_

inherited

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

Definition at line 1380 of file function_internal.hpp.

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

incref_

signal_t casadi::FunctionInternal::incref_

inherited

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

Definition at line 1365 of file function_internal.hpp.

Referenced by casadi::External::any_symbol_found(), casadi::External::codegen_declarations(), casadi::External::codegen_incref(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), and casadi::External::init_external().

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

interp_

enum casadi::SundialsInterface::InterpType casadi::SundialsInterface::interp_

inherited

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

is_diff_in_

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

inherited

Definition at line 1312 of file function_internal.hpp.

Referenced by casadi::FiniteDiff::codegen_body(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::definition(), casadi::FiniteDiff::eval(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwd_seed(), casadi::FunctionInternal::generate_options(), casadi::FiniteDiff::get_sparsity_in(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::MapSum::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::serialize_body(), casadi::MXFunction::sp_forward(), casadi::SXFunction::sp_forward(), casadi::MXFunction::sp_reverse(), casadi::SXFunction::sp_reverse(), and casadi::FunctionInternal::wrap().

is_diff_out_

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

inherited

Definition at line 1312 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::MapSum::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::serialize_body(), casadi::MXFunction::sp_forward(), casadi::SXFunction::sp_forward(), casadi::MXFunction::sp_reverse(), casadi::SXFunction::sp_reverse(), casadi::FunctionInternal::symbolicAdjSeed(), and casadi::FunctionInternal::wrap().

iter_

casadi_int casadi::CvodesInterface::iter_

protected

Definition at line 188 of file cvodes_interface.hpp.

Referenced by CvodesInterface(), impulseB(), init(), init_mem(), and serialize_body().

jac_penalty_

double casadi::FunctionInternal::jac_penalty_

inherited

Definition at line 1410 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 1391 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 1454 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 1323 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 1340 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 1328 of file function_internal.hpp.

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

jit_directory_

std::string casadi::FunctionInternal::jit_directory_

inherited

Definition at line 1339 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), and casadi::FunctionInternal::~FunctionInternal().

jit_name_

std::string casadi::FunctionInternal::jit_name_

inherited

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

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

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

jit_serialize_

std::string casadi::FunctionInternal::jit_serialize_

inherited

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

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

linear_solver_

std::string casadi::SundialsInterface::linear_solver_

inherited

Options

Definition at line 196 of file sundials_interface.hpp.

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

linear_solver_options_

Dict casadi::SundialsInterface::linear_solver_options_

inherited

Options

Definition at line 197 of file sundials_interface.hpp.

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

linsolF_

Linsol casadi::SundialsInterface::linsolF_

inherited

Definition at line 209 of file sundials_interface.hpp.

Referenced by casadi::SundialsInterface::init(), casadi::SundialsInterface::init_mem(), casadi::SundialsInterface::serialize_body(), casadi::SundialsInterface::set_work(), casadi::IdasInterface::solve_transposed(), and casadi::SundialsInterface::SundialsInterface().

lmm_

casadi_int casadi::CvodesInterface::lmm_

protected

Definition at line 187 of file cvodes_interface.hpp.

Referenced by CvodesInterface(), impulseB(), init(), init_mem(), and 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 1442 of file function_internal.hpp.

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

max_krylov_

casadi_int casadi::SundialsInterface::max_krylov_

inherited

Options

Definition at line 198 of file sundials_interface.hpp.

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

max_multistep_order_

casadi_int casadi::SundialsInterface::max_multistep_order_

inherited

Options

Definition at line 195 of file sundials_interface.hpp.

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

max_num_dir_

casadi_int casadi::FunctionInternal::max_num_dir_

inherited

Definition at line 1420 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_steps_

casadi_int casadi::SundialsInterface::max_num_steps_

inherited

Options

Definition at line 190 of file sundials_interface.hpp.

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

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

max_order_

casadi_int casadi::SundialsInterface::max_order_

inherited

Options

Definition at line 204 of file sundials_interface.hpp.

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

max_step_size_

double casadi::SundialsInterface::max_step_size_

inherited

Options

Definition at line 202 of file sundials_interface.hpp.

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

meta_doc

const std::string casadi::CvodesInterface::meta_doc

static

Definition at line 151 of file cvodes_interface.hpp.

Referenced by casadi::casadi_register_integrator_cvodes().

min_step_size_

double casadi::CvodesInterface::min_step_size_

Definition at line 112 of file cvodes_interface.hpp.

Referenced by CvodesInterface(), init(), init_mem(), and serialize_body().

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 1309 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::ThreadMap::codegen_body(), casadi::MapSum::codegen_body(), casadi::MXFunction::codegen_body(), casadi::Switch::codegen_body(), casadi::SXFunction::codegen_body(), casadi::FastNewton::codegen_body(), casadi::ThreadMap::codegen_declarations(), 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::MXFunction::eval_activity(), 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::SXFunction::print_arg(), 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 1309 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::ThreadMap::codegen_body(), casadi::MapSum::codegen_body(), casadi::MXFunction::codegen_body(), casadi::Switch::codegen_body(), casadi::SXFunction::codegen_body(), casadi::FastNewton::codegen_body(), casadi::ThreadMap::codegen_declarations(), 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_activity(), casadi::MXFunction::eval_activity(), 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::FixedStepIntegrator::impulseB(), casadi::Integrator::init(), casadi::FixedStepIntegrator::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 casadi::FixedStepIntegrator::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::BlazingSplineFunction::init(), casadi::External::init(), casadi::FunctionInternal::init(), casadi::MXFunction::init(), casadi::SXFunction::init(), init(), casadi::IdasInterface::init(), casadi::External::init_external(), casadi::GenericExternal::init_external(), casadi::OnnxRuntimeInterface::init_mem(), casadi::FunctionInternal::jac_is_symm(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::map(), casadi::OracleFunction::monitored(), casadi::MXFunction::print_arg(), casadi::SXFunction::print_arg(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_out(), casadi::MXFunction::print_res(), casadi::SXFunction::print_res(), casadi::ProtoFunction::print_time(), casadi::ProtoFunction::ProtoFunction(), 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 1318 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 1318 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(), 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 1306 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().

newton_scheme_

enum casadi::SundialsInterface::NewtonScheme casadi::SundialsInterface::newton_scheme_

inherited

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

nfwd_

casadi_int casadi::Integrator::nfwd_

inherited

Definition at line 391 of file integrator_impl.hpp.

Referenced by casadi::FixedStepIntegrator::advance_noevent(), 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::FixedStepIntegrator::impulseB(), casadi::Integrator::init(), casadi::FixedStepIntegrator::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(), casadi::FixedStepIntegrator::stepB(), casadi::FixedStepIntegrator::stepF(), and casadi::Integrator::trigger_event().

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

nonlin_conv_coeff_

double casadi::SundialsInterface::nonlin_conv_coeff_

inherited

Options

Definition at line 203 of file sundials_interface.hpp.

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

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(), casadi::FixedStepIntegrator::stepB(), casadi::FixedStepIntegrator::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 casadi::FixedStepIntegrator::stepF().

nq_

casadi_int casadi::Integrator::nq_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by casadi::FixedStepIntegrator::advance_noevent(), advance_noevent(), casadi::IdasInterface::advance_noevent(), casadi::Integrator::eval(), casadi::Integrator::get_q(), casadi::Integrator::init(), casadi::FixedStepIntegrator::init(), casadi::SundialsInterface::init(), init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), reset(), casadi::SundialsInterface::reset(), casadi::Integrator::serialize_body(), casadi::Integrator::set_q(), casadi::Integrator::set_work(), casadi::FixedStepIntegrator::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 casadi::FixedStepIntegrator::stepB().

nrp_

casadi_int casadi::Integrator::nrp_

inherited

Definition at line 403 of file integrator_impl.hpp.

Referenced by casadi::Integrator::eval(), casadi::FixedStepIntegrator::impulseB(), casadi::SundialsInterface::impulseB(), casadi::Integrator::init(), casadi::Integrator::Integrator(), casadi::FixedStepIntegrator::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 casadi::FixedStepIntegrator::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(), casadi::FixedStepIntegrator::init(), casadi::SundialsInterface::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::FixedStepIntegrator::resetB(), casadi::FixedStepIntegrator::retreat(), retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), casadi::FixedStepIntegrator::set_work(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

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 casadi::FixedStepIntegrator::stepB().

nrx_

casadi_int casadi::Integrator::nrx_

inherited

Definition at line 400 of file integrator_impl.hpp.

Referenced by casadi::FixedStepIntegrator::advance_noevent(), advance_noevent(), casadi::IdasInterface::advance_noevent(), casadi::FixedStepIntegrator::create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_reverse(), casadi::FixedStepIntegrator::impulseB(), casadi::IdasInterface::impulseB(), casadi::SundialsInterface::impulseB(), casadi::Integrator::init(), casadi::FixedStepIntegrator::init(), init(), init_mem(), casadi::IdasInterface::init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::SundialsInterface::print_stats(), casadi::FixedStepIntegrator::reset(), reset(), casadi::FixedStepIntegrator::resetB(), casadi::SundialsInterface::resetB(), casadi::FixedStepIntegrator::retreat(), retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), casadi::FixedStepIntegrator::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::FixedStepIntegrator::impulseB(), 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(), casadi::IdasInterface::impulseB(), casadi::SundialsInterface::impulseB(), casadi::Integrator::init(), 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(), casadi::FixedStepIntegrator::stepB(), casadi::FixedStepIntegrator::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(), casadi::FixedStepIntegrator::retreat(), 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 casadi::FixedStepIntegrator::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(), casadi::FixedStepIntegrator::init(), casadi::SundialsInterface::init(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::FixedStepIntegrator::resetB(), casadi::FixedStepIntegrator::retreat(), retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::serialize_body(), casadi::FixedStepIntegrator::set_work(), casadi::Integrator::sp_forward(), and casadi::Integrator::sp_reverse().

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(), casadi::FixedStepIntegrator::stepB(), casadi::FixedStepIntegrator::stepF(), and casadi::Integrator::trigger_event().

nx_

casadi_int casadi::Integrator::nx_

inherited

Definition at line 397 of file integrator_impl.hpp.

Referenced by casadi::FixedStepIntegrator::advance_noevent(), advance_noevent(), casadi::IdasInterface::advance_noevent(), casadi::Integrator::calc_edot(), casadi::Integrator::eval(), casadi::Integrator::get_x(), casadi::Integrator::init(), casadi::FixedStepIntegrator::init(), init(), casadi::IdasInterface::init(), casadi::SundialsInterface::init(), casadi::IdasInterface::init_mem(), casadi::SundialsInterface::init_mem(), casadi::Integrator::Integrator(), casadi::FixedStepIntegrator::reset(), casadi::SundialsInterface::reset(), casadi::FixedStepIntegrator::retreat(), casadi::Integrator::serialize_body(), casadi::Integrator::set_work(), casadi::FixedStepIntegrator::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::FixedStepIntegrator::advance_noevent(), 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 casadi::IdasInterface::advance_noevent(), casadi::Collocation::algebraic_state_output(), casadi::FixedStepIntegrator::create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_z(), casadi::Integrator::init(), 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::CvodesInterface::options_

static

Initial value:

= {{&SundialsInterface::options_},
    {{"linear_multistep_method",
      {OT_STRING,
      "Integrator scheme: BDF|adams"}},
    {"nonlinear_solver_iteration",
      {OT_STRING,
      "Nonlinear solver type: NEWTON|functional"}},
    {"min_step_size",
      {OT_DOUBLE,
      "Min step size [default: 0/0.0]"}},
    {"fsens_all_at_once",
      {OT_BOOL,
      "Calculate all right hand sides of the sensitivity equations at once"}},
    {"always_recalculate_jacobian",
     {OT_BOOL,
      "Recalculate Jacobian before factorizations, even if Jacobian is current [default: true]"}}
    }
}

Definition at line 110 of file cvodes_interface.hpp.

Referenced by casadi::casadi_register_integrator_cvodes().

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_canonical_

bool casadi::FunctionInternal::print_canonical_

inherited

Definition at line 1439 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::MXFunction::print_arg(), casadi::SXFunction::print_arg(), casadi::FunctionInternal::print_in(), casadi::FunctionInternal::print_out(), casadi::MXFunction::print_res(), casadi::SXFunction::print_res(), and casadi::FunctionInternal::serialize_body().

print_in_

bool casadi::FunctionInternal::print_in_

inherited

Definition at line 1435 of file function_internal.hpp.

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

print_out_

bool casadi::FunctionInternal::print_out_

inherited

Definition at line 1436 of file function_internal.hpp.

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

print_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 casadi::FixedStepIntegrator::create_advanced(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::FunctionInternal::init(), casadi::Nlpsol::Nlpsol(), casadi::ProtoFunction::print_time(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

quad_err_con_

bool casadi::SundialsInterface::quad_err_con_

inherited

Options

Definition at line 192 of file sundials_interface.hpp.

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

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

registered_functions_

std::vector<Function> casadi::FunctionInternal::registered_functions_

inherited

Definition at line 1460 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::alloc(), casadi::FunctionInternal::find(), casadi::FunctionInternal::FunctionInternal(), and casadi::FunctionInternal::serialize_body().

regularity_check_

bool casadi::ProtoFunction::regularity_check_

inherited

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

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

reltol_

double casadi::SundialsInterface::reltol_

inherited

Options

Definition at line 189 of file sundials_interface.hpp.

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

reverse_options_

Dict casadi::FunctionInternal::reverse_options_

inherited

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

scale_abstol_

bool casadi::SundialsInterface::scale_abstol_

inherited

Options

Definition at line 205 of file sundials_interface.hpp.

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

second_order_correction_

bool casadi::SundialsInterface::second_order_correction_

inherited

Options

Definition at line 200 of file sundials_interface.hpp.

Referenced by casadi::SundialsInterface::init(), casadi::SundialsInterface::serialize_body(), casadi::IdasInterface::solve_transposed(), and casadi::SundialsInterface::SundialsInterface().

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

step0_

double casadi::SundialsInterface::step0_

inherited

Options

Definition at line 201 of file sundials_interface.hpp.

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

steps_per_checkpoint_

casadi_int casadi::SundialsInterface::steps_per_checkpoint_

inherited

Options

Definition at line 193 of file sundials_interface.hpp.

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

stop_at_end_

bool casadi::SundialsInterface::stop_at_end_

inherited

Options

Definition at line 191 of file sundials_interface.hpp.

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

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 casadi::FixedStepIntegrator::create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::IdasInterface::impulseB(), casadi::Integrator::init(), casadi::FixedStepIntegrator::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 casadi::FixedStepIntegrator::create_advanced(), casadi::Integrator::eval(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::Integrator::init(), casadi::FixedStepIntegrator::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().

use_precon_

bool casadi::SundialsInterface::use_precon_

inherited

Options

Definition at line 199 of file sundials_interface.hpp.

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

user_data_

void* casadi::FunctionInternal::user_data_

inherited

Definition at line 1402 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::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::CodeGenerator::generate_dump(), 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::MadmpecInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), init(), casadi::IdasInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Scpgen::init(), casadi::Sqpmethod::init(), casadi::IpoptInterface::init_mem(), casadi::MosekInterface::init_mem(), casadi::IdasInterface::init_mem(), casadi::UnoInterface::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(), 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:

• cvodes_interface.hpp
• cvodes_interface.cpp
• cvodes_interface_meta.cpp