'blocksqp' plugin for Nlpsol More...

#include <blocksqp.hpp>

Detailed Description

This is a modified version of blockSQP by Janka et al.

Author: Dennis Janka, Joel Andersson

Date: 2012-2015, 2016

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

List of available options
Id	Type	Description
block_hess	OT_INT	Blockwise Hessian approximation?
col_eps	OT_DOUBLE	Epsilon for COL scaling strategy
col_tau1	OT_DOUBLE	tau1 for COL scaling strategy
col_tau2	OT_DOUBLE	tau2 for COL scaling strategy
conv_strategy	OT_INT	Convexification strategy
delta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
delta_h0	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
eps	OT_DOUBLE	Values smaller than this are regarded as numerically zero
eta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
fallback_scaling	OT_INT	If indefinite update is used, the type of fallback strategy
fallback_update	OT_INT	If indefinite update is used, the type of fallback strategy
gamma_f	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
gamma_theta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
globalization	OT_BOOL	Enable globalization
hess_damp	OT_INT	Activate Powell damping for BFGS
hess_damp_fac	OT_DOUBLE	Damping factor for BFGS Powell modification
hess_lim_mem	OT_INT	Full or limited memory
hess_memsize	OT_INT	Memory size for L-BFGS updates
hess_scaling	OT_INT	Scaling strategy for Hessian approximation
hess_update	OT_INT	Type of Hessian approximation
ini_hess_diag	OT_DOUBLE	Initial Hessian guess: diagonal matrix diag(iniHessDiag)
kappa_f	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
kappa_minus	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
kappa_plus	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
kappa_plus_max	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
kappa_soc	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
linsol	OT_STRING	The linear solver to be used by the QP method
max_consec_reduced_steps	OT_INT	Maximum number of consecutive reduced steps
max_consec_skipped_updates	OT_INT	Maximum number of consecutive skipped updates
max_conv_qp	OT_INT	How many additional QPs may be solved for convexification per iteration?
max_it_qp	OT_INT	Maximum number of QP iterations per SQP iteration
max_iter	OT_INT	Maximum number of SQP iterations
max_line_search	OT_INT	Maximum number of steps in line search
max_soc_iter	OT_INT	Maximum number of SOC line search iterations
max_time_qp	OT_DOUBLE	Maximum number of time in seconds per QP solve per SQP iteration
nlinfeastol	OT_DOUBLE	Nonlinear feasibility tolerance
obj_lo	OT_DOUBLE	Lower bound on objective function [-inf]
obj_up	OT_DOUBLE	Upper bound on objective function [inf]
opttol	OT_DOUBLE	Optimality tolerance
print_header	OT_BOOL	Print solver header at startup
print_iteration	OT_BOOL	Print SQP iterations
print_maxit_reached	OT_BOOL	Print error when maximum number of SQP iterations reached
qp_init	OT_BOOL	Use warmstarting
qpsol	OT_STRING	The QP solver to be used by the SQP method
qpsol_options	OT_DICT	Options to be passed to the QP solver
restore_feas	OT_BOOL	Use feasibility restoration phase
rho	OT_DOUBLE	Feasibility restoration phase parameter
s_f	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
s_theta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
schur	OT_BOOL	Use qpOASES Schur compliment approach
skip_first_globalization	OT_BOOL	No globalization strategy in first iteration
theta_max	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
theta_min	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper
warmstart	OT_BOOL	Use warmstarting
which_second_derv	OT_INT	For which block should second derivatives be provided by the user
zeta	OT_DOUBLE	Feasibility restoration phase parameter

List of available options
Id	Type	Description	Used in
ad_weight	OT_DOUBLE	Weighting factor for derivative calculation.When there is an option of either using forward or reverse mode directional derivatives, the condition ad_weightnf<=(1-ad_weight)na is used where nf and na are estimates of the number of forward/reverse mode directional derivatives needed. By default, ad_weight is calculated automatically, but this can be overridden by setting this option. In particular, 0 means forcing forward mode and 1 forcing reverse mode. Leave unset for (class specific) heuristics.	casadi::FunctionInternal
ad_weight_sp	OT_DOUBLE	Weighting factor for sparsity pattern calculation calculation.Overrides default behavior. Set to 0 and 1 to force forward and reverse mode respectively. Cf. option "ad_weight". When set to -1, sparsity is completely ignored and dense matrices are used.	casadi::FunctionInternal
always_inline	OT_BOOL	Force inlining.	casadi::FunctionInternal
block_hess	OT_INT	Blockwise Hessian approximation?	casadi::Blocksqp
bound_consistency	OT_BOOL	Ensure that primal-dual solution is consistent with the bounds	casadi::Nlpsol
cache	OT_DICT	Prepopulate the function cache. Default: empty	casadi::FunctionInternal
calc_f	OT_BOOL	Calculate 'f' in the Nlpsol base class	casadi::Nlpsol
calc_g	OT_BOOL	Calculate 'g' in the Nlpsol base class	casadi::Nlpsol
calc_lam_p	OT_BOOL	Calculate 'lam_p' in the Nlpsol base class	casadi::Nlpsol
calc_lam_x	OT_BOOL	Calculate 'lam_x' in the Nlpsol base class	casadi::Nlpsol
calc_multipliers	OT_BOOL	Calculate Lagrange multipliers in the Nlpsol base class	casadi::Nlpsol
col_eps	OT_DOUBLE	Epsilon for COL scaling strategy	casadi::Blocksqp
col_tau1	OT_DOUBLE	tau1 for COL scaling strategy	casadi::Blocksqp
col_tau2	OT_DOUBLE	tau2 for COL scaling strategy	casadi::Blocksqp
common_options	OT_DICT	Options for auto-generated functions	casadi::OracleFunction
compiler	OT_STRING	Just-in-time compiler plugin to be used.	casadi::FunctionInternal
conv_strategy	OT_INT	Convexification strategy	casadi::Blocksqp
custom_jacobian	OT_FUNCTION	Override CasADi's AD. Use together with 'jac_penalty': 0. Note: Highly experimental. Syntax may break often.	casadi::FunctionInternal
delta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
delta_h0	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
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
detect_simple_bounds	OT_BOOL	Automatically detect simple bounds (lbx/ubx) (default false). This is hopefully beneficial to speed and robustness but may also have adverse affects: 1) Subtleties in heuristics and stopping criteria may change the solution, 2) IPOPT may lie about multipliers of simple equality bounds unless 'fixed_variable_treatment' is set to 'relax_bounds'.	casadi::Nlpsol
detect_simple_bounds_is_simple	OT_BOOLVECTOR	For internal use only.	casadi::Nlpsol
detect_simple_bounds_parts	OT_FUNCTION	For internal use only.	casadi::Nlpsol
detect_simple_bounds_target_x	OT_INTVECTOR	For internal use only.	casadi::Nlpsol
discrete	OT_BOOLVECTOR	Indicates which of the variables are discrete, i.e. integer-valued	casadi::Nlpsol
dump	OT_BOOL	Dump function to file upon first evaluation. [false]	casadi::FunctionInternal
dump_dir	OT_STRING	Directory to dump inputs/outputs to. Make sure the directory exists [.]	casadi::FunctionInternal
dump_format	OT_STRING	Choose file format to dump matrices. See DM.from_file [mtx]	casadi::FunctionInternal
dump_in	OT_BOOL	Dump numerical values of inputs to file (readable with DM.from_file) [default: false]	casadi::FunctionInternal
dump_out	OT_BOOL	Dump numerical values of outputs to file (readable with DM.from_file) [default: false]	casadi::FunctionInternal
enable_fd	OT_BOOL	Enable derivative calculation by finite differencing. [default: false]]	casadi::FunctionInternal
enable_forward	OT_BOOL	Enable derivative calculation using generated functions for Jacobian-times-vector products - typically using forward mode AD - if available. [default: true]	casadi::FunctionInternal
enable_jacobian	OT_BOOL	Enable derivative calculation using generated functions for Jacobians of all differentiable outputs with respect to all differentiable inputs - if available. [default: true]	casadi::FunctionInternal
enable_reverse	OT_BOOL	Enable derivative calculation using generated functions for transposed Jacobian-times-vector products - typically using reverse mode AD - if available. [default: true]	casadi::FunctionInternal
eps	OT_DOUBLE	Values smaller than this are regarded as numerically zero	casadi::Blocksqp
equality	OT_BOOLVECTOR	Indicate an upfront hint which of the constraints are equalities. Some solvers may be able to exploit this knowledge. When true, the corresponding lower and upper bounds are assumed equal. When false, the corresponding bounds may be equal or different.	casadi::Nlpsol
error_on_fail	OT_BOOL	Throw exceptions when function evaluation fails (default true).	casadi::ProtoFunction
eta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
eval_errors_fatal	OT_BOOL	When errors occur during evaluation of f,g,...,stop the iterations	casadi::Nlpsol
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
fallback_scaling	OT_INT	If indefinite update is used, the type of fallback strategy	casadi::Blocksqp
fallback_update	OT_INT	If indefinite update is used, the type of fallback strategy	casadi::Blocksqp
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
gamma_f	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
gamma_theta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
gather_stats	OT_BOOL	Deprecated option (ignored): Statistics are now always collected.	casadi::FunctionInternal
globalization	OT_BOOL	Enable globalization	casadi::Blocksqp
hess_damp	OT_INT	Activate Powell damping for BFGS	casadi::Blocksqp
hess_damp_fac	OT_DOUBLE	Damping factor for BFGS Powell modification	casadi::Blocksqp
hess_lim_mem	OT_INT	Full or limited memory	casadi::Blocksqp
hess_memsize	OT_INT	Memory size for L-BFGS updates	casadi::Blocksqp
hess_scaling	OT_INT	Scaling strategy for Hessian approximation	casadi::Blocksqp
hess_update	OT_INT	Type of Hessian approximation	casadi::Blocksqp
ignore_check_vec	OT_BOOL	If set to true, the input shape of F will not be checked.	casadi::Nlpsol
ini_hess_diag	OT_DOUBLE	Initial Hessian guess: diagonal matrix diag(iniHessDiag)	casadi::Blocksqp
input_scheme	OT_STRINGVECTOR	Deprecated option (ignored)	casadi::FunctionInternal
inputs_check	OT_BOOL	Throw exceptions when the numerical values of the inputs don't make sense	casadi::FunctionInternal
is_diff_in	OT_BOOLVECTOR	Indicate for each input if it should be differentiable.	casadi::FunctionInternal
is_diff_out	OT_BOOLVECTOR	Indicate for each output if it should be differentiable.	casadi::FunctionInternal
iteration_callback	OT_FUNCTION	A function that will be called at each iteration with the solver as input. Check documentation of Callback.	casadi::Nlpsol
iteration_callback_ignore_errors	OT_BOOL	If set to true, errors thrown by iteration_callback will be ignored.	casadi::Nlpsol
iteration_callback_step	OT_INT	Only call the callback function every few iterations.	casadi::Nlpsol
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
kappa_f	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
kappa_minus	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
kappa_plus	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
kappa_plus_max	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
kappa_soc	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
linsol	OT_STRING	The linear solver to be used by the QP method	casadi::Blocksqp
max_consec_reduced_steps	OT_INT	Maximum number of consecutive reduced steps	casadi::Blocksqp
max_consec_skipped_updates	OT_INT	Maximum number of consecutive skipped updates	casadi::Blocksqp
max_conv_qp	OT_INT	How many additional QPs may be solved for convexification per iteration?	casadi::Blocksqp
max_io	OT_INT	Acceptable number of inputs and outputs. Warn if exceeded.	casadi::FunctionInternal
max_it_qp	OT_INT	Maximum number of QP iterations per SQP iteration	casadi::Blocksqp
max_iter	OT_INT	Maximum number of SQP iterations	casadi::Blocksqp
max_line_search	OT_INT	Maximum number of steps in line search	casadi::Blocksqp
max_num_dir	OT_INT	Specify the maximum number of directions for derivative functions. Overrules the builtin optimized_num_dir.	casadi::FunctionInternal
max_soc_iter	OT_INT	Maximum number of SOC line search iterations	casadi::Blocksqp
max_time_qp	OT_DOUBLE	Maximum number of time in seconds per QP solve per SQP iteration	casadi::Blocksqp
min_lam	OT_DOUBLE	Minimum allowed multiplier value	casadi::Nlpsol
monitor	OT_STRINGVECTOR	Set of user problem functions to be monitored	casadi::OracleFunction
never_inline	OT_BOOL	Forbid inlining.	casadi::FunctionInternal
nlinfeastol	OT_DOUBLE	Nonlinear feasibility tolerance	casadi::Blocksqp
no_nlp_grad	OT_BOOL	Prevent the creation of the 'nlp_grad' function	casadi::Nlpsol
obj_lo	OT_DOUBLE	Lower bound on objective function [-inf]	casadi::Blocksqp
obj_up	OT_DOUBLE	Upper bound on objective function [inf]	casadi::Blocksqp
opttol	OT_DOUBLE	Optimality tolerance	casadi::Blocksqp
oracle_options	OT_DICT	Options to be passed to the oracle function	casadi::Nlpsol
output_scheme	OT_STRINGVECTOR	Deprecated option (ignored)	casadi::FunctionInternal
post_expand	OT_BOOL	After construction, expand this Function. Default: False	casadi::FunctionInternal
post_expand_options	OT_DICT	Options to be passed to post-construction expansion. Default: empty	casadi::FunctionInternal
postpone_expand	OT_BOOL	When expand is active, postpone it until after creation of derivatives. Default: False	casadi::OracleFunction
print_header	OT_BOOL	Print solver header at startup	casadi::Blocksqp
print_in	OT_BOOL	Print numerical values of inputs [default: false]	casadi::FunctionInternal
print_iteration	OT_BOOL	Print SQP iterations	casadi::Blocksqp
print_maxit_reached	OT_BOOL	Print error when maximum number of SQP iterations reached	casadi::Blocksqp
print_out	OT_BOOL	Print numerical values of outputs [default: false]	casadi::FunctionInternal
print_time	OT_BOOL	print information about execution time. Implies record_time.	casadi::ProtoFunction
qp_init	OT_BOOL	Use warmstarting	casadi::Blocksqp
qpsol	OT_STRING	The QP solver to be used by the SQP method	casadi::Blocksqp
qpsol_options	OT_DICT	Options to be passed to the QP solver	casadi::Blocksqp
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
restore_feas	OT_BOOL	Use feasibility restoration phase	casadi::Blocksqp
reverse_options	OT_DICT	Options to be passed to a reverse mode constructor	casadi::FunctionInternal
rho	OT_DOUBLE	Feasibility restoration phase parameter	casadi::Blocksqp
s_f	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
s_theta	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
schur	OT_BOOL	Use qpOASES Schur compliment approach	casadi::Blocksqp
sens_linsol	OT_STRING	Linear solver used for parametric sensitivities (default 'qr').	casadi::Nlpsol
sens_linsol_options	OT_DICT	Linear solver options used for parametric sensitivities.	casadi::Nlpsol
show_eval_warnings	OT_BOOL	Show warnings generated from function evaluations [true]	casadi::OracleFunction
skip_first_globalization	OT_BOOL	No globalization strategy in first iteration	casadi::Blocksqp
specific_options	OT_DICT	Options for specific auto-generated functions, overwriting the defaults from common_options. Nested dictionary.	casadi::OracleFunction
theta_max	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
theta_min	OT_DOUBLE	Filter line search parameter, cf. IPOPT paper	casadi::Blocksqp
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
verbose_init	OT_BOOL	Print out timing information about the different stages of initialization	casadi::Nlpsol
warmstart	OT_BOOL	Use warmstarting	casadi::Blocksqp
warn_initial_bounds	OT_BOOL	Warn if the initial guess does not satisfy LBX and UBX	casadi::Nlpsol
which_second_derv	OT_INT	For which block should second derivatives be provided by the user	casadi::Blocksqp
zeta	OT_DOUBLE	Feasibility restoration phase parameter	casadi::Blocksqp

Definition at line 151 of file blocksqp.hpp.

Inheritance diagram for casadi::Blocksqp:

[legend]

Collaboration diagram for casadi::Blocksqp:

[legend]

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

using	weak_ref_type = WeakRefInternal

typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	Blocksqp (const std::string &name, const Function &nlp)

	~Blocksqp () override

const char *	plugin_name () const override

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

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

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

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

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

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

int	solve (void *mem) const override

casadi_int	run (BlocksqpMemory *m, casadi_int maxIt, casadi_int warmStart=0) const
	Main Loop of SQP method. More...

void	calcLagrangeGradient (BlocksqpMemory m, const double lam_x, const double lam_g, const double grad_f, const double jacNz, double grad_lag, casadi_int flag) const
	Compute gradient of Lagrangian function (sparse version) More...

void	calcLagrangeGradient (BlocksqpMemory m, double grad_lag, casadi_int flag) const
	Overloaded function for convenience, uses current variables of SQPiterate vars. More...

void	printInfo (BlocksqpMemory *m) const
	Print information about the SQP method. More...

bool	calcOptTol (BlocksqpMemory *m) const
	Update optimization tolerance (similar to SNOPT) in current iterate. More...

void	updateStepBounds (BlocksqpMemory *m, bool soc) const

casadi_int	solveQP (BlocksqpMemory m, double deltaXi, double *lambdaQP, bool matricesChanged=true) const

void	computeNextHessian (BlocksqpMemory *m, casadi_int idx, casadi_int maxQP) const

casadi_int	fullstep (BlocksqpMemory *m) const
	No globalization strategy. More...

void	acceptStep (BlocksqpMemory m, const double deltaXi, const double *lambdaQP, double alpha, casadi_int nSOCS) const
	Set new primal dual iterate. More...

void	acceptStep (BlocksqpMemory *m, double alpha) const

void	reduceStepsize (BlocksqpMemory m, double alpha) const

casadi_int	filterLineSearch (BlocksqpMemory *m) const

void	initializeFilter (BlocksqpMemory *m) const

bool	pairInFilter (BlocksqpMemory *m, double cNorm, double obj) const

void	augmentFilter (BlocksqpMemory *m, double cNorm, double obj) const

bool	secondOrderCorrection (BlocksqpMemory *m, double cNorm, double cNormTrial, double dfTdeltaXi, bool swCond, casadi_int it) const

void	reduceSOCStepsize (BlocksqpMemory m, double alphaSOC) const

casadi_int	feasibilityRestorationHeuristic (BlocksqpMemory *m) const

casadi_int	feasibilityRestorationPhase (BlocksqpMemory *m) const

casadi_int	kktErrorReduction (BlocksqpMemory *m) const

void	calcInitialHessian (BlocksqpMemory *m) const

void	calcInitialHessian (BlocksqpMemory *m, casadi_int b) const

void	resetHessian (BlocksqpMemory *m) const

void	resetHessian (BlocksqpMemory *m, casadi_int b) const

void	calcHessianUpdate (BlocksqpMemory *m, casadi_int updateType, casadi_int hessScaling) const

void	calcHessianUpdateLimitedMemory (BlocksqpMemory *m, casadi_int updateType, casadi_int hessScaling) const

void	calcHessianUpdateExact (BlocksqpMemory *m) const

void	calcSR1 (BlocksqpMemory m, const double gamma, const double *delta, casadi_int b) const

void	calcBFGS (BlocksqpMemory m, const double gamma, const double *delta, casadi_int b) const

void	updateDeltaGamma (BlocksqpMemory *m) const

void	sizeInitialHessian (BlocksqpMemory m, const double gamma, const double *delta, casadi_int b, casadi_int option) const

void	sizeHessianCOL (BlocksqpMemory m, const double gamma, const double *delta, casadi_int b) const

void	initStats (BlocksqpMemory *m) const

void	updateStats (BlocksqpMemory *m) const

void	printProgress (BlocksqpMemory *m) const
	Print one line of output to stdout about the current iteration. More...

void	reset_sqp (BlocksqpMemory *m) const
	Reset variables that any SQP code needs. More...

void	convertHessian (BlocksqpMemory *m) const
	Convert *hess to column compressed sparse format. More...

void	initIterate (BlocksqpMemory *m) const
	Set initial filter, objective function, tolerances etc. More...

casadi_int	evaluate (BlocksqpMemory m, double f, double g, double grad_f, double *jac_g) const
	Evaluate objective and constraints, including derivatives. More...

casadi_int	evaluate (BlocksqpMemory m, const double xk, double f, double g) const
	Evaluate objective and constraints, no derivatives. More...

casadi_int	evaluate (BlocksqpMemory m, double exact_hess_lag) const
	Evaluate exact hessian of Lagrangian. More...

double	lInfConstraintNorm (BlocksqpMemory m, const double xk, const double *g) const

void	serialize_body (SerializingStream &s) const override
	Serialize an object without type information. 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	disp_more (std::ostream &stream) const override
	Print description. More...

virtual void	check_inputs (void *mem) const
	Check if the inputs correspond to a well-posed problem. More...

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

virtual bool	integer_support () const
	Can discrete variables be treated. More...

int	eval (const double arg, double res, casadi_int iw, double w, void *mem) const final
	Evaluate numerically. More...

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

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

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

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

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

int	callback (NlpsolMemory *m) const

Function	kkt () const

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

virtual DM	getReducedHessian ()

virtual void	setOptionsFromFile (const std::string &file)
	Read options from parameter xml. More...

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

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

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

void	expand ()

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

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

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

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

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

void	set_function (const Function &fcn)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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_max_in (casadi_int ind) const
	Get largest input value. More...

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

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

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

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

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

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

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

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

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

virtual int	sp_forward (const bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem) const
	Propagate sparsity 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...

virtual int	sp_reverse (bvec_t arg, bvec_t res, casadi_int iw, bvec_t w, void *mem) const
	Propagate sparsity backwards. 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 void	merge (const std::vector< MX > &arg, std::vector< MX > &subs_from, std::vector< MX > &subs_to) const
	List merge opportunitities. More...

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

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

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

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

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

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

void	print_option (const std::string &name, std::ostream &stream) const
	Print all information there is to know about a certain option. More...

bool	has_option (const std::string &option_name) const
	Does a particular option exist. More...

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

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

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

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

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

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

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

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

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

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

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

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

std::string	debug_repr (const SharedObjectInternal *) const

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


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

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


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

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


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

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


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

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


bool	has_reverse (casadi_int nadj) const override
	Generate a function that calculates reverse mode 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 reverse mode derivatives. More...


virtual bool	has_spfwd () const
	Is the class able to propagate seeds through the algorithm? More...

virtual bool	has_sprev () const
	Is the class able to propagate seeds through the algorithm? More...


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


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

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


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

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


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

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


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


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


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

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

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

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


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

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

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

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


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

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


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

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


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

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

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


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

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

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


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


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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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


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

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

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

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


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

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

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

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

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

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


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

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


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

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

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

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

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

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

Sparsity	get_jac_sparsity_hierarchical_symm (casadi_int oind, casadi_int iind) const

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


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

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

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

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


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

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

Static Public Member Functions
static Nlpsol *	creator (const std::string &name, const Function &nlp)
	Create a new NLP Solver. More...

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

static void	bound_consistency (casadi_int n, double z, double lam, const double lbz, const double ubz)

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

template<typename Type >
static void	append_to_vec (GenericType &t, Type el)
	WORKAROUND: Add an element to an std::vector stored in a GenericType: More...

template<typename XType >
static Function	create_oracle (const std::map< std::string, XType > &d, const Dict &opts)
	Convert dictionary to Problem. More...

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

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

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

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

static std::string	string_from_UnifiedReturnStatus (UnifiedReturnStatus status)

static bool	has_plugin (const std::string &pname, bool verbose=false)
	Check if a plugin is available or can be loaded. More...

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

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

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

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

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

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

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

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

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


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

Public Attributes
casadi_int	nblocks_

std::vector< casadi_int >	blocks_

std::vector< casadi_int >	dim_

casadi_int	nnz_H_

Sparsity	Asp_

Sparsity	Hsp_

Sparsity	exact_hess_lag_sp_

std::string	linsol_plugin_
	QP solver for the subproblems. More...

bool	print_header_

bool	print_iteration_

double	eps_

double	opttol_

double	nlinfeastol_

bool	schur_

bool	globalization_

bool	restore_feas_

casadi_int	max_line_search_

casadi_int	max_consec_reduced_steps_

casadi_int	max_consec_skipped_updates_

casadi_int	max_it_qp_

casadi_int	max_iter_

bool	warmstart_

bool	qp_init_

bool	block_hess_

casadi_int	hess_scaling_

casadi_int	fallback_scaling_

double	max_time_qp_

double	ini_hess_diag_

double	col_eps_

double	col_tau1_

double	col_tau2_

casadi_int	hess_damp_

double	hess_damp_fac_

casadi_int	hess_update_

casadi_int	fallback_update_

casadi_int	hess_lim_mem_

casadi_int	hess_memsize_

casadi_int	which_second_derv_

bool	skip_first_globalization_

casadi_int	conv_strategy_

casadi_int	max_conv_qp_

casadi_int	max_soc_iter_

double	gamma_theta_

double	gamma_f_

double	kappa_soc_

double	kappa_f_

double	theta_max_

double	theta_min_

double	delta_

double	s_theta_

double	s_f_

double	kappa_minus_

double	kappa_plus_

double	kappa_plus_max_

double	delta_h0_

double	eta_

double	obj_lo_

double	obj_up_

double	rho_

double	zeta_

Function	rp_solver_

bool	print_maxit_reached_

casadi_nlpsol_prob< double >	p_nlp_

casadi_int	nx_
	Number of variables. More...

casadi_int	ng_
	Number of constraints. More...

casadi_int	np_
	Number of parameters. More...

Function	fcallback_
	callback function, executed at each iteration More...

casadi_int	callback_step_
	Execute the callback function only after this amount of iterations. More...

std::string	sens_linsol_
	Linear solver and options. More...

Dict	sens_linsol_options_

std::vector< char >	detect_simple_bounds_is_simple_

Function	detect_simple_bounds_parts_

std::vector< casadi_int >	detect_simple_bounds_target_x_

std::vector< casadi_int >	detect_simple_bounds_target_g_

bool	mi_

WeakRef	kkt_
	Cache for KKT function. More...

bool	always_inline_

bool	never_inline_

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

size_t	n_out_

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

std::vector< bool >	is_diff_out_

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

std::vector< Sparsity >	sparsity_out_

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

std::vector< std::string >	name_out_

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

bool	jit_cleanup_
	Cleanup jit source file. More...

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

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

std::string	jit_base_name_

bool	jit_temp_suffix_
	Use a temporary name. More...

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

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

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

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

bool	has_refcount_
	Reference counting in codegen? More...

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

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

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

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

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

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

Importer	compiler_

Dict	jit_options_

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

bool	enable_forward_

bool	enable_reverse_

bool	enable_jacobian_

bool	enable_fd_

bool	enable_forward_op_

bool	enable_reverse_op_

bool	enable_jacobian_op_

bool	enable_fd_op_

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

double	ad_weight_sp_

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

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

Dict	fd_options_

double	fd_step_

std::string	fd_method_

bool	print_in_

bool	print_out_

casadi_int	max_io_

bool	dump_in_

bool	dump_out_

bool	dump_

std::string	dump_dir_

std::string	dump_format_

Dict	forward_options_

Dict	reverse_options_

Dict	jacobian_options_

Dict	der_options_

Function	custom_jacobian_

casadi_int	dump_count_

std::string	name_
	Name. More...

bool	verbose_
	Verbose printout. More...

bool	print_time_

bool	record_time_

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

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


bool	eval_errors_fatal_
	Options. More...

bool	warn_initial_bounds_
	Options. More...

bool	iteration_callback_ignore_errors_
	Options. More...

bool	calc_multipliers_
	Options. More...

bool	calc_lam_x_
	Options. More...

bool	calc_lam_p_
	Options. More...

bool	calc_f_
	Options. More...

bool	calc_g_
	Options. More...

bool	bound_consistency_
	Options. More...

double	min_lam_
	Options. More...

bool	no_nlp_grad_
	Options. More...

std::vector< bool >	discrete_
	Options. More...

std::vector< bool >	equality_
	Options. More...

Static Public Attributes
static const std::string	meta_doc
	A documentation string. More...

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

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

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

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

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

void	initSingleton ()

void	destroySingleton ()

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

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

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

Dict	common_options_
	Options for creating functions. More...

Dict	specific_options_

bool	show_eval_warnings_
	Show evaluation warnings. More...

int	max_num_threads_

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

std::vector< std::string >	monitor_

size_t	stride_arg_

size_t	stride_res_

size_t	stride_iw_

size_t	stride_w_

bool	post_expand_

static const Options	options_
	Options. More...

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

Member Typedef Documentation

◆ Creator

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

inherited

Definition at line 277 of file nlpsol_impl.hpp.

◆ RegFcn

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

inherited

Definition at line 73 of file plugin_interface.hpp.

◆ weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

◆ Blocksqp() [1/2]

casadi::Blocksqp::Blocksqp	(	const std::string &	name,
		const Function &	nlp
	)

explicit

Definition at line 49 of file blocksqp.cpp.

50 : Nlpsol(name, nlp) {

51 }

casadi::Nlpsol::Nlpsol

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

Constructor.

Definition: nlpsol.cpp:267

◆ ~Blocksqp()

casadi::Blocksqp::~Blocksqp ( )

override

Definition at line 54 of file blocksqp.cpp.

                       {
     clear_mem();
   }

References casadi::ProtoFunction::clear_mem().

◆ Blocksqp() [2/2]

casadi::Blocksqp::Blocksqp ( DeserializingStream & s )

explicitprotected

Definition at line 2848 of file blocksqp.cpp.

                                            : Nlpsol(s) {
     s.version("Blocksqp", 1);
     s.unpack("Blocksqp::nblocks", nblocks_);
     s.unpack("Blocksqp::blocks", blocks_);
     s.unpack("Blocksqp::dim", dim_);
     s.unpack("Blocksqp::nnz_H", nnz_H_);
     s.unpack("Blocksqp::Asp", Asp_);
     s.unpack("Blocksqp::Hsp", Hsp_);
     s.unpack("Blocksqp::exact_hess_lag_sp_", exact_hess_lag_sp_);
     s.unpack("Blocksqp::linsol_plugin", linsol_plugin_);
     s.unpack("Blocksqp::print_header", print_header_);
     s.unpack("Blocksqp::print_iteration", print_iteration_);
     s.unpack("Blocksqp::eps", eps_);
     s.unpack("Blocksqp::opttol", opttol_);
     s.unpack("Blocksqp::nlinfeastol", nlinfeastol_);
     s.unpack("Blocksqp::schur", schur_);
     s.unpack("Blocksqp::globalization", globalization_);
     s.unpack("Blocksqp::restore_feas", restore_feas_);
     s.unpack("Blocksqp::max_line_search", max_line_search_);
     s.unpack("Blocksqp::max_consec_reduced_steps", max_consec_reduced_steps_);
     s.unpack("Blocksqp::max_consec_skipped_updates", max_consec_skipped_updates_);
     s.unpack("Blocksqp::max_it_qp", max_it_qp_);
     s.unpack("Blocksqp::max_iter", max_iter_);
     s.unpack("Blocksqp::warmstart", warmstart_);
     s.unpack("Blocksqp::qp_init", qp_init_);
     s.unpack("Blocksqp::block_hess", block_hess_);
     s.unpack("Blocksqp::hess_scaling", hess_scaling_);
     s.unpack("Blocksqp::fallback_scaling", fallback_scaling_);
     s.unpack("Blocksqp::max_time_qp", max_time_qp_);
     s.unpack("Blocksqp::ini_hess_diag", ini_hess_diag_);
     s.unpack("Blocksqp::col_eps", col_eps_);
     s.unpack("Blocksqp::col_tau1", col_tau1_);
     s.unpack("Blocksqp::col_tau2", col_tau2_);
     s.unpack("Blocksqp::hess_damp", hess_damp_);
     s.unpack("Blocksqp::hess_damp_fac", hess_damp_fac_);
     s.unpack("Blocksqp::hess_update", hess_update_);
     s.unpack("Blocksqp::fallback_update", fallback_update_);
     s.unpack("Blocksqp::hess_lim_mem", hess_lim_mem_);
     s.unpack("Blocksqp::hess_memsize", hess_memsize_);
     s.unpack("Blocksqp::which_second_derv", which_second_derv_);
     s.unpack("Blocksqp::skip_first_globalization", skip_first_globalization_);
     s.unpack("Blocksqp::conv_strategy", conv_strategy_);
     s.unpack("Blocksqp::max_conv_qp", max_conv_qp_);
     s.unpack("Blocksqp::max_soc_iter", max_soc_iter_);
     s.unpack("Blocksqp::gamma_theta", gamma_theta_);
     s.unpack("Blocksqp::gamma_f", gamma_f_);
     s.unpack("Blocksqp::kappa_soc", kappa_soc_);
     s.unpack("Blocksqp::kappa_f", kappa_f_);
     s.unpack("Blocksqp::theta_max", theta_max_);
     s.unpack("Blocksqp::theta_min", theta_min_);
     s.unpack("Blocksqp::delta", delta_);
     s.unpack("Blocksqp::s_theta", s_theta_);
     s.unpack("Blocksqp::s_f", s_f_);
     s.unpack("Blocksqp::kappa_minus", kappa_minus_);
     s.unpack("Blocksqp::kappa_plus", kappa_plus_);
     s.unpack("Blocksqp::kappa_plus_max", kappa_plus_max_);
     s.unpack("Blocksqp::delta_h0", delta_h0_);
     s.unpack("Blocksqp::eta", eta_);
     s.unpack("Blocksqp::obj_lo", obj_lo_);
     s.unpack("Blocksqp::obj_up", obj_up_);
     s.unpack("Blocksqp::rho", rho_);
     s.unpack("Blocksqp::zeta", zeta_);
     s.unpack("Blocksqp::rp_solver", rp_solver_);
     s.unpack("Blocksqp::print_maxit_reached", print_maxit_reached_);
  
   }

References Asp_, block_hess_, blocks_, col_eps_, col_tau1_, col_tau2_, conv_strategy_, delta_, delta_h0_, dim_, eps_, eta_, exact_hess_lag_sp_, fallback_scaling_, fallback_update_, gamma_f_, gamma_theta_, globalization_, hess_damp_, hess_damp_fac_, hess_lim_mem_, hess_memsize_, hess_scaling_, hess_update_, Hsp_, ini_hess_diag_, kappa_f_, kappa_minus_, kappa_plus_, kappa_plus_max_, kappa_soc_, linsol_plugin_, max_consec_reduced_steps_, max_consec_skipped_updates_, max_conv_qp_, max_it_qp_, max_iter_, max_line_search_, max_soc_iter_, max_time_qp_, nblocks_, nlinfeastol_, nnz_H_, obj_lo_, obj_up_, opttol_, print_header_, print_iteration_, print_maxit_reached_, qp_init_, restore_feas_, rho_, rp_solver_, s_f_, s_theta_, schur_, skip_first_globalization_, theta_max_, theta_min_, casadi::DeserializingStream::unpack(), casadi::DeserializingStream::version(), warmstart_, which_second_derv_, and zeta_.

Member Function Documentation

◆ acceptStep() [1/2]

void casadi::Blocksqp::acceptStep	(	BlocksqpMemory *	m,
		const double *	deltaXi,
		const double *	lambdaQP,
		double	alpha,
		casadi_int	nSOCS
	)		const

Definition at line 1107 of file blocksqp.cpp.

                                                                   {
     auto d_nlp = &m->d_nlp;
     double lStpNorm;
  
     // Current alpha
     m->alpha = alpha;
     m->nSOCS = nSOCS;
  
     // Set new x by accepting the current trial step
     for (casadi_int k=0; k<nx_; k++) {
       d_nlp->z[k] = m->trial_xk[k];
       m->dxk[k] = alpha * deltaXi[k];
     }
  
     // Store the infinity norm of the multiplier step
     m->lambdaStepNorm = 0.0;
     for (casadi_int k=0; k<nx_; k++)
       if ((lStpNorm = fabs(alpha*lambdaQP[k] - alpha*m->lam_xk[k])) > m->lambdaStepNorm)
         m->lambdaStepNorm = lStpNorm;
     for (casadi_int k=0; k<ng_; k++)
       if ((lStpNorm = fabs(alpha*lambdaQP[nx_+k] - alpha*m->lam_gk[k])) > m->lambdaStepNorm)
         m->lambdaStepNorm = lStpNorm;
  
     // Set new multipliers
     for (casadi_int k=0; k<nx_; k++)
       m->lam_xk[k] = (1.0 - alpha)*m->lam_xk[k] + alpha*lambdaQP[k];
     for (casadi_int k=0; k<ng_; k++)
       m->lam_gk[k] = (1.0 - alpha)*m->lam_gk[k] + alpha*lambdaQP[nx_+k];
  
     // Count consecutive reduced steps
     if (m->alpha < 1.0)
       m->reducedStepCount++;
     else
       m->reducedStepCount = 0;
   }

References casadi::BlocksqpMemory::alpha, casadi::NlpsolMemory::d_nlp, casadi::BlocksqpMemory::dxk, casadi::BlocksqpMemory::lam_gk, casadi::BlocksqpMemory::lam_xk, casadi::BlocksqpMemory::lambdaStepNorm, casadi::Nlpsol::ng_, casadi::BlocksqpMemory::nSOCS, casadi::Nlpsol::nx_, casadi::BlocksqpMemory::reducedStepCount, and casadi::BlocksqpMemory::trial_xk.

Referenced by acceptStep(), filterLineSearch(), fullstep(), kktErrorReduction(), and secondOrderCorrection().

◆ acceptStep() [2/2]

void casadi::Blocksqp::acceptStep	(	BlocksqpMemory *	m,
		double	alpha
	)		const

Definition at line 1102 of file blocksqp.cpp.

                                                     {
     acceptStep(m, m->dxk, m->lam_qp, alpha, 0);
   }

References acceptStep(), casadi::BlocksqpMemory::dxk, and casadi::BlocksqpMemory::lam_qp.

◆ ad_weight()

double casadi::FunctionInternal::ad_weight ( ) const

virtualinherited

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

Definition at line 3190 of file function_internal.cpp.

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

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

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

◆ add_embedded()

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

inherited

Definition at line 3633 of file function_internal.cpp.

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

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

Referenced by casadi::MXFunction::find(), casadi::Switch::find(), casadi::SXFunction::find(), and casadi::BSplineInterpolant::find().

◆ adjViaJac()

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

virtualinherited

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

Definition at line 2925 of file function_internal.cpp.

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

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

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

◆ all_scalar()

bool casadi::FunctionInternal::all_scalar ( ) const

inherited

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

Definition at line 3664 of file function_internal.cpp.

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

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

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

◆ alloc()

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

inherited

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

Definition at line 2874 of file function_internal.cpp.

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

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

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

◆ alloc_arg()

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

inherited

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

Definition at line 2842 of file function_internal.cpp.

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

References casadi::FunctionInternal::sz_arg().

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

◆ alloc_iw()

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

inherited

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

Definition at line 2858 of file function_internal.cpp.

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

References casadi::FunctionInternal::sz_iw().

◆ alloc_mem()

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

inlineoverridevirtual

Reimplemented from casadi::Nlpsol.

Definition at line 177 of file blocksqp.hpp.

177 { return new BlocksqpMemory();}

◆ alloc_res()

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

inherited

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

Definition at line 2850 of file function_internal.cpp.

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

References casadi::FunctionInternal::sz_res().

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

◆ alloc_w()

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

inherited

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

Definition at line 2866 of file function_internal.cpp.

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

References casadi::FunctionInternal::sz_w().

◆ append_to_vec()

template<typename Type >

static void casadi::Nlpsol::append_to_vec	(	GenericType &	t,
		Type	el
	)

inlinestaticinherited

Definition at line 312 of file nlpsol_impl.hpp.

                                                                                {
       std::vector<Type> v = t;
       v.push_back(el);
       t = v;
     }

◆ augmentFilter()

void casadi::Blocksqp::augmentFilter	(	BlocksqpMemory *	m,
		double	cNorm,
		double	obj
	)		const

Augment the filter: F_k+1 = F_k U { (c,f) | c > (1-gammaTheta)cNorm and f > obj-gammaF*c

Definition at line 1741 of file blocksqp.cpp.

                                                                    {
     std::pair<double, double> entry((1-gamma_theta_)*cNorm,
                                     obj-gamma_f_*cNorm);
  
     // Augment filter by current element
     m->filter.insert(entry);
  
     // Remove dominated elements
     auto iter=m->filter.begin();
     while (iter != m->filter.end()) {
       if (iter->first > entry.first && iter->second > entry.second) {
         auto iterToRemove = iter;
         iter++;
         m->filter.erase(iterToRemove);
       } else {
         iter++;
       }
     }
   }

References casadi::BlocksqpMemory::filter, gamma_f_, and gamma_theta_.

Referenced by filterLineSearch().

◆ bound_consistency()

void casadi::Nlpsol::bound_consistency	(	casadi_int	n,
		double *	z,
		double *	lam,
		const double *	lbz,
		const double *	ubz
	)

staticinherited

Definition at line 678 of file nlpsol.cpp.

                                                                        {
     casadi_assert_dev(z!=nullptr);
     casadi_assert_dev(lam!=nullptr);
     casadi_assert_dev(lbz!=nullptr);
     casadi_assert_dev(ubz!=nullptr);
     // Local variables
     casadi_int i;
     // Loop over variables
     for (i=0; i<n; ++i) {
       // Make sure bounds are respected
       z[i] = std::fmin(std::fmax(z[i], lbz[i]), ubz[i]);
       // Adjust multipliers
       if (std::isinf(lbz[i]) && std::isinf(ubz[i])) {
         // Both multipliers are infinite
         lam[i] = 0.;
       } else if (std::isinf(lbz[i]) || z[i] - lbz[i] > ubz[i] - z[i]) {
         // Infinite lower bound or closer to upper bound than lower bound
         lam[i] = std::fmax(0., lam[i]);
       } else if (std::isinf(ubz[i]) || z[i] - lbz[i] < ubz[i] - z[i]) {
         // Infinite upper bound or closer to lower bound than upper bound
         lam[i] = std::fmin(0., lam[i]);
       }
     }
   }

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

◆ cache()

Dict casadi::FunctionInternal::cache ( ) const

inherited

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

Definition at line 970 of file function_internal.cpp.

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

References casadi::FunctionInternal::cache_.

◆ calc_function()

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

inherited

Definition at line 302 of file oracle_function.cpp.

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

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

◆ calc_sp_forward()

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

inherited

Definition at line 418 of file oracle_function.cpp.

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

References casadi::OracleFunction::get_function().

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

◆ calc_sp_reverse()

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

inherited

Definition at line 423 of file oracle_function.cpp.

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

References casadi::OracleFunction::get_function().

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

◆ calcBFGS()

void casadi::Blocksqp::calcBFGS	(	BlocksqpMemory *	m,
		const double *	gamma,
		const double *	delta,
		casadi_int	b
	)		const

Definition at line 2133 of file blocksqp.cpp.

                                              {
     casadi_int dim = dim_[b];
     double h1 = 0.0;
     double h2 = 0.0;
     double thetaPowell = 0.0;
     casadi_int damped;
  
     /* Work with a local copy of gamma because damping may need to change gamma.
      * Note that m->gamma needs to remain unchanged!
      * This may be important in a limited memory context:
      * When information is "forgotten", B_i-1 is different and the
      *  original gamma might lead to an undamped update with the new B_i-1! */
     std::vector<double> gamma2(gamma, gamma+dim);
  
     double *B = m->hess[b];
  
     // Bdelta = B*delta (if sizing is enabled, B is the sized B!)
     // h1 = delta^T * B * delta
     // h2 = delta^T * gamma
     std::vector<double> Bdelta(dim, 0.0);
     for (casadi_int i=0; i<dim; i++) {
       for (casadi_int k=0; k<dim; k++)
         Bdelta[i] += B[i+k*dim] * delta[k];
  
       h1 += delta[i] * Bdelta[i];
       //h2 += delta[i] * gamma[i];
     }
     h2 = m->delta_gamma[b];
  
     /* Powell's damping strategy to maintain pos. def. (Nocedal/Wright p.537; SNOPT paper)
      * Interpolates between current approximation and unmodified BFGS */
     damped = 0;
     if (hess_damp_)
       if (h2 < hess_damp_fac_ * h1 / m->alpha && fabs(h1 - h2) > 1.0e-12) {
         // At the first iteration h1 and h2 are equal due to COL scaling
  
         thetaPowell = (1.0 - hess_damp_fac_)*h1 / (h1 - h2);
  
         // Redefine gamma and h2 = delta^T * gamma
         h2 = 0.0;
         for (casadi_int i=0; i<dim; i++) {
           gamma2[i] = thetaPowell*gamma2[i] + (1.0 - thetaPowell)*Bdelta[i];
           h2 += delta[i] * gamma2[i];
         }
  
         // Also redefine deltaGamma for computation of sizing factor in the next iteration
         m->delta_gamma[b] = h2;
  
         damped = 1;
       }
  
     // For statistics: count number of damped blocks
     m->hessDamped += damped;
  
     // B_k+1 = B_k - Bdelta * (Bdelta)^T / h1 + gamma * gamma^T / h2
     double myEps = 1.0e2 * eps_;
     if (fabs(h1) < myEps || fabs(h2) < myEps) {
       // don't perform update because of bad condition, might introduce negative eigenvalues
       m->noUpdateCounter[b]++;
       m->hessDamped -= damped;
       m->hessSkipped++;
       m->nTotalSkippedUpdates++;
     } else {
       for (casadi_int i=0; i<dim; i++)
         for (casadi_int j=0; j<dim; j++)
           B[i+j*dim] += - Bdelta[i]*Bdelta[j]/h1 + gamma2[i]*gamma2[j]/h2;
  
       m->noUpdateCounter[b] = 0;
     }
   }

References casadi::BlocksqpMemory::delta_gamma, dim_, eps_, casadi::BlocksqpMemory::hess, hess_damp_, hess_damp_fac_, casadi::BlocksqpMemory::hessDamped, casadi::BlocksqpMemory::hessSkipped, casadi::BlocksqpMemory::noUpdateCounter, and casadi::BlocksqpMemory::nTotalSkippedUpdates.

Referenced by calcHessianUpdate(), and calcHessianUpdateLimitedMemory().

◆ calcHessianUpdate()

void casadi::Blocksqp::calcHessianUpdate	(	BlocksqpMemory *	m,
		casadi_int	updateType,
		casadi_int	hessScaling
	)		const

Apply BFGS or SR1 update blockwise and size blocks

Definition at line 1923 of file blocksqp.cpp.

                                                                                             {
     casadi_int nBlocks;
     bool firstIter;
  
     //if objective derv is computed exactly, don't set the last block!
     if (which_second_derv_ == 1 && block_hess_)
       nBlocks = nblocks_ - 1;
     else
       nBlocks = nblocks_;
  
     // Statistics: how often is damping active, what is the average COL sizing factor?
     m->hessDamped = 0;
     m->averageSizingFactor = 0.0;
  
     for (casadi_int b=0; b<nBlocks; b++) {
       casadi_int dim = dim_[b];
  
       // smallGamma and smallDelta are subvectors of gamma and delta,
       // corresponding to partially separability
       double* smallGamma = m->gammaMat + blocks_[b];
       double* smallDelta = m->deltaMat + blocks_[b];
  
       // Is this the first iteration or the first after a Hessian reset?
       firstIter = (m->noUpdateCounter[b] == -1);
  
       // Update sTs, sTs_ and sTy, sTy_
       m->delta_norm_old[b] = m->delta_norm[b];
       m->delta_gamma_old[b] = m->delta_gamma[b];
       m->delta_norm[b] = casadi_dot(dim, smallDelta, smallDelta);
       m->delta_gamma[b] = casadi_dot(dim, smallDelta, smallGamma);
  
       // Sizing before the update
       if (hessScaling < 4 && firstIter)
         sizeInitialHessian(m, smallGamma, smallDelta, b, hessScaling);
       else if (hessScaling == 4)
         sizeHessianCOL(m, smallGamma, smallDelta, b);
  
       // Compute the new update
       if (updateType == 1) {
         calcSR1(m, smallGamma, smallDelta, b);
  
         // Prepare to compute fallback update as well
         m->hess = m->hess2;
  
         // Sizing the fallback update
         if (fallback_scaling_ < 4 && firstIter)
           sizeInitialHessian(m, smallGamma, smallDelta, b, fallback_scaling_);
         else if (fallback_scaling_ == 4)
           sizeHessianCOL(m, smallGamma, smallDelta, b);
  
         // Compute fallback update
         if (fallback_update_ == 2)
           calcBFGS(m, smallGamma, smallDelta, b);
  
         // Reset pointer
         m->hess = m->hess1;
       } else if (updateType == 2) {
         calcBFGS(m, smallGamma, smallDelta, b);
       }
  
       // If an update is skipped to often, reset Hessian block
       if (m->noUpdateCounter[b] > max_consec_skipped_updates_) {
         resetHessian(m, b);
       }
     }
  
     // statistics: average sizing factor
     m->averageSizingFactor /= nBlocks;
   }

Referenced by calcHessianUpdateExact(), and run().

◆ calcHessianUpdateExact()

void casadi::Blocksqp::calcHessianUpdateExact ( BlocksqpMemory * m ) const

Definition at line 2096 of file blocksqp.cpp.

                                                   {
     // compute exact hessian
     (void)evaluate(m, m->exact_hess_lag);
  
     // assign exact hessian to blocks
     const casadi_int* col = exact_hess_lag_sp_.colind();
     const casadi_int* row = exact_hess_lag_sp_.row();
     casadi_int s, dim;
  
     for (casadi_int k=0; k<nblocks_; k++) {
       s = blocks_[k];
       dim = dim_[k];
       for (casadi_int i=0; i<dim; i++)
         // Set diagonal to 0 (may have been 1 because of CalcInitialHessian)
         m->hess[k][i + i*dim] = 0.0;
       for (casadi_int j=0; j<dim; j++) {
         for (casadi_int i=col[j+s]; i<col[j+1+s]; i++) {
           m->hess[k][row[i]-row[col[s]] + j*dim] = m->exact_hess_lag[i];
           if (row[i]-row[col[s]] < j)
             m->hess[k][j + (row[i]-row[col[s]])*dim] = m->exact_hess_lag[i];
         }
       }
     }
  
     // Prepare to compute fallback update as well
     m->hess = m->hess2;
     if (fallback_update_ == 2 && !hess_lim_mem_)
         calcHessianUpdate(m, fallback_update_, fallback_scaling_);
     else if (fallback_update_ == 0)
         calcInitialHessian(m);  // Set fallback as Identity
  
     // Reset pointer
     m->hess = m->hess1;
   }

References blocks_, calcHessianUpdate(), calcInitialHessian(), casadi::Sparsity::colind(), dim_, evaluate(), casadi::BlocksqpMemory::exact_hess_lag, exact_hess_lag_sp_, fallback_scaling_, fallback_update_, casadi::BlocksqpMemory::hess, casadi::BlocksqpMemory::hess1, casadi::BlocksqpMemory::hess2, hess_lim_mem_, nblocks_, and casadi::Sparsity::row().

Referenced by run().

◆ calcHessianUpdateLimitedMemory()

void casadi::Blocksqp::calcHessianUpdateLimitedMemory	(	BlocksqpMemory *	m,
		casadi_int	updateType,
		casadi_int	hessScaling
	)		const

Definition at line 1995 of file blocksqp.cpp.

                                                            {
     casadi_int nBlocks;
     casadi_int m2, pos, posOldest, posNewest;
     casadi_int hessDamped, hessSkipped;
     double averageSizingFactor;
  
     //if objective derv is computed exactly, don't set the last block!
     if (which_second_derv_ == 1 && block_hess_) {
       nBlocks = nblocks_ - 1;
     } else {
       nBlocks = nblocks_;
     }
  
     // Statistics: how often is damping active, what is the average COL sizing factor?
     m->hessDamped = 0;
     m->hessSkipped = 0;
     m->averageSizingFactor = 0.0;
  
     for (casadi_int b=0; b<nBlocks; b++) {
       casadi_int dim = dim_[b];
  
       // smallGamma and smallDelta are submatrices of gammaMat, deltaMat,
       // i.e. subvectors of gamma and delta from m prev. iterations
       double *smallGamma = m->gammaMat + blocks_[b];
       double *smallDelta = m->deltaMat + blocks_[b];
  
       // Memory structure
       if (m->itCount > hess_memsize_) {
         m2 = hess_memsize_;
         posOldest = m->itCount % m2;
         posNewest = (m->itCount-1) % m2;
       } else {
         m2 = m->itCount;
         posOldest = 0;
         posNewest = m2-1;
       }
  
       // Set B_0 (pretend it's the first step)
       calcInitialHessian(m, b);
       m->delta_norm[b] = 1.0;
       m->delta_norm_old[b] = 1.0;
       m->delta_gamma[b] = 0.0;
       m->delta_gamma_old[b] = 0.0;
       m->noUpdateCounter[b] = -1;
  
       // Size the initial update, but with the most recent delta/gamma-pair
       double *gammai = smallGamma + nx_*posNewest;
       double *deltai = smallDelta + nx_*posNewest;
       sizeInitialHessian(m, gammai, deltai, b, hessScaling);
  
       for (casadi_int i=0; i<m2; i++) {
         pos = (posOldest+i) % m2;
  
         // Get new vector from list
         gammai = smallGamma + nx_*pos;
         deltai = smallDelta + nx_*pos;
  
         // Update sTs, sTs_ and sTy, sTy_
         m->delta_norm_old[b] = m->delta_norm[b];
         m->delta_gamma_old[b] = m->delta_gamma[b];
         m->delta_norm[b] = casadi_dot(dim, deltai, deltai);
         m->delta_gamma[b] = casadi_dot(dim, gammai, deltai);
  
         // Save statistics, we want to record them only for the most recent update
         averageSizingFactor = m->averageSizingFactor;
         hessDamped = m->hessDamped;
         hessSkipped = m->hessSkipped;
  
         // Selective sizing before the update
         if (hessScaling == 4) sizeHessianCOL(m, gammai, deltai, b);
  
         // Compute the new update
         if (updateType == 1) {
           calcSR1(m, gammai, deltai, b);
         } else if (updateType == 2) {
           calcBFGS(m, gammai, deltai, b);
         }
  
         m->nTotalUpdates++;
  
         // Count damping statistics only for the most recent update
         if (pos != posNewest) {
           m->hessDamped = hessDamped;
           m->hessSkipped = hessSkipped;
           if (hessScaling == 4)
             m->averageSizingFactor = averageSizingFactor;
         }
       }
  
       // If an update is skipped to often, reset Hessian block
       if (m->noUpdateCounter[b] > max_consec_skipped_updates_) {
         resetHessian(m, b);
       }
     }
     //blocks
     m->averageSizingFactor /= nBlocks;
   }

Referenced by computeNextHessian(), and run().

◆ calcInitialHessian() [1/2]

void casadi::Blocksqp::calcInitialHessian ( BlocksqpMemory * m ) const

Initial Hessian: Identity matrix

Definition at line 1765 of file blocksqp.cpp.

                                                            {
     for (casadi_int b=0; b<nblocks_; b++)
       //if objective derv is computed exactly, don't set the last block!
       if (!(which_second_derv_ == 1 && block_hess_
         && b == nblocks_-1))
         calcInitialHessian(m, b);
   }

References block_hess_, nblocks_, and which_second_derv_.

Referenced by calcHessianUpdateExact(), calcHessianUpdateLimitedMemory(), resetHessian(), and run().

◆ calcInitialHessian() [2/2]

void casadi::Blocksqp::calcInitialHessian	(	BlocksqpMemory *	m,
		casadi_int	b
	)		const

Initial Hessian for one block: Identity matrix

Definition at line 1777 of file blocksqp.cpp.

                                                                          {
     casadi_int dim = dim_[b];
     casadi_fill(m->hess[b], dim*dim, 0.);
  
     // Each block is a diagonal matrix
     for (casadi_int i=0; i<dim; i++)
       m->hess[b][i+i*dim] = ini_hess_diag_;
  
     // If we maintain 2 Hessians, also reset the second one
     if (m->hess2 != nullptr) {
       casadi_fill(m->hess2[b], dim*dim, 0.);
       for (casadi_int i=0; i<dim; i++)
         m->hess2[b][i+i*dim] = ini_hess_diag_;
     }
   }

References casadi::casadi_fill(), dim_, casadi::BlocksqpMemory::hess, casadi::BlocksqpMemory::hess2, and ini_hess_diag_.

◆ calcLagrangeGradient() [1/2]

void casadi::Blocksqp::calcLagrangeGradient	(	BlocksqpMemory *	m,
		const double *	lam_x,
		const double *	lam_g,
		const double *	grad_f,
		const double *	jacNz,
		double *	grad_lag,
		casadi_int	flag
	)		const

Compute gradient of Lagrangian or difference of Lagrangian gradients (sparse version)

flag == 0: output dL(xk, lambda) flag == 1: output dL(xi_k+1, lambda_k+1) - L(xi_k, lambda_k+1) flag == 2: output dL(xi_k+1, lambda_k+1) - df(xi)

Definition at line 952 of file blocksqp.cpp.

                                              {
  
     // Objective gradient
     if (flag == 0) {
       casadi_copy(grad_f, nx_, grad_lag);
     } else if (flag == 1) {
       casadi_scal(nx_, -1., grad_lag);
       casadi_axpy(nx_, 1., grad_f, grad_lag);
     } else {
       casadi_fill(grad_lag, nx_, 0.);
     }
  
     // - lambdaT * constrJac
     const casadi_int* jacIndRow = Asp_.row();
     const casadi_int* jacIndCol = Asp_.colind();
     for (casadi_int iVar=0; iVar<nx_; iVar++) {
       for (casadi_int iCon=jacIndCol[iVar]; iCon<jacIndCol[iVar+1]; iCon++) {
         grad_lag[iVar] -= lam_g[jacIndRow[iCon]] * jacNz[iCon];
       }
     }
  
     // - lambdaT * simpleBounds
     casadi_axpy(nx_, -1., lam_x, grad_lag);
   }

References Asp_, casadi::casadi_axpy(), casadi::casadi_copy(), casadi::casadi_fill(), casadi::casadi_scal(), casadi::Sparsity::colind(), casadi::Nlpsol::nx_, and casadi::Sparsity::row().

Referenced by calcLagrangeGradient(), calcOptTol(), kktErrorReduction(), and run().

◆ calcLagrangeGradient() [2/2]

void casadi::Blocksqp::calcLagrangeGradient	(	BlocksqpMemory *	m,
		double *	grad_lag,
		casadi_int	flag
	)		const

Wrapper if called with standard arguments

Definition at line 984 of file blocksqp.cpp.

                                                                                    {
     calcLagrangeGradient(m, m->lam_xk, m->lam_gk, m->grad_fk, m->jac_g,
       grad_lag, flag);
   }

References calcLagrangeGradient(), casadi::BlocksqpMemory::grad_fk, casadi::BlocksqpMemory::jac_g, casadi::BlocksqpMemory::lam_gk, and casadi::BlocksqpMemory::lam_xk.

◆ calcOptTol()

bool casadi::Blocksqp::calcOptTol ( BlocksqpMemory * m ) const

Compute optimality conditions: ||grad_lag(xk,lambda)||_infty / (1 + ||lambda||_infty) <= TOL and ||constrViolation||_infty / (1 + ||xi||_infty) <= TOL

Definition at line 997 of file blocksqp.cpp.

                                                    {
     auto d_nlp = &m->d_nlp;
     // scaled norm of Lagrangian gradient
     calcLagrangeGradient(m, m->grad_lagk, 0);
     m->gradNorm = casadi_norm_inf(nx_, m->grad_lagk);
     m->tol = m->gradNorm/(1.0+fmax(casadi_norm_inf(nx_, m->lam_xk),
                                    casadi_norm_inf(ng_, m->lam_gk)));
  
     // norm of constraint violation
     m->cNorm  = lInfConstraintNorm(m, d_nlp->z, m->gk);
     m->cNormS = m->cNorm /(1.0 + casadi_norm_inf(nx_, d_nlp->z));
  
     return m->tol <= opttol_ && m->cNormS <= nlinfeastol_;
   }

References calcLagrangeGradient(), casadi::casadi_norm_inf(), casadi::BlocksqpMemory::cNorm, casadi::BlocksqpMemory::cNormS, casadi::NlpsolMemory::d_nlp, casadi::BlocksqpMemory::gk, casadi::BlocksqpMemory::grad_lagk, casadi::BlocksqpMemory::gradNorm, casadi::BlocksqpMemory::lam_gk, casadi::BlocksqpMemory::lam_xk, lInfConstraintNorm(), casadi::Nlpsol::ng_, nlinfeastol_, casadi::Nlpsol::nx_, opttol_, and casadi::BlocksqpMemory::tol.

Referenced by run().

◆ calcSR1()

void casadi::Blocksqp::calcSR1	(	BlocksqpMemory *	m,
		const double *	gamma,
		const double *	delta,
		casadi_int	b
	)		const

Definition at line 2207 of file blocksqp.cpp.

                                                    {
     casadi_int dim = dim_[b];
     double *B = m->hess[b];
     double myEps = 1.0e2 * eps_;
     double r = 1.0e-8;
     double h = 0.0;
  
     // gmBdelta = gamma - B*delta
     // h = (gamma - B*delta)^T * delta
     std::vector<double> gmBdelta(dim);
     for (casadi_int i=0; i<dim; i++) {
       gmBdelta[i] = gamma[i];
       for (casadi_int k=0; k<dim; k++)
         gmBdelta[i] -= B[i+k*dim] * delta[k];
  
       h += (gmBdelta[i] * delta[i]);
     }
  
     // B_k+1 = B_k + gmBdelta * gmBdelta^T / h
     if (fabs(h) < r * casadi_norm_2(dim, delta)
       *casadi_norm_2(dim, get_ptr(gmBdelta)) || fabs(h) < myEps) {
       // Skip update if denominator is too small
       m->noUpdateCounter[b]++;
       m->hessSkipped++;
       m->nTotalSkippedUpdates++;
     } else {
       for (casadi_int i=0; i<dim; i++)
         for (casadi_int j=0; j<dim; j++)
           B[i+j*dim] += gmBdelta[i]*gmBdelta[j]/h;
       m->noUpdateCounter[b] = 0;
     }
   }

References casadi::casadi_norm_2(), dim_, eps_, casadi::get_ptr(), casadi::BlocksqpMemory::hess, casadi::BlocksqpMemory::hessSkipped, casadi::BlocksqpMemory::noUpdateCounter, and casadi::BlocksqpMemory::nTotalSkippedUpdates.

Referenced by calcHessianUpdate(), and calcHessianUpdateLimitedMemory().

◆ call()

template<typename M >

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

inherited

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

Definition at line 1536 of file function_internal.hpp.

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

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

◆ call_forward() [1/2]

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

virtualinherited

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

Definition at line 2945 of file function_internal.cpp.

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

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

◆ call_forward() [2/2]

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

virtualinherited

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

Definition at line 3164 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ call_gen() [1/2]

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

inherited

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

Definition at line 3838 of file function_internal.cpp.

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

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

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

◆ call_gen() [2/2]

template<typename D >

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

inherited

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

Definition at line 1640 of file function_internal.hpp.

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

◆ call_reverse() [1/2]

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

virtualinherited

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

Definition at line 3050 of file function_internal.cpp.

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

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

◆ call_reverse() [2/2]

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

virtualinherited

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

Definition at line 3177 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ callback()

int casadi::Nlpsol::callback ( NlpsolMemory * m ) const

inherited

Definition at line 1121 of file nlpsol.cpp.

                                             {
     // Quick return if no callback function
     if (fcallback_.is_null()) return 0;
     // Callback inputs
     std::fill_n(m->arg, fcallback_.n_in(), nullptr);
  
     auto d_nlp = &m->d_nlp;
  
     m->arg[NLPSOL_X] = d_nlp->z;
     m->arg[NLPSOL_F] = &d_nlp->objective;
     m->arg[NLPSOL_G] = d_nlp->z + nx_;
     m->arg[NLPSOL_LAM_G] = d_nlp->lam + nx_;
     m->arg[NLPSOL_LAM_X] = d_nlp->lam;
  
     // Callback outputs
     std::fill_n(m->res, fcallback_.n_out(), nullptr);
     double ret = 0;
     m->res[0] = &ret;
  
     // Start timer
     m->fstats.at("callback_fun").tic();
     try {
       // Evaluate
       fcallback_(m->arg, m->res, m->iw, m->w, 0);
     } catch(KeyboardInterruptException& ex) {
       (void)ex;  // unused
       throw;
     } catch(std::exception& ex) {
       print("WARNING: intermediate_callback error: %s\n", ex.what());
       if (!iteration_callback_ignore_errors_) ret=1;
     }
  
     // User user interruption?
     if (static_cast<casadi_int>(ret)) return 1;
  
     // Stop timer
     m->fstats.at("callback_fun").toc();
  
     return 0;
   }

References casadi::OracleMemory::arg, casadi::NlpsolMemory::d_nlp, casadi::Nlpsol::fcallback_, casadi::ProtoFunctionMemory::fstats, casadi::GenericShared< Shared, Internal >::is_null(), casadi::Nlpsol::iteration_callback_ignore_errors_, casadi::OracleMemory::iw, casadi::Function::n_in(), casadi::Function::n_out(), casadi::NLPSOL_F, casadi::NLPSOL_G, casadi::NLPSOL_LAM_G, casadi::NLPSOL_LAM_X, casadi::NLPSOL_X, casadi::Nlpsol::nx_, casadi::ProtoFunction::print(), casadi::OracleMemory::res, casadi::OracleMemory::w, and casadi::CasadiException::what().

Referenced by casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), and casadi::Sqpmethod::solve().

◆ change_option()

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

overridevirtualinherited

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

Reimplemented from casadi::ProtoFunction.

Reimplemented in casadi::MXFunction.

Definition at line 423 of file function_internal.cpp.

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

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

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

◆ check_arg()

template<typename M >

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

inherited

Raises errors.

Parameters

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

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

Definition at line 1687 of file function_internal.hpp.

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

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

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

◆ check_inputs()

void casadi::Nlpsol::check_inputs ( void * mem ) const

virtualinherited

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

Definition at line 613 of file nlpsol.cpp.

                                            {
     auto m = static_cast<NlpsolMemory*>(mem);
     auto d_nlp = &m->d_nlp;
  
     // Skip check?
     if (!inputs_check_) return;
  
     const double inf = std::numeric_limits<double>::infinity();
  
     // Number of equality constraints
     casadi_int n_eq = 0;
  
     // Detect ill-posed problems (simple bounds)
     for (casadi_int i=0; i<nx_; ++i) {
       double lb = d_nlp->lbx ? d_nlp->lbx[i] : get_default_in(NLPSOL_LBX);
       double ub = d_nlp->ubx ? d_nlp->ubx[i] : get_default_in(NLPSOL_UBX);
       double x0 = d_nlp->x0 ? d_nlp->x0[i] : get_default_in(NLPSOL_X0);
       casadi_assert(lb <= ub && lb!=inf && ub!=-inf,
           "Ill-posed problem detected: "
           "LBX[" + str(i) + "] <= UBX[" + str(i) + "] was violated. "
           "Got LBX[" + str(i) + "]=" + str(lb) + " and UBX[" + str(i) + "] = " + str(ub) + ".");
       if (warn_initial_bounds_ && (x0>ub || x0<lb)) {
         casadi_warning("Nlpsol: The initial guess does not satisfy LBX and UBX. "
           "Option 'warn_initial_bounds' controls this warning.");
         break;
       }
       if (lb==ub) n_eq++;
     }
  
     // Detect ill-posed problems (nonlinear bounds)
     for (casadi_int i=0; i<nnz_out(NLPSOL_G); ++i) {
       double lb = d_nlp->lbg ? d_nlp->lbg[i] : get_default_in(NLPSOL_LBG);
       double ub = d_nlp->ubg ? d_nlp->ubg[i] : get_default_in(NLPSOL_UBG);
       casadi_assert(lb <= ub && lb!=inf && ub!=-inf,
         "Ill-posed problem detected: "
         "LBG[" + str(i) + "] <= UBG[" + str(i) + "] was violated. "
         "Got LBG[" + str(i) + "] = " + str(lb) + " and UBG[" + str(i) + "] = " + str(ub) + ".");
       if (lb==ub) n_eq++;
     }
  
     // Make sure enough degrees of freedom
     using casadi::str; // Workaround, MingGW bug, cf. CasADi issue #890
     if (n_eq> nx_) {
       casadi_warning("NLP is overconstrained: There are " + str(n_eq) +
       " equality constraints but only " + str(nx_) + " variables.");
     }
   }

References casadi::NlpsolMemory::d_nlp, casadi::Nlpsol::get_default_in(), casadi::inf, casadi::FunctionInternal::inputs_check_, casadi::NLPSOL_G, casadi::NLPSOL_LBG, casadi::NLPSOL_LBX, casadi::NLPSOL_UBG, casadi::NLPSOL_UBX, casadi::NLPSOL_X0, casadi::FunctionInternal::nnz_out(), casadi::Nlpsol::nx_, casadi::str(), and casadi::Nlpsol::warn_initial_bounds_.

Referenced by casadi::Nlpsol::eval(), casadi::AlpaqaInterface::set_work(), and casadi::SLEQPInterface::set_work().

◆ check_mat()

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

staticinherited

Helper function

Parameters

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

Definition at line 3376 of file function_internal.cpp.

                                                                                              {
     // Matching dimensions
     if (arg.size()==inp.size()) return true;
     // Calling with empty matrix - set all to zero
     if (arg.is_empty()) return true;
     // Calling with a scalar - set all
     if (arg.is_scalar()) return true;
     // Vectors that are transposes of each other
     if (arg.is_vector() && inp.size()==std::make_pair(arg.size2(), arg.size1())) return true;
     // Horizontal repmat
     if (arg.size1()==inp.size1() && arg.size2()>0 && inp.size2()>0
         && inp.size2()%arg.size2()==0) return true;
     if (npar==-1) return false;
     // Evaluate with multiple arguments
     if (arg.size1()==inp.size1() && arg.size2()>0 && inp.size2()>0
         && arg.size2()%(npar*inp.size2())==0) {
       npar *= arg.size2()/(npar*inp.size2());
       return true;
     }
     // No match
     return false;
   }

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

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

◆ check_mem_count()

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

inlinevirtualinherited

Purpose if to allow more helpful error messages

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

Reimplemented in casadi::FmuFunction.

Definition at line 179 of file function_internal.hpp.

179 { }

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

◆ check_res()

template<typename M >

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

inherited

Raises errors.

Parameters

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

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

Definition at line 1711 of file function_internal.hpp.

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

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

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

◆ checkout()

int casadi::ProtoFunction::checkout ( ) const

inherited

Definition at line 3585 of file function_internal.cpp.

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

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

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

◆ class_name()

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

inlineoverridevirtual

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

Reimplemented from casadi::Nlpsol.

Definition at line 160 of file blocksqp.hpp.

160 { return "Blocksqp";}

◆ clear_mem()

void casadi::ProtoFunction::clear_mem ( )

inherited

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

Definition at line 3473 of file function_internal.cpp.

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

References casadi::ProtoFunction::free_mem().

◆ codegen()

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

inherited

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

Definition at line 2306 of file function_internal.cpp.

                                                                                {
     // Define function
     g << "/* " << definition() << " */\n";
     g << "static " << signature(fname) << " {\n";
  
     // Reset local variables, flush buffer
     g.flush(g.body);
  
     g.scope_enter();
  
     // Generate function body (to buffer)
     codegen_body(g);
  
     g.scope_exit();
  
     // Finalize the function
     g << "return 0;\n";
     g << "}\n\n";
  
     // Flush to function body
     g.flush(g.body);
   }

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

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

◆ codegen_alloc_mem()

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

virtualinherited

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

Reimplemented in casadi::External.

Definition at line 2354 of file function_internal.cpp.

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

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

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

◆ codegen_body()

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

virtualinherited

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

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

Definition at line 2742 of file function_internal.cpp.

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

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

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

◆ codegen_body_enter()

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

overridevirtualinherited

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

Reimplemented from casadi::OracleFunction.

Definition at line 1179 of file nlpsol.cpp.

                                                         {
     OracleFunction::codegen_body_enter(g);
     g.local("d_nlp", "struct casadi_nlpsol_data");
     g.local("p_nlp", "struct casadi_nlpsol_prob");
  
     g << "d_nlp.oracle = &d_oracle;\n";
  
     g << "d_nlp.p = arg[" << NLPSOL_P << "];\n";
     g << "d_nlp.lbx = arg[" << NLPSOL_LBX << "];\n";
     g << "d_nlp.ubx = arg[" << NLPSOL_UBX << "];\n";
     g << "d_nlp.lbg = arg[" << NLPSOL_LBG << "];\n";
     g << "d_nlp.ubg = arg[" << NLPSOL_UBG << "];\n";
     g << "d_nlp.x0 = arg[" << NLPSOL_X0 << "];\n";
     g << "d_nlp.lam_x0 = arg[" << NLPSOL_LAM_X0 << "];\n";
     g << "d_nlp.lam_g0 = arg[" << NLPSOL_LAM_G0 << "];\n";
  
     g << "d_nlp.x = res[" << NLPSOL_X << "];\n";
     g << "d_nlp.f = res[" << NLPSOL_F << "];\n";
     g << "d_nlp.g = res[" << NLPSOL_G << "];\n";
     g << "d_nlp.lam_x = res[" << NLPSOL_LAM_X << "];\n";
     g << "d_nlp.lam_g = res[" << NLPSOL_LAM_G << "];\n";
     g << "d_nlp.lam_p = res[" << NLPSOL_LAM_P << "];\n";
  
     g << "d_nlp.prob = &p_nlp;\n";
     g << "p_nlp.nx = " << nx_ << ";\n";
     g << "p_nlp.ng = " << ng_ << ";\n";
     g << "p_nlp.np = " << np_ << ";\n";
     g << "p_nlp.detect_bounds.ng = " << detect_simple_bounds_is_simple_.size() << ";\n";
     if (detect_simple_bounds_is_simple_.size()) {
  
  
       g << "p_nlp.detect_bounds.sz_arg = " << detect_simple_bounds_parts_.sz_arg() << ";\n";
       g << "p_nlp.detect_bounds.sz_res = " << detect_simple_bounds_parts_.sz_res() << ";\n";
       g << "p_nlp.detect_bounds.sz_iw = " << detect_simple_bounds_parts_.sz_iw() << ";\n";
       g << "p_nlp.detect_bounds.sz_w = " << detect_simple_bounds_parts_.sz_w() << ";\n";
  
       g << "p_nlp.detect_bounds.nb = " << detect_simple_bounds_target_x_.size() << ";\n";
       g << "p_nlp.detect_bounds.target_x = "
         << g.constant(detect_simple_bounds_target_x_) << ";\n";
       g << "p_nlp.detect_bounds.target_g = "
         << g.constant(detect_simple_bounds_target_g_) << ";\n";
       g << "p_nlp.detect_bounds.is_simple = "
         << g.constant(detect_simple_bounds_is_simple_) << ";\n";
       std::string w =
         g.shorthand(g.wrapper(detect_simple_bounds_parts_, "detect_simple_bounds_wrapper"));
       g << "p_nlp.detect_bounds.callback = " << w << ";\n";
       g << "p_nlp.detect_bounds.callback_data = 0;\n";
     }
     g << "casadi_nlpsol_init(&d_nlp, &arg, &res, &iw, &w);\n";
  
     // Set initial guess
     g.copy_default("d_nlp.x0", nx_, "d_nlp.z", "0", false);
  
     // Read simple bounds and multiplier guesses
     g.copy_default("d_nlp.lbx", nx_, "d_nlp.lbz", "-casadi_inf", false);
     g.copy_default("d_nlp.ubx", nx_, "d_nlp.ubz", "casadi_inf", false);
     g.copy_default("d_nlp.lam_x0", nx_, "d_nlp.lam", "0", false);
  
     if (detect_simple_bounds_is_simple_.empty()) {
       // Read constraint bounds and multiplier guesses
       g.copy_default("d_nlp.lbg", ng_, "d_nlp.lbz+"+str(nx_),
         "-casadi_inf", false);
       g.copy_default("d_nlp.ubg", ng_, "d_nlp.ubz+"+str(nx_),
         "casadi_inf", false);
       g.copy_default("d_nlp.lam_g0", ng_, "d_nlp.lam+"+str(nx_), "0", false);
     } else {
       g << "if (casadi_detect_bounds_before(&d_nlp)) return 1;\n";
     }
  
   }

References casadi::OracleFunction::codegen_body_enter(), casadi::CodeGenerator::constant(), casadi::CodeGenerator::copy_default(), casadi::Nlpsol::detect_simple_bounds_is_simple_, casadi::Nlpsol::detect_simple_bounds_parts_, casadi::Nlpsol::detect_simple_bounds_target_g_, casadi::Nlpsol::detect_simple_bounds_target_x_, casadi::CodeGenerator::local(), casadi::Nlpsol::ng_, casadi::NLPSOL_F, casadi::NLPSOL_G, casadi::NLPSOL_LAM_G, casadi::NLPSOL_LAM_G0, casadi::NLPSOL_LAM_P, casadi::NLPSOL_LAM_X, casadi::NLPSOL_LAM_X0, casadi::NLPSOL_LBG, casadi::NLPSOL_LBX, casadi::NLPSOL_P, casadi::NLPSOL_UBG, casadi::NLPSOL_UBX, casadi::NLPSOL_X, casadi::NLPSOL_X0, casadi::Nlpsol::np_, casadi::Nlpsol::nx_, casadi::CodeGenerator::shorthand(), casadi::str(), casadi::Function::sz_arg(), casadi::Function::sz_iw(), casadi::Function::sz_res(), casadi::Function::sz_w(), and casadi::CodeGenerator::wrapper().

Referenced by casadi::FatropInterface::codegen_body(), casadi::IpoptInterface::codegen_body(), casadi::MadnlpInterface::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), and casadi::Sqpmethod::codegen_body().

◆ codegen_body_exit()

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

overridevirtualinherited

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

Reimplemented from casadi::OracleFunction.

Definition at line 1269 of file nlpsol.cpp.

                                                        {
     if (calc_f_ || calc_g_ || calc_lam_x_ || calc_lam_p_) {
       g.local("one", "const casadi_real");
       g.init_local("one", "1");
       g << "d->arg[0] = d_nlp.z;\n";
       g << "d->arg[1] = d_nlp.p;\n";
       g << "d->arg[2] = &one;\n";
       g << "d->arg[3] = d_nlp.lam+" + str(nx_) + ";\n";
       g << "d->res[0] = " << (calc_f_ ? "&d_nlp.objective" : "0") << ";\n";
       g << "d->res[1] = " << (calc_g_ ? "d_nlp.z+" + str(nx_) : "0") << ";\n";
       g << "d->res[2] = " << (calc_lam_x_ ? "d_nlp.lam+" + str(nx_) : "0") << ";\n";
       g << "d->res[3] = " << (calc_lam_p_ ? "d_nlp.lam_p" : "0") << ";\n";
       std::string nlp_grad = g(get_function("nlp_grad"), "d->arg", "d->res", "d->iw", "d->w");
       g << "if (" + nlp_grad + ") return 1;\n";
       if (calc_lam_x_) g << g.scal(nx_, "-1.0", "d_nlp.lam") << "\n";
       if (calc_lam_p_) g << g.scal(np_, "-1.0", "d_nlp.lam_p") << "\n";
     }
     if (bound_consistency_) {
       g << g.bound_consistency(nx_+ng_, "d_nlp.z", "d_nlp.lam", "d_nlp.lbz", "d_nlp.ubz") << ";\n";
     }
  
     g << g.copy("d_nlp.z", nx_, "d_nlp.x") << "\n";
  
     if (detect_simple_bounds_is_simple_.empty()) {
       g << g.copy("d_nlp.z + " + str(nx_), ng_, "d_nlp.g") << "\n";
       g << g.copy("d_nlp.lam", nx_, "d_nlp.lam_x") << "\n";
       g << g.copy("d_nlp.lam + " + str(nx_), ng_, "d_nlp.lam_g") << "\n";
     } else {
       g << "if (casadi_detect_bounds_after(&d_nlp)) return 1;\n";
     }
  
     g.copy_check("&d_nlp.objective", 1, "d_nlp.f", false, true);
     g.copy_check("d_nlp.lam_p", np_, "d_nlp.lam_p", false, true);
  
     OracleFunction::codegen_body_exit(g);
   }

References casadi::CodeGenerator::bound_consistency(), casadi::Nlpsol::bound_consistency_, casadi::Nlpsol::calc_f_, casadi::Nlpsol::calc_g_, casadi::Nlpsol::calc_lam_p_, casadi::Nlpsol::calc_lam_x_, casadi::OracleFunction::codegen_body_exit(), casadi::CodeGenerator::copy(), casadi::CodeGenerator::copy_check(), casadi::Nlpsol::detect_simple_bounds_is_simple_, casadi::OracleFunction::get_function(), casadi::CodeGenerator::init_local(), casadi::CodeGenerator::local(), casadi::Nlpsol::ng_, casadi::Nlpsol::np_, casadi::Nlpsol::nx_, casadi::CodeGenerator::scal(), and casadi::str().

Referenced by casadi::FatropInterface::codegen_body(), casadi::IpoptInterface::codegen_body(), casadi::MadnlpInterface::codegen_body(), and casadi::Sqpmethod::codegen_body().

◆ codegen_checkout()

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

virtualinherited

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

Reimplemented in casadi::External.

Definition at line 2363 of file function_internal.cpp.

                                                                 {
     std::string name = codegen_name(g, false);
     std::string stack_counter = g.shorthand(name + "_unused_stack_counter");
     std::string stack = g.shorthand(name + "_unused_stack");
     std::string mem_counter = g.shorthand(name + "_mem_counter");
     std::string mem_array = g.shorthand(name + "_mem");
     std::string alloc_mem = g.shorthand(name + "_alloc_mem");
     std::string init_mem = g.shorthand(name + "_init_mem");
  
     g.auxiliaries << "static int " << mem_counter  << " = 0;\n";
     g.auxiliaries << "static int " << stack_counter  << " = -1;\n";
     g.auxiliaries << "static int " << stack << "[CASADI_MAX_NUM_THREADS];\n";
     g.auxiliaries << "static " << codegen_mem_type() <<
                " " << mem_array << "[CASADI_MAX_NUM_THREADS];\n\n";
     g << "int mid;\n";
     g << "if (" << stack_counter << ">=0) {\n";
     g << "return " << stack << "[" << stack_counter << "--];\n";
     g << "} else {\n";
     g << "if (" << mem_counter << "==CASADI_MAX_NUM_THREADS) return -1;\n";
     g << "mid = " << alloc_mem << "();\n";
     g << "if (mid<0) return -1;\n";
     g << "if(" << init_mem << "(mid)) return -1;\n";
     g << "return mid;\n";
     g << "}\n";
   }

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

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

◆ codegen_declarations()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Reimplemented in casadi::Sqpmethod, casadi::Feasiblesqpmethod, casadi::MadnlpInterface, casadi::IpoptInterface, and casadi::FatropInterface.

Definition at line 1250 of file nlpsol.cpp.

                                                           {
     g.add_auxiliary(CodeGenerator::AUX_FILL);
     if (calc_f_ || calc_g_ || calc_lam_x_ || calc_lam_p_)
       g.add_dependency(get_function("nlp_grad"));
  
     if (detect_simple_bounds_is_simple_.size()) {
       g.add_dependency(detect_simple_bounds_parts_);
       std::string w =
         g.shorthand(g.wrapper(detect_simple_bounds_parts_, "detect_simple_bounds_wrapper"));
  
       g << "int " << w
         << "(const casadi_real** arg, casadi_real** res, "
         << "casadi_int* iw, casadi_real* w, void* callback_data) {\n";
       std::string flag = g(detect_simple_bounds_parts_, "arg", "res", "iw", "w");
       g << "return " + flag + ";\n";
       g << "}\n";
     }
   }

References casadi::CodeGenerator::add_auxiliary(), casadi::CodeGenerator::add_dependency(), casadi::CodeGenerator::AUX_FILL, casadi::Nlpsol::calc_f_, casadi::Nlpsol::calc_g_, casadi::Nlpsol::calc_lam_p_, casadi::Nlpsol::calc_lam_x_, casadi::Nlpsol::detect_simple_bounds_is_simple_, casadi::Nlpsol::detect_simple_bounds_parts_, casadi::OracleFunction::get_function(), casadi::CodeGenerator::shorthand(), and casadi::CodeGenerator::wrapper().

Referenced by casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::MadnlpInterface::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_declarations(), and casadi::Sqpmethod::codegen_declarations().

◆ codegen_decref()

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

inlinevirtualinherited

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

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

Definition at line 849 of file function_internal.hpp.

849 {}

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

◆ codegen_free_mem()

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

inlinevirtualinherited

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

Reimplemented in casadi::OsqpInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, and casadi::External.

Definition at line 864 of file function_internal.hpp.

864 {}

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

◆ codegen_incref()

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

inlinevirtualinherited

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

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

Definition at line 844 of file function_internal.hpp.

844 {}

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

◆ codegen_init_mem()

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

virtualinherited

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

Reimplemented in casadi::OsqpInterface, casadi::MadnlpInterface, casadi::IpoptInterface, casadi::HighsInterface, casadi::FatropInterface, casadi::DaqpInterface, casadi::ClarabelInterface, and casadi::External.

Definition at line 2350 of file function_internal.cpp.

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

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

◆ codegen_mem()

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

inherited

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

Definition at line 2732 of file function_internal.cpp.

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

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

◆ codegen_mem_type()

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

inlinevirtualinherited

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

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

Definition at line 899 of file function_internal.hpp.

899 { return ""; }

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

◆ codegen_meta()

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

inherited

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

Definition at line 2400 of file function_internal.cpp.

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

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

◆ codegen_name()

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

virtualinherited

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

Definition at line 2717 of file function_internal.cpp.

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

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

Referenced by casadi::FunctionInternal::codegen_alloc_mem(), casadi::FunctionInternal::codegen_checkout(), casadi::Call::codegen_decref(), casadi::Call::codegen_incref(), casadi::FunctionInternal::codegen_mem(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_release(), and casadi::CodeGenerator::mem().

◆ codegen_release()

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

virtualinherited

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

Reimplemented in casadi::External.

Definition at line 2389 of file function_internal.cpp.

                                                                {
     std::string name = codegen_name(g, false);
     std::string stack_counter = g.shorthand(name + "_unused_stack_counter");
     std::string stack = g.shorthand(name + "_unused_stack");
     g << stack << "[++" << stack_counter << "] = mem;\n";
   }

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

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

◆ codegen_sparsities()

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

inherited

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

Definition at line 2396 of file function_internal.cpp.

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

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

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

◆ codegen_sz_arg()

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

virtualinherited

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

Definition at line 2829 of file function_internal.cpp.

                                                                       {
     return sz_arg();
   }

References casadi::FunctionInternal::sz_arg().

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

◆ codegen_sz_iw()

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

virtualinherited

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

Definition at line 2835 of file function_internal.cpp.

                                                                      {
     return sz_iw();
   }

References casadi::FunctionInternal::sz_iw().

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

◆ codegen_sz_res()

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

virtualinherited

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

Definition at line 2832 of file function_internal.cpp.

                                                                       {
     return sz_res();
   }

References casadi::FunctionInternal::sz_res().

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

◆ codegen_sz_w()

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

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 2838 of file function_internal.cpp.

                                                                     {
     return sz_w();
   }

References casadi::FunctionInternal::sz_w().

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

◆ computeNextHessian()

void casadi::Blocksqp::computeNextHessian	(	BlocksqpMemory *	m,
		casadi_int	idx,
		casadi_int	maxQP
	)		const

Definition at line 2254 of file blocksqp.cpp.

                                                                                 {
     // Compute fallback update only once
     if (idx == 1) {
         // Switch storage
         m->hess = m->hess2;
  
         // If last block contains exact Hessian, we need to copy it
         if (which_second_derv_ == 1) {
           casadi_int dim = dim_[nblocks_-1];
           casadi_copy(m->hess1[nblocks_-1], dim*dim, m->hess2[nblocks_-1]);
         }
  
         // Limited memory: compute fallback update only when needed
         if (hess_lim_mem_) {
             m->itCount--;
             casadi_int hessDampSave = hess_damp_;
             const_cast<Blocksqp*>(this)->hess_damp_ = 1;
             calcHessianUpdateLimitedMemory(m, fallback_update_, fallback_scaling_);
             const_cast<Blocksqp*>(this)->hess_damp_ = hessDampSave;
             m->itCount++;
           }
         /* Full memory: both updates must be computed in every iteration
          * so switching storage is enough */
       }
  
     // 'Nontrivial' convex combinations
     if (maxQP > 2) {
         /* Convexification parameter: mu_l = l / (maxQP-1).
          * Compute it only in the first iteration, afterwards update
          * by recursion: mu_l/mu_(l-1) */
         double idxF = idx;
         double mu = (idx==1) ? 1.0 / (maxQP-1) : idxF / (idxF - 1.0);
         double mu1 = 1.0 - mu;
         for (casadi_int b=0; b<nblocks_; b++) {
           casadi_int dim = dim_[b];
           for (casadi_int i=0; i<dim; i++) {
             for (casadi_int j=0; j<dim; j++) {
               m->hess2[b][i+j*dim] *= mu;
               m->hess2[b][i+j*dim] += mu1 * m->hess1[b][i+j*dim];
             }
           }
         }
     }
   }

References calcHessianUpdateLimitedMemory(), casadi::casadi_copy(), dim_, fallback_scaling_, fallback_update_, casadi::BlocksqpMemory::hess, casadi::BlocksqpMemory::hess1, casadi::BlocksqpMemory::hess2, hess_damp_, hess_lim_mem_, casadi::BlocksqpMemory::itCount, nblocks_, and which_second_derv_.

Referenced by solveQP().

◆ construct()

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

inherited

Prepares the function for evaluation

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

Definition at line 137 of file function_internal.cpp.

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

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

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

◆ convert_arg() [1/2]

template<typename M >

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

inherited

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

Definition at line 1811 of file function_internal.hpp.

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

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

◆ convert_arg() [2/2]

template<typename M >

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

inherited

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

Definition at line 1799 of file function_internal.hpp.

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

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

◆ convert_res() [1/2]

template<typename M >

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

inherited

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

Definition at line 1840 of file function_internal.hpp.

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

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

◆ convert_res() [2/2]

template<typename M >

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

inherited

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

Definition at line 1828 of file function_internal.hpp.

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

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

◆ convertHessian()

void casadi::Blocksqp::convertHessian ( BlocksqpMemory * m ) const

Convert array *hess to a single symmetric sparse matrix in Harwell-Boeing format (as used by qpOASES)

Definition at line 2712 of file blocksqp.cpp.

                                           {
     casadi_int count, colCountTotal, rowOffset;
     casadi_int nnz;
  
     // 1) count nonzero elements
     nnz = 0;
     for (casadi_int b=0; b<nblocks_; b++) {
       casadi_int dim = dim_[b];
       for (casadi_int i=0; i<dim; i++) {
         for (casadi_int j=0; j<dim; j++) {
           if (fabs(m->hess[b][i+j*dim]) > eps_) {
             nnz++;
           }
         }
       }
     }
  
     m->hessIndCol = m->hessIndRow + nnz;
     m->hessIndLo = m->hessIndCol + (nx_+1);
  
     // 2) store matrix entries columnwise in hessNz
     count = 0; // runs over all nonzero elements
     colCountTotal = 0; // keep track of position in large matrix
     rowOffset = 0;
     for (casadi_int b=0; b<nblocks_; b++) {
       casadi_int dim = dim_[b];
  
       for (casadi_int i=0; i<dim; i++) {
         // column 'colCountTotal' starts at element 'count'
         m->hessIndCol[colCountTotal] = count;
  
         for (casadi_int j=0; j<dim; j++) {
           if (fabs(m->hess[b][i+j*dim]) > eps_) {
               m->hess_lag[count] = m->hess[b][i+j*dim];
               m->hessIndRow[count] = j + rowOffset;
               count++;
           }
         }
         colCountTotal++;
       }
       rowOffset += dim;
     }
     m->hessIndCol[colCountTotal] = count;
  
     // 3) Set reference to lower triangular matrix
     for (casadi_int j=0; j<nx_; j++) {
       casadi_int i;
       for (i=m->hessIndCol[j]; i<m->hessIndCol[j+1] && m->hessIndRow[i]<j; i++) {}
       m->hessIndLo[j] = i;
     }
  
     if (count != nnz)
       print("***WARNING: Error in convertHessian: %i elements processed, "
             "should be %i elements!\n", count, nnz);
   }

References dim_, eps_, casadi::BlocksqpMemory::hess, casadi::BlocksqpMemory::hess_lag, casadi::BlocksqpMemory::hessIndCol, casadi::BlocksqpMemory::hessIndLo, casadi::BlocksqpMemory::hessIndRow, nblocks_, casadi::Nlpsol::nx_, and casadi::ProtoFunction::print().

Referenced by solveQP().

◆ create_forward()

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

inherited

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

Definition at line 278 of file oracle_function.cpp.

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

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

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

◆ create_function() [1/3]

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

inherited

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

Definition at line 235 of file oracle_function.cpp.

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

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

◆ create_function() [2/3]

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

inherited

Create an oracle function from MX

Definition at line 187 of file oracle_function.cpp.

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

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

◆ create_function() [3/3]

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

inherited

Create an oracle function

Definition at line 179 of file oracle_function.cpp.

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

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

◆ create_oracle()

template<typename XType >

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

staticinherited

Definition at line 129 of file nlpsol.cpp.

                                                    {
     std::vector<XType> nl_in(NL_NUM_IN), nl_out(NL_NUM_OUT);
     for (auto&& i : d) {
       if (i.first=="x") {
         nl_in[NL_X]=i.second;
       } else if (i.first=="p") {
         nl_in[NL_P]=i.second;
       } else if (i.first=="f") {
         nl_out[NL_F]=i.second;
       } else if (i.first=="g") {
         nl_out[NL_G]=i.second;
       } else {
         casadi_error("No such field: " + i.first);
       }
     }
     if (nl_out[NL_F].is_empty()) nl_out[NL_F] = 0;
     if (nl_out[NL_G].is_empty()) nl_out[NL_G] = XType(0, 1);
  
     // Options for the oracle
     Dict oracle_options;
     Dict::const_iterator it = opts.find("oracle_options");
     if (it != opts.end()) {
       // "oracle_options" has been set
       oracle_options = it->second;
     } else {
       // Propagate selected options from Nlpsol to oracle by default
       for (const char* op : {"verbose", "regularity_check"})
       if ((it = opts.find(op)) != opts.end()) {
         oracle_options[op] = it->second;
       }
     }
  
     // Create oracle
     return Function("nlp", nl_in, nl_out, NL_INPUTS, NL_OUTPUTS, oracle_options);
   }

References casadi::FunctionInternal::Function, casadi::NL_F, casadi::NL_G, casadi::NL_INPUTS, casadi::NL_NUM_IN, casadi::NL_NUM_OUT, casadi::NL_OUTPUTS, casadi::NL_P, and casadi::NL_X.

Referenced by casadi::construct_nlpsol().

◆ creator()

static Nlpsol* casadi::Blocksqp::creator	(	const std::string &	name,
		const Function &	nlp
	)

inlinestatic

Definition at line 163 of file blocksqp.hpp.

                                                                        {
       return new Blocksqp(name, nlp);
     }

Referenced by casadi::casadi_register_nlpsol_blocksqp().

◆ debug_repr()

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

inherited

Definition at line 62 of file generic_shared_internal.hpp.

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

◆ definition()

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

inherited

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

Definition at line 941 of file function_internal.cpp.

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

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

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

◆ deserialize()

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

inlinestatic

Definition at line 406 of file blocksqp.hpp.

406 { return new Blocksqp(s); }

Referenced by casadi::casadi_register_nlpsol_blocksqp().

◆ destroySingleton()

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

inlineprotectedinherited

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

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

◆ diff_prefix()

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

inherited

Definition at line 2043 of file function_internal.cpp.

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

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

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

◆ disp()

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

overridevirtualinherited

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

Implements casadi::SharedObjectInternal.

Definition at line 962 of file function_internal.cpp.

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

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

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

◆ disp_more()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 842 of file nlpsol.cpp.

                                                  {
     stream << "minimize f(x;p) subject to lbx<=x<=ubx, lbg<=g(x;p)<=ubg defined by:\n";
     oracle_.disp(stream, true);
   }

References casadi::SharedObject::disp(), and casadi::OracleFunction::oracle_.

◆ dm_in() [1/2]

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

inherited

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

Definition at line 3244 of file function_internal.cpp.

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

References casadi::FunctionInternal::n_in_.

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

◆ dm_in() [2/2]

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

inherited

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

Definition at line 3220 of file function_internal.cpp.

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

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

◆ dm_out() [1/2]

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

inherited

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

Definition at line 3252 of file function_internal.cpp.

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

References casadi::FunctionInternal::n_out_.

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

◆ dm_out() [2/2]

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

inherited

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

Definition at line 3224 of file function_internal.cpp.

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

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

◆ ensure_stacked()

template<typename MatType >

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

staticinherited

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

Definition at line 1857 of file function_internal.hpp.

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

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

◆ eval()

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

finalvirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 704 of file nlpsol.cpp.

                                                                                                {
     auto m = static_cast<NlpsolMemory*>(mem);
  
     auto d_nlp = &m->d_nlp;
  
     // Reset the solver, prepare for solution
     setup(m, arg, res, iw, w);
     auto p_nlp = d_nlp->prob;
  
     // Set initial guess
     casadi_copy(d_nlp->x0, nx_, d_nlp->z);
  
     // Read simple bounds and multiplier guesses
     casadi_copy(d_nlp->lbx, nx_, d_nlp->lbz);
     casadi_copy(d_nlp->ubx, nx_, d_nlp->ubz);
     casadi_copy(d_nlp->lam_x0, nx_, d_nlp->lam);
  
     if (p_nlp->detect_bounds.ng==0) {
       // Read constraint bounds and multiplier guesses
       casadi_copy(d_nlp->lbg, ng_, d_nlp->lbz+nx_);
       casadi_copy(d_nlp->ubg, ng_, d_nlp->ubz+nx_);
       casadi_copy(d_nlp->lam_g0, ng_, d_nlp->lam+nx_);
     } else {
       if (casadi_detect_bounds_before(d_nlp)) return 1;
     }
  
     // Set multipliers to nan
     casadi_fill(d_nlp->lam_p, np_, nan);
  
     // Reset f, g
     d_nlp->objective = nan;
     casadi_fill(d_nlp->z + nx_, ng_, nan);
  
     // Check the provided inputs
     check_inputs(m);
  
     // Solve the NLP
     int flag = solve(m);
  
     // Join statistics (introduced for parallel oracle facilities)
     join_results(m);
  
     // Calculate multiplers
     if ((calc_f_ || calc_g_ || calc_lam_x_ || calc_lam_p_) && !flag) {
       const double lam_f = 1.;
       m->arg[0] = d_nlp->z;
       m->arg[1] = d_nlp->p;
       m->arg[2] = &lam_f;
       m->arg[3] = d_nlp->lam + nx_;
       m->res[0] = calc_f_ ? &d_nlp->objective : nullptr;
       m->res[1] = calc_g_ ? d_nlp->z + nx_ : nullptr;
       m->res[2] = calc_lam_x_ ? d_nlp->lam : nullptr;
       m->res[3] = calc_lam_p_ ? d_nlp->lam_p : nullptr;
       if (calc_function(m, "nlp_grad")) {
         casadi_warning("Failed to calculate multipliers");
       }
       if (calc_lam_x_) casadi_scal(nx_, -1., d_nlp->lam);
       if (calc_lam_p_) casadi_scal(np_, -1., d_nlp->lam_p);
     }
  
     // Make sure that an optimal solution is consistant with bounds
     if (bound_consistency_ && !flag) {
       bound_consistency(nx_+ng_, d_nlp->z, d_nlp->lam, d_nlp->lbz, d_nlp->ubz);
     }
  
     // Get optimal solution
     casadi_copy(d_nlp->z, nx_, d_nlp->x);
  
     if (p_nlp->detect_bounds.ng==0) {
       casadi_copy(d_nlp->z + nx_, ng_, d_nlp->g);
       casadi_copy(d_nlp->lam, nx_, d_nlp->lam_x);
       casadi_copy(d_nlp->lam + nx_, ng_, d_nlp->lam_g);
     } else {
       if (casadi_detect_bounds_after(d_nlp)) return 1;
     }
  
     casadi_copy(d_nlp->lam_p, np_, d_nlp->lam_p);
     casadi_copy(&d_nlp->objective, 1, d_nlp->f);
  
     if (m->success) m->unified_return_status = SOLVER_RET_SUCCESS;
  
     if (error_on_fail_ && !m->success)
       casadi_error("nlpsol process failed. "
                    "Set 'error_on_fail' option to false to ignore this error.");
  
     if (m->unified_return_status==SOLVER_RET_EXCEPTION) {
       casadi_error("An exception was raised in the solver.");
     }
     return flag;
   }

References casadi::Nlpsol::bound_consistency(), casadi::Nlpsol::bound_consistency_, casadi::Nlpsol::calc_f_, casadi::OracleFunction::calc_function(), casadi::Nlpsol::calc_g_, casadi::Nlpsol::calc_lam_p_, casadi::Nlpsol::calc_lam_x_, casadi::casadi_copy(), casadi::casadi_fill(), casadi::casadi_scal(), casadi::Nlpsol::check_inputs(), casadi::NlpsolMemory::d_nlp, casadi::ProtoFunction::error_on_fail_, casadi::OracleFunction::join_results(), casadi::nan, casadi::Nlpsol::ng_, casadi::Nlpsol::np_, casadi::Nlpsol::nx_, casadi::FunctionInternal::setup(), casadi::Nlpsol::solve(), casadi::SOLVER_RET_EXCEPTION, and casadi::SOLVER_RET_SUCCESS.

◆ eval_dm()

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

virtualinherited

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

Reimplemented in casadi::CallbackInternal.

Definition at line 2026 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

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

◆ eval_gen() [1/3]

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

inlineinherited

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

Definition at line 430 of file function_internal.hpp.

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

◆ eval_gen() [2/3]

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

inherited

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

Definition at line 830 of file function_internal.cpp.

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

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

◆ eval_gen() [3/3]

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

inlineinherited

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

Definition at line 426 of file function_internal.hpp.

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

◆ eval_mx()

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

virtualinherited

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

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

Definition at line 2241 of file function_internal.cpp.

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

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

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

◆ eval_sx()

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

virtualinherited

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

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

Definition at line 2030 of file function_internal.cpp.

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

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

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

◆ evaluate() [1/3]

casadi_int casadi::Blocksqp::evaluate	(	BlocksqpMemory *	m,
		const double *	xk,
		double *	f,
		double *	g
	)		const

Definition at line 2796 of file blocksqp.cpp.

                             {
     auto d_nlp = &m->d_nlp;
     m->arg[0] = xk; // x
     m->arg[1] = d_nlp->p; // p
     m->res[0] = f; // f
     m->res[1] = g; // g
     return calc_function(m, "nlp_fg");
   }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::NlpsolMemory::d_nlp, and casadi::OracleMemory::res.

◆ evaluate() [2/3]

casadi_int casadi::Blocksqp::evaluate	(	BlocksqpMemory *	m,
		double *	exact_hess_lag
	)		const

Definition at line 2807 of file blocksqp.cpp.

                                          {
     auto d_nlp = &m->d_nlp;
     static std::vector<double> ones;
     ones.resize(nx_);
     for (casadi_int i=0; i<nx_; ++i) ones[i] = 1.0;
     static std::vector<double> minus_lam_gk;
     minus_lam_gk.resize(ng_);
     // Langrange function in blocksqp is L = f - lambdaT * g, whereas + in casadi
     for (casadi_int i=0; i<ng_; ++i) minus_lam_gk[i] = -m->lam_gk[i];
     m->arg[0] = d_nlp->z; // x
     m->arg[1] = d_nlp->p; // p
     m->arg[2] = get_ptr(ones); // lam:f
     m->arg[3] = get_ptr(minus_lam_gk); // lam:g
     m->res[0] = exact_hess_lag; // hess:gamma:x:x
     return calc_function(m, "nlp_hess_l");;
   }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::NlpsolMemory::d_nlp, casadi::get_ptr(), casadi::BlocksqpMemory::lam_gk, casadi::Nlpsol::ng_, casadi::Nlpsol::nx_, and casadi::OracleMemory::res.

◆ evaluate() [3/3]

casadi_int casadi::Blocksqp::evaluate	(	BlocksqpMemory *	m,
		double *	f,
		double *	g,
		double *	grad_f,
		double *	jac_g
	)		const

Definition at line 2782 of file blocksqp.cpp.

                                                 {
     auto d_nlp = &m->d_nlp;
     m->arg[0] = d_nlp->z; // x
     m->arg[1] = d_nlp->p; // p
     m->res[0] = f; // f
     m->res[1] = g; // g
     m->res[2] = grad_f; // grad:f:x
     m->res[3] = jac_g; // jac:g:x
     return calc_function(m, "nlp_gf_jg");
   }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::NlpsolMemory::d_nlp, and casadi::OracleMemory::res.

Referenced by calcHessianUpdateExact(), feasibilityRestorationPhase(), filterLineSearch(), fullstep(), kktErrorReduction(), run(), and secondOrderCorrection().

◆ expand()

void casadi::OracleFunction::expand ( )

inherited

Definition at line 455 of file oracle_function.cpp.

                             {
   oracle_ = oracle_.expand();
 }

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

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

◆ export_code()

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

virtualinherited

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

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

Definition at line 2201 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ factory()

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

virtualinherited

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

Definition at line 3613 of file function_internal.cpp.

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

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

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

◆ feasibilityRestorationHeuristic()

casadi_int casadi::Blocksqp::feasibilityRestorationHeuristic ( BlocksqpMemory * m ) const

Try to (partly) improve constraint violation by satisfying the (pseudo) continuity constraints, i.e. do a single shooting iteration with the current controls and measurement weights q and w

Definition at line 1636 of file blocksqp.cpp.

                                                                               {
     auto d_nlp = &m->d_nlp;
     m->nRestHeurCalls++;
  
     // Call problem specific heuristic to reduce constraint violation.
     // For shooting methods that means setting consistent values for
     // shooting nodes by one forward integration.
     for (casadi_int k=0; k<nx_; k++) // input: last successful step
       m->trial_xk[k] = d_nlp->z[k];
  
     // FIXME(@jaeandersson) Not implemented
     return -1;
   }

References casadi::NlpsolMemory::d_nlp, casadi::BlocksqpMemory::nRestHeurCalls, casadi::Nlpsol::nx_, and casadi::BlocksqpMemory::trial_xk.

Referenced by run().

◆ feasibilityRestorationPhase()

casadi_int casadi::Blocksqp::feasibilityRestorationPhase ( BlocksqpMemory * m ) const

Minimize constraint violation by solving an NLP with minimum norm objective

"The dreaded restoration phase" – Nick Gould

Definition at line 1434 of file blocksqp.cpp.

                                                                           {
     auto d_nlp = &m->d_nlp;
     // No Feasibility restoration phase
     if (!restore_feas_) return -1;
  
     m->nRestPhaseCalls++;
  
     casadi_int ret, info;
     casadi_int maxRestIt = 100;
     casadi_int warmStart;
     double cNormTrial, objTrial, lStpNorm;
  
  
     // Create Input for the minimum norm NLP
     DMDict solver_in;
  
     // The reference point is the starting value for the restoration phase
     std::vector<double> in_x0(d_nlp->z, d_nlp->z+nx_);
  
     // Initialize slack variables such that the constraints are feasible
     for (casadi_int i=0; i<ng_; i++) {
       if (m->gk[i] <= d_nlp->lbz[i+nx_])
         in_x0.push_back(m->gk[i] - d_nlp->lbz[i+nx_]);
       else if (m->gk[i] > d_nlp->ubz[i+nx_])
         in_x0.push_back(m->gk[i] - d_nlp->ubz[i+nx_]);
       else
         in_x0.push_back(0.0);
     }
  
     // Add current iterate xk to parameter p
     std::vector<double> in_p(d_nlp->p, d_nlp->p+np_);
     std::vector<double> in_p2(d_nlp->z, d_nlp->z+nx_);
     in_p.insert(in_p.end(), in_p2.begin(), in_p2.end());
  
     // Set bounds for variables
     std::vector<double> in_lbx(d_nlp->lbz, d_nlp->lbz+nx_);
     std::vector<double> in_ubx(d_nlp->ubz, d_nlp->ubz+nx_);
     for (casadi_int i=0; i<ng_; i++) {
       in_lbx.push_back(-inf);
       in_ubx.push_back(inf);
     }
  
     // Set bounds for constraints
     std::vector<double> in_lbg(d_nlp->lbz+nx_, d_nlp->lbz+nx_+ng_);
     std::vector<double> in_ubg(d_nlp->ubz+nx_, d_nlp->ubz+nx_+ng_);
  
     solver_in["x0"] = in_x0;
     solver_in["p"] = in_p;
     solver_in["lbx"] = in_lbx;
     solver_in["ubx"] = in_ubx;
     solver_in["lbg"] = in_lbg;
     solver_in["ubg"] = in_ubg;
  
       /*
  
         Consider the following simple call:
         auto solver_out = rp_solver_(solver_in);
  
         This call in fact allocates memory,
         calls a memory-less eval(),
         and clears up the memory again.
  
         Since we want to access the memory later on,
         we need to unravel the simple call into its parts,
         and avoid the memory cleanup
  
       */
  
     // perform first iteration for the minimum norm NLP
  
     // Get the number of inputs and outputs
     int n_in = rp_solver_.n_in();
     int n_out = rp_solver_.n_out();
  
     // Get default inputs
     std::vector<DM> arg_v(n_in);
     for (casadi_int i=0; i<arg_v.size(); i++)
       arg_v[i] = DM::repmat(rp_solver_.default_in(i), rp_solver_.size1_in(i), 1);
  
     // Assign provided inputs
     for (auto&& e : solver_in) arg_v.at(rp_solver_.index_in(e.first)) = e.second;
  
     // Check sparsities
     for (casadi_int i=0; i<arg_v.size(); i++)
       casadi_assert_dev(arg_v[i].sparsity()==rp_solver_.sparsity_in(i));
  
     // Allocate results
     std::vector<DM> res(n_out);
     for (casadi_int i=0; i<n_out; i++) {
       if (res[i].sparsity()!=rp_solver_.sparsity_out(i))
         res[i] = DM::zeros(rp_solver_.sparsity_out(i));
     }
  
     // Allocate temporary memory if needed
     std::vector<casadi_int> iw_tmp(rp_solver_.sz_iw());
     std::vector<double> w_tmp(rp_solver_.sz_w());
  
     // Get pointers to input arguments
     std::vector<const double*> argp(rp_solver_.sz_arg());
     for (casadi_int i=0; i<n_in; ++i) argp[i] = get_ptr(arg_v[i]);
  
     // Get pointers to output arguments
     std::vector<double*> resp(rp_solver_.sz_res());
     for (casadi_int i=0; i<n_out; i++) resp[i] = get_ptr(res[i]);
  
     void* mem2 = rp_solver_.memory(0);
  
     // perform The m
     rp_solver_->eval(get_ptr(argp), get_ptr(resp), get_ptr(iw_tmp), get_ptr(w_tmp), mem2);
  
     // Get BlocksqpMemory and Blocksqp from restoration phase
     auto m2 = static_cast<BlocksqpMemory*>(mem2);
     const Blocksqp* bp = static_cast<const Blocksqp*>(rp_solver_.get());
     ret = m2->ret_;
  
     warmStart = 1;
     for (casadi_int it=0; it<maxRestIt; it++) {
       // One iteration for minimum norm NLP
       if (it > 0)
         ret = bp->run(m2, 1, warmStart);
  
       // If restMethod yields error, stop restoration phase
       if (ret == -1)
         break;
  
       // Get new xi from the restoration phase
       for (casadi_int i=0; i<nx_; i++)
         m->trial_xk[i] = m2->d_nlp.z[i];
  
       // Compute objective at trial point
       info = evaluate(m, m->trial_xk, &objTrial, m->gk);
       m->nFunCalls++;
       cNormTrial = lInfConstraintNorm(m, m->trial_xk, m->gk);
       if ( info != 0 || objTrial < obj_lo_ || objTrial > obj_up_ ||
           !(objTrial == objTrial) || !(cNormTrial == cNormTrial) )
         continue;
  
       // Is this iterate acceptable for the filter?
       if (!pairInFilter(m, cNormTrial, objTrial)) {
         // success
         print("Found a point acceptable for the filter.\n");
         ret = 0;
         break;
       }
  
       // If minimum norm NLP has converged, declare local infeasibility
         if (m2->tol < opttol_ && m2->cNormS < nlinfeastol_) {
           ret = 1;
           break;
         }
     }
  
     // Success or locally infeasible
     if (ret == 0 || ret == 1) {
         // Store the infinity norm of the multiplier step
         m->lambdaStepNorm = 0.0;
         // Compute restoration step
         for (casadi_int k=0; k<nx_; k++) {
             m->dxk[k] = d_nlp->z[k];
  
             d_nlp->z[k] = m->trial_xk[k];
  
             // Store lInf norm of dual step
             if ((lStpNorm = fabs(m2->lam_xk[k] - m->lam_xk[k])) > m->lambdaStepNorm)
                 m->lambdaStepNorm = lStpNorm;
             m->lam_xk[k] = m2->lam_xk[k];
             m->lam_qp[k] = m2->lam_qp[k];
  
             m->dxk[k] -= d_nlp->z[k];
         }
         for (casadi_int k=0; k<ng_; k++) {
             // skip the dual variables for the slack variables in the restoration problem
             if ((lStpNorm = fabs(m2->lam_gk[k] - m->lam_gk[k])) > m->lambdaStepNorm)
                 m->lambdaStepNorm = lStpNorm;
             m->lam_gk[k] = m2->lam_gk[k];
             m->lam_qp[k] = m2->lam_qp[nx_+ng_+k];
         }
         m->alpha = 1.0;
         m->nSOCS = 0;
  
         // reset reduced step counter
         m->reducedStepCount = 0;
  
         // reset Hessian and limited memory information
         resetHessian(m);
     }
  
     if (ret == 1) {
         if (print_iteration_) printProgress(m);
         updateStats(m);
         print("The problem seems to be locally infeasible. Infeasibilities minimized.\n");
     }
  
     return ret;
   }

Referenced by run().

◆ filterLineSearch()

casadi_int casadi::Blocksqp::filterLineSearch ( BlocksqpMemory * m ) const

Backtracking line search based on a filter as described in Ipopt paper (Waechter 2006)

Definition at line 1217 of file blocksqp.cpp.

                                                                {
     auto d_nlp = &m->d_nlp;
     double alpha = 1.0;
     double cNormTrial=0, objTrial, dfTdeltaXi=0;
  
     // Compute ||constr(xi)|| at old point
     double cNorm = lInfConstraintNorm(m, d_nlp->z, m->gk);
  
     // Backtracking line search
     casadi_int k;
     for (k=0; k<max_line_search_; k++) {
       // Compute new trial point
       for (casadi_int i=0; i<nx_; i++)
         m->trial_xk[i] = d_nlp->z[i] + alpha * m->dxk[i];
  
       // Compute grad(f)^T * deltaXi
       dfTdeltaXi = 0.0;
       for (casadi_int i=0; i<nx_; i++)
         dfTdeltaXi += m->grad_fk[i] * m->dxk[i];
  
       // Compute objective and at ||constr(trial_xk)||_1 at trial point
       casadi_int info = evaluate(m, m->trial_xk, &objTrial, m->gk);
       m->nFunCalls++;
       cNormTrial = lInfConstraintNorm(m, m->trial_xk, m->gk);
       // Reduce step if evaluation fails, if lower bound is violated or if objective is NaN
       if (info != 0 || objTrial < obj_lo_ || objTrial > obj_up_
         || !(objTrial == objTrial) || !(cNormTrial == cNormTrial)) {
           // evaluation error, reduce stepsize
           reduceStepsize(m, &alpha);
           continue;
         }
  
       // Check acceptability to the filter
       if (pairInFilter(m, cNormTrial, objTrial)) {
         // Trial point is in the prohibited region defined by
         // the filter, try second order correction
         if (secondOrderCorrection(m, cNorm, cNormTrial, dfTdeltaXi, 0, k)) {
           break; // SOC yielded suitable alpha, stop
         } else {
           reduceStepsize(m, &alpha);
           continue;
         }
       }
  
       // Check sufficient decrease, case I:
       // If we are (almost) feasible and a "switching condition" is satisfied
       // require sufficient progress in the objective instead of bi-objective condition
       if (cNorm <= theta_min_) {
         // Switching condition, part 1: grad(f)^T * deltaXi < 0 ?
         if (dfTdeltaXi < 0)
           // Switching condition, part 2: alpha * (- grad(f)^T * deltaXi)**sF
           // > delta * cNorm**sTheta ?
           if (alpha * pow((-dfTdeltaXi), s_f_)
           > delta_ * pow(cNorm, s_theta_)) {
             // Switching conditions hold: Require satisfaction of Armijo condition for objective
             if (objTrial > m->obj + eta_*alpha*dfTdeltaXi) {
               // Armijo condition violated, try second order correction
               if (secondOrderCorrection(m, cNorm, cNormTrial, dfTdeltaXi, 1, k)) {
                 break; // SOC yielded suitable alpha, stop
               } else {
                 reduceStepsize(m, &alpha);
                 continue;
               }
             } else {
               // found suitable alpha, stop
               acceptStep(m, alpha);
               break;
             }
           }
       }
  
       // Check sufficient decrease, case II:
       // Bi-objective (filter) condition
       if (cNormTrial < (1.0 - gamma_theta_) * cNorm
       || objTrial < m->obj - gamma_f_ * cNorm) {
         // found suitable alpha, stop
         acceptStep(m, alpha);
         break;
       } else {
         // Trial point is dominated by current point, try second order correction
         if (secondOrderCorrection(m, cNorm, cNormTrial, dfTdeltaXi, 0, k)) {
           break; // SOC yielded suitable alpha, stop
         } else {
           reduceStepsize(m, &alpha);
           continue;
         }
       }
     }
  
     // No step could be found by the line search
     if (k == max_line_search_) return 1;
  
     // Augment the filter if switching condition or Armijo condition does not hold
     if (dfTdeltaXi >= 0) {
       augmentFilter(m, cNormTrial, objTrial);
     } else if (alpha * pow((-dfTdeltaXi), s_f_) > delta_ * pow(cNorm, s_theta_)) {
       // careful with neg. exponents!
       augmentFilter(m, cNormTrial, objTrial);
     } else if (objTrial <= m->obj + eta_*alpha*dfTdeltaXi) {
       augmentFilter(m, cNormTrial, objTrial);
     }
  
     return 0;
   }

References acceptStep(), augmentFilter(), casadi::NlpsolMemory::d_nlp, delta_, casadi::BlocksqpMemory::dxk, eta_, evaluate(), gamma_f_, gamma_theta_, casadi::BlocksqpMemory::gk, casadi::BlocksqpMemory::grad_fk, casadi::FunctionInternal::info(), lInfConstraintNorm(), max_line_search_, casadi::BlocksqpMemory::nFunCalls, casadi::Nlpsol::nx_, casadi::BlocksqpMemory::obj, obj_up_, pairInFilter(), reduceStepsize(), s_f_, s_theta_, secondOrderCorrection(), theta_min_, and casadi::BlocksqpMemory::trial_xk.

Referenced by run().

◆ finalize()

void casadi::OracleFunction::finalize ( )

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 122 of file oracle_function.cpp.

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

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

◆ find()

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

inlinevirtualinherited

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

Definition at line 371 of file function_internal.hpp.

371 {}

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

◆ format_time()

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

inherited

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

Definition at line 3772 of file function_internal.cpp.

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

References casadi::ProtoFunction::sprint().

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

◆ forward()

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

inherited

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

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

Definition at line 2079 of file function_internal.cpp.

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

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

◆ forward_name()

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

inlinestaticinherited

Definition at line 633 of file function_internal.hpp.

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

References casadi::str().

◆ free_mem()

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

inlineoverridevirtual

Reimplemented from casadi::Nlpsol.

Definition at line 183 of file blocksqp.hpp.

183 { delete static_cast<BlocksqpMemory*>(mem);}

◆ free_mx()

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

virtualinherited

Reimplemented in casadi::MXFunction.

Definition at line 3293 of file function_internal.cpp.

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

◆ free_sx()

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

virtualinherited

Reimplemented in casadi::SXFunction.

Definition at line 3297 of file function_internal.cpp.

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

◆ from_compact()

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

inherited

Definition at line 1844 of file function_internal.cpp.

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

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

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

◆ fullstep()

casadi_int casadi::Blocksqp::fullstep ( BlocksqpMemory * m ) const

Take a full Quasi-Newton step, except when integrator fails: xk = xk + deltaXi lambda = lambdaQP

Definition at line 1179 of file blocksqp.cpp.

                                                        {
     auto d_nlp = &m->d_nlp;
     double alpha;
     double objTrial, cNormTrial;
  
     // Backtracking line search
     alpha = 1.0;
     for (casadi_int k=0; k<10; k++) {
       // Compute new trial point
       for (casadi_int i=0; i<nx_; i++)
         m->trial_xk[i] = d_nlp->z[i] + alpha * m->dxk[i];
  
       // Compute problem functions at trial point
       casadi_int info = evaluate(m, m->trial_xk, &objTrial, m->gk);
       m->nFunCalls++;
       cNormTrial = lInfConstraintNorm(m, m->trial_xk, m->gk);
       // Reduce step if evaluation fails, if lower bound is violated
       // or if objective or a constraint is NaN
       if (info != 0 || objTrial < obj_lo_ || objTrial > obj_up_
         || !(objTrial == objTrial) || !(cNormTrial == cNormTrial)) {
         print("info=%i, objTrial=%g\n", info, objTrial);
         // evaluation error, reduce stepsize
         reduceStepsize(m, &alpha);
         continue;
       } else {
         acceptStep(m, alpha);
         return 0;
       }
     }
     return 1;
   }

References acceptStep(), casadi::NlpsolMemory::d_nlp, casadi::BlocksqpMemory::dxk, evaluate(), casadi::BlocksqpMemory::gk, casadi::FunctionInternal::info(), lInfConstraintNorm(), casadi::BlocksqpMemory::nFunCalls, casadi::Nlpsol::nx_, obj_up_, casadi::ProtoFunction::print(), reduceStepsize(), and casadi::BlocksqpMemory::trial_xk.

Referenced by run().

◆ fwd_seed()

template<typename MatType >

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

inherited

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

Definition at line 1496 of file function_internal.hpp.

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

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

◆ fwdViaJac()

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

virtualinherited

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

Definition at line 2909 of file function_internal.cpp.

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

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

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

◆ generate_dependencies()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 428 of file oracle_function.cpp.

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

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

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

◆ generate_in()

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

inherited

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

Definition at line 731 of file function_internal.cpp.

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

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

◆ generate_lifted()

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

virtualinherited

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

Reimplemented in casadi::MXFunction.

Definition at line 3301 of file function_internal.cpp.

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

◆ generate_options()

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

overridevirtualinherited

Reimplemented from casadi::ProtoFunction.

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

Definition at line 382 of file function_internal.cpp.

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

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

◆ generate_out()

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

inherited

Definition at line 747 of file function_internal.cpp.

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

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

◆ get_abstol()

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

inlinevirtualinherited

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

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

Definition at line 1094 of file function_internal.hpp.

                                       {
       return eps;
     }

References casadi::eps.

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

◆ get_default_in()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 204 of file nlpsol_impl.hpp.

204 { return nlpsol_default_in(ind);}

casadi::nlpsol_default_in

double nlpsol_default_in(casadi_int ind)

Default input for an NLP solver.

Definition: nlpsol.cpp:212

References casadi::nlpsol_default_in().

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

◆ get_diff_in()

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

inlinevirtualinherited

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

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

Definition at line 1111 of file function_internal.hpp.

1111 { return true; }

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

◆ get_diff_out()

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

inlinevirtualinherited

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

Reimplemented in casadi::GenericExternal.

Definition at line 1116 of file function_internal.hpp.

1116 { return true; }

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

◆ get_forward()

Function casadi::Nlpsol::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_1o2

Reimplemented from casadi::FunctionInternal.

Definition at line 868 of file nlpsol.cpp.

                                       {
     casadi_assert(detect_simple_bounds_is_simple_.empty(),
       "Simple bound detection not compatible with get_forward");
  
     // Symbolic expression for the input
     std::vector<MX> arg = mx_in(), res = mx_out();
  
     // Initial guesses not used for derivative calculations
     for (NlpsolInput i : {NLPSOL_X0, NLPSOL_LAM_X0, NLPSOL_LAM_G0}) {
       std::string name = arg[i].is_symbolic() ? arg[i].name() : "tmp_get_forward";
       arg[i] = MX::sym(name, Sparsity(arg[i].size()));
     }
  
     // Optimal solution
     MX x = res[NLPSOL_X];
     MX lam_g = res[NLPSOL_LAM_G];
     MX lam_x = res[NLPSOL_LAM_X];
     MX lam_p = res[NLPSOL_LAM_P];
     MX f = res[NLPSOL_F];
     MX g = res[NLPSOL_G];
  
     // Inputs used
     MX lbx = arg[NLPSOL_LBX];
     MX ubx = arg[NLPSOL_UBX];
     MX lbg = arg[NLPSOL_LBG];
     MX ubg = arg[NLPSOL_UBG];
     MX p = arg[NLPSOL_P];
  
     // Get KKT function
     Function kkt = this->kkt();
  
     // Hessian of the Lagrangian, Jacobian of the constraints
     std::vector<MX> HJ_res = kkt({x, p, 1, lam_g});
     MX JG = HJ_res.at(0);
     MX HL = HJ_res.at(1);
  
     // Active set (assumed known and given by the multiplier signs)
     MX ubIx = lam_x > min_lam_;
     MX lbIx = lam_x < -min_lam_;
     MX bIx = ubIx + lbIx;
     MX iIx = 1-bIx;
     MX ubIg = lam_g > min_lam_;
     MX lbIg = lam_g < -min_lam_;
     MX bIg = ubIg + lbIg;
     MX iIg = 1-bIg;
  
     // KKT matrix
     MX H_11 = mtimes(diag(iIx), HL) + diag(bIx);
     MX H_12 = mtimes(diag(iIx), JG.T());
     MX H_21 = mtimes(diag(bIg), JG);
     MX H_22 = diag(-iIg);
     MX H = MX::blockcat({{H_11, H_12}, {H_21, H_22}});
  
     // Sensitivity inputs
     std::vector<MX> fseed(NLPSOL_NUM_IN);
     MX fwd_lbx = fseed[NLPSOL_LBX] = MX::sym("fwd_lbx", repmat(x.sparsity(), 1, nfwd));
     MX fwd_ubx = fseed[NLPSOL_UBX] = MX::sym("fwd_ubx", repmat(x.sparsity(), 1, nfwd));
     MX fwd_lbg = fseed[NLPSOL_LBG] = MX::sym("fwd_lbg", repmat(g.sparsity(), 1, nfwd));
     MX fwd_ubg = fseed[NLPSOL_UBG] = MX::sym("fwd_ubg", repmat(g.sparsity(), 1, nfwd));
     MX fwd_p = fseed[NLPSOL_P] = MX::sym("fwd_p", repmat(p.sparsity(), 1, nfwd));
  
     // Guesses are unused
     for (NlpsolInput i : {NLPSOL_X0, NLPSOL_LAM_X0, NLPSOL_LAM_G0}) {
       fseed[i] = MX(repmat(Sparsity(arg[i].size()), 1, nfwd));
     }
  
     // nlp_grad has the signature
     // (x, p, lam_f, lam_g) -> (f, g, grad_x, grad_p)
     // with lam_f=1 and lam_g=lam_g, grad_x = -lam_x, grad_p=-lam_p
     Function nlp_grad = get_function("nlp_grad");
  
     // fwd_nlp_grad has the signature
     // (x, p, lam_f, lam_g, f, g, grad_x, grad_p,
     //  fwd_x, fwd_p, fwd_lam_f, fwd_lam_g)
     // -> (fwd_f, fwd_g, fwd_grad_x, fwd_grad_p)
     Function fwd_nlp_grad = nlp_grad.forward(nfwd);
  
     // Calculate sensitivities from fwd_p
     std::vector<MX> vv = {x, p, 1, lam_g, f, g, -lam_x, -lam_p, 0., fwd_p, 0., 0.};
     vv = fwd_nlp_grad(vv);
     MX fwd_g_p = vv.at(1);
     MX fwd_gL_p = vv.at(2);
  
     // Propagate forward seeds
     MX fwd_alpha_x = (if_else(lbIx, fwd_lbx, 0) + if_else(ubIx, fwd_ubx, 0))
                    - if_else(iIx, fwd_gL_p, 0);
     MX fwd_alpha_g = (if_else(ubIg, fwd_ubg, 0) + if_else(lbIg, fwd_lbg, 0))
                    - if_else(bIg, fwd_g_p, 0);
     MX v = MX::vertcat({fwd_alpha_x, fwd_alpha_g});
  
     // Solve
     v = MX::solve(H, v, sens_linsol_, sens_linsol_options_);
  
     // Extract sensitivities in x, lam_x and lam_g
     std::vector<MX> v_split = vertsplit(v, {0, nx_, nx_+ng_});
     MX fwd_x = v_split.at(0);
     MX fwd_lam_g = v_split.at(1);
  
     // Calculate sensitivities in lam_x, lam_g
     vv = {x, p, 1, lam_g, f, g, -lam_x, -lam_p,
           fwd_x, fwd_p, 0, fwd_lam_g};
     vv = fwd_nlp_grad(vv);
     MX fwd_f = vv.at(0);
     MX fwd_g = vv.at(1);
     MX fwd_lam_x = -vv.at(2);
     MX fwd_lam_p = -vv.at(3);
  
     // Forward sensitivities
     std::vector<MX> fsens(NLPSOL_NUM_OUT);
     fsens[NLPSOL_X] = fwd_x;
     fsens[NLPSOL_F] = fwd_f;
     fsens[NLPSOL_G] = fwd_g;
     fsens[NLPSOL_LAM_X] = fwd_lam_x;
     fsens[NLPSOL_LAM_G] = fwd_lam_g;
     fsens[NLPSOL_LAM_P] = fwd_lam_p;
  
     // Gather return values
     arg.insert(arg.end(), res.begin(), res.end());
     arg.insert(arg.end(), fseed.begin(), fseed.end());
     res = fsens;
  
     Dict options = opts;
     options["allow_duplicate_io_names"] = true;
  
     return Function(name, arg, res, inames, onames, options);
   }

References casadi::MX::blockcat(), casadi::Nlpsol::detect_simple_bounds_is_simple_, casadi::Function::forward(), casadi::FunctionInternal::Function, casadi::OracleFunction::get_function(), casadi::if_else(), casadi::Nlpsol::kkt(), casadi::Nlpsol::min_lam_, casadi::FunctionInternal::mx_in(), casadi::FunctionInternal::mx_out(), casadi::Nlpsol::ng_, casadi::NLPSOL_F, casadi::NLPSOL_G, casadi::NLPSOL_LAM_G, casadi::NLPSOL_LAM_G0, casadi::NLPSOL_LAM_P, casadi::NLPSOL_LAM_X, casadi::NLPSOL_LAM_X0, casadi::NLPSOL_LBG, casadi::NLPSOL_LBX, casadi::NLPSOL_NUM_IN, casadi::NLPSOL_NUM_OUT, casadi::NLPSOL_P, casadi::NLPSOL_UBG, casadi::NLPSOL_UBX, casadi::NLPSOL_X, casadi::NLPSOL_X0, casadi::Nlpsol::nx_, casadi::Nlpsol::sens_linsol_, casadi::Nlpsol::sens_linsol_options_, casadi::MX::solve(), casadi::MX::sparsity(), casadi::GenericMatrix< MX >::sym(), and casadi::MX::vertcat().

◆ get_free()

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

virtualinherited

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

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

Definition at line 936 of file function_internal.cpp.

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

References casadi::FunctionInternal::has_free().

◆ get_function() [1/2]

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

overridevirtualinherited

-1 Indicates irregularity

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

Reimplemented from casadi::FunctionInternal.

Definition at line 531 of file oracle_function.cpp.

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

References casadi::OracleFunction::all_functions_.

Referenced by casadi::Rootfinder::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::OracleFunction::calc_function(), casadi::OracleFunction::calc_sp_forward(), casadi::OracleFunction::calc_sp_reverse(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::codegen_declarations(), casadi::FatropInterface::codegen_declarations(), casadi::IpoptInterface::codegen_declarations(), casadi::MadnlpInterface::codegen_declarations(), casadi::FastNewton::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), 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(), init(), casadi::BonminInterface::init(), casadi::FatropInterface::init(), casadi::IpoptInterface::init(), casadi::MadnlpInterface::init(), casadi::SLEQPInterface::init(), casadi::SundialsInterface::init(), casadi::FastNewton::init(), casadi::Feasiblesqpmethod::init(), casadi::Sqpmethod::init(), casadi::OracleFunction::monitored(), casadi::FatropInterface::set_fatrop_prob(), casadi::IpoptInterface::set_ipopt_prob(), casadi::MadnlpInterface::set_madnlp_prob(), casadi::SundialsInterface::set_work(), casadi::Collocation::setup_step(), casadi::RungeKutta::setup_step(), casadi::Integrator::sp_jac_dae(), and casadi::Integrator::sp_jac_rdae().

◆ get_function() [2/2]

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 540 of file oracle_function.cpp.

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

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

◆ get_jac_sparsity()

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

virtualinherited

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

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

Definition at line 1787 of file function_internal.cpp.

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

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

◆ get_jac_sparsity_gen()

template<bool fwd>

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

inherited

Definition at line 1132 of file function_internal.cpp.

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

◆ get_jac_sparsity_hierarchical()

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

inherited

Decide which ad_mode to take

Definition at line 1472 of file function_internal.cpp.

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

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

◆ get_jac_sparsity_hierarchical_symm()

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

inherited

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

Definition at line 1237 of file function_internal.cpp.

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

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

◆ get_jacobian()

Function casadi::FunctionInternal::get_jacobian	(	const std::string &	name,
		const std::vector< std::string > &	inames,
		const std::vector< std::string > &	onames,
		const Dict &	opts
	)		const

virtualinherited

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

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

Definition at line 2298 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

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

◆ get_max_in()

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

inlinevirtualinherited

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

Definition at line 1065 of file function_internal.hpp.

                                                     {
       return inf;
     }

References casadi::inf.

◆ get_min_in()

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

inlinevirtualinherited

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

Definition at line 1072 of file function_internal.hpp.

                                                     {
       return -inf;
     }

References casadi::inf.

◆ get_n_in()

size_t casadi::Nlpsol::get_n_in ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 145 of file nlpsol_impl.hpp.

145 { return NLPSOL_NUM_IN;}

References casadi::NLPSOL_NUM_IN.

◆ get_n_out()

size_t casadi::Nlpsol::get_n_out ( )

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 146 of file nlpsol_impl.hpp.

146 { return NLPSOL_NUM_OUT;}

References casadi::NLPSOL_NUM_OUT.

◆ get_name_in()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 161 of file nlpsol_impl.hpp.

161 { return nlpsol_in(i);}

casadi::nlpsol_in

std::vector< std::string > nlpsol_in()

Get input scheme of NLP solvers.

Definition: nlpsol.cpp:200

References casadi::nlpsol_in().

◆ get_name_out()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 162 of file nlpsol_impl.hpp.

162 { return nlpsol_out(i);}

casadi::nlpsol_out

std::vector< std::string > nlpsol_out()

Get NLP solver output scheme of NLP solvers.

Definition: nlpsol.cpp:206

References casadi::nlpsol_out().

◆ get_nominal_in()

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

inlinevirtualinherited

Reimplemented in casadi::FmuFunction.

Definition at line 1076 of file function_internal.hpp.

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

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

◆ get_nominal_out()

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

inlinevirtualinherited

Reimplemented in casadi::FmuFunction.

Definition at line 1080 of file function_internal.hpp.

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

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

◆ get_options()

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

inlineoverridevirtual

Reimplemented from casadi::Nlpsol.

Definition at line 170 of file blocksqp.hpp.

170 { return options_;}

casadi::Blocksqp::options_

static const Options options_

Options.

Definition: blocksqp.hpp:169

◆ get_partition()

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

inherited

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

Definition at line 1927 of file function_internal.cpp.

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

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

◆ get_reltol()

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

inlinevirtualinherited

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

Reimplemented in casadi::SundialsInterface.

Definition at line 1087 of file function_internal.hpp.

                                       {
       return eps;
     }

References casadi::eps.

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

◆ get_reverse()

Function casadi::Nlpsol::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_1o3

Reimplemented from casadi::FunctionInternal.

Definition at line 999 of file nlpsol.cpp.

                                       {
     casadi_assert(detect_simple_bounds_is_simple_.empty(),
       "Simple bound detection not compatible with get_reverse");
  
     // Symbolic expression for the input
     std::vector<MX> arg = mx_in(), res = mx_out();
  
     // Initial guesses not used for derivative calculations
     for (NlpsolInput i : {NLPSOL_X0, NLPSOL_LAM_X0, NLPSOL_LAM_G0}) {
       std::string name = arg[i].is_symbolic() ? arg[i].name() : "tmp_get_reverse";
       arg[i] = MX::sym(name, Sparsity(arg[i].size()));
     }
  
     // Optimal solution
     MX x = res[NLPSOL_X];
     MX lam_g = res[NLPSOL_LAM_G];
     MX lam_x = res[NLPSOL_LAM_X];
     MX lam_p = res[NLPSOL_LAM_P];
     MX f = res[NLPSOL_F];
     MX g = res[NLPSOL_G];
  
     // Inputs used
     MX lbx = arg[NLPSOL_LBX];
     MX ubx = arg[NLPSOL_UBX];
     MX lbg = arg[NLPSOL_LBG];
     MX ubg = arg[NLPSOL_UBG];
     MX p = arg[NLPSOL_P];
  
     // Get KKT function
     Function kkt = this->kkt();
  
     // Hessian of the Lagrangian, Jacobian of the constraints
     std::vector<MX> HJ_res = kkt({x, p, 1, lam_g});
     MX JG = HJ_res.at(0);
     MX HL = HJ_res.at(1);
  
     // Active set (assumed known and given by the multiplier signs)
     MX ubIx = lam_x > min_lam_;
     MX lbIx = lam_x < -min_lam_;
     MX bIx = ubIx + lbIx;
     MX iIx = 1-bIx;
     MX ubIg = lam_g > min_lam_;
     MX lbIg = lam_g < -min_lam_;
     MX bIg = ubIg + lbIg;
     MX iIg = 1-bIg;
  
     // KKT matrix
     MX H_11 = mtimes(diag(iIx), HL) + diag(bIx);
     MX H_12 = mtimes(diag(iIx), JG.T());
     MX H_21 = mtimes(diag(bIg), JG);
     MX H_22 = diag(-iIg);
     MX H = MX::blockcat({{H_11, H_12}, {H_21, H_22}});
  
     // Sensitivity inputs
     std::vector<MX> aseed(NLPSOL_NUM_OUT);
     MX adj_x = aseed[NLPSOL_X] = MX::sym("adj_x", repmat(x.sparsity(), 1, nadj));
     MX adj_lam_g = aseed[NLPSOL_LAM_G] = MX::sym("adj_lam_g", repmat(g.sparsity(), 1, nadj));
     MX adj_lam_x = aseed[NLPSOL_LAM_X] = MX::sym("adj_lam_x", repmat(x.sparsity(), 1, nadj));
     MX adj_lam_p = aseed[NLPSOL_LAM_P] = MX::sym("adj_lam_p", repmat(p.sparsity(), 1, nadj));
     MX adj_f = aseed[NLPSOL_F] = MX::sym("adj_f", Sparsity::dense(1, nadj));
     MX adj_g = aseed[NLPSOL_G] = MX::sym("adj_g", repmat(g.sparsity(), 1, nadj));
  
     // nlp_grad has the signature
     // (x, p, lam_f, lam_g) -> (f, g, grad_x, grad_p)
     // with lam_f=1 and lam_g=lam_g, grad_x = -lam_x, grad_p=-lam_p
     Function nlp_grad = get_function("nlp_grad");
  
     // rev_nlp_grad has the signature
     // (x, p, lam_f, lam_g, f, g, grad_x, grad_p,
     //  adj_f, adj_g, adj_grad_x, adj_grad_p)
     // -> (adj_x, adj_p, adj_lam_f, adj_lam_g)
     Function rev_nlp_grad = nlp_grad.reverse(nadj);
  
     // Calculate sensitivities from f, g and lam_x
     std::vector<MX> vv = {x, p, 1, lam_g, f, g, -lam_x, -lam_p,
                      adj_f, adj_g, -adj_lam_x, -adj_lam_p};
     vv = rev_nlp_grad(vv);
     MX adj_x0 = vv.at(0);
     MX adj_p0 = vv.at(1);
     MX adj_lam_g0 = vv.at(3);
  
     // Solve to get beta_x_bar, beta_g_bar
     MX v = MX::vertcat({adj_x + adj_x0, adj_lam_g + adj_lam_g0});
     v = MX::solve(H.T(), v, sens_linsol_, sens_linsol_options_);
     std::vector<MX> v_split = vertsplit(v, {0, nx_, nx_+ng_});
     MX beta_x_bar = v_split.at(0);
     MX beta_g_bar = v_split.at(1);
  
     // Calculate sensitivities in p
     vv = {x, p, 1, lam_g, f, g, -lam_x, -lam_p,
           0, bIg*beta_g_bar, iIx*beta_x_bar, 0};
     vv = rev_nlp_grad(vv);
     MX adj_p = vv.at(1);
  
     // Reverse sensitivities
     std::vector<MX> asens(NLPSOL_NUM_IN);
     asens[NLPSOL_UBX] = if_else(ubIx, beta_x_bar, 0);
     asens[NLPSOL_LBX] = if_else(lbIx, beta_x_bar, 0);
     asens[NLPSOL_UBG] = if_else(ubIg, beta_g_bar, 0);
     asens[NLPSOL_LBG] = if_else(lbIg, beta_g_bar, 0);
     asens[NLPSOL_P] = adj_p0 - adj_p;
  
     // Guesses are unused
     for (NlpsolInput i : {NLPSOL_X0, NLPSOL_LAM_X0, NLPSOL_LAM_G0}) {
       asens[i] = MX(repmat(Sparsity(arg[i].size()), 1, nadj));
     }
  
     // Gather return values
     arg.insert(arg.end(), res.begin(), res.end());
     arg.insert(arg.end(), aseed.begin(), aseed.end());
     res = asens;
  
     Dict options = opts;
     options["allow_duplicate_io_names"] = true;
  
     return Function(name, arg, res, inames, onames, options);
   }

References casadi::MX::blockcat(), casadi::Sparsity::dense(), casadi::Nlpsol::detect_simple_bounds_is_simple_, casadi::FunctionInternal::Function, casadi::OracleFunction::get_function(), casadi::if_else(), casadi::Nlpsol::kkt(), casadi::Nlpsol::min_lam_, casadi::FunctionInternal::mx_in(), casadi::FunctionInternal::mx_out(), casadi::Nlpsol::ng_, casadi::NLPSOL_F, casadi::NLPSOL_G, casadi::NLPSOL_LAM_G, casadi::NLPSOL_LAM_G0, casadi::NLPSOL_LAM_P, casadi::NLPSOL_LAM_X, casadi::NLPSOL_LAM_X0, casadi::NLPSOL_LBG, casadi::NLPSOL_LBX, casadi::NLPSOL_NUM_IN, casadi::NLPSOL_NUM_OUT, casadi::NLPSOL_P, casadi::NLPSOL_UBG, casadi::NLPSOL_UBX, casadi::NLPSOL_X, casadi::NLPSOL_X0, casadi::Nlpsol::nx_, casadi::Function::reverse(), casadi::Nlpsol::sens_linsol_, casadi::Nlpsol::sens_linsol_options_, casadi::MX::solve(), casadi::MX::sparsity(), casadi::GenericMatrix< MX >::sym(), casadi::MX::T(), and casadi::MX::vertcat().

◆ get_sparsity_in()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 294 of file nlpsol.cpp.

                                                {
     switch (static_cast<NlpsolInput>(i)) {
     case NLPSOL_X0:
     case NLPSOL_LBX:
     case NLPSOL_UBX:
     case NLPSOL_LAM_X0:
       return get_sparsity_out(NLPSOL_X);
     case NLPSOL_LBG:
     case NLPSOL_UBG:
     case NLPSOL_LAM_G0:
       return get_sparsity_out(NLPSOL_G);
     case NLPSOL_P:
       return oracle_.sparsity_in(NL_P);
     case NLPSOL_NUM_IN: break;
     }
     return Sparsity();
   }

References casadi::Nlpsol::get_sparsity_out(), casadi::NL_P, casadi::NLPSOL_G, casadi::NLPSOL_LAM_G0, casadi::NLPSOL_LAM_X0, casadi::NLPSOL_LBG, casadi::NLPSOL_LBX, casadi::NLPSOL_NUM_IN, casadi::NLPSOL_P, casadi::NLPSOL_UBG, casadi::NLPSOL_UBX, casadi::NLPSOL_X, casadi::NLPSOL_X0, casadi::OracleFunction::oracle_, and casadi::Function::sparsity_in().

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

◆ get_sparsity_out()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 312 of file nlpsol.cpp.

                                                 {
     switch (static_cast<NlpsolOutput>(i)) {
     case NLPSOL_F:
       return oracle_.sparsity_out(NL_F);
     case NLPSOL_X:
     case NLPSOL_LAM_X:
       return oracle_.sparsity_in(NL_X);
     case NLPSOL_LAM_G:
     case NLPSOL_G:
       if (detect_simple_bounds_is_simple_.empty()) {
         return oracle_.sparsity_out(NL_G);
       } else {
         return Sparsity::dense(detect_simple_bounds_is_simple_.size());
       }
     case NLPSOL_LAM_P:
       return get_sparsity_in(NLPSOL_P);
     case NLPSOL_NUM_OUT: break;
     }
     return Sparsity();
   }

References casadi::Sparsity::dense(), casadi::Nlpsol::detect_simple_bounds_is_simple_, casadi::Nlpsol::get_sparsity_in(), casadi::NL_F, casadi::NL_G, casadi::NL_X, casadi::NLPSOL_F, casadi::NLPSOL_G, casadi::NLPSOL_LAM_G, casadi::NLPSOL_LAM_P, casadi::NLPSOL_LAM_X, casadi::NLPSOL_NUM_OUT, casadi::NLPSOL_P, casadi::NLPSOL_X, casadi::OracleFunction::oracle_, casadi::Function::sparsity_in(), and casadi::Function::sparsity_out().

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

◆ get_stats()

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

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

Definition at line 1162 of file nlpsol.cpp.

                                         {
     Dict stats = OracleFunction::get_stats(mem);
     auto m = static_cast<NlpsolMemory*>(mem);
     casadi_assert(m->d_nlp.prob,
       "No stats available: nlp Solver instance has not yet been called with numerical arguments.");
     auto d_nlp = &m->d_nlp;
     stats["success"] = m->success;
     stats["unified_return_status"] = string_from_UnifiedReturnStatus(m->unified_return_status);
     if (d_nlp->prob && d_nlp->prob->detect_bounds.ng) {
       std::vector<bool> is_simple;
       assign_vector(detect_simple_bounds_is_simple_, is_simple);
       stats["detect_simple_bounds_is_simple"] = is_simple;
       stats["detect_simple_bounds_target_x"] = detect_simple_bounds_target_x_;
     }
     return stats;
   }

References casadi::assign_vector(), casadi::Nlpsol::detect_simple_bounds_is_simple_, casadi::Nlpsol::detect_simple_bounds_target_x_, casadi::OracleFunction::get_stats(), and casadi::FunctionInternal::string_from_UnifiedReturnStatus().

Referenced by casadi::AlpaqaInterface::get_stats(), casadi::BonminInterface::get_stats(), casadi::FatropInterface::get_stats(), casadi::IpoptInterface::get_stats(), casadi::KnitroInterface::get_stats(), casadi::MadnlpInterface::get_stats(), casadi::SLEQPInterface::get_stats(), casadi::SnoptInterface::get_stats(), casadi::WorhpInterface::get_stats(), casadi::Feasiblesqpmethod::get_stats(), casadi::Qrsqp::get_stats(), casadi::Scpgen::get_stats(), and casadi::Sqpmethod::get_stats().

◆ getAdaptorSolverName()

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

inlinevirtualinherited

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

Definition at line 304 of file function_internal.hpp.

304 { return ""; }

◆ getCount()

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

inherited

Definition at line 60 of file generic_shared_internal.hpp.

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

◆ getPlugin()

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

◆ getReducedHessian()

DM casadi::Nlpsol::getReducedHessian ( )

virtualinherited

Definition at line 669 of file nlpsol.cpp.

                                {
     casadi_error("getReducedHessian not defined for class " + class_name());
     return DM();
   }

References casadi::Nlpsol::class_name().

◆ has_codegen()

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

inlinevirtualinherited

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

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

Definition at line 909 of file function_internal.hpp.

909 { return false;}

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

◆ has_derivative()

bool casadi::FunctionInternal::has_derivative ( ) const

inherited

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

Definition at line 2905 of file function_internal.cpp.

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

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

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

◆ has_eval_dm()

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

inlinevirtualinherited

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

Reimplemented in casadi::CallbackInternal.

Definition at line 419 of file function_internal.hpp.

419 { return false;}

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

◆ has_forward()

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

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 248 of file nlpsol_impl.hpp.

248 { return true;}

◆ has_free()

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

inlinevirtualinherited

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

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

Definition at line 738 of file function_internal.hpp.

738 { return false;}

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

◆ has_function()

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

overridevirtualinherited

Reimplemented from casadi::FunctionInternal.

Definition at line 556 of file oracle_function.cpp.

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

References casadi::OracleFunction::all_functions_.

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

◆ has_jac_sparsity()

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

inlinevirtualinherited

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

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

Definition at line 628 of file function_internal.hpp.

628 { return false;}

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

◆ has_jacobian()

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

inlinevirtualinherited

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

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

Definition at line 615 of file function_internal.hpp.

615 { return false;}

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

◆ has_memory()

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

inherited

Definition at line 3581 of file function_internal.cpp.

                                               {
     return ind<mem_.size();
   }

◆ has_option()

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

inherited

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

Definition at line 920 of file function_internal.cpp.

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

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

◆ has_plugin()

bool casadi::PluginInterface< Nlpsol >::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::Nlpsol::has_reverse ( casadi_int nadj ) const

inlineoverridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 259 of file nlpsol_impl.hpp.

259 { return true;}

◆ has_spfwd()

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

inlinevirtualinherited

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

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

Definition at line 389 of file function_internal.hpp.

389 { return false;}

Referenced by casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::FunctionInternal::jac_sparsity(), and casadi::FunctionInternal::sp_weight().

◆ has_sprev()

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

inlinevirtualinherited

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

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

Definition at line 390 of file function_internal.hpp.

390 { return false;}

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

◆ incache()

bool casadi::FunctionInternal::incache	(	const std::string &	fname,
		Function &	f,
		const std::string &	suffix = `""`
	)		const

inherited

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

Definition at line 994 of file function_internal.cpp.

                                      {
     return cache_.incache(fname + ":" + suffix, f);
   }

References casadi::FunctionInternal::cache_.

Referenced by casadi::MapSum::create(), casadi::OracleFunction::create_function(), casadi::FunctionInternal::forward(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::map(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::wrap().

◆ index_in()

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

inlineinherited

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

Definition at line 1121 of file function_internal.hpp.

                                                      {
       for (casadi_int i=0; i<name_in_.size(); ++i) {
         if (name_in_[i]==name) return i;
       }
       casadi_error("FunctionInternal::index_in: could not find entry \""
                    + name + "\". Available names are: " + str(name_in_) + ".");
       return -1;
     }

References casadi::str().

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

◆ index_out()

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

inlineinherited

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

Definition at line 1133 of file function_internal.hpp.

                                                       {
       for (casadi_int i=0; i<name_out_.size(); ++i) {
         if (name_out_[i]==name) return i;
       }
       casadi_error("FunctionInternal::index_out: could not find entry \""
                    + name + "\". Available names are: " + str(name_out_) + ".");
       return -1;
     }

References casadi::str().

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

◆ info()

Dict casadi::FunctionInternal::info ( ) const

virtualinherited

Obtain information about function

Reimplemented in casadi::Switch, and casadi::Map.

Definition at line 2941 of file function_internal.cpp.

                                     {
     return Dict();
   }

Referenced by casadi::MXFunction::export_code_body(), feasibilityRestorationPhase(), filterLineSearch(), fullstep(), casadi::BSplineInterpolant::init(), kktErrorReduction(), casadi::Feasiblesqpmethod::print_iteration(), casadi::Sqpmethod::print_iteration(), secondOrderCorrection(), casadi::SnoptInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Sqpmethod::solve(), and casadi::Sqpmethod::solve_elastic_mode().

◆ init()

void casadi::Blocksqp::init ( const Dict & opts )

overridevirtual

Reimplemented from casadi::Nlpsol.

Definition at line 231 of file blocksqp.cpp.

                                       {
     // Call the init method of the base class
     Nlpsol::init(opts);
  
     // Set default options
     //string qpsol_plugin = "qpoases";
     //Dict qpsol_options;
     linsol_plugin_ = "ma27";
     print_header_ = true;
     print_iteration_ = true;
     eps_ = 1.0e-16;
     opttol_ = 1.0e-6;
     nlinfeastol_ = 1.0e-6;
     schur_ = true;
     globalization_ = true;
     restore_feas_ = true;
     max_line_search_ = 20;
     max_consec_reduced_steps_ = 100;
     max_consec_skipped_updates_ = 100;
     max_iter_ = 100;
     warmstart_ = false;
     max_it_qp_ = 5000;
     block_hess_ = true;
     hess_scaling_ = 2;
     fallback_scaling_ = 4;
     max_time_qp_ = 10000.0;
     ini_hess_diag_ = 1.0;
     col_eps_ = 0.1;
     col_tau1_ = 0.5;
     col_tau2_ = 1.0e4;
     hess_damp_ = 1;
     hess_damp_fac_ = 0.2;
     hess_update_ = 1;
     fallback_update_ = 2;
     hess_lim_mem_ = 1;
     hess_memsize_ = 20;
     which_second_derv_ = 0;
     skip_first_globalization_ = false;
     conv_strategy_ = 0;
     max_conv_qp_ = 1;
     max_soc_iter_ = 3;
     gamma_theta_ = 1.0e-5;
     gamma_f_ = 1.0e-5;
     kappa_soc_ = 0.99;
     kappa_f_ = 0.999;
     theta_max_ = 1.0e7;
     theta_min_ = 1.0e-5;
     delta_ = 1.0;
     s_theta_ = 1.1;
     s_f_ = 2.3;
     kappa_minus_ = 0.333;
     kappa_plus_ = 8.0;
     kappa_plus_max_ = 100.0;
     delta_h0_ = 1.0e-4;
     eta_ = 1.0e-4;
     obj_lo_ = -inf;
     obj_up_ = inf;
     rho_ = 1.0e3;
     zeta_ = 1.0e-3;
     print_maxit_reached_ = true;
     qp_init_ = true;
  
     // Read user options
     for (auto&& op : opts) {
       if (op.first=="qpsol") {
         //qpsol_plugin = op.second.to_string();
         casadi_warning("Option 'qpsol' currently not supported, ignored");
       } else if (op.first=="qpsol_options") {
         //qpsol_options = op.second;
         casadi_warning("Option 'qpsol_options' currently not supported, ignored");
       } else if (op.first=="linsol") {
         linsol_plugin_ = std::string(op.second);
       } else if (op.first=="print_header") {
         print_header_ = op.second;
       } else if (op.first=="print_iteration") {
           print_iteration_ = op.second;
       } else if (op.first=="eps") {
         eps_ = op.second;
       } else if (op.first=="opttol") {
         opttol_ = op.second;
       } else if (op.first=="nlinfeastol") {
         nlinfeastol_ = op.second;
       } else if (op.first=="schur") {
         schur_ = op.second;
       } else if (op.first=="globalization") {
         globalization_ = op.second;
       } else if (op.first=="restore_feas") {
         restore_feas_ = op.second;
       } else if (op.first=="max_line_search") {
         max_line_search_ = op.second;
       } else if (op.first=="max_consec_reduced_steps") {
         max_consec_reduced_steps_ = op.second;
       } else if (op.first=="max_consec_skipped_updates") {
         max_consec_skipped_updates_ = op.second;
       } else if (op.first=="max_iter") {
         max_iter_ = op.second;
       } else if (op.first=="warmstart") {
         warmstart_ = op.second;
       } else if (op.first=="qp_init") {
         qp_init_ = op.second;
       } else if (op.first=="max_it_qp") {
         max_it_qp_ = op.second;
       } else if (op.first=="block_hess") {
         block_hess_ = op.second;
       } else if (op.first=="hess_scaling") {
         hess_scaling_ = op.second;
       } else if (op.first=="fallback_scaling") {
         fallback_scaling_ = op.second;
       } else if (op.first=="max_time_qp") {
         max_time_qp_ = op.second;
       } else if (op.first=="ini_hess_diag") {
         ini_hess_diag_ = op.second;
       } else if (op.first=="col_eps") {
         col_eps_ = op.second;
       } else if (op.first=="col_tau1") {
         col_tau1_ = op.second;
       } else if (op.first=="col_tau2") {
         col_tau2_ = op.second;
       } else if (op.first=="hess_damp") {
         hess_damp_ = op.second;
       } else if (op.first=="hess_damp_fac") {
         hess_damp_fac_ = op.second;
       } else if (op.first=="hess_update") {
         hess_update_ = op.second;
       } else if (op.first=="fallback_update") {
         fallback_update_ = op.second;
       } else if (op.first=="hess_lim_mem") {
         hess_lim_mem_ = op.second;
       } else if (op.first=="hess_memsize") {
         hess_memsize_ = op.second;
       } else if (op.first=="which_second_derv") {
         which_second_derv_ = op.second;
       } else if (op.first=="skip_first_globalization") {
         skip_first_globalization_ = op.second;
       } else if (op.first=="conv_strategy") {
         conv_strategy_ = op.second;
       } else if (op.first=="max_conv_qp") {
         max_conv_qp_ = op.second;
       } else if (op.first=="max_soc_iter") {
         max_soc_iter_ = op.second;
       } else if (op.first=="gamma_theta") {
         gamma_theta_ = op.second;
       } else if (op.first=="gamma_f") {
         gamma_f_ = op.second;
       } else if (op.first=="kappa_soc") {
         kappa_soc_ = op.second;
       } else if (op.first=="kappa_f") {
         kappa_f_ = op.second;
       } else if (op.first=="theta_max") {
         theta_max_ = op.second;
       } else if (op.first=="theta_min") {
         theta_min_ = op.second;
       } else if (op.first=="delta") {
         delta_ = op.second;
       } else if (op.first=="s_theta") {
         s_theta_ = op.second;
       } else if (op.first=="s_f") {
         s_f_ = op.second;
       } else if (op.first=="kappa_minus") {
         kappa_minus_ = op.second;
       } else if (op.first=="kappa_plus") {
         kappa_plus_ = op.second;
       } else if (op.first=="kappa_plus_max") {
         kappa_plus_max_ = op.second;
       } else if (op.first=="delta_h0") {
         delta_h0_ = op.second;
       } else if (op.first=="eta") {
         eta_ = op.second;
       } else if (op.first=="obj_lo") {
         obj_lo_ = op.second;
       } else if (op.first=="obj_up") {
         obj_up_ = op.second;
       } else if (op.first=="rho") {
         rho_ = op.second;
       } else if (op.first=="zeta") {
         zeta_ = op.second;
       } else if (op.first=="print_maxit_reached") {
         print_maxit_reached_ = op.second;
       }
     }
  
     // If we compute second constraints derivatives switch to
     // finite differences Hessian (convenience)
     if (which_second_derv_ == 2) {
       hess_update_ = 4;
       block_hess_ = true;
     }
  
     // If we don't use limited memory BFGS we need to store only one vector.
     if (!hess_lim_mem_) hess_memsize_ = 1;
     if (!schur_ && hess_update_ == 1) {
       print("***WARNING: SR1 update only works with qpOASES Schur complement version. "
              "Using BFGS updates instead.\n");
       hess_update_ = 2;
       hess_scaling_ = fallback_scaling_;
     }
  
     // Setup feasibility restoration phase
     if (restore_feas_) {
       // get orignal nlp
       Function nlp = oracle_;
       std::vector<MX> resv;
       std::vector<MX> argv = nlp.mx_in();
  
       // build fesibility restoration phase nlp
       MX p = MX::sym("p", nlp.size1_in("x"));
       MX s = MX::sym("s", nlp.size1_out("g"));
  
       MX d = fmin(1.0, 1.0/abs(p)) * (argv.at(0) - p);
       MX f_rp = 0.5 * rho_ * dot(s, s) + zeta_/2.0 * dot(d, d);
       MX g_rp = nlp(argv).at(1) - s;
  
       MXDict nlp_rp = {{"x", MX::vertcat({argv.at(0), s})},
                        {"p", MX::vertcat({argv.at(1), p})},
                        {"f", f_rp},
                        {"g", g_rp}};
  
       // Set options for the SQP method for the restoration problem
       Dict solver_options;
       solver_options["globalization"] = true;
       solver_options["which_second_derv"] = 0;
       solver_options["restore_feas"] = false;
       solver_options["hess_update"] = 2;
       solver_options["hess_lim_mem"] = 1;
       solver_options["hess_scaling"] = 2;
       solver_options["opttol"] = opttol_;
       solver_options["nlinfeastol"] = nlinfeastol_;
       solver_options["max_iter"] = 1;
       solver_options["print_time"] = false;
       solver_options["print_header"] = false;
       solver_options["print_iteration"] = false;
       solver_options["print_maxit_reached"] = false;
  
       // Create and initialize solver for the restoration problem
       rp_solver_ = nlpsol("rpsolver", "blocksqp", nlp_rp, solver_options);
     }
  
     // Setup NLP functions
     create_function("nlp_fg", {"x", "p"}, {"f", "g"});
     Function gf_jg = create_function("nlp_gf_jg", {"x", "p"},
                                      {"f", "g", "grad:f:x", "jac:g:x"});
     Asp_ = gf_jg.sparsity_out("jac_g_x");
  
     if (!block_hess_) {
       // No block-structured Hessian
       blocks_ = {0, nx_};
       which_second_derv_ = 0;
       Hsp_ = Sparsity::dense(nx_, nx_);
     } else {
       // Detect block structure
  
       // Get the sparsity pattern for the Hessian of the Lagrangian
       Function grad_lag = oracle_.factory("grad_lag",
                                           {"x", "p", "lam:f", "lam:g"}, {"grad:gamma:x"},
                                           {{"gamma", {"f", "g"}}});
       Hsp_ = grad_lag.sparsity_jac("x", "grad_gamma_x", false, true);
  
       // Make sure diagonal exists
       Hsp_ = Hsp_ + Sparsity::diag(nx_);
  
       // Find the strongly connected components of the Hessian
       // Unlike Sparsity::scc, assume ordered
       const casadi_int* colind = Hsp_.colind();
       const casadi_int* row = Hsp_.row();
       blocks_.push_back(0);
       casadi_int ind = 0;
       while (ind < nx_) {
         // Find the next cutoff
         casadi_int next=ind+1;
         while (ind<next && ind<nx_) {
           for (casadi_int k=colind[ind]; k<colind[ind+1]; ++k) next = std::max(next, 1+row[k]);
           ind++;
         }
         blocks_.push_back(next);
       }
     }
  
     // Number of blocks
     nblocks_ = blocks_.size()-1;
  
     // Blocksizes
     dim_.resize(nblocks_);
     casadi_int max_size = 0;
     nnz_H_ = 0;
     for (casadi_int i=0; i<nblocks_; ++i) {
       dim_[i] = blocks_[i+1]-blocks_[i];
       max_size = std::max(max_size, dim_[i]);
       nnz_H_ += dim_[i]*dim_[i];
     }
  
     create_function("nlp_hess_l", {"x", "p", "lam:f", "lam:g"},
                     {"triu:hess:gamma:x:x"}, {{"gamma", {"f", "g"}}});
     exact_hess_lag_sp_ = get_function("nlp_hess_l").sparsity_out(0);
  
     if (verbose_) casadi_message(str(nblocks_) + " blocks of max size " + str(max_size) + ".");
  
     // Allocate a QP solver
     //casadi_assert(!qpsol_plugin.empty(), "'qpsol' option has not been set");
     //qpsol_ = conic("qpsol", qpsol_plugin, {{"h", Hsp_}, {"a", Asp_}},
     //               qpsol_options);
     //alloc(qpsol_);
  
     // Allocate memory
     alloc_w(Asp_.nnz(), true); // jac
     alloc_w(nx_, true); // lam_xk
     alloc_w(ng_, true); // lam_gk
     alloc_w(ng_, true); // gk
     alloc_w(nx_, true); // grad_fk
     alloc_w(nx_, true); // grad_lagk
     alloc_w(nx_+ng_, true); // lam_qp
     alloc_w(nblocks_, true); // delta_norm
     alloc_w(nblocks_, true); // delta_norm_old
     alloc_w(nblocks_, true); // delta_gamma
     alloc_w(nblocks_, true); // delta_gamma_old
     alloc_w(nblocks_, true); // delta_h
     alloc_w(nx_, true); // trial_xk
     alloc_w(nx_, true); // lbx_qp
     alloc_w(nx_, true); // ubx_qp
     alloc_w(ng_, true); // lba_qp
     alloc_w(ng_, true); // uba_qp
     alloc_w(ng_, true); // jac_times_dxk
     alloc_w(nx_*hess_memsize_, true); // deltaMat
     alloc_w(nx_*hess_memsize_, true); // gammaMat
     alloc_w(Asp_.nnz(), true); // jac_g
     alloc_w(nnz_H_, true); // hess_lag
     alloc_iw(nblocks_, true); // noUpdateCounter
  
     // Allocate block diagonal Hessian(s)
     casadi_int n_hess = hess_update_==1 || hess_update_==4 ? 2 : 1;
     alloc_res(nblocks_*n_hess, true);
     alloc_w(n_hess*nnz_H_, true);
     alloc_iw(nnz_H_ + (nx_+1) + nx_, true); // hessIndRow
     alloc_w(exact_hess_lag_sp_.nnz(), true); // exact_hess_lag
   }

References casadi::FunctionInternal::alloc_iw(), casadi::FunctionInternal::alloc_res(), casadi::FunctionInternal::alloc_w(), Asp_, block_hess_, blocks_, col_eps_, col_tau1_, col_tau2_, casadi::Sparsity::colind(), conv_strategy_, casadi::OracleFunction::create_function(), delta_, delta_h0_, casadi::Sparsity::dense(), casadi::Sparsity::diag(), dim_, casadi::dot(), eps_, eta_, exact_hess_lag_sp_, casadi::Function::factory(), fallback_scaling_, fallback_update_, gamma_f_, gamma_theta_, casadi::OracleFunction::get_function(), globalization_, hess_damp_, hess_damp_fac_, hess_lim_mem_, hess_memsize_, hess_scaling_, hess_update_, Hsp_, casadi::inf, ini_hess_diag_, casadi::Nlpsol::init(), kappa_f_, kappa_minus_, kappa_plus_, kappa_plus_max_, kappa_soc_, linsol_plugin_, max_consec_reduced_steps_, max_consec_skipped_updates_, max_conv_qp_, max_it_qp_, max_iter_, max_line_search_, max_soc_iter_, max_time_qp_, casadi::Function::mx_in(), nblocks_, casadi::Nlpsol::ng_, nlinfeastol_, casadi::nlpsol(), casadi::Sparsity::nnz(), nnz_H_, casadi::Nlpsol::nx_, obj_lo_, obj_up_, opttol_, casadi::OracleFunction::oracle_, casadi::ProtoFunction::print(), print_header_, print_iteration_, print_maxit_reached_, qp_init_, restore_feas_, rho_, casadi::Sparsity::row(), rp_solver_, s_f_, s_theta_, schur_, casadi::Function::size1_in(), casadi::Function::size1_out(), skip_first_globalization_, casadi::Function::sparsity_jac(), casadi::str(), casadi::GenericMatrix< MX >::sym(), theta_max_, theta_min_, casadi::ProtoFunction::verbose_, casadi::MX::vertcat(), warmstart_, which_second_derv_, and zeta_.

◆ init_mem()

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

overridevirtual

Reimplemented from casadi::Nlpsol.

Definition at line 566 of file blocksqp.cpp.

                                         {
     if (Nlpsol::init_mem(mem)) return 1;
     auto m = static_cast<BlocksqpMemory*>(mem);
  
     // Create qpOASES memory
     if (schur_) {
       m->qpoases_mem = new QpoasesMemory();
       m->qpoases_mem->linsol_plugin = linsol_plugin_;
     }
  
     m->qp = nullptr;
     m->colind.resize(Asp_.size2()+1);
     m->row.resize(Asp_.nnz());
     return 0;
   }

References Asp_, casadi::Nlpsol::init_mem(), linsol_plugin_, casadi::Sparsity::nnz(), casadi::BlocksqpMemory::qpoases_mem, schur_, and casadi::Sparsity::size2().

◆ initializeFilter()

void casadi::Blocksqp::initializeFilter ( BlocksqpMemory * m ) const

Definition at line 1722 of file blocksqp.cpp.

                                                          {
     std::pair<double, double> initPair(theta_max_, obj_lo_);
  
     // Remove all elements
     auto iter=m->filter.begin();
     while (iter != m->filter.end()) {
       std::set< std::pair<double, double> >::iterator iterToRemove = iter;
       iter++;
       m->filter.erase(iterToRemove);
     }
  
     // Initialize with pair (maxConstrViolation, objLowerBound);
     m->filter.insert(initPair);
   }

References casadi::BlocksqpMemory::filter, obj_lo_, and theta_max_.

Referenced by solve().

◆ initIterate()

void casadi::Blocksqp::initIterate ( BlocksqpMemory * m ) const

Definition at line 2769 of file blocksqp.cpp.

                                                     {
     m->alpha = 1.0;
     m->nSOCS = 0;
     m->reducedStepCount = 0;
     m->steptype = 0;
  
     m->obj = inf;
     m->tol = inf;
     m->cNorm = theta_max_;
     m->gradNorm = inf;
     m->lambdaStepNorm = 0.0;
   }

References casadi::BlocksqpMemory::alpha, casadi::BlocksqpMemory::cNorm, casadi::BlocksqpMemory::gradNorm, casadi::inf, casadi::BlocksqpMemory::lambdaStepNorm, casadi::BlocksqpMemory::nSOCS, casadi::BlocksqpMemory::obj, casadi::BlocksqpMemory::reducedStepCount, casadi::BlocksqpMemory::steptype, theta_max_, and casadi::BlocksqpMemory::tol.

Referenced by solve().

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

◆ initStats()

void casadi::Blocksqp::initStats ( BlocksqpMemory * m ) const

Definition at line 2608 of file blocksqp.cpp.

                                                   {
     m->itCount = 0;
     m->qpItTotal = 0;
     m->qpIterations = 0;
     m->hessSkipped = 0;
     m->hessDamped = 0;
     m->averageSizingFactor = 0.0;
   }

References casadi::BlocksqpMemory::averageSizingFactor, casadi::BlocksqpMemory::hessDamped, casadi::BlocksqpMemory::hessSkipped, casadi::BlocksqpMemory::itCount, casadi::BlocksqpMemory::qpIterations, and casadi::BlocksqpMemory::qpItTotal.

Referenced by solve().

◆ instantiate()

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

staticinherited

Definition at line 106 of file plugin_interface.hpp.

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

◆ instruction_constant()

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

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 3318 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_id()

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

virtualinherited

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

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

Definition at line 3310 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_input()

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

virtualinherited

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

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

Definition at line 3314 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_MX()

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

virtualinherited

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

Reimplemented in casadi::MXFunction.

Definition at line 3326 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instruction_output()

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

virtualinherited

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

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

Definition at line 3322 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ instructions_sx()

SX casadi::FunctionInternal::instructions_sx ( ) const

virtualinherited

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

Reimplemented in casadi::SXFunction.

Definition at line 3330 of file function_internal.cpp.

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

References casadi::SharedObjectInternal::class_name().

◆ integer_support()

virtual bool casadi::Nlpsol::integer_support ( ) const

inlinevirtualinherited

Reimplemented in casadi::KnitroInterface, and casadi::BonminInterface.

Definition at line 207 of file nlpsol_impl.hpp.

207 { return false;}

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

◆ is_a()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 290 of file nlpsol.cpp.

                                                                {
     return type=="Nlpsol" || (recursive && OracleFunction::is_a(type, recursive));
   }

References casadi::FunctionInternal::is_a().

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

◆ jac_is_symm()

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

virtualinherited

Definition at line 1774 of file function_internal.cpp.

                                                                            {
     // If derivative expression
     if (!derivative_of_.is_null()) {
       std::string n = derivative_of_.name();
       // Reverse move
       if (name_ == "adj1_" + n) {
         if (iind == oind) return true;
       }
     }
     // Not symmetric by default
     return false;
   }

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

◆ jac_sparsity()

Sparsity & casadi::FunctionInternal::jac_sparsity	(	casadi_int	oind,
		casadi_int	iind,
		bool	compact,
		bool	symmetric
	)		const

inherited

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

Definition at line 1862 of file function_internal.cpp.

                             {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     // Safe access to jac_sparsity_
     std::lock_guard<std::mutex> lock(jac_sparsity_mtx_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
     // If first call, allocate cache
     for (bool c : {false, true}) {
       if (jac_sparsity_[c].empty()) jac_sparsity_[c].resize(n_in_ * n_out_);
     }
     // Flat index
     casadi_int ind = iind + oind * n_in_;
     // Reference to the block
     Sparsity& jsp = jac_sparsity_[compact].at(ind);
     // If null, generate
     if (jsp.is_null()) {
       // Use (non)-compact pattern, if given
       Sparsity& jsp_other = jac_sparsity_[!compact].at(ind);
       if (!jsp_other.is_null()) {
         jsp = compact ? to_compact(oind, iind, jsp_other) : from_compact(oind, iind, jsp_other);
       } else {
         // Generate pattern
         Sparsity sp;
         bool sp_is_compact;
         if (!is_diff_out_.at(oind) || !is_diff_in_.at(iind)) {
           // All-zero sparse
           sp = Sparsity(nnz_out(oind), nnz_in(iind));
           sp_is_compact = true;
         } else {
           // Use internal routine to determine sparsity
           if (has_spfwd() || has_sprev() || has_jac_sparsity(oind, iind)) {
             sp = get_jac_sparsity(oind, iind, symmetric);
           }
           // If null, dense
           if (sp.is_null()) sp = Sparsity::dense(nnz_out(oind), nnz_in(iind));
           // Is the return the compact pattern?
           sp_is_compact = sp.size1() == nnz_out(oind) && sp.size2() == nnz_in(iind);
         }
         // Save to cache and convert if needed
         if (sp_is_compact == compact) {
           jsp = sp;
         } else {
           jsp_other = sp;
           jsp = compact ? to_compact(oind, iind, sp) : from_compact(oind, iind, sp);
         }
       }
     }
  
     // Make sure the Jacobian is symmetric if requested, cf. #1522, #3074, #3134
     if (symmetric) {
       if (compact) {
         Sparsity sp = from_compact(oind, iind, jsp);
         if (!sp.is_symmetric()) {
           sp = sp * sp.T();
           jsp = to_compact(oind, iind, sp);
         }
       } else {
         if (!jsp.is_symmetric()) jsp = jsp * jsp.T();
       }
     }
  
     // Return a reference to the block
     return jsp;
   }

Referenced by casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::sp_forward_block(), and casadi::FunctionInternal::sp_reverse().

◆ jacobian()

Function casadi::FunctionInternal::jacobian ( ) const

inherited

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

Definition at line 2257 of file function_internal.cpp.

                                             {
     // Used wrapped function if jacobian not available
     if (!has_jacobian()) {
       // Derivative information must be available
       casadi_assert(has_derivative(),
                             "Derivatives cannot be calculated for " + name_);
       return wrap().jacobian();
     }
     // Retrieve/generate cached
     Function f;
     std::string fname = "jac_" + name_;
     if (!incache(fname, f)) {
       // Names of inputs
       std::vector<std::string> inames;
       for (casadi_int i=0; i<n_in_; ++i) inames.push_back(name_in_[i]);
       for (casadi_int i=0; i<n_out_; ++i) inames.push_back("out_" + name_out_[i]);
       // Names of outputs
       std::vector<std::string> onames;
       onames.reserve(n_in_ * n_out_);
       for (size_t oind = 0; oind < n_out_; ++oind) {
         for (size_t iind = 0; iind < n_in_; ++iind) {
           onames.push_back("jac_" + name_out_[oind] + "_" + name_in_[iind]);
         }
       }
       // Options
       Dict opts = combine(jacobian_options_, der_options_);
       opts["derivative_of"] = self();
       // Generate derivative function
       casadi_assert_dev(enable_jacobian_);
       f = get_jacobian(fname, inames, onames, opts);
       // Consistency checks
       casadi_assert(f.n_in() == inames.size(),
         "Mismatching input signature, expected " + str(inames));
       casadi_assert(f.n_out() == onames.size(),
         "Mismatching output signature, expected " + str(onames));
       // Save to cache
       tocache_if_missing(f);
     }
     return f;
   }

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

◆ jit_dependencies()

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

overridevirtualinherited

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

Reimplemented from casadi::FunctionInternal.

Definition at line 438 of file oracle_function.cpp.

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

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

◆ join_results()

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

inherited

Definition at line 168 of file oracle_function.cpp.

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

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

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

◆ kkt()

Function casadi::Nlpsol::kkt ( ) const

inherited

Definition at line 847 of file nlpsol.cpp.

                              {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     // Safe access to kkt_
     std::lock_guard<std::mutex> lock(kkt_mtx_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
     // Quick return if cached
     SharedObject temp;
     if (kkt_.shared_if_alive(temp)) {
       return shared_cast<Function>(temp);
     }
  
     // Generate KKT function
     Function ret = oracle_.factory("kkt", {"x", "p", "lam:f", "lam:g"},
       {"jac:g:x", "hess:gamma:x:x"}, {{"gamma", {"f", "g"}}});
  
     // Cache and return
     kkt_ = ret;
     return ret;
   }

References casadi::Function::factory(), casadi::Nlpsol::kkt_, casadi::OracleFunction::oracle_, and casadi::GenericWeakRef< Shared, Internal >::shared_if_alive().

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

◆ kktErrorReduction()

casadi_int casadi::Blocksqp::kktErrorReduction ( BlocksqpMemory * m ) const

If the line search fails, check if the full step reduces the KKT error by a factor kappaF.

Definition at line 1654 of file blocksqp.cpp.

                                                                 {
     auto d_nlp = &m->d_nlp;
     casadi_int info = 0;
     double objTrial, cNormTrial, trialGradNorm, trialTol;
  
     // Compute new trial point
     for (casadi_int i=0; i<nx_; i++)
       m->trial_xk[i] = d_nlp->z[i] + m->dxk[i];
  
     // Compute objective and ||constr(trial_xk)|| at trial point
     std::vector<double> trialConstr(ng_, 0.);
     info = evaluate(m, m->trial_xk, &objTrial, get_ptr(trialConstr));
     m->nFunCalls++;
     cNormTrial = lInfConstraintNorm(m, m->trial_xk, get_ptr(trialConstr));
     if (info != 0 || objTrial < obj_lo_ || objTrial > obj_up_
       || !(objTrial == objTrial) || !(cNormTrial == cNormTrial)) {
       // evaluation error
       return 1;
     }
  
     // Compute KKT error of the new point
  
     // scaled norm of Lagrangian gradient
     std::vector<double> trialGradLagrange(nx_, 0.);
     calcLagrangeGradient(m, m->lam_qp, m->lam_qp+nx_, m->grad_fk,
                          m->jac_g,
                          get_ptr(trialGradLagrange), 0);
  
     trialGradNorm = casadi_norm_inf(nx_, get_ptr(trialGradLagrange));
     trialTol = trialGradNorm/(1.0+casadi_norm_inf(nx_+ng_, m->lam_qp));
  
     if (fmax(cNormTrial, trialTol) < kappa_f_ * fmax(m->cNorm, m->tol)) {
       acceptStep(m, 1.0);
       return 0;
     } else {
       return 1;
     }
   }

Referenced by run().

◆ lInfConstraintNorm()

double casadi::Blocksqp::lInfConstraintNorm	(	BlocksqpMemory *	m,
		const double *	xk,
		const double *	g
	)		const

Definition at line 2840 of file blocksqp.cpp.

                                                                                  {
     auto d_nlp = &m->d_nlp;
     return fmax(casadi_max_viol(nx_, xk, d_nlp->lbz, d_nlp->ubz),
                 casadi_max_viol(ng_, g, d_nlp->lbz+nx_, d_nlp->ubz+nx_));
   }

References casadi::casadi_max_viol(), casadi::NlpsolMemory::d_nlp, casadi::Nlpsol::ng_, and casadi::Nlpsol::nx_.

Referenced by calcOptTol(), feasibilityRestorationPhase(), filterLineSearch(), fullstep(), kktErrorReduction(), and secondOrderCorrection().

◆ load_library()

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

staticinherited

Definition at line 92 of file plugin_interface.hpp.

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

◆ load_plugin()

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

staticinherited

Definition at line 88 of file plugin_interface.hpp.

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

◆ local_init_mem()

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

inherited

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

Definition at line 465 of file oracle_function.cpp.

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

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

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

◆ map()

Function casadi::FunctionInternal::map	(	casadi_int	n,
		const std::string &	parallelization
	)		const

inherited

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

Definition at line 1007 of file function_internal.cpp.

                                                                                      {
     Function f;
     if (parallelization=="serial") {
       // Serial maps are cached
       std::string fname = "map" + str(n) + "_" + name_;
       if (!incache(fname, f)) {
         // Create new serial map
         f = Map::create(parallelization, self(), n);
         casadi_assert_dev(f.name()==fname);
         // Save in cache
         tocache_if_missing(f);
       }
     } else {
       // Non-serial maps are not cached
       f = Map::create(parallelization, self(), n);
     }
     return f;
   }

References casadi::Map::create(), casadi::FunctionInternal::incache(), casadi::Function::name(), casadi::ProtoFunction::name_, casadi::str(), and casadi::FunctionInternal::tocache_if_missing().

Referenced by casadi::Dple::get_forward(), casadi::Dple::get_reverse(), and casadi::FunctionInternal::mapsum_mx().

◆ mapsum_mx()

std::vector< MX > casadi::FunctionInternal::mapsum_mx	(	const std::vector< MX > &	arg,
		const std::string &	parallelization
	)

inherited

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

Definition at line 3339 of file function_internal.cpp.

                                                                 {
     if (x.empty()) return x;
     // Check number of arguments
     casadi_assert(x.size()==n_in_, "mapsum_mx: Wrong number_i of arguments");
     // Number of parallel calls
     casadi_int npar = 1;
     // Check/replace arguments
     std::vector<MX> x_mod(x.size());
     for (casadi_int i=0; i<n_in_; ++i) {
       if (check_mat(x[i].sparsity(), sparsity_in_[i], npar)) {
         x_mod[i] = replace_mat(x[i], sparsity_in_[i], npar);
       } else {
         // Mismatching sparsity: The following will throw an error message
         npar = 0;
         check_arg(x, npar);
       }
     }
  
     casadi_int n = 1;
     for (casadi_int i=0; i<x_mod.size(); ++i) {
       n = std::max(x_mod[i].size2() / size2_in(i), n);
     }
  
     std::vector<casadi_int> reduce_in;
     for (casadi_int i=0; i<x_mod.size(); ++i) {
       if (x_mod[i].size2()/size2_in(i)!=n) {
         reduce_in.push_back(i);
       }
     }
  
     Function ms = self().map("mapsum", parallelization, n, reduce_in, range(n_out_));
  
     // Call the internal function
     return ms(x_mod);
   }

References casadi::FunctionInternal::check_arg(), casadi::FunctionInternal::check_mat(), casadi::FunctionInternal::map(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::range(), casadi::replace_mat(), casadi::FunctionInternal::size2_in(), and casadi::FunctionInternal::sparsity_in_.

◆ matching_arg()

template<typename M >

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

inherited

Raises errors

Parameters

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

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

Definition at line 1722 of file function_internal.hpp.

                                                                                      {
     check_arg(arg, npar);
     for (casadi_int i=0; i<n_in_; ++i) {
       if (arg.at(i).size1()!=size1_in(i)) return false;
       if (arg.at(i).size2()!=size2_in(i) && arg.at(i).size2()!=npar*size2_in(i)) return false;
     }
     return true;
   }

References casadi::FunctionInternal::check_arg(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::size1_in(), and casadi::FunctionInternal::size2_in().

Referenced by casadi::MXFunction::ad_forward(), casadi::SXFunction::ad_forward(), casadi::FunctionInternal::call(), casadi::FunctionInternal::call_forward(), and casadi::FunctionInternal::nz_in().

◆ matching_res()

template<typename M >

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

inherited

Raises errors

Parameters

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

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

Definition at line 1732 of file function_internal.hpp.

                                                                                      {
     check_res(res, npar);
     for (casadi_int i=0; i<n_out_; ++i) {
       if (res.at(i).size1()!=size1_out(i)) return false;
       if (res.at(i).size2()!=size2_out(i) && res.at(i).size2()!=npar*size2_out(i)) return false;
     }
     return true;
   }

References casadi::FunctionInternal::check_res(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::size1_out(), and casadi::FunctionInternal::size2_out().

Referenced by casadi::MXFunction::ad_reverse(), casadi::SXFunction::ad_reverse(), casadi::FunctionInternal::call_reverse(), and casadi::FunctionInternal::nz_out().

◆ memory()

void * casadi::ProtoFunction::memory ( int ind ) const

inherited

Definition at line 3574 of file function_internal.cpp.

                                            {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
     return mem_.at(ind);
   }

Referenced by casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::Sqpmethod::solve_ela_QP(), and casadi::Sqpmethod::solve_QP().

◆ merge()

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

virtualinherited

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

Reimplemented in casadi::BlazingSplineFunction.

Definition at line 3288 of file function_internal.cpp.

                                                             {
     return;
   }

◆ monitored()

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

virtualinherited

Definition at line 548 of file oracle_function.cpp.

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

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

Referenced by casadi::OracleFunction::calc_function().

◆ mx_in() [1/2]

const std::vector< MX > casadi::FunctionInternal::mx_in ( ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Reimplemented in casadi::MXFunction.

Definition at line 3268 of file function_internal.cpp.

                                                     {
     std::vector<MX> ret(n_in_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = mx_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_in_.

Referenced by casadi::Nlpsol::get_forward(), casadi::LinearInterpolantJac::get_jacobian(), casadi::Nlpsol::get_reverse(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

◆ mx_in() [2/2]

const MX casadi::FunctionInternal::mx_in ( casadi_int ind ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Reimplemented in casadi::MXFunction.

Definition at line 3260 of file function_internal.cpp.

                                                        {
     return MX::sym(name_in_.at(ind), sparsity_in(ind));
   }

References casadi::FunctionInternal::name_in_, casadi::FunctionInternal::sparsity_in(), and casadi::GenericMatrix< MX >::sym().

◆ mx_out() [1/2]

const std::vector< MX > casadi::FunctionInternal::mx_out ( ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Definition at line 3276 of file function_internal.cpp.

                                                      {
     std::vector<MX> ret(n_out_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = mx_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_out_.

Referenced by casadi::Nlpsol::get_forward(), and casadi::Nlpsol::get_reverse().

◆ mx_out() [2/2]

const MX casadi::FunctionInternal::mx_out ( casadi_int ind ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Definition at line 3264 of file function_internal.cpp.

                                                         {
     return MX::sym(name_out_.at(ind), sparsity_out(ind));
   }

References casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sparsity_out(), and casadi::GenericMatrix< MX >::sym().

◆ n_instructions()

casadi_int casadi::FunctionInternal::n_instructions ( ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_la

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 3306 of file function_internal.cpp.

                                                     {
     casadi_error("'n_instructions' not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

◆ n_nodes()

casadi_int casadi::FunctionInternal::n_nodes ( ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_lf

Reimplemented in casadi::SXFunction, and casadi::MXFunction.

Definition at line 3334 of file function_internal.cpp.

                                              {
     casadi_error("'n_nodes' not defined for " + class_name());
   }

References casadi::SharedObjectInternal::class_name().

◆ nnz_in() [1/2]

casadi_int casadi::FunctionInternal::nnz_in ( ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_me

Definition at line 2217 of file function_internal.cpp.

                                             {
     casadi_int ret=0;
     for (casadi_int iind=0; iind<n_in_; ++iind) ret += nnz_in(iind);
     return ret;
   }

References casadi::FunctionInternal::n_in_.

◆ nnz_in() [2/2]

casadi_int casadi::FunctionInternal::nnz_in ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_me

Definition at line 969 of file function_internal.hpp.

969 { return sparsity_in(ind).nnz(); }

◆ nnz_out() [1/2]

casadi_int casadi::FunctionInternal::nnz_out ( ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_me

Definition at line 2223 of file function_internal.cpp.

                                              {
     casadi_int ret=0;
     for (casadi_int oind=0; oind<n_out_; ++oind) ret += nnz_out(oind);
     return ret;
   }

References casadi::FunctionInternal::n_out_.

◆ nnz_out() [2/2]

casadi_int casadi::FunctionInternal::nnz_out ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_me

Definition at line 971 of file function_internal.hpp.

971 { return sparsity_out(ind).nnz(); }

◆ numel_in() [1/2]

casadi_int casadi::FunctionInternal::numel_in ( ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mf

Definition at line 2229 of file function_internal.cpp.

                                               {
     casadi_int ret=0;
     for (casadi_int iind=0; iind<n_in_; ++iind) ret += numel_in(iind);
     return ret;
   }

References casadi::FunctionInternal::n_in_.

Referenced by casadi::FunctionInternal::from_compact(), and casadi::Integrator::get_reverse().

◆ numel_in() [2/2]

casadi_int casadi::FunctionInternal::numel_in ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mf

Definition at line 979 of file function_internal.hpp.

979 { return sparsity_in(ind).numel(); }

casadi::Sparsity::numel

casadi_int numel() const

The total number of elements, including structural zeros, i.e. size2()*size1()

Definition: sparsity.cpp:132

◆ numel_out() [1/2]

casadi_int casadi::FunctionInternal::numel_out ( ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mf

Definition at line 2235 of file function_internal.cpp.

                                                {
     casadi_int ret=0;
     for (casadi_int oind=0; oind<n_out_; ++oind) ret += numel_out(oind);
     return ret;
   }

References casadi::FunctionInternal::n_out_.

Referenced by casadi::FunctionInternal::from_compact(), and casadi::Integrator::get_reverse().

◆ numel_out() [2/2]

casadi_int casadi::FunctionInternal::numel_out ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mf

Definition at line 980 of file function_internal.hpp.

980 { return sparsity_out(ind).numel(); }

◆ nz_in() [1/2]

std::vector< double > casadi::FunctionInternal::nz_in ( const std::vector< DM > & arg ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kt

Definition at line 3429 of file function_internal.cpp.

                                                                           {
     // Disallow parallel inputs
     casadi_int npar = -1;
     if (!matching_arg(arg, npar)) {
       return nz_in(replace_arg(arg, npar));
     }
  
     std::vector<DM> arg2 = project_arg(arg, 1);
     std::vector<double> ret(nnz_in());
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_in_;++i) {
       const double* e = arg2.at(i).ptr();
       std::copy(e, e+nnz_in(i), ret.begin()+offset);
       offset+= nnz_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::project_arg(), and casadi::FunctionInternal::replace_arg().

Referenced by casadi::SXFunction::call_fwd(), casadi::SXFunction::call_rev(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical().

◆ nz_in() [2/2]

std::vector< DM > casadi::FunctionInternal::nz_in ( const std::vector< double > & arg ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kt

Definition at line 3399 of file function_internal.cpp.

                                                                           {
     casadi_assert(nnz_in()==arg.size(),
       "Dimension mismatch. Expecting " + str(nnz_in()) +
       ", got " + str(arg.size()) + " instead.");
  
     std::vector<DM> ret = dm_in();
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_in_;++i) {
       DM& r = ret.at(i);
       std::copy(arg.begin()+offset, arg.begin()+offset+nnz_in(i), r.ptr());
       offset+= nnz_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::dm_in(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::nnz_in(), casadi::Matrix< Scalar >::ptr(), and casadi::str().

◆ nz_out() [1/2]

std::vector< double > casadi::FunctionInternal::nz_out ( const std::vector< DM > & res ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kt

Definition at line 3447 of file function_internal.cpp.

                                                                            {
     // Disallow parallel inputs
     casadi_int npar = -1;
     if (!matching_res(res, npar)) {
       return nz_out(replace_res(res, npar));
     }
  
     std::vector<DM> res2 = project_res(res, 1);
     std::vector<double> ret(nnz_out());
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_out_;++i) {
       const double* e = res2.at(i).ptr();
       std::copy(e, e+nnz_out(i), ret.begin()+offset);
       offset+= nnz_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::matching_res(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_out(), casadi::FunctionInternal::project_res(), and casadi::FunctionInternal::replace_res().

Referenced by casadi::SXFunction::call_fwd(), casadi::SXFunction::call_rev(), casadi::SXFunction::call_setup(), casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical().

◆ nz_out() [2/2]

std::vector< DM > casadi::FunctionInternal::nz_out ( const std::vector< double > & res ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kt

Definition at line 3414 of file function_internal.cpp.

                                                                            {
     casadi_assert(nnz_out()==res.size(),
       "Dimension mismatch. Expecting " + str(nnz_out()) +
       ", got " + str(res.size()) + " instead.");
  
     std::vector<DM> ret = dm_out();
     casadi_int offset = 0;
     for (casadi_int i=0;i<n_out_;++i) {
       DM& r = ret.at(i);
       std::copy(res.begin()+offset, res.begin()+offset+nnz_out(i), r.ptr());
       offset+= nnz_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::dm_out(), casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_out(), casadi::Matrix< Scalar >::ptr(), and casadi::str().

◆ oracle()

const Function& casadi::OracleFunction::oracle ( ) const

inlineoverridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_h

Reimplemented from casadi::FunctionInternal.

Definition at line 147 of file oracle_function.hpp.

147 { return oracle_;}

Referenced by casadi::OracleFunction::create_function(), casadi::AmplInterface::init(), and casadi::Scpgen::init().

◆ pairInFilter()

bool casadi::Blocksqp::pairInFilter	(	BlocksqpMemory *	m,
		double	cNorm,
		double	obj
	)		const

Check if current entry is accepted to the filter: (cNorm, obj) in F_k

Definition at line 1697 of file blocksqp.cpp.

                                                                   {
     /*
      * A pair is in the filter if:
      * - it increases the objective and
      * - it also increases the constraint violation
      * The second expression in the if-clause states that we exclude
      * entries that are within the feasibility tolerance, e.g.
      * if an entry improves the constraint violation from 1e-16 to 1e-17,
      * but increases the objective considerably we also think of this entry
      * as dominated
      */
  
     for (auto&& f : m->filter) {
       if ((cNorm >= (1.0 - gamma_theta_) * f.first ||
            (cNorm < 0.01 * nlinfeastol_ && f.first < 0.01 * nlinfeastol_)) &&
           obj >= f.second - gamma_f_ * f.first) {
         return 1;
       }
     }
  
     return 0;
   }

References casadi::BlocksqpMemory::filter, gamma_f_, gamma_theta_, and nlinfeastol_.

Referenced by feasibilityRestorationPhase(), filterLineSearch(), and secondOrderCorrection().

◆ plugin_deserialize()

Deserialize casadi::PluginInterface< Nlpsol >::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::Blocksqp::plugin_name ( ) const

inlineoverridevirtual

Implements casadi::PluginInterface< Nlpsol >.

Definition at line 157 of file blocksqp.hpp.

157 { return "blocksqp";}

◆ plugin_options()

const Options & casadi::PluginInterface< Nlpsol >::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< Nlpsol >::Plugin casadi::PluginInterface< Nlpsol >::pluginFromRegFcn ( RegFcn regfcn )

staticinherited

Definition at line 85 of file plugin_interface.hpp.

                                                               {
     // Create a temporary struct
     Plugin plugin;
  
     // Set the fields
     int flag = regfcn(&plugin);
     casadi_assert(flag==0, "Registration of plugin failed.");
  
     return plugin;
   }

◆ print()

void casadi::ProtoFunction::print	(	const char *	fmt,
			...
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_jr

Definition at line 3813 of file function_internal.cpp.

                                                       {
     // Variable number of arguments
     va_list args;
     va_start(args, fmt);
     // Static & dynamic buffers
     char buf[256];
     size_t buf_sz = sizeof(buf);
     char* buf_dyn = nullptr;
     // Try to print with a small buffer
     casadi_int n = vsnprintf(buf, buf_sz, fmt, args);
     // Need a larger buffer?
     if (n>static_cast<casadi_int>(buf_sz)) {
       buf_sz = static_cast<size_t>(n+1);
       buf_dyn = new char[buf_sz];
       n = vsnprintf(buf_dyn, buf_sz, fmt, args);
     }
     // Print buffer content
     if (n>=0) uout() << (buf_dyn ? buf_dyn : buf) << std::flush;
     // Cleanup
     delete[] buf_dyn;
     va_end(args);
     // Throw error if failure
     casadi_assert(n>=0, "Print failure while processing '" + std::string(fmt) + "'");
   }

References casadi::uout().

Referenced by casadi::Feasiblesqpmethod::anderson_acc_step_update(), casadi::Nlpsol::callback(), convertHessian(), casadi::FmuFunction::eval_task(), casadi::Feasiblesqpmethod::feasibility_iterations(), feasibilityRestorationPhase(), fullstep(), 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(), printInfo(), printProgress(), run(), 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 solveQP().

◆ print_dimensions()

void casadi::FunctionInternal::print_dimensions ( std::ostream & stream ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mb

Definition at line 899 of file function_internal.cpp.

                                                                   {
     stream << " Number of inputs: " << n_in_ << std::endl;
     for (casadi_int i=0; i<n_in_; ++i) {
       stream << "  Input " << i  << " (\"" << name_in_[i] << "\"): "
              << sparsity_in_[i].dim() << std::endl;
     }
     stream << " Number of outputs: " << n_out_ << std::endl;
     for (casadi_int i=0; i<n_out_; ++i) {
       stream << "  Output " << i  << " (\"" << name_out_[i] << "\"): "
              << sparsity_out_[i].dim() << std::endl;
     }
   }

References casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sparsity_in_, and casadi::FunctionInternal::sparsity_out_.

◆ print_in()

void casadi::FunctionInternal::print_in	(	std::ostream &	stream,
		const double **	arg,
		bool	truncate
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nv

Definition at line 804 of file function_internal.cpp.

                                                                                              {
     stream << "Function " << name_ << " (" << this << ")" << std::endl;
     for (casadi_int i=0; i<n_in_; ++i) {
       stream << "Input " << i << " (" << name_in_[i] << "): ";
       if (arg[i]) {
         DM::print_default(stream, sparsity_in_[i], arg[i], truncate);
         stream << std::endl;
       } else {
         stream << "NULL" << std::endl;
       }
     }
   }

References casadi::FunctionInternal::n_in_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::Matrix< double >::print_default(), and casadi::FunctionInternal::sparsity_in_.

Referenced by casadi::FunctionInternal::eval_gen().

◆ print_option()

void casadi::ProtoFunction::print_option	(	const std::string &	name,
		std::ostream &	stream
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ji

Definition at line 916 of file function_internal.cpp.

                                                                                   {
     get_options().print_one(name, stream);
   }

References casadi::ProtoFunction::get_options(), and casadi::Options::print_one().

◆ print_options()

void casadi::ProtoFunction::print_options ( std::ostream & stream ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_jh

Definition at line 912 of file function_internal.cpp.

                                                             {
     get_options().print_all(stream);
   }

References casadi::ProtoFunction::get_options(), and casadi::Options::print_all().

◆ print_out()

void casadi::FunctionInternal::print_out	(	std::ostream &	stream,
		double **	res,
		bool	truncate
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nw

Definition at line 817 of file function_internal.cpp.

                                                                                         {
     stream << "Function " << name_ << " (" << this << ")" << std::endl;
     for (casadi_int i=0; i<n_out_; ++i) {
       stream << "Output " << i << " (" << name_out_[i] << "): ";
       if (res[i]) {
         DM::print_default(stream, sparsity_out_[i], res[i], truncate);
         stream << std::endl;
       } else {
         stream << "NULL" << std::endl;
       }
     }
   }

References casadi::FunctionInternal::n_out_, casadi::ProtoFunction::name_, casadi::FunctionInternal::name_out_, casadi::Matrix< double >::print_default(), and casadi::FunctionInternal::sparsity_out_.

Referenced by casadi::FunctionInternal::eval_gen().

◆ print_time()

void casadi::ProtoFunction::print_time ( const std::map< std::string, FStats > & fstats ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ju

Definition at line 3733 of file function_internal.cpp.

                                                                               {
     if (!print_time_) return;
     // Length of the name being printed
     size_t name_len=0;
     for (auto &&s : fstats) {
       name_len = std::max(s.first.size(), name_len);
     }
     name_len = std::max(name_.size(), name_len);
  
     // Print name with a given length. Format: "%NNs "
     char namefmt[10];
     sprint(namefmt, sizeof(namefmt), "%%%ds ", static_cast<casadi_int>(name_len));
  
     // Print header
     print(namefmt, name_.c_str());
  
     print(" : %8s %10s %8s %10s %9s\n", "t_proc", "(avg)", "t_wall", "(avg)", "n_eval");
  
  
     char buffer_proc[10];
     char buffer_wall[10];
     char buffer_proc_avg[10];
     char buffer_wall_avg[10];
  
     // Print keys
     for (const auto &s : fstats) {
       if (s.second.n_call!=0) {
         print(namefmt, s.first.c_str());
         format_time(buffer_proc, s.second.t_proc);
         format_time(buffer_wall, s.second.t_wall);
         format_time(buffer_proc_avg, s.second.t_proc/s.second.n_call);
         format_time(buffer_wall_avg, s.second.t_wall/s.second.n_call);
         print(" | %s (%s) %s (%s) %9d\n",
           buffer_proc, buffer_proc_avg,
           buffer_wall, buffer_wall_avg, s.second.n_call);
       }
     }
   }

References casadi::ProtoFunction::format_time(), casadi::ProtoFunction::name_, casadi::ProtoFunction::print(), casadi::ProtoFunction::print_time_, and casadi::ProtoFunction::sprint().

Referenced by casadi::FunctionInternal::eval_gen().

◆ printInfo()

void casadi::Blocksqp::printInfo ( BlocksqpMemory * m ) const

Definition at line 1012 of file blocksqp.cpp.

                                                   {
     char hessString1[100];
     char hessString2[100];
     char globString[100];
     char qpString[100];
  
     /* QP Solver */
     if (schur_)
       strcpy(qpString, "sparse, Schur complement approach");
     else
       strcpy(qpString, "sparse, reduced Hessian factorization");
  
     /* Globalization */
     if (globalization_) {
       strcpy(globString, "filter line search");
     } else {
       strcpy(globString, "none (full step)");
     }
  
     /* Hessian approximation */
     if (block_hess_ && (hess_update_ == 1 || hess_update_ == 2))
       strcpy(hessString1, "block ");
     else
       strcpy(hessString1, "");
  
     if (hess_lim_mem_ && (hess_update_ == 1 || hess_update_ == 2))
       strcat(hessString1, "L-");
  
     /* Fallback Hessian */
     if (hess_update_ == 1 || hess_update_ == 4
       || (hess_update_ == 2 && !hess_damp_)) {
         strcpy(hessString2, hessString1);
  
         /* Fallback Hessian update type */
         if (fallback_update_ == 0) {
           strcat(hessString2, "Id");
         } else if (fallback_update_ == 1) {
           strcat(hessString2, "SR1");
         } else if (fallback_update_ == 2) {
           strcat(hessString2, "BFGS");
         } else if (fallback_update_ == 4) {
           strcat(hessString2, "Finite differences");
         }
  
         /* Fallback Hessian scaling */
         if (fallback_scaling_ == 1) {
           strcat(hessString2, ", SP");
         } else if (fallback_scaling_ == 2) {
           strcat(hessString2, ", OL");
         } else if (fallback_scaling_ == 3) {
           strcat(hessString2, ", mean");
         } else if (fallback_scaling_ == 4) {
           strcat(hessString2, ", selective sizing");
         }
       } else {
         strcpy(hessString2, "-");
     }
  
     /* First Hessian update type */
     if (hess_update_ == 0) {
       strcat(hessString1, "Id");
     } else if (hess_update_ == 1) {
       strcat(hessString1, "SR1");
     } else if (hess_update_ == 2) {
       strcat(hessString1, "BFGS");
     } else if (hess_update_ == 4) {
       strcat(hessString1, "Finite differences");
     }
  
     /* First Hessian scaling */
     if (hess_scaling_ == 1) {
       strcat(hessString1, ", SP");
     } else if (hess_scaling_ == 2) {
       strcat(hessString1, ", OL");
     } else if (hess_scaling_ == 3) {
       strcat(hessString1, ", mean");
     } else if (hess_scaling_ == 4) {
       strcat(hessString1, ", selective sizing");
     }
  
     print("\n+---------------------------------------------------------------+\n");
     print("| Starting blockSQP with the following algorithmic settings:    |\n");
     print("+---------------------------------------------------------------+\n");
     print("| qpOASES flavor            | %-34s|\n", qpString);
     print("| Globalization             | %-34s|\n", globString);
     print("| 1st Hessian approximation | %-34s|\n", hessString1);
     print("| 2nd Hessian approximation | %-34s|\n", hessString2);
     print("+---------------------------------------------------------------+\n\n");
   }

References block_hess_, fallback_scaling_, fallback_update_, globalization_, hess_damp_, hess_lim_mem_, hess_scaling_, hess_update_, casadi::ProtoFunction::print(), and schur_.

Referenced by solve().

◆ printProgress()

void casadi::Blocksqp::printProgress ( BlocksqpMemory * m ) const

Definition at line 2555 of file blocksqp.cpp.

                                                       {
     /*
      * m->steptype:
      *-1: full step was accepted because it reduces the KKT error although line search failed
      * 0: standard line search step
      * 1: Hessian has been reset to identity
      * 2: feasibility restoration heuristic has been called
      * 3: feasibility restoration phase has been called
      */
  
      // Print headline every twenty iterations
     if (m->itCount % 20 == 0) {
       print("%-8s", "   it");
       print("%-21s", " qpIt");
       print("%-9s", "obj");
       print("%-11s", "feas");
       print("%-7s", "opt");
       print("%-11s", "|lgrd|");
       print("%-9s", "|stp|");
       print("%-10s", "|lstp|");
       print("%-8s", "alpha");
       print("%-6s", "nSOCS");
       print("%-18s", "sk, da, sca");
       print("%-6s", "QPr,mu");
       print("\n");
     }
  
     if (m->itCount == 0) {
       // Values for first iteration
       print("%5i  ", m->itCount);
       print("%11i ", 0);
       print("% 10e  ", m->obj);
       print("%-10.2e", m->cNormS);
       print("%-10.2e", m->tol);
       print("\n");
     } else {
       // All values
       print("%5i  ", m->itCount);
       print("%5i+%5i ", m->qpIterations, m->qpIterations2);
       print("% 10e  ", m->obj);
       print("%-10.2e", m->cNormS);
       print("%-10.2e", m->tol);
       print("%-10.2e", m->gradNorm);
       print("%-10.2e", casadi_norm_inf(nx_, m->dxk));
       print("%-10.2e", m->lambdaStepNorm);
       print("%-9.1e", m->alpha);
       print("%5i", m->nSOCS);
       print("%3i, %3i, %-9.1e", m->hessSkipped, m->hessDamped, m->averageSizingFactor);
       print("%i, %-9.1e", m->qpResolve, casadi_norm_1(nblocks_, m->delta_h)/nblocks_);
       print("\n");
     }
   }

Referenced by feasibilityRestorationPhase(), and run().

◆ project_arg()

template<typename M >

std::vector< M > casadi::FunctionInternal::project_arg	(	const std::vector< M > &	arg,
		casadi_int	npar
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kn

Definition at line 1594 of file function_internal.hpp.

                                                               {
     casadi_assert_dev(arg.size()==n_in_);
  
     // Which arguments require mapped evaluation
     std::vector<bool> mapped(n_in_);
     for (casadi_int i=0; i<n_in_; ++i) {
       mapped[i] = arg[i].size2()!=size2_in(i);
     }
  
     // Check if matching input sparsity
     std::vector<bool> matching(n_in_);
     bool any_mismatch = false;
     for (casadi_int i=0; i<n_in_; ++i) {
       if (mapped[i]) {
         matching[i] = arg[i].sparsity().is_stacked(sparsity_in(i), npar);
       } else {
         matching[i] = arg[i].sparsity()==sparsity_in(i);
       }
       any_mismatch = any_mismatch || !matching[i];
     }
  
     // Correct input sparsity
     if (any_mismatch) {
       std::vector<M> arg2(arg);
       for (casadi_int i=0; i<n_in_; ++i) {
         if (!matching[i]) {
           if (mapped[i]) {
             arg2[i] = project(arg2[i], repmat(sparsity_in(i), 1, npar));
           } else {
             arg2[i] = project(arg2[i], sparsity_in(i));
           }
         }
       }
       return arg2;
     }
     return arg;
   }

References casadi::FunctionInternal::n_in_, casadi::FunctionInternal::size2_in(), and casadi::FunctionInternal::sparsity_in().

Referenced by casadi::FunctionInternal::call_gen(), and casadi::FunctionInternal::nz_in().

◆ project_res()

template<typename M >

std::vector< M > casadi::FunctionInternal::project_res	(	const std::vector< M > &	arg,
		casadi_int	npar
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ko

Definition at line 1634 of file function_internal.hpp.

                                                                 {
       return arg;
   }

Referenced by casadi::FunctionInternal::nz_out().

◆ purgable()

template<typename MatType >

bool casadi::FunctionInternal::purgable ( const std::vector< MatType > & seed )

staticinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nq

Definition at line 1487 of file function_internal.hpp.

                                                              {
     for (auto i=v.begin(); i!=v.end(); ++i) {
       if (!i->is_zero()) return false;
     }
     return true;
   }

Referenced by casadi::MXFunction::ad_forward(), and casadi::MXFunction::ad_reverse().

◆ reduceSOCStepsize()

void casadi::Blocksqp::reduceSOCStepsize	(	BlocksqpMemory *	m,
		double *	alphaSOC
	)		const

Definition at line 1150 of file blocksqp.cpp.

                                                                {
     auto d_nlp = &m->d_nlp;
     // Update bounds on linearized constraints for the next SOC QP:
     // That is different from the update for the first SOC QP!
     for (casadi_int i=0; i<ng_; i++) {
       double lbg = d_nlp->lbz[i + nx_];
       double ubg = d_nlp->ubz[i + nx_];
       if (lbg != inf) {
         m->lba_qp[i] = *alphaSOC * m->lba_qp[i] - m->gk[i];
       } else {
         m->lba_qp[i] = inf;
       }
  
       if (ubg != inf) {
         m->uba_qp[i] = *alphaSOC * m->uba_qp[i] - m->gk[i];
       } else {
         m->uba_qp[i] = inf;
       }
     }
  
     *alphaSOC *= 0.5;
   }

References casadi::NlpsolMemory::d_nlp, casadi::BlocksqpMemory::gk, casadi::inf, casadi::BlocksqpMemory::lba_qp, casadi_nlpsol_data< T1 >::lbz, casadi::Nlpsol::ng_, casadi::Nlpsol::nx_, and casadi::BlocksqpMemory::uba_qp.

◆ reduceStepsize()

void casadi::Blocksqp::reduceStepsize	(	BlocksqpMemory *	m,
		double *	alpha
	)		const

Definition at line 1145 of file blocksqp.cpp.

                                                          {
     *alpha = (*alpha) * 0.5;
   }

Referenced by filterLineSearch(), and fullstep().

◆ registerPlugin() [1/2]

void casadi::PluginInterface< Nlpsol >::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< Nlpsol >::registerPlugin	(	RegFcn	regfcn,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 99 of file plugin_interface.hpp.

                                                                               {
     registerPlugin(pluginFromRegFcn(regfcn), needs_lock);
   }

◆ release()

void casadi::ProtoFunction::release ( int mem ) const

inherited

Definition at line 3606 of file function_internal.cpp.

                                            {
 #ifdef CASADI_WITH_THREAD
     std::lock_guard<std::mutex> lock(mtx_);
 #endif //CASADI_WITH_THREAD
     unused_.push(mem);
   }

◆ replace_arg()

template<typename M >

std::vector< M > casadi::FunctionInternal::replace_arg	(	const std::vector< M > &	arg,
		casadi_int	npar
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_km

Definition at line 1767 of file function_internal.hpp.

                                                               {
     std::vector<M> r(arg.size());
     for (casadi_int i=0; i<r.size(); ++i) r[i] = replace_mat(arg[i], sparsity_in(i), npar);
     return r;
   }

References casadi::replace_mat(), and casadi::FunctionInternal::sparsity_in().

Referenced by casadi::FunctionInternal::call(), casadi::FunctionInternal::nz_in(), and casadi::FunctionInternal::replace_fseed().

◆ replace_aseed() [1/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_aseed	(	const std::vector< std::vector< M > > &	aseed,
		casadi_int	npar
	)		const

inherited

Definition at line 1791 of file function_internal.hpp.

                                                                               {
     std::vector<std::vector<M> > r(aseed.size());
     for (casadi_int d=0; d<r.size(); ++d) r[d] = replace_res(aseed[d], npar);
     return r;
   }

References casadi::FunctionInternal::replace_res().

◆ replace_aseed() [2/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_aseed	(	const std::vector< std::vector< M >> &	aseed,
		casadi_int	npar
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kr

Referenced by casadi::MXFunction::ad_reverse(), casadi::SXFunction::ad_reverse(), and casadi::FunctionInternal::call_reverse().

◆ replace_fseed() [1/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_fseed	(	const std::vector< std::vector< M > > &	fseed,
		casadi_int	npar
	)		const

inherited

Definition at line 1783 of file function_internal.hpp.

                                                                               {
     std::vector<std::vector<M> > r(fseed.size());
     for (casadi_int d=0; d<r.size(); ++d) r[d] = replace_arg(fseed[d], npar);
     return r;
   }

References casadi::FunctionInternal::replace_arg().

◆ replace_fseed() [2/2]

template<typename M >

std::vector<std::vector<M> > casadi::FunctionInternal::replace_fseed	(	const std::vector< std::vector< M >> &	fseed,
		casadi_int	npar
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kq

Referenced by casadi::MXFunction::ad_forward(), casadi::SXFunction::ad_forward(), and casadi::FunctionInternal::call_forward().

◆ replace_res()

template<typename M >

std::vector< M > casadi::FunctionInternal::replace_res	(	const std::vector< M > &	res,
		casadi_int	npar
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_kp

Definition at line 1775 of file function_internal.hpp.

                                                               {
     std::vector<M> r(res.size());
     for (casadi_int i=0; i<r.size(); ++i) r[i] = replace_mat(res[i], sparsity_out(i), npar);
     return r;
   }

References casadi::replace_mat(), and casadi::FunctionInternal::sparsity_out().

Referenced by casadi::FunctionInternal::nz_out(), and casadi::FunctionInternal::replace_aseed().

◆ reset_sqp()

void casadi::Blocksqp::reset_sqp ( BlocksqpMemory * m ) const

Allocate memory for variables required by all optimization algorithms except for the Jacobian

Definition at line 2637 of file blocksqp.cpp.

                                                   {
     // dual variables (for general constraints and variable bounds)
     casadi_fill(m->lam_xk, nx_, 0.);
     casadi_fill(m->lam_gk, ng_, 0.);
  
     // constraint vector with lower and upper bounds
     // (Box constraints are not included in the constraint list)
     casadi_fill(m->gk, ng_, 0.);
  
     // gradient of objective
     casadi_fill(m->grad_fk, nx_, 0.);
  
     // gradient of Lagrangian
     casadi_fill(m->grad_lagk, nx_, 0.);
  
     // current step
     casadi_fill(m->deltaMat, nx_*hess_memsize_, 0.);
     m->dxk = m->deltaMat;
  
     // trial step (temporary variable, for line search)
     casadi_fill(m->trial_xk, nx_, 0.);
  
     // bounds for step (QP subproblem)
     casadi_fill(m->lbx_qp, nx_, 0.);
     casadi_fill(m->ubx_qp, nx_, 0.);
     casadi_fill(m->lba_qp, ng_, 0.);
     casadi_fill(m->uba_qp, ng_, 0.);
  
     // product of constraint Jacobian with step (deltaXi)
     casadi_fill(m->jac_times_dxk, ng_, 0.);
  
     // dual variables of QP (simple bounds and general constraints)
     casadi_fill(m->lam_qp, nx_+ng_, 0.);
  
     // line search parameters
     casadi_fill(m->delta_h, nblocks_, 0.);
  
     // filter as a set of pairs
     m->filter.clear();
  
     // difference of Lagrangian gradients
     casadi_fill(m->gammaMat, nx_*hess_memsize_, 0.);
     m->gamma = m->gammaMat;
  
     // Scalars that are used in various Hessian update procedures
     casadi_fill(m->noUpdateCounter, nblocks_, casadi_int(-1));
  
     // For selective sizing: for each block save sTs, sTs_, sTy, sTy_
     casadi_fill(m->delta_norm, nblocks_, 1.);
     casadi_fill(m->delta_norm_old, nblocks_, 1.);
     casadi_fill(m->delta_gamma, nblocks_, 0.);
     casadi_fill(m->delta_gamma_old, nblocks_, 0.);
  
     // Create one Matrix for one diagonal block in the Hessian
     for (casadi_int b=0; b<nblocks_; b++) {
       casadi_int dim = dim_[b];
       casadi_fill(m->hess1[b], dim*dim, 0.);
     }
  
     // For SR1 or finite differences, maintain two Hessians
     if (hess_update_ == 1 || hess_update_ == 4) {
       for (casadi_int b=0; b<nblocks_; b++) {
         casadi_int dim = dim_[b];
         casadi_fill(m->hess2[b], dim*dim, 0.);
       }
     }
  
     // Set Hessian pointer
     m->hess = m->hess1;
   }

Referenced by solve().

◆ resetHessian() [1/2]

void casadi::Blocksqp::resetHessian ( BlocksqpMemory * m ) const

Definition at line 1794 of file blocksqp.cpp.

                                                      {
     for (casadi_int b=0; b<nblocks_; b++) {
       if (!(which_second_derv_ == 1 && block_hess_ && b == nblocks_ - 1)) {
         // if objective derv is computed exactly, don't set the last block!
         resetHessian(m, b);
       }
     }
   }

References block_hess_, nblocks_, and which_second_derv_.

Referenced by calcHessianUpdate(), calcHessianUpdateLimitedMemory(), feasibilityRestorationPhase(), and run().

◆ resetHessian() [2/2]

void casadi::Blocksqp::resetHessian	(	BlocksqpMemory *	m,
		casadi_int	b
	)		const

Definition at line 1804 of file blocksqp.cpp.

                                                                    {
     casadi_int dim = dim_[b];
  
     // smallGamma and smallDelta are either subvectors of gamma and delta
     // or submatrices of gammaMat, deltaMat, i.e. subvectors of gamma and delta
     // from m prev. iterations (for L-BFGS)
     double *smallGamma = m->gammaMat + blocks_[b];
     double *smallDelta = m->deltaMat + blocks_[b];
  
     for (casadi_int i=0; i<hess_memsize_; ++i) {
       // Remove past information on Lagrangian gradient difference
       casadi_fill(smallGamma, dim, 0.);
       smallGamma += nx_;
  
       // Remove past information on steps
       smallDelta += nx_;
       casadi_fill(smallDelta, dim, 0.);
     }
  
     // Remove information on old scalars (used for COL sizing)
     m->delta_norm[b] = 1.0;
     m->delta_gamma[b] = 0.0;
     m->delta_norm_old[b] = 1.0;
     m->delta_gamma_old[b] = 0.0;
  
     m->noUpdateCounter[b] = -1;
  
     calcInitialHessian(m, b);
   }

References blocks_, calcInitialHessian(), casadi::casadi_fill(), casadi::BlocksqpMemory::delta_gamma, casadi::BlocksqpMemory::delta_gamma_old, casadi::BlocksqpMemory::delta_norm, casadi::BlocksqpMemory::delta_norm_old, casadi::BlocksqpMemory::deltaMat, dim_, casadi::BlocksqpMemory::gammaMat, hess_memsize_, casadi::BlocksqpMemory::noUpdateCounter, and casadi::Nlpsol::nx_.

◆ reverse()

Function casadi::FunctionInternal::reverse ( casadi_int nadj ) const

inherited

reverse(nadj) returns a cached instance if available, and calls Function get_reverse(casadi_int nadj) if no cached version is available.

Extra doc: https://github.com/casadi/casadi/wiki/L_l1

Definition at line 2140 of file function_internal.cpp.

                                                           {
     casadi_assert_dev(nadj>=0);
     // Used wrapped function if reverse not available
     if (!enable_reverse_) {
       // Derivative information must be available
       casadi_assert(has_derivative(), "Derivatives cannot be calculated for " + name_);
       return wrap().reverse(nadj);
     }
     // Retrieve/generate cached
     Function f;
     std::string fname = reverse_name(name_, nadj);
     if (!incache(fname, f)) {
       casadi_int i;
       // Prefix to be used for adjoint seeds, sensitivities
       std::string pref = diff_prefix("adj");
       // Names of inputs
       std::vector<std::string> inames;
       for (i=0; i<n_in_; ++i) inames.push_back(name_in_[i]);
       for (i=0; i<n_out_; ++i) inames.push_back("out_" + name_out_[i]);
       for (i=0; i<n_out_; ++i) inames.push_back(pref + name_out_[i]);
       // Names of outputs
       std::vector<std::string> onames;
       for (casadi_int i=0; i<n_in_; ++i) onames.push_back(pref + name_in_[i]);
       // Options
       Dict opts = combine(reverse_options_, der_options_);
       opts = combine(opts, generate_options("reverse"));
       opts["derivative_of"] = self();
       // Generate derivative function
       casadi_assert_dev(enable_reverse_);
       f = get_reverse(nadj, fname, inames, onames, opts);
       // Consistency check for inputs
       casadi_assert_dev(f.n_in()==n_in_ + n_out_ + n_out_);
       casadi_int ind=0;
       for (i=0; i<n_in_; ++i) f.assert_size_in(ind++, size1_in(i), size2_in(i));
       for (i=0; i<n_out_; ++i) f.assert_size_in(ind++, size1_out(i), size2_out(i));
       for (i=0; i<n_out_; ++i) f.assert_size_in(ind++, size1_out(i), nadj*size2_out(i));
       // Consistency check for outputs
       casadi_assert_dev(f.n_out()==n_in_);
       for (i=0; i<n_in_; ++i) f.assert_sparsity_out(i, sparsity_in(i), nadj);
       // Save to cache
       tocache_if_missing(f);
     }
     return f;
   }

Referenced by casadi::FunctionInternal::call_reverse(), and casadi::Function::reverse().

◆ reverse_name()

static std::string casadi::FunctionInternal::reverse_name	(	const std::string &	fcn,
		casadi_int	nadj
	)

inlinestaticinherited

Definition at line 657 of file function_internal.hpp.

                                                                          {
       return "adj" + str(nadj) + "_" + fcn;
     }

References casadi::str().

Referenced by casadi::FunctionInternal::reverse(), and casadi::FixedStepIntegrator::stepB().

◆ run()

casadi_int casadi::Blocksqp::run	(	BlocksqpMemory *	m,
		casadi_int	maxIt,
		casadi_int	warmStart = `0`
	)		const

Set initial Hessian approximation

Evaluate all functions and gradients for xk_0

Check if converged

Solve QP subproblem with qpOASES or QPOPT

Determine steplength alpha

Calculate "old" Lagrange gradient: gamma = dL(xi_k, lambda_k+1)

Evaluate functions and gradients at the new xk

Check if converged

Print one line of output for the current iteration

Calculate difference of old and new Lagrange gradient:

Revise Hessian approximation

Definition at line 740 of file blocksqp.cpp.

                                                                                           {
     casadi_int it, infoQP = 0;
     bool skipLineSearch = false;
     bool hasConverged = false;
  
     if (warmStart == 0 || m->itCount == 0) {
       // SQP iteration 0
  
       calcInitialHessian(m);
  
       switch (evaluate(m, &m->obj, m->gk, m->grad_fk, m->jac_g)) {
         case -1:
           m->unified_return_status = SOLVER_RET_NAN;
           return -1;
         case 0:
           break;
         default:
           return 1;
       }
       m->nDerCalls++;
  
       hasConverged = calcOptTol(m);
       if (print_iteration_) printProgress(m);
       updateStats(m);
       if (hasConverged) {
         if (print_iteration_ && m->steptype < 2) {
           print("\n***CONVERGENCE ACHIEVED!***\n");
         }
         return 0;
       }
       m->itCount++;
     }
  
     /*
      * SQP Loop: during first iteration, m->itCount = 1
      */
     for (it=0; it<maxIt; it++) {
       updateStepBounds(m, 0);
       infoQP = solveQP(m, m->dxk, m->lam_qp);
  
       if (infoQP == 1) {
           // 1.) Maximum number of iterations reached
           print("***WARNING: Maximum number of QP iterations exceeded.***\n");
       } else if (infoQP == 2 || infoQP > 3) {
           // 2.) QP error (e.g., unbounded), solve again with pos.def. diagonal matrix (identity)
           print("***WARNING: QP error. Solve again with identity matrix.***\n");
           resetHessian(m);
           infoQP = solveQP(m, m->dxk, m->lam_qp);
           if (infoQP) {
             // If there is still an error, terminate.
             print("***WARNING: QP error. Stop.***\n");
             return -1;
           } else {
             m->steptype = 1;
           }
         } else if (infoQP == 3) {
         // 3.) QP infeasible, try to restore feasibility
         bool qpError = true;
         skipLineSearch = true; // don't do line search with restoration step
  
         // Try to reduce constraint violation by heuristic
         if (m->steptype < 2) {
           print("***WARNING: QP infeasible. Trying to reduce constraint violation ...");
           qpError = feasibilityRestorationHeuristic(m);
           if (!qpError) {
             m->steptype = 2;
             print("Success.***\n");
           } else {
             print("Failure.***\n");
           }
         }
  
         // Invoke feasibility restoration phase
         //if (qpError && m->steptype < 3 && restore_feas_)
         if (qpError && restore_feas_ && m->cNorm > 0.01 * nlinfeastol_) {
           print("***Start feasibility restoration phase.***\n");
           m->steptype = 3;
           qpError = feasibilityRestorationPhase(m);
         }
  
         // If everything failed, abort.
         if (qpError) {
           print("***WARNING: QP error. Stop.\n");
           return -1;
         }
       }
  
       if (!globalization_ || (skip_first_globalization_ && m->itCount == 1)) {
         // No globalization strategy, but reduce step if function cannot be evaluated
         if (fullstep(m)) {
           print("***WARNING: Constraint or objective could "
                          "not be evaluated at new point. Stop.***\n");
           return -1;
         }
         m->steptype = 0;
       } else if (globalization_ && !skipLineSearch) {
         // Filter line search based on Waechter et al., 2006 (Ipopt paper)
         if (filterLineSearch(m) || m->reducedStepCount > max_consec_reduced_steps_) {
           // Filter line search did not produce a step. Now there are a few things we can try ...
           bool lsError = true;
  
           // Heuristic 1: Check if the full step reduces the KKT error by at
           // least kappaF, if so, accept the step.
           lsError = kktErrorReduction(m);
           if (!lsError)
             m->steptype = -1;
  
           // Heuristic 2: Try to reduce constraint violation by closing
           // continuity gaps to produce an admissable iterate
           if (lsError && m->cNorm > 0.01 * nlinfeastol_ && m->steptype < 2) {
             // Don't do this twice in a row!
             print("***WARNING: Steplength too short. "
                   "Trying to reduce constraint violation...");
  
             // Integration over whole time interval
             lsError = feasibilityRestorationHeuristic(m);
             if (!lsError) {
                 m->steptype = 2;
                 print("Success.***\n");
               } else {
               print("***WARNING: Failed.***\n");
             }
           }
  
           // Heuristic 3: Recompute step with a diagonal Hessian
           if (lsError && m->steptype != 1 && m->steptype != 2) {
             // After closing continuity gaps, we already take a step with initial Hessian.
             // If this step is not accepted then this will cause an infinite loop!
  
             print("***WARNING: Steplength too short. "
                   "Trying to find a new step with identity Hessian.***\n");
             m->steptype = 1;
  
             resetHessian(m);
             continue;
           }
  
           // If this does not yield a successful step, start restoration phase
           if (lsError && m->cNorm > 0.01 * nlinfeastol_ && restore_feas_) {
             print("***WARNING: Steplength too short. "
                            "Start feasibility restoration phase.***\n");
             m->steptype = 3;
  
             // Solve NLP with minimum norm objective
             lsError = feasibilityRestorationPhase(m);
           }
  
           // If everything failed, abort.
           if (lsError) {
             print("***WARNING: Line search error. Stop.***\n");
             return -1;
           }
         } else {
           m->steptype = 0;
         }
       }
  
       calcLagrangeGradient(m, m->gamma, 0);
  
       (void)evaluate(m, &m->obj, m->gk, m->grad_fk, m->jac_g);
       m->nDerCalls++;
  
       hasConverged = calcOptTol(m);
  
       if (print_iteration_) printProgress(m);
       updateStats(m);
       if (hasConverged && m->steptype < 2) {
         if (print_iteration_) print("\n***CONVERGENCE ACHIEVED!***\n");
         m->itCount++;
         return 0; //Convergence achieved!
       }
  
       // gamma = -gamma + dL(xi_k+1, lambda_k+1)
       calcLagrangeGradient(m, m->gamma, 1);
  
       if (hess_update_ < 4 && !hess_lim_mem_) {
         calcHessianUpdate(m, hess_update_, hess_scaling_);
       } else if (hess_update_ < 4 && hess_lim_mem_) {
         calcHessianUpdateLimitedMemory(m, hess_update_, hess_scaling_);
       } else if (hess_update_ == 4) {
         calcHessianUpdateExact(m);
       }
  
       // If limited memory updates  are used, set pointers deltaXi and
       // gamma to the next column in deltaMat and gammaMat
       updateDeltaGamma(m);
  
       m->itCount++;
       skipLineSearch = false;
     }
  
     return 1;
   }

Referenced by feasibilityRestorationPhase(), and solve().

◆ secondOrderCorrection()

bool casadi::Blocksqp::secondOrderCorrection	(	BlocksqpMemory *	m,
		double	cNorm,
		double	cNormTrial,
		double	dfTdeltaXi,
		bool	swCond,
		casadi_int	it
	)		const

Perform a second order correction step, i.e. solve the QP:

min_d d^TBd + d^T grad_fk s.t. bl <= A^Td + constr(xi+alpha*deltaXi) - A^TdeltaXi <= bu

Definition at line 1331 of file blocksqp.cpp.

                                                          {
     auto d_nlp = &m->d_nlp;
  
     // Perform SOC only on the first iteration of backtracking line search
     if (it > 0) return false;
     // If constraint violation of the trialstep is lower than the current one skip SOC
     if (cNormTrial < cNorm) return false;
  
     casadi_int nSOCS = 0;
     double cNormTrialSOC, cNormOld, objTrialSOC;
  
     // m->gk contains result at first trial point: c(xi+deltaXi)
     // m->jac_times_dxk and m->grad_fk are unchanged so far.
  
     // First SOC step
     std::vector<double> deltaXiSOC(nx_, 0.);
     std::vector<double> lambdaQPSOC(nx_+ng_, 0.);
  
     // Second order correction loop
     cNormOld = cNorm;
     for (casadi_int k=0; k<max_soc_iter_; k++) {
       nSOCS++;
  
       // Update bounds for SOC QP
       updateStepBounds(m, 1);
  
       // Solve SOC QP to obtain new, corrected deltaXi
       // (store in separate vector to avoid conflict with original deltaXi
       // -> need it in linesearch!)
       casadi_int info = solveQP(m, get_ptr(deltaXiSOC), get_ptr(lambdaQPSOC), false);
       if (info != 0) return false; // Could not solve QP, abort SOC
  
       // Set new SOC trial point
       for (casadi_int i=0; i<nx_; i++) {
         m->trial_xk[i] = d_nlp->z[i] + deltaXiSOC[i];
       }
  
       // Compute objective and ||constr(trialXiSOC)||_1 at SOC trial point
       info = evaluate(m, m->trial_xk, &objTrialSOC, m->gk);
       m->nFunCalls++;
       cNormTrialSOC = lInfConstraintNorm(m, m->trial_xk, m->gk);
       if (info != 0 || objTrialSOC < obj_lo_ || objTrialSOC > obj_up_
         || !(objTrialSOC == objTrialSOC) || !(cNormTrialSOC == cNormTrialSOC)) {
         return false; // evaluation error, abort SOC
       }
  
       // Check acceptability to the filter (in SOC)
       if (pairInFilter(m, cNormTrialSOC, objTrialSOC)) {
         // Trial point is in the prohibited region defined by the filter, abort SOC
         return false;
       }
  
       // Check sufficient decrease, case I (in SOC)
       // (Almost feasible and switching condition holds for line search alpha)
       if (cNorm <= theta_min_ && swCond) {
         if (objTrialSOC > m->obj + eta_*dfTdeltaXi) {
           // Armijo condition does not hold for SOC step, next SOC step
  
           // If constraint violation gets worse by SOC, abort
           if (cNormTrialSOC > kappa_soc_ * cNormOld) {
             return false;
           } else {
             cNormOld = cNormTrialSOC;
           }
           continue;
         } else {
           // found suitable alpha during SOC, stop
           acceptStep(m, get_ptr(deltaXiSOC), get_ptr(lambdaQPSOC), 1.0, nSOCS);
           return true;
         }
       }
  
       // Check sufficient decrease, case II (in SOC)
       if (cNorm > theta_min_ || !swCond) {
         if (cNormTrialSOC < (1.0 - gamma_theta_) * cNorm
         || objTrialSOC < m->obj - gamma_f_ * cNorm) {
           // found suitable alpha during SOC, stop
           acceptStep(m, get_ptr(deltaXiSOC), get_ptr(lambdaQPSOC), 1.0, nSOCS);
           return true;
         } else {
           // Trial point is dominated by current point, next SOC step
  
           // If constraint violation gets worse by SOC, abort
           if (cNormTrialSOC > kappa_soc_ * cNormOld) {
             return false;
           } else {
             cNormOld = cNormTrialSOC;
           }
           continue;
         }
       }
     }
  
     return false;
   }

References acceptStep(), casadi::NlpsolMemory::d_nlp, eta_, evaluate(), gamma_f_, gamma_theta_, casadi::get_ptr(), casadi::BlocksqpMemory::gk, casadi::FunctionInternal::info(), kappa_soc_, lInfConstraintNorm(), max_soc_iter_, casadi::BlocksqpMemory::nFunCalls, casadi::Nlpsol::ng_, casadi::Nlpsol::nx_, casadi::BlocksqpMemory::obj, obj_up_, pairInFilter(), solveQP(), theta_min_, casadi::BlocksqpMemory::trial_xk, and updateStepBounds().

Referenced by filterLineSearch().

◆ self()

Function casadi::FunctionInternal::self ( ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_k8

Definition at line 348 of file function_internal.hpp.

348 { return shared_from_this<Function>();}

◆ serialize()

void casadi::ProtoFunction::serialize ( SerializingStream & s ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_jv

Definition at line 4090 of file function_internal.cpp.

                                                           {
     serialize_type(s);
     serialize_body(s);
   }

References casadi::ProtoFunction::serialize_body(), and casadi::ProtoFunction::serialize_type().

◆ serialize_base_function()

std::string casadi::Nlpsol::serialize_base_function ( ) const

inlineoverridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1no

Reimplemented from casadi::ProtoFunction.

Definition at line 133 of file nlpsol_impl.hpp.

133 { return "Nlpsol"; }

◆ serialize_body()

void casadi::Blocksqp::serialize_body ( SerializingStream & s ) const

overridevirtual

Reimplemented from casadi::Nlpsol.

Definition at line 2915 of file blocksqp.cpp.

                                                           {
     Nlpsol::serialize_body(s);
     s.version("Blocksqp", 1);
     s.pack("Blocksqp::nblocks", nblocks_);
     s.pack("Blocksqp::blocks", blocks_);
     s.pack("Blocksqp::dim", dim_);
     s.pack("Blocksqp::nnz_H", nnz_H_);
     s.pack("Blocksqp::Asp", Asp_);
     s.pack("Blocksqp::Hsp", Hsp_);
     s.pack("Blocksqp::exact_hess_lag_sp_", exact_hess_lag_sp_);
     s.pack("Blocksqp::linsol_plugin", linsol_plugin_);
     s.pack("Blocksqp::print_header", print_header_);
     s.pack("Blocksqp::print_iteration", print_iteration_);
     s.pack("Blocksqp::eps", eps_);
     s.pack("Blocksqp::opttol", opttol_);
     s.pack("Blocksqp::nlinfeastol", nlinfeastol_);
     s.pack("Blocksqp::schur", schur_);
     s.pack("Blocksqp::globalization", globalization_);
     s.pack("Blocksqp::restore_feas", restore_feas_);
     s.pack("Blocksqp::max_line_search", max_line_search_);
     s.pack("Blocksqp::max_consec_reduced_steps", max_consec_reduced_steps_);
     s.pack("Blocksqp::max_consec_skipped_updates", max_consec_skipped_updates_);
     s.pack("Blocksqp::max_it_qp", max_it_qp_);
     s.pack("Blocksqp::max_iter", max_iter_);
     s.pack("Blocksqp::warmstart", warmstart_);
     s.pack("Blocksqp::qp_init", qp_init_);
     s.pack("Blocksqp::block_hess", block_hess_);
     s.pack("Blocksqp::hess_scaling", hess_scaling_);
     s.pack("Blocksqp::fallback_scaling", fallback_scaling_);
     s.pack("Blocksqp::max_time_qp", max_time_qp_);
     s.pack("Blocksqp::ini_hess_diag", ini_hess_diag_);
     s.pack("Blocksqp::col_eps", col_eps_);
     s.pack("Blocksqp::col_tau1", col_tau1_);
     s.pack("Blocksqp::col_tau2", col_tau2_);
     s.pack("Blocksqp::hess_damp", hess_damp_);
     s.pack("Blocksqp::hess_damp_fac", hess_damp_fac_);
     s.pack("Blocksqp::hess_update", hess_update_);
     s.pack("Blocksqp::fallback_update", fallback_update_);
     s.pack("Blocksqp::hess_lim_mem", hess_lim_mem_);
     s.pack("Blocksqp::hess_memsize", hess_memsize_);
     s.pack("Blocksqp::which_second_derv", which_second_derv_);
     s.pack("Blocksqp::skip_first_globalization", skip_first_globalization_);
     s.pack("Blocksqp::conv_strategy", conv_strategy_);
     s.pack("Blocksqp::max_conv_qp", max_conv_qp_);
     s.pack("Blocksqp::max_soc_iter", max_soc_iter_);
     s.pack("Blocksqp::gamma_theta", gamma_theta_);
     s.pack("Blocksqp::gamma_f", gamma_f_);
     s.pack("Blocksqp::kappa_soc", kappa_soc_);
     s.pack("Blocksqp::kappa_f", kappa_f_);
     s.pack("Blocksqp::theta_max", theta_max_);
     s.pack("Blocksqp::theta_min", theta_min_);
     s.pack("Blocksqp::delta", delta_);
     s.pack("Blocksqp::s_theta", s_theta_);
     s.pack("Blocksqp::s_f", s_f_);
     s.pack("Blocksqp::kappa_minus", kappa_minus_);
     s.pack("Blocksqp::kappa_plus", kappa_plus_);
     s.pack("Blocksqp::kappa_plus_max", kappa_plus_max_);
     s.pack("Blocksqp::delta_h0", delta_h0_);
     s.pack("Blocksqp::eta", eta_);
     s.pack("Blocksqp::obj_lo", obj_lo_);
     s.pack("Blocksqp::obj_up", obj_up_);
     s.pack("Blocksqp::rho", rho_);
     s.pack("Blocksqp::zeta", zeta_);
     s.pack("Blocksqp::rp_solver", rp_solver_);
     s.pack("Blocksqp::print_maxit_reached", print_maxit_reached_);
   }

References Asp_, block_hess_, blocks_, col_eps_, col_tau1_, col_tau2_, conv_strategy_, delta_, delta_h0_, dim_, eps_, eta_, exact_hess_lag_sp_, fallback_scaling_, fallback_update_, gamma_f_, gamma_theta_, globalization_, hess_damp_, hess_damp_fac_, hess_lim_mem_, hess_memsize_, hess_scaling_, hess_update_, Hsp_, ini_hess_diag_, kappa_f_, kappa_minus_, kappa_plus_, kappa_plus_max_, kappa_soc_, linsol_plugin_, max_consec_reduced_steps_, max_consec_skipped_updates_, max_conv_qp_, max_it_qp_, max_iter_, max_line_search_, max_soc_iter_, max_time_qp_, nblocks_, nlinfeastol_, nnz_H_, obj_lo_, obj_up_, opttol_, casadi::SerializingStream::pack(), print_header_, print_iteration_, print_maxit_reached_, qp_init_, restore_feas_, rho_, rp_solver_, s_f_, s_theta_, schur_, casadi::Nlpsol::serialize_body(), skip_first_globalization_, theta_max_, theta_min_, casadi::SerializingStream::version(), warmstart_, which_second_derv_, and zeta_.

◆ serialize_type()

void casadi::Nlpsol::serialize_type ( SerializingStream & s ) const

overridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nm

Reimplemented from casadi::FunctionInternal.

Definition at line 1336 of file nlpsol.cpp.

                                                         {
     OracleFunction::serialize_type(s);
     PluginInterface<Nlpsol>::serialize_type(s);
   }

References casadi::PluginInterface< Derived >::serialize_type(), and casadi::FunctionInternal::serialize_type().

◆ set_function() [1/2]

void casadi::OracleFunction::set_function ( const Function & fcn )

inlineinherited

Register the function for evaluation and statistics gathering

Definition at line 183 of file oracle_function.hpp.

183 { set_function(fcn, fcn.name()); }

References casadi::Function::name(), and casadi::OracleFunction::set_function().

Referenced by casadi::OracleFunction::set_function().

◆ set_function() [2/2]

void casadi::OracleFunction::set_function	(	const Function &	fcn,
		const std::string &	fname,
		bool	jit = `false`
	)

inherited

Register the function for evaluation and statistics gathering

Definition at line 286 of file oracle_function.cpp.

                                                                     {
   casadi_assert(!has_function(fname), "Duplicate function " + fname);
   RegFun& r = all_functions_[fname];
   r.f = fcn;
   r.jit = jit;
 }

References casadi::OracleFunction::all_functions_, casadi::OracleFunction::RegFun::f, casadi::OracleFunction::has_function(), and casadi::OracleFunction::RegFun::jit.

Referenced by casadi::OracleFunction::create_forward(), casadi::OracleFunction::create_function(), casadi::Integrator::init(), casadi::ImplicitFixedStepIntegrator::init(), casadi::Rootfinder::init(), casadi::BonminInterface::init(), casadi::IpoptInterface::init(), casadi::SundialsInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Newton::init(), casadi::Sqpmethod::init(), casadi::Collocation::setup_step(), and casadi::RungeKutta::setup_step().

◆ set_jac_sparsity()

void casadi::FunctionInternal::set_jac_sparsity	(	casadi_int	oind,
		casadi_int	iind,
		const Sparsity &	sp
	)

protectedinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nx

Definition at line 3677 of file function_internal.cpp.

                                                                                               {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     // Safe access to jac_sparsity_
     std::lock_guard<std::mutex> lock(jac_sparsity_mtx_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi_int ind = iind + oind * n_in_;
     jac_sparsity_[false].resize(n_in_ * n_out_);
     jac_sparsity_[false].at(ind) = sp;
     jac_sparsity_[true].resize(n_in_ * n_out_);
     jac_sparsity_[true].at(ind) = to_compact(oind, iind, sp);
   }

References casadi::FunctionInternal::jac_sparsity_, casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, and casadi::FunctionInternal::to_compact().

◆ set_temp()

void casadi::OracleFunction::set_temp	(	void *	mem,
		const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w
	)		const

overridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_q

Reimplemented from casadi::FunctionInternal.

Definition at line 505 of file oracle_function.cpp.

                                                            {
  
   auto m = static_cast<OracleMemory*>(mem);
   m->arg = arg;
   m->res = res;
   m->iw = iw;
   m->w = w;
   m->d_oracle.arg = arg;
   m->d_oracle.res = res;
   m->d_oracle.iw = iw;
   m->d_oracle.w = w;
   for (int i = 0; i < max_num_threads_; ++i) {
     auto* ml = m->thread_local_mem[i];
     for (auto&& s : ml->fstats) s.second.reset();
     ml->arg = arg;
     ml->res = res;
     ml->iw = iw;
     ml->w = w;
     arg += stride_arg_;
     res += stride_res_;
     iw += stride_iw_;
     w += stride_w_;
   }
 }

References casadi::OracleMemory::arg, casadi::OracleFunction::max_num_threads_, casadi::OracleFunction::stride_arg_, casadi::OracleFunction::stride_iw_, casadi::OracleFunction::stride_res_, and casadi::OracleFunction::stride_w_.

◆ set_work()

void casadi::Blocksqp::set_work	(	void *	mem,
		const double **&	arg,
		double **&	res,
		casadi_int *&	iw,
		double *&	w
	)		const

overridevirtual

Reimplemented from casadi::Nlpsol.

Definition at line 582 of file blocksqp.cpp.

                                                                       {
     auto m = static_cast<BlocksqpMemory*>(mem);
  
     // Set work in base classes
     Nlpsol::set_work(mem, arg, res, iw, w);
  
     // Temporary memory
     m->jac = w; w += Asp_.nnz();
     m->lam_xk = w; w += nx_;
     m->lam_gk = w; w += ng_;
     m->gk = w; w += ng_;
     m->grad_fk = w; w += nx_;
     m->grad_lagk = w; w += nx_;
     m->lam_qp = w; w += nx_+ng_;
     m->delta_norm = w; w += nblocks_;
     m->delta_norm_old = w; w += nblocks_;
     m->delta_gamma = w; w += nblocks_;
     m->delta_gamma_old = w; w += nblocks_;
     m->delta_h = w; w += nblocks_;
     m->trial_xk = w; w += nx_;
     m->lbx_qp = w; w += nx_;
     m->ubx_qp = w; w += nx_;
     m->lba_qp = w; w += ng_;
     m->uba_qp = w; w += ng_;
     m->jac_times_dxk = w; w += ng_;
     m->deltaMat = w; w += nx_*hess_memsize_;
     m->gammaMat = w; w += nx_*hess_memsize_;
     m->jac_g = w; w += Asp_.nnz();
     m->hess_lag = w; w += nnz_H_;
     m->hessIndRow = reinterpret_cast<int*>(iw); iw += nnz_H_ + (nx_+1) + nx_;
     m->noUpdateCounter = iw; iw += nblocks_;
  
     // First Hessian
     m->hess1 = res; res += nblocks_;
     for (casadi_int b=0; b<nblocks_; b++) {
       m->hess1[b] = w; w += dim_[b]*dim_[b];
     }
  
     // Second Hessian, for SR1 or finite differences
     if (hess_update_ == 1 || hess_update_ == 4) {
       m->hess2 = res; res += nblocks_;
       for (casadi_int b=0; b<nblocks_; b++) {
         m->hess2[b] = w; w += dim_[b]*dim_[b];
       }
     } else {
       m->hess2 = nullptr;
     }
  
     m->exact_hess_lag = w; w += exact_hess_lag_sp_.nnz();
   }

References Asp_, dim_, exact_hess_lag_sp_, hess_memsize_, hess_update_, nblocks_, casadi::Nlpsol::ng_, casadi::Sparsity::nnz(), nnz_H_, casadi::Nlpsol::nx_, and casadi::Nlpsol::set_work().

◆ setOptionsFromFile()

void casadi::Nlpsol::setOptionsFromFile ( const std::string & file )

virtualinherited

Definition at line 674 of file nlpsol.cpp.

                                                         {
     casadi_error("setOptionsFromFile not defined for class " + class_name());
   }

References casadi::Nlpsol::class_name().

◆ setup()

void casadi::FunctionInternal::setup	(	void *	mem,
		const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nb

Definition at line 3465 of file function_internal.cpp.

                                                                 {
     set_work(mem, arg, res, iw, w);
     set_temp(mem, arg, res, iw, w);
     auto m = static_cast<FunctionMemory*>(mem);
     m->stats_available = true;
   }

References casadi::FunctionInternal::set_temp(), casadi::FunctionInternal::set_work(), and casadi::FunctionMemory::stats_available.

Referenced by casadi::Conic::eval(), casadi::Nlpsol::eval(), casadi::CallbackInternal::eval(), casadi::FiniteDiff::eval(), casadi::FmuFunction::eval(), casadi::Integrator::eval(), casadi::Map::eval(), casadi::OmpMap::eval(), casadi::ThreadMap::eval(), casadi::MapSum::eval(), casadi::MXFunction::eval(), casadi::Rootfinder::eval(), casadi::Switch::eval(), casadi::SXFunction::eval(), casadi::SlicotDple::eval(), casadi::SlicotExpm::eval(), casadi::BSplineInterpolant::eval(), and casadi::LinearInterpolant::eval().

◆ shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
       B ret;
       ret.own(static_cast<Internal*>(this));
       return ret;
     }

◆ shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                      {
       casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
       B ret;
       ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
       return ret;
     }

◆ shortname()

static std::string casadi::Nlpsol::shortname ( )

inlinestaticinherited

Definition at line 293 of file nlpsol_impl.hpp.

293 { return "nlpsol";}

◆ signature()

std::string casadi::FunctionInternal::signature ( const std::string & fname ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ly

Definition at line 2329 of file function_internal.cpp.

                                                                     {
     return "int " + fname + "(const casadi_real** arg, casadi_real** res, "
                             "casadi_int* iw, casadi_real* w, int mem)";
   }

Referenced by casadi::CodeGenerator::add(), casadi::FunctionInternal::codegen(), and casadi::External::codegen_declarations().

◆ signature_unrolled()

std::string casadi::FunctionInternal::signature_unrolled ( const std::string & fname ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_27o

Definition at line 2334 of file function_internal.cpp.

                                                                              {
     std::vector<std::string> args;
     for (auto e : name_in_) {
       args.push_back("const casadi_real* " + str(e));
     }
     for (auto e : name_out_) {
       args.push_back("casadi_real* " + str(e));
     }
     args.push_back("const casadi_real** arg");
     args.push_back("casadi_real** res");
     args.push_back("casadi_int* iw");
     args.push_back("casadi_real* w");
     args.push_back("int mem");
     return "int " + fname + "_unrolled(" + join(args, ", ") + ")";
   }

References casadi::join(), casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, and casadi::str().

Referenced by casadi::CodeGenerator::add().

◆ size1_in()

casadi_int casadi::FunctionInternal::size1_in ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mg

Definition at line 988 of file function_internal.hpp.

988 { return sparsity_in(ind).size1(); }

casadi::Sparsity::size1

casadi_int size1() const

Get the number of rows.

Definition: sparsity.cpp:124

Referenced by casadi::FunctionInternal::check_arg(), casadi::FmuFunction::eval(), casadi::FmuFunction::eval_task(), casadi::FunctionInternal::forward(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), casadi::FunctionInternal::matching_arg(), and casadi::FunctionInternal::reverse().

◆ size1_out()

casadi_int casadi::FunctionInternal::size1_out ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mg

Definition at line 990 of file function_internal.hpp.

990 { return sparsity_out(ind).size1(); }

Referenced by casadi::FmuFunction::eval_task(), casadi::FunctionInternal::forward(), casadi::Integrator::get_forward(), casadi::LinearInterpolantJac::get_jacobian(), casadi::FunctionInternal::matching_res(), and casadi::FunctionInternal::reverse().

◆ size2_in()

casadi_int casadi::FunctionInternal::size2_in ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mg

Definition at line 989 of file function_internal.hpp.

989 { return sparsity_in(ind).size2(); }

Referenced by casadi::FunctionInternal::call_gen(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::check_arg(), casadi::FunctionInternal::forward(), casadi::Integrator::get_reverse(), casadi::FunctionInternal::mapsum_mx(), casadi::FunctionInternal::matching_arg(), casadi::FunctionInternal::project_arg(), and casadi::FunctionInternal::reverse().

◆ size2_out()

casadi_int casadi::FunctionInternal::size2_out ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mg

Definition at line 991 of file function_internal.hpp.

991 { return sparsity_out(ind).size2(); }

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::forward(), casadi::Integrator::get_forward(), casadi::LinearInterpolantJac::get_jacobian(), casadi::FunctionInternal::matching_res(), and casadi::FunctionInternal::reverse().

◆ size_in()

std::pair<casadi_int, casadi_int> casadi::FunctionInternal::size_in ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mg

Definition at line 992 of file function_internal.hpp.

                                                                   {
       return sparsity_in(ind).size();
     }

Referenced by casadi::Rootfinder::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::MXFunction::ad_reverse(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::fwd_seed(), casadi::Dple::get_forward(), and casadi::Dple::get_reverse().

◆ size_out()

std::pair<casadi_int, casadi_int> casadi::FunctionInternal::size_out ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mg

Definition at line 995 of file function_internal.hpp.

                                                                    {
       return sparsity_out(ind).size();
     }

Referenced by casadi::MXFunction::ad_forward(), casadi::Rootfinder::ad_reverse(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::check_res(), casadi::FunctionInternal::eval(), casadi::Integrator::get_forward(), casadi::Integrator::get_reverse(), and casadi::Nlpsol::init().

◆ sizeHessianCOL()

void casadi::Blocksqp::sizeHessianCOL	(	BlocksqpMemory *	m,
		const double *	gamma,
		const double *	delta,
		casadi_int	b
	)		const

Definition at line 1873 of file blocksqp.cpp.

                                                           {
     casadi_int dim = dim_[b];
     double theta, scale, myEps = 1.0e3 * eps_;
     double deltaNorm, deltaNormOld, deltaGamma, deltaGammaOld, deltaBdelta;
  
     // Get sTs, sTs_, sTy, sTy_, sTBs
     deltaNorm = m->delta_norm[b];
     deltaGamma = m->delta_gamma[b];
     deltaNormOld = m->delta_norm_old[b];
     deltaGammaOld = m->delta_gamma_old[b];
     deltaBdelta = 0.0;
     for (casadi_int i=0; i<dim; i++)
       for (casadi_int j=0; j<dim; j++)
         deltaBdelta += delta[i] * m->hess[b][i+j*dim] * delta[j];
  
     // Centered Oren-Luenberger factor
     if (m->noUpdateCounter[b] == -1) {
       // in the first iteration, this should equal the OL factor
       theta = 1.0;
     } else {
       theta = fmin(col_tau1_, col_tau2_ * deltaNorm);
     }
     if (deltaNorm > myEps && deltaNormOld > myEps) {
       scale = (1.0 - theta)*deltaGammaOld / deltaNormOld + theta*deltaBdelta / deltaNorm;
       if (scale > eps_)
         scale = ((1.0 - theta)*deltaGammaOld / deltaNormOld + theta*deltaGamma / deltaNorm) / scale;
     } else {
       scale = 1.0;
     }
  
     // Size only if factor is between zero and one
     if (scale < 1.0 && scale > 0.0) {
       scale = fmax(col_eps_, scale);
       //print("Sizing value (COL) block %i = %g\n", b, scale);
       for (casadi_int i=0; i<dim; i++)
         for (casadi_int j=0; j<dim; j++)
           m->hess[b][i+j*dim] *= scale;
  
       // statistics: average sizing factor
       m->averageSizingFactor += scale;
     } else {
       m->averageSizingFactor += 1.0;
     }
   }

References casadi::BlocksqpMemory::averageSizingFactor, col_eps_, col_tau1_, col_tau2_, casadi::BlocksqpMemory::delta_gamma, casadi::BlocksqpMemory::delta_gamma_old, casadi::BlocksqpMemory::delta_norm, casadi::BlocksqpMemory::delta_norm_old, dim_, eps_, casadi::BlocksqpMemory::hess, and casadi::BlocksqpMemory::noUpdateCounter.

Referenced by calcHessianUpdate(), and calcHessianUpdateLimitedMemory().

◆ sizeInitialHessian()

void casadi::Blocksqp::sizeInitialHessian	(	BlocksqpMemory *	m,
		const double *	gamma,
		const double *	delta,
		casadi_int	b,
		casadi_int	option
	)		const

Definition at line 1834 of file blocksqp.cpp.

                                                                                  {
     casadi_int dim = dim_[b];
     double scale;
     double myEps = 1.0e3 * eps_;
  
     if (option == 1) {
       // Shanno-Phua
       scale = casadi_dot(dim, gamma, gamma)
         / fmax(casadi_dot(dim, delta, gamma), myEps);
     } else if (option == 2) {
       // Oren-Luenberger
       scale = casadi_dot(dim, delta, gamma)
         / fmax(casadi_dot(dim, delta, delta), myEps);
       scale = fmin(scale, 1.0);
     } else if (option == 3) {
       // Geometric mean of 1 and 2
       scale = sqrt(casadi_dot(dim, gamma, gamma)
         / fmax(casadi_dot(dim, delta, delta), myEps));
     } else {
       // Invalid option, ignore
       return;
     }
  
     if (scale > 0.0) {
       scale = fmax(scale, myEps);
       for (casadi_int i=0; i<dim; i++)
         for (casadi_int j=0; j<dim; j++)
           m->hess[b][i+j*dim] *= scale;
     } else {
       scale = 1.0;
     }
  
     // statistics: average sizing factor
     m->averageSizingFactor += scale;
   }

References casadi::BlocksqpMemory::averageSizingFactor, casadi::casadi_dot(), dim_, eps_, and casadi::BlocksqpMemory::hess.

Referenced by calcHessianUpdate(), and calcHessianUpdateLimitedMemory().

◆ slice()

Function casadi::FunctionInternal::slice	(	const std::string &	name,
		const std::vector< casadi_int > &	order_in,
		const std::vector< casadi_int > &	order_out,
		const Dict &	opts
	)		const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l2

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, and casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >.

Definition at line 3658 of file function_internal.cpp.

                                                                         {
     return wrap().slice(name, order_in, order_out, opts);
   }

References casadi::Function::slice(), and casadi::FunctionInternal::wrap().

Referenced by casadi::Function::slice().

◆ solve()

int casadi::Blocksqp::solve ( void * mem ) const

overridevirtual

Implements casadi::Nlpsol.

Definition at line 634 of file blocksqp.cpp.

                                      {
     auto m = static_cast<BlocksqpMemory*>(mem);
     auto d_nlp = &m->d_nlp;
  
     casadi_int ret = 0;
  
     // Create problem evaluation object
     std::vector<casadi_int> blocks = blocks_;
  
     /*-------------------------------------------------*/
     /* Create blockSQP method object and run algorithm */
     /*-------------------------------------------------*/
     m->itCount = 0;
     m->qpItTotal = 0;
     m->qpIterations = 0;
     m->qpIterations2 = 0;
     m->qpResolve = 0;
     m->rejectedSR1 = 0;
     m->hessSkipped = 0;
     m->hessDamped = 0;
     m->averageSizingFactor = 0.0;
     m->nFunCalls = 0;
     m->nDerCalls = 0;
     m->nRestHeurCalls = 0;
     m->nRestPhaseCalls = 0;
  
     m->nTotalUpdates = 0;
     m->nTotalSkippedUpdates = 0;
  
     casadi_int maxblocksize = 1;
  
     for (casadi_int k=0; k<nblocks_+1; k++) {
       if (k > 0)
         if (blocks_[k] - blocks_[k-1] > maxblocksize)
           maxblocksize = blocks_[k] - blocks_[k-1];
     }
  
     if (hess_lim_mem_ && hess_memsize_ == 0)
       const_cast<Blocksqp*>(this)->hess_memsize_ = maxblocksize;
  
     // Reset the SQP metod
     reset_sqp(m);
  
     // Free existing memory, if any
     if (qp_init_) {
       delete m->qp;
       m->qp = nullptr;
     }
     if (!m->qp) {
       if (schur_) {
         m->qp = new qpOASES::SQProblemSchur(nx_, ng_, qpOASES::HST_UNKNOWN, 50,
                                             m->qpoases_mem,
                                             QpoasesInterface::qpoases_init,
                                             QpoasesInterface::qpoases_sfact,
                                             QpoasesInterface::qpoases_nfact,
                                             QpoasesInterface::qpoases_solve);
       } else {
         m->qp = new qpOASES::SQProblem(nx_, ng_);
       }
     }
  
     // Print header and information about the algorithmic parameters
     if (print_header_) printInfo(m);
  
     // Open output files
     initStats(m);
     initIterate(m);
  
     // Initialize filter with pair (maxConstrViolation, objLowerBound)
     initializeFilter(m);
  
     // Primal-dual initial guess
     casadi_copy(d_nlp->lam, nx_, m->lam_xk);
     casadi_scal(nx_, -1., m->lam_xk);
     casadi_copy(d_nlp->lam + nx_, ng_, m->lam_gk);
     casadi_scal(ng_, -1., m->lam_gk);
  
     casadi_copy(m->lam_xk, nx_, m->lam_qp);
     casadi_copy(m->lam_gk, ng_, m->lam_qp+nx_);
  
     ret = run(m, max_iter_, warmstart_);
  
     m->success = ret==0;
     m->ret_ = ret;
  
     if (ret==1) {
       if (print_maxit_reached_) print("***WARNING: Maximum number of iterations reached\n");
       m->unified_return_status = SOLVER_RET_LIMITED;
     }
  
  
     // Get optimal cost
     d_nlp->objective = m->obj;
     // Get constraints at solution
     casadi_copy(m->gk, ng_, d_nlp->z + nx_);
     // Get dual solution (simple bounds)
     if (d_nlp->lam) {
       casadi_copy(m->lam_xk, nx_, d_nlp->lam);
       casadi_scal(nx_, -1., d_nlp->lam);
     }
     // Get dual solution (nonlinear bounds)
     casadi_copy(m->lam_gk, ng_, d_nlp->lam + nx_);
     casadi_scal(ng_, -1., d_nlp->lam + nx_);
     return 0;
   }

References blocks_, casadi::casadi_copy(), casadi::casadi_scal(), casadi::NlpsolMemory::d_nlp, hess_lim_mem_, hess_memsize_, initializeFilter(), initIterate(), initStats(), max_iter_, nblocks_, casadi::Nlpsol::ng_, casadi::Nlpsol::nx_, casadi::ProtoFunction::print(), print_header_, print_maxit_reached_, printInfo(), qp_init_, casadi::QpoasesInterface::qpoases_init(), casadi::QpoasesInterface::qpoases_nfact(), casadi::QpoasesInterface::qpoases_sfact(), casadi::QpoasesInterface::qpoases_solve(), reset_sqp(), run(), schur_, casadi::SOLVER_RET_LIMITED, and warmstart_.

◆ solveQP()

casadi_int casadi::Blocksqp::solveQP	(	BlocksqpMemory *	m,
		double *	deltaXi,
		double *	lambdaQP,
		bool	matricesChanged = `true`
	)		const

Inner loop of SQP algorithm: Solve a sequence of QPs until pos. def. assumption (G3*) is satisfied.

Definition at line 2305 of file blocksqp.cpp.

                                 {
     casadi_int maxQP, l;
     if (globalization_ &&
         (hess_update_ == 1 || hess_update_ == 4) &&
         matricesChanged &&
         m->itCount > 1) {
         maxQP = max_conv_qp_ + 1;
       } else {
       maxQP = 1;
     }
  
     /*
      * Prepare for qpOASES
      */
  
     // Setup QProblem data
     if (matricesChanged) {
       delete m->A;
       m->A = nullptr;
       copy_vector(Asp_.colind(), m->colind);
       copy_vector(Asp_.row(), m->row);
       int* jacIndRow = get_ptr(m->row);
       int* jacIndCol = get_ptr(m->colind);
       m->A = new qpOASES::SparseMatrix(ng_, nx_,
                                        jacIndRow, jacIndCol, m->jac_g);
     }
     double *g = m->grad_fk;
     double *lb = m->lbx_qp;
     double *lu = m->ubx_qp;
     double *lbA = m->lba_qp;
     double *luA = m->uba_qp;
  
     // qpOASES options
     qpOASES::Options opts;
     if (matricesChanged && maxQP > 1)
       opts.enableInertiaCorrection = qpOASES::BT_FALSE;
     else
       opts.enableInertiaCorrection = qpOASES::BT_TRUE;
     opts.enableEqualities = qpOASES::BT_TRUE;
     opts.initialStatusBounds = qpOASES::ST_INACTIVE;
     opts.printLevel = qpOASES::PL_NONE;
     opts.numRefinementSteps = 2;
     opts.epsLITests =  2.2204e-08;
     m->qp->setOptions(opts);
  
     // Other variables for qpOASES
     double cpuTime = matricesChanged ? max_time_qp_ : 0.1*max_time_qp_;
     int maxIt = matricesChanged ? max_it_qp_ : static_cast<int>(0.1*max_it_qp_);
     qpOASES::SolutionAnalysis solAna;
     qpOASES::returnValue ret = qpOASES::RET_INFO_UNDEFINED;
  
     /*
      * QP solving loop for convex combinations (sequential)
      */
     for (l=0; l<maxQP; l++) {
         /*
          * Compute a new Hessian
          */
         if (l > 0) {
           // If the solution of the first QP was rejected, consider second Hessian
           m->qpResolve++;
           computeNextHessian(m, l, maxQP);
         }
  
         if (l == maxQP-1) {
           // Enable inertia correction for supposedly convex QPs, just in case
           opts.enableInertiaCorrection = qpOASES::BT_TRUE;
           m->qp->setOptions(opts);
         }
  
         /*
          * Prepare the current Hessian for qpOASES
          */
         if (matricesChanged) {
           // Convert block-Hessian to sparse format
           convertHessian(m);
           delete m->H;
           m->H = nullptr;
           m->H = new qpOASES::SymSparseMat(nx_, nx_,
                                            m->hessIndRow, m->hessIndCol,
                                            m->hess_lag);
           m->H->createDiagInfo();
         }
  
         /*
          * Call qpOASES
          */
         if (matricesChanged) {
             maxIt = max_it_qp_;
             cpuTime = max_time_qp_;
             if (m->qp->getStatus() == qpOASES::QPS_HOMOTOPYQPSOLVED ||
                 m->qp->getStatus() == qpOASES::QPS_SOLVED) {
                 ret = m->qp->hotstart(m->H, g, m->A, lb, lu, lbA, luA, maxIt, &cpuTime);
               } else {
                 if (warmstart_) {
                   ret = m->qp->init(m->H, g, m->A, lb, lu, lbA, luA, maxIt, &cpuTime,
                     deltaXi, lambdaQP);
                 } else {
                   ret = m->qp->init(m->H, g, m->A, lb, lu, lbA, luA, maxIt, &cpuTime);
                 }
               }
           } else {
             // Second order correction: H and A do not change
             maxIt = static_cast<int>(0.1*max_it_qp_);
             cpuTime = 0.1*max_time_qp_;
             ret = m->qp->hotstart(g, lb, lu, lbA, luA, maxIt, &cpuTime);
           }
  
         /*
          * Check assumption (G3*) if nonconvex QP was solved
          */
         if (l < maxQP-1 && matricesChanged) {
             if (ret == qpOASES::SUCCESSFUL_RETURN) {
                 if (schur_) {
                   ret = solAna.checkCurvatureOnStronglyActiveConstraints(
                     dynamic_cast<qpOASES::SQProblemSchur*>(m->qp));
                 } else {
                   ret = solAna.checkCurvatureOnStronglyActiveConstraints(m->qp);
                 }
               }
  
             if (ret == qpOASES::SUCCESSFUL_RETURN) {
               // QP was solved successfully and curvature is positive after removing bounds
                 m->qpIterations = maxIt + 1;
                 break; // Success!
               } else {
               // QP solution is rejected, save statistics
                 if (ret == qpOASES::RET_SETUP_AUXILIARYQP_FAILED)
                   m->qpIterations2++;
                 else
                   m->qpIterations2 += maxIt + 1;
                 m->rejectedSR1++;
               }
           } else {
             // Convex QP was solved, no need to check assumption (G3*)
             m->qpIterations += maxIt + 1;
           }
  
       } // End of QP solving loop
  
     /*
      * Post-processing
      */
  
     // Get solution from qpOASES
     m->qp->getPrimalSolution(deltaXi);
     m->qp->getDualSolution(lambdaQP);
     m->qpObj = m->qp->getObjVal();
  
     // Compute constrJac*deltaXi, need this for second order correction step
     casadi_fill(m->jac_times_dxk, ng_, 0.);
     casadi_mv(m->jac_g, Asp_, deltaXi, m->jac_times_dxk, 0);
  
     // Print qpOASES error code, if any
     if (ret != qpOASES::SUCCESSFUL_RETURN && matricesChanged)
       print("***WARNING: qpOASES error message: \"%s\"\n",
               qpOASES::MessageHandling::getErrorCodeMessage(ret));
  
     // Point Hessian again to the first Hessian
     m->hess = m->hess1;
  
     /* For full-memory Hessian: Restore fallback Hessian if convex combinations
      * were used during the loop */
     if (!hess_lim_mem_ && maxQP > 2 && matricesChanged) {
         double mu = 1.0 / l;
         double mu1 = 1.0 - mu;
         casadi_int nBlocks = (which_second_derv_ == 1) ? nblocks_-1 : nblocks_;
         for (casadi_int b=0; b<nBlocks; b++) {
           casadi_int dim = dim_[b];
           for (casadi_int i=0; i<dim; i++) {
             for (casadi_int j=0; j<dim; j++) {
               m->hess2[b][i+j*dim] *= mu;
               m->hess2[b][i+j*dim] += mu1 * m->hess1[b][i+j*dim];
             }
           }
         }
     }
  
     /* Return code depending on qpOASES returnvalue
      * 0: Success
      * 1: Maximum number of iterations reached
      * 2: Unbounded
      * 3: Infeasible
      * 4: Other error */
      switch (ret) {
         case qpOASES::SUCCESSFUL_RETURN:
           return 0;
         case qpOASES::RET_MAX_NWSR_REACHED:
           return 1;
         case qpOASES::RET_HESSIAN_NOT_SPD:
         case qpOASES::RET_HESSIAN_INDEFINITE:
         case qpOASES::RET_INIT_FAILED_UNBOUNDEDNESS:
         case qpOASES::RET_QP_UNBOUNDED:
         case qpOASES::RET_HOTSTART_STOPPED_UNBOUNDEDNESS:
           return 2;
         case qpOASES::RET_INIT_FAILED_INFEASIBILITY:
         case qpOASES::RET_QP_INFEASIBLE:
         case qpOASES::RET_HOTSTART_STOPPED_INFEASIBILITY:
           return 3;
         default:
           return 4;
      }
   }

Referenced by run(), and secondOrderCorrection().

◆ sp_forward()

int casadi::FunctionInternal::sp_forward	(	const bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem
	)		const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mw

Reimplemented in casadi::BSplineInterpolant, casadi::SXFunction, casadi::Rootfinder, casadi::MXFunction, casadi::MapSum, casadi::Map, and casadi::Integrator.

Definition at line 2754 of file function_internal.cpp.

                                                                                            {
     // Loop over outputs
     for (casadi_int oind=0; oind<n_out_; ++oind) {
       // Skip if nothing to assign
       if (res[oind]==nullptr || nnz_out(oind)==0) continue;
       // Clear result
       casadi_clear(res[oind], nnz_out(oind));
       // Loop over inputs
       for (casadi_int iind=0; iind<n_in_; ++iind) {
         // Skip if no seeds
         if (arg[iind]==nullptr || nnz_in(iind)==0) continue;
         // Propagate sparsity for the specific block
         if (sp_forward_block(arg, res, iw, w, mem, oind, iind)) return 1;
       }
     }
     return 0;
   }

References casadi::casadi_clear(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), and casadi::FunctionInternal::sp_forward_block().

Referenced by casadi::MXFunction::sp_forward(), casadi::SXFunction::sp_forward(), and casadi::BSplineInterpolant::sp_forward().

◆ sp_forward_block()

int casadi::FunctionInternal::sp_forward_block	(	const bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem,
		casadi_int	oind,
		casadi_int	iind
	)		const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mx

Definition at line 2773 of file function_internal.cpp.

                                                                                     {
     // Get the sparsity of the Jacobian block
     Sparsity sp = jac_sparsity(oind, iind, true, false);
     if (sp.is_null() || sp.nnz() == 0) return 0; // Skip if zero
     // Carry out the sparse matrix-vector multiplication
     casadi_int d1 = sp.size2();
     const casadi_int *colind = sp.colind(), *row = sp.row();
     for (casadi_int cc=0; cc<d1; ++cc) {
       for (casadi_int el = colind[cc]; el < colind[cc+1]; ++el) {
         res[oind][row[el]] |= arg[iind][cc];
       }
     }
     return 0;
   }

References casadi::Sparsity::colind(), casadi::GenericShared< Shared, Internal >::is_null(), casadi::FunctionInternal::jac_sparsity(), casadi::Sparsity::nnz(), casadi::Sparsity::row(), and casadi::Sparsity::size2().

Referenced by casadi::FunctionInternal::sp_forward().

◆ sp_reverse()

int casadi::FunctionInternal::sp_reverse	(	bvec_t **	arg,
		bvec_t **	res,
		casadi_int *	iw,
		bvec_t *	w,
		void *	mem
	)		const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_my

Reimplemented in casadi::BSplineInterpolant, casadi::SXFunction, casadi::Rootfinder, casadi::MXFunction, casadi::MapSum, casadi::Map, and casadi::Integrator.

Definition at line 2789 of file function_internal.cpp.

                                                                                      {
     // Loop over outputs
     for (casadi_int oind=0; oind<n_out_; ++oind) {
       // Skip if nothing to assign
       if (res[oind]==nullptr || nnz_out(oind)==0) continue;
  
       // Loop over inputs
       for (casadi_int iind=0; iind<n_in_; ++iind) {
         // Skip if no seeds
         if (arg[iind]==nullptr || nnz_in(iind)==0) continue;
  
         // Get the sparsity of the Jacobian block
         Sparsity sp = jac_sparsity(oind, iind, true, false);
         if (sp.is_null() || sp.nnz() == 0) continue; // 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) {
             arg[iind][cc] |= res[oind][row[el]];
           }
         }
       }
  
       // Clear seeds
       casadi_clear(res[oind], nnz_out(oind));
     }
     return 0;
   }

References casadi::casadi_clear(), casadi::Sparsity::colind(), casadi::GenericShared< Shared, Internal >::is_null(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::n_in_, casadi::FunctionInternal::n_out_, casadi::Sparsity::nnz(), casadi::FunctionInternal::nnz_in(), casadi::FunctionInternal::nnz_out(), casadi::Sparsity::row(), and casadi::Sparsity::size2().

Referenced by casadi::MXFunction::sp_reverse(), casadi::SXFunction::sp_reverse(), and casadi::BSplineInterpolant::sp_reverse().

◆ sp_weight()

double casadi::FunctionInternal::sp_weight ( ) const

virtualinherited

sparsity propagation

Extra doc: https://github.com/casadi/casadi/wiki/L_l6

Definition at line 3201 of file function_internal.cpp.

                                            {
     // If reverse mode propagation unavailable, use forward
     if (!has_sprev()) return 0;
  
     // If forward mode propagation unavailable, use reverse
     if (!has_spfwd()) return 1;
  
     // Use the (potentially user set) option
     return ad_weight_sp_;
   }

References casadi::FunctionInternal::ad_weight_sp_, casadi::FunctionInternal::has_spfwd(), and casadi::FunctionInternal::has_sprev().

Referenced by casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::MXFunction::sp_forward(), casadi::SXFunction::sp_forward(), casadi::MXFunction::sp_reverse(), casadi::SXFunction::sp_reverse(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

◆ sparsity_in()

const Sparsity& casadi::FunctionInternal::sparsity_in ( casadi_int ind ) const

inlineinherited

◆ sparsity_out()

const Sparsity& casadi::FunctionInternal::sparsity_out ( casadi_int ind ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mh

Definition at line 1005 of file function_internal.hpp.

1005 { return sparsity_out_.at(ind); }

◆ sprint()

void casadi::ProtoFunction::sprint	(	char *	buf,
		size_t	buf_sz,
		const char *	fmt,
			...
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_js

Definition at line 3801 of file function_internal.cpp.

                                                                                  {
     // Variable number of arguments
     va_list args;
     va_start(args, fmt);
     // Print to buffer
     casadi_int n = vsnprintf(buf, buf_sz, fmt, args);
     // Cleanup
     va_end(args);
     // Throw error if failure
     casadi_assert(n>=0 && n<buf_sz, "Print failure while processing '" + std::string(fmt) + "'");
   }

Referenced by casadi::ProtoFunction::format_time(), and casadi::ProtoFunction::print_time().

◆ string_from_UnifiedReturnStatus()

std::string casadi::FunctionInternal::string_from_UnifiedReturnStatus ( UnifiedReturnStatus status )

staticinherited

Definition at line 3869 of file function_internal.cpp.

                                                                                         {
     switch (status) {
       case SOLVER_RET_LIMITED:  return "SOLVER_RET_LIMITED";
       case SOLVER_RET_NAN:  return "SOLVER_RET_NAN";
       case SOLVER_RET_SUCCESS:  return "SOLVER_RET_SUCCESS";
       default: return "SOLVER_RET_UNKNOWN";
     }
   }

References casadi::SOLVER_RET_LIMITED, casadi::SOLVER_RET_NAN, and casadi::SOLVER_RET_SUCCESS.

Referenced by casadi::Conic::get_stats(), casadi::Nlpsol::get_stats(), and casadi::Rootfinder::get_stats().

◆ sx_in() [1/2]

const std::vector< SX > casadi::FunctionInternal::sx_in ( ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Reimplemented in casadi::SXFunction.

Definition at line 3228 of file function_internal.cpp.

                                                     {
     std::vector<SX> ret(n_in_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = sx_in(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_in_.

◆ sx_in() [2/2]

const SX casadi::FunctionInternal::sx_in ( casadi_int ind ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Reimplemented in casadi::SXFunction.

Definition at line 3212 of file function_internal.cpp.

                                                        {
     return SX::sym(name_in_.at(ind), sparsity_in(ind));
   }

References casadi::FunctionInternal::name_in_, casadi::FunctionInternal::sparsity_in(), and casadi::GenericMatrix< Matrix< Scalar > >::sym().

◆ sx_out() [1/2]

const std::vector< SX > casadi::FunctionInternal::sx_out ( ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Definition at line 3236 of file function_internal.cpp.

                                                      {
     std::vector<SX> ret(n_out_);
     for (casadi_int i=0; i<ret.size(); ++i) {
       ret[i] = sx_out(i);
     }
     return ret;
   }

References casadi::FunctionInternal::n_out_.

◆ sx_out() [2/2]

const SX casadi::FunctionInternal::sx_out ( casadi_int ind ) const

virtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_l7

Definition at line 3216 of file function_internal.cpp.

                                                         {
     return SX::sym(name_out_.at(ind), sparsity_out(ind));
   }

References casadi::FunctionInternal::name_out_, casadi::FunctionInternal::sparsity_out(), and casadi::GenericMatrix< Matrix< Scalar > >::sym().

◆ symbolic_output()

std::vector< MX > casadi::FunctionInternal::symbolic_output ( const std::vector< MX > & arg ) const

virtualinherited

Reimplemented in casadi::MXFunction.

Definition at line 1066 of file function_internal.cpp.

                                                                                 {
     return self()(arg);
   }

Referenced by casadi::MXFunction::symbolic_output().

◆ symbolicAdjSeed()

template<typename MatType >

std::vector< std::vector< MatType > > casadi::FunctionInternal::symbolicAdjSeed	(	casadi_int	nadj,
		const std::vector< MatType > &	v
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ns

Definition at line 1512 of file function_internal.hpp.

                                                                       {
     std::vector<std::vector<MatType> > aseed(nadj, v);
     for (casadi_int dir=0; dir<nadj; ++dir) {
       // Replace symbolic inputs
       casadi_int oind=0;
       for (typename std::vector<MatType>::iterator i=aseed[dir].begin();
           i!=aseed[dir].end();
           ++i, ++oind) {
         // Name of the adjoint seed
         std::stringstream ss;
         ss << "a";
         if (nadj>1) ss << dir << "_";
         ss << oind;
  
         // Save to matrix
         *i = MatType::sym(ss.str(), is_diff_out_[oind] ? i->sparsity() : Sparsity(i->size()));
  
       }
     }
     return aseed;
   }

References casadi::FunctionInternal::is_diff_out_.

◆ sz_arg()

size_t casadi::FunctionInternal::sz_arg ( ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_n0

Definition at line 1167 of file function_internal.hpp.

1167 { return sz_arg_per_ + sz_arg_tmp_;}

◆ sz_iw()

size_t casadi::FunctionInternal::sz_iw ( ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_n2

Definition at line 1177 of file function_internal.hpp.

1177 { return sz_iw_per_ + sz_iw_tmp_;}

◆ sz_res()

size_t casadi::FunctionInternal::sz_res ( ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_n1

Definition at line 1172 of file function_internal.hpp.

1172 { return sz_res_per_ + sz_res_tmp_;}

◆ sz_w()

size_t casadi::FunctionInternal::sz_w ( ) const

inlineinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_n3

Definition at line 1182 of file function_internal.hpp.

1182 { return sz_w_per_ + sz_w_tmp_;}

◆ sz_work()

void casadi::FunctionInternal::sz_work	(	size_t &	sz_arg,
		size_t &	sz_res,
		size_t &	sz_iw,
		size_t &	sz_w
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_mz

Definition at line 2821 of file function_internal.cpp.

                                                                     {
     sz_arg = this->sz_arg();
     sz_res = this->sz_res();
     sz_iw = this->sz_iw();
     sz_w = this->sz_w();
   }

References casadi::FunctionInternal::sz_arg(), casadi::FunctionInternal::sz_iw(), casadi::FunctionInternal::sz_res(), and casadi::FunctionInternal::sz_w().

◆ to_compact()

Sparsity casadi::FunctionInternal::to_compact	(	casadi_int	oind,
		casadi_int	iind,
		const Sparsity &	sp
	)		const

inherited

Definition at line 1837 of file function_internal.cpp.

                                 {
     // Strip rows and columns
     std::vector<casadi_int> mapping;
     return sp.sub(sparsity_out(oind).find(), sparsity_in(iind).find(), mapping);
   }

References casadi::FunctionInternal::find(), casadi::FunctionInternal::sparsity_in(), casadi::FunctionInternal::sparsity_out(), and casadi::Sparsity::sub().

Referenced by casadi::FunctionInternal::jac_sparsity(), and casadi::FunctionInternal::set_jac_sparsity().

◆ tocache()

void casadi::FunctionInternal::tocache	(	const Function &	f,
		const std::string &	suffix = `""`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ll

Definition at line 999 of file function_internal.cpp.

                                                                                  {
     cache_.tocache(f.name() + ":" + suffix, f);
   }

References casadi::FunctionInternal::cache_, and casadi::Function::name().

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::BlazingSplineFunction::get_jacobian(), and casadi::FunctionInternal::init().

◆ tocache_if_missing()

void casadi::FunctionInternal::tocache_if_missing	(	Function &	f,
		const std::string &	suffix = `""`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_29j

Definition at line 1003 of file function_internal.cpp.

                                                                                       {
     cache_.tocache_if_missing(f.name() + ":" + suffix, f);
   }

References casadi::FunctionInternal::cache_, and casadi::Function::name().

Referenced by casadi::MapSum::create(), casadi::OracleFunction::create_function(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::map(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::wrap().

◆ updateDeltaGamma()

void casadi::Blocksqp::updateDeltaGamma ( BlocksqpMemory * m ) const

Set deltaXi and gamma as a column in the matrix containing the m most recent delta and gamma

Definition at line 2247 of file blocksqp.cpp.

                                                          {
     if (hess_memsize_ == 1) return;
  
     m->dxk = m->deltaMat + nx_*(m->itCount % hess_memsize_);
     m->gamma = m->gammaMat + nx_*(m->itCount % hess_memsize_);
   }

References casadi::BlocksqpMemory::deltaMat, casadi::BlocksqpMemory::dxk, casadi::BlocksqpMemory::gamma, casadi::BlocksqpMemory::gammaMat, hess_memsize_, casadi::BlocksqpMemory::itCount, and casadi::Nlpsol::nx_.

Referenced by run().

◆ updateStats()

void casadi::Blocksqp::updateStats ( BlocksqpMemory * m ) const

Definition at line 2617 of file blocksqp.cpp.

                                                     {
     // Do not accidentally print hessSkipped in the next iteration
     m->hessSkipped = 0;
     m->hessDamped = 0;
  
     // qpIterations = number of iterations for the QP that determines the step,
     // can be a resolve (+SOC)
     // qpIterations2 = number of iterations for a QP which solution was discarded
     m->qpItTotal += m->qpIterations;
     m->qpItTotal += m->qpIterations2;
     m->qpIterations = 0;
     m->qpIterations2 = 0;
     m->qpResolve = 0;
   }

References casadi::BlocksqpMemory::hessDamped, casadi::BlocksqpMemory::hessSkipped, casadi::BlocksqpMemory::qpIterations, casadi::BlocksqpMemory::qpIterations2, casadi::BlocksqpMemory::qpItTotal, and casadi::BlocksqpMemory::qpResolve.

Referenced by feasibilityRestorationPhase(), and run().

◆ updateStepBounds()

void casadi::Blocksqp::updateStepBounds	(	BlocksqpMemory *	m,
		bool	soc
	)		const

Set bounds on the step (in the QP), either according to variable bounds in the NLP or according to trust region box radius

Definition at line 2516 of file blocksqp.cpp.

                                                                    {
     auto d_nlp = &m->d_nlp;
     // Bounds on step
     for (casadi_int i=0; i<nx_; i++) {
       double lbx = d_nlp->lbz[i];
       if (lbx != inf) {
         m->lbx_qp[i] = lbx - d_nlp->z[i];
       } else {
         m->lbx_qp[i] = inf;
       }
  
       double ubx = d_nlp->ubz[i];
       if (ubx != inf) {
         m->ubx_qp[i] = ubx - d_nlp->z[i];
       } else {
         m->ubx_qp[i] = inf;
       }
     }
  
     // Bounds on linearized constraints
     for (casadi_int i=0; i<ng_; i++) {
       double lbg = d_nlp->lbz[i+nx_];
       if (lbg != inf) {
         m->lba_qp[i] = lbg - m->gk[i];
         if (soc) m->lba_qp[i] += m->jac_times_dxk[i];
       } else {
         m->lba_qp[i] = inf;
       }
  
       double ubg = d_nlp->ubz[i+nx_];
       if (ubg != inf) {
         m->uba_qp[i] = ubg - m->gk[i];
         if (soc) m->uba_qp[i] += m->jac_times_dxk[i];
       } else {
         m->uba_qp[i] = inf;
       }
     }
   }

References casadi::NlpsolMemory::d_nlp, casadi::BlocksqpMemory::gk, casadi::inf, casadi::BlocksqpMemory::jac_times_dxk, casadi::BlocksqpMemory::lba_qp, casadi::BlocksqpMemory::lbx_qp, casadi_nlpsol_data< T1 >::lbz, casadi::Nlpsol::ng_, casadi::Nlpsol::nx_, casadi::BlocksqpMemory::uba_qp, and casadi::BlocksqpMemory::ubx_qp.

Referenced by run(), and secondOrderCorrection().

◆ uses_output()

bool casadi::Nlpsol::uses_output ( ) const

inlineoverridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1o1

Reimplemented from casadi::FunctionInternal.

Definition at line 239 of file nlpsol_impl.hpp.

239 {return true;}

◆ weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1ai

Definition at line 67 of file generic_shared_internal.hpp.

                                                                                   {
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
   }

◆ which_depends()

std::vector< bool > casadi::FunctionInternal::which_depends	(	const std::string &	s_in,
		const std::vector< std::string > &	s_out,
		casadi_int	order,
		bool	tr = `false`
	)		const

virtualinherited

Parameters

[in]	s_in	Input name
[in]	s_out	Output name(s)
[in]	order	Only 1 (linear) and 2 (nonlinear) allowed
[in]	tr	Flip the relationship. Return which expressions contain the variables

Extra doc: https://github.com/casadi/casadi/wiki/L_k9

Reimplemented in casadi::XFunction< DerivedType, MatType, NodeType >, casadi::XFunction< MXFunction, MX, MXNode >, and casadi::XFunction< SXFunction, Matrix< SXElem >, SXNode >.

Definition at line 3644 of file function_internal.cpp.

                                        {
     Function f = shared_from_this<Function>();
     f = f.wrap();
     return f.which_depends(s_in, s_out, order, tr);
   }

References casadi::Function::which_depends(), and casadi::Function::wrap().

◆ wrap()

Function casadi::FunctionInternal::wrap ( ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_li

Definition at line 1044 of file function_internal.cpp.

                                         {
     Function f;
     std::string fname = "wrap_" + name_;
     if (!incache(fname, f)) {
       // Options
       Dict opts;
       opts["derivative_of"] = derivative_of_;
       opts["ad_weight"] = ad_weight();
       opts["ad_weight_sp"] = sp_weight();
       opts["max_num_dir"] = max_num_dir_;
       opts["is_diff_in"] = is_diff_in_;
       opts["is_diff_out"] = is_diff_out_;
       // Wrap the function
       std::vector<MX> arg = mx_in();
       std::vector<MX> res = self()(arg);
       f = Function(fname, arg, res, name_in_, name_out_, opts);
       // Save in cache
       tocache_if_missing(f);
     }
     return f;
   }

Referenced by casadi::FunctionInternal::eval_mx(), casadi::FunctionInternal::factory(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::reverse(), casadi::FunctionInternal::slice(), and casadi::Function::wrap().

◆ wrap_as_needed()

Function casadi::FunctionInternal::wrap_as_needed ( const Dict & opts ) const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_lj

Definition at line 1026 of file function_internal.cpp.

                                                                   {
     if (opts.empty()) return shared_from_this<Function>();
     std::string fname = "wrap_" + name_;
     // Options
     Dict my_opts = opts;
     my_opts["derivative_of"] = derivative_of_;
     if (my_opts.find("ad_weight")==my_opts.end())
       my_opts["ad_weight"] = ad_weight();
     if (my_opts.find("ad_weight_sp")==my_opts.end())
       my_opts["ad_weight_sp"] = sp_weight();
     if (my_opts.find("max_num_dir")==my_opts.end())
       my_opts["max_num_dir"] = max_num_dir_;
     // Wrap the function
     std::vector<MX> arg = mx_in();
     std::vector<MX> res = self()(arg);
     return Function(fname, arg, res, name_in_, name_out_, my_opts);
   }

References casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::derivative_of_, casadi::FunctionInternal::Function, casadi::FunctionInternal::max_num_dir_, casadi::FunctionInternal::mx_in(), casadi::ProtoFunction::name_, casadi::FunctionInternal::name_in_, casadi::FunctionInternal::name_out_, and casadi::FunctionInternal::sp_weight().

Referenced by casadi::Function::wrap_as_needed().

Member Data Documentation

◆ ad_weight_

double casadi::FunctionInternal::ad_weight_

inherited

Definition at line 1359 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ ad_weight_sp_

double casadi::FunctionInternal::ad_weight_sp_

inherited

Definition at line 1359 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::sp_weight().

◆ all_functions_

std::map<std::string, RegFun> casadi::OracleFunction::all_functions_

protectedinherited

Definition at line 104 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::generate_dependencies(), casadi::OracleFunction::get_function(), casadi::OracleFunction::has_function(), casadi::OracleFunction::init_mem(), casadi::OracleFunction::jit_dependencies(), casadi::OracleFunction::local_init_mem(), casadi::OracleFunction::monitored(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_function().

◆ always_inline_

bool casadi::FunctionInternal::always_inline_

inherited

Definition at line 1258 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::eval_mx(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::FunctionInternal::eval_sx(), casadi::MXFunction::eval_sx(), casadi::SXFunction::eval_sx(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ Asp_

Sparsity casadi::Blocksqp::Asp_

Definition at line 202 of file blocksqp.hpp.

Referenced by Blocksqp(), calcLagrangeGradient(), init(), init_mem(), serialize_body(), set_work(), and solveQP().

◆ block_hess_

bool casadi::Blocksqp::block_hess_

Definition at line 356 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdate(), calcHessianUpdateLimitedMemory(), calcInitialHessian(), init(), printInfo(), resetHessian(), and serialize_body().

◆ blocks_

std::vector<casadi_int> casadi::Blocksqp::blocks_

Definition at line 197 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdate(), calcHessianUpdateExact(), calcHessianUpdateLimitedMemory(), init(), resetHessian(), serialize_body(), and solve().

◆ bound_consistency_

bool casadi::Nlpsol::bound_consistency_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 98 of file nlpsol_impl.hpp.

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::eval(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ cache_

WeakCache<std::string, Function> casadi::FunctionInternal::cache_

mutableinherited

Definition at line 1330 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::cache(), casadi::FunctionInternal::incache(), casadi::FunctionInternal::tocache(), and casadi::FunctionInternal::tocache_if_missing().

◆ cache_init_

Dict casadi::FunctionInternal::cache_init_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_26h

Definition at line 1327 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ calc_f_

bool casadi::Nlpsol::calc_f_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 97 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Nlpsol::eval(), casadi::Nlpsol::init(), casadi::FatropInterface::init(), casadi::MadnlpInterface::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ calc_g_

bool casadi::Nlpsol::calc_g_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 97 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Nlpsol::eval(), casadi::Nlpsol::init(), casadi::FatropInterface::init(), casadi::MadnlpInterface::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ calc_lam_p_

bool casadi::Nlpsol::calc_lam_p_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 97 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Nlpsol::eval(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ calc_lam_x_

bool casadi::Nlpsol::calc_lam_x_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 97 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::codegen_declarations(), casadi::Sqpmethod::codegen_declarations(), casadi::Nlpsol::eval(), casadi::Nlpsol::init(), casadi::AlpaqaInterface::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ calc_multipliers_

bool casadi::Nlpsol::calc_multipliers_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 96 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ callback_step_

casadi_int casadi::Nlpsol::callback_step_

inherited

Definition at line 78 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::init(), casadi::BonminUserClass::intermediate_callback(), casadi::IpoptUserClass::intermediate_callback(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ checkout_

casadi_checkout_t casadi::FunctionInternal::checkout_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nl

Definition at line 1307 of file function_internal.hpp.

Referenced by casadi::GenericExternal::any_symbol_found(), casadi::External::codegen_checkout(), casadi::External::codegen_declarations(), casadi::External::codegen_mem_type(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::GenericExternal::init_external(), and casadi::FunctionBuffer::operator=().

◆ col_eps_

double casadi::Blocksqp::col_eps_

Definition at line 361 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and sizeHessianCOL().

◆ col_tau1_

double casadi::Blocksqp::col_tau1_

Definition at line 362 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and sizeHessianCOL().

◆ col_tau2_

double casadi::Blocksqp::col_tau2_

Definition at line 363 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and sizeHessianCOL().

◆ common_options_

Dict casadi::OracleFunction::common_options_

protectedinherited

Definition at line 86 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::create_function(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), and casadi::OracleFunction::serialize_body().

◆ compiler_

Importer casadi::FunctionInternal::compiler_

inherited

Definition at line 1348 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::Scpgen::init(), casadi::OracleFunction::jit_dependencies(), and casadi::FunctionInternal::serialize_body().

◆ compiler_plugin_

std::string casadi::FunctionInternal::compiler_plugin_

inherited

Definition at line 1347 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::Scpgen::init(), casadi::OracleFunction::jit_dependencies(), and casadi::FunctionInternal::serialize_body().

◆ conv_strategy_

casadi_int casadi::Blocksqp::conv_strategy_

Definition at line 373 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

◆ custom_jacobian_

Function casadi::FunctionInternal::custom_jacobian_

inherited

Definition at line 1396 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ delta_

double casadi::Blocksqp::delta_

Definition at line 385 of file blocksqp.hpp.

Referenced by Blocksqp(), filterLineSearch(), init(), and serialize_body().

◆ delta_h0_

double casadi::Blocksqp::delta_h0_

Definition at line 391 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

◆ der_options_

Dict casadi::FunctionInternal::der_options_

inherited

Definition at line 1393 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::serialize_body().

◆ derivative_of_

Function casadi::FunctionInternal::derivative_of_

inherited

Definition at line 1341 of file function_internal.hpp.

◆ deserialize_map

std::map< std::string, ProtoFunction *(*)(DeserializingStream &)> casadi::FunctionInternal::deserialize_map

staticinherited

Initial value:

= {
    {"MXFunction", MXFunction::deserialize},
    {"SXFunction", SXFunction::deserialize},
    {"Interpolant", Interpolant::deserialize},
    {"Switch", Switch::deserialize},
    {"Map", Map::deserialize},
    {"MapSum", MapSum::deserialize},
    {"Nlpsol", Nlpsol::deserialize},
    {"Rootfinder", Rootfinder::deserialize},
    {"Integrator", Integrator::deserialize},
    {"External", External::deserialize},
    {"Conic", Conic::deserialize},
    {"FmuFunction", FmuFunction::deserialize},
    {"BlazingSplineFunction", BlazingSplineFunction::deserialize}
  }

Definition at line 1447 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::deserialize().

◆ detect_simple_bounds_is_simple_

std::vector<char> casadi::Nlpsol::detect_simple_bounds_is_simple_

inherited

Definition at line 84 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_enter(), casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::codegen_declarations(), casadi::Nlpsol::get_forward(), casadi::Nlpsol::get_reverse(), casadi::Nlpsol::get_sparsity_out(), casadi::Nlpsol::get_stats(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ detect_simple_bounds_parts_

Function casadi::Nlpsol::detect_simple_bounds_parts_

inherited

Definition at line 85 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_enter(), casadi::Nlpsol::codegen_declarations(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ detect_simple_bounds_target_g_

std::vector<casadi_int> casadi::Nlpsol::detect_simple_bounds_target_g_

inherited

Definition at line 87 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_enter(), casadi::Nlpsol::init(), and casadi::Nlpsol::Nlpsol().

◆ detect_simple_bounds_target_x_

std::vector<casadi_int> casadi::Nlpsol::detect_simple_bounds_target_x_

inherited

Definition at line 86 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::codegen_body_enter(), casadi::Nlpsol::get_stats(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ dim_

std::vector<casadi_int> casadi::Blocksqp::dim_

Definition at line 198 of file blocksqp.hpp.

Referenced by Blocksqp(), calcBFGS(), calcHessianUpdate(), calcHessianUpdateExact(), calcHessianUpdateLimitedMemory(), calcInitialHessian(), calcSR1(), computeNextHessian(), convertHessian(), init(), reset_sqp(), resetHessian(), serialize_body(), set_work(), sizeHessianCOL(), sizeInitialHessian(), and solveQP().

◆ discrete_

std::vector<bool> casadi::Nlpsol::discrete_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 101 of file nlpsol_impl.hpp.

Referenced by casadi::BonminUserClass::get_variables_types(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), casadi::Nlpsol::serialize_body(), and casadi::KnitroInterface::solve().

◆ dump_

bool casadi::FunctionInternal::dump_

inherited

Definition at line 1384 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), and casadi::FunctionInternal::init().

◆ dump_count_

casadi_int casadi::FunctionInternal::dump_count_

mutableinherited

Definition at line 1402 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal().

◆ dump_dir_

std::string casadi::FunctionInternal::dump_dir_

inherited

Definition at line 1387 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_format_

std::string casadi::FunctionInternal::dump_format_

inherited

Definition at line 1390 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_in_

bool casadi::FunctionInternal::dump_in_

inherited

Definition at line 1384 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ dump_out_

bool casadi::FunctionInternal::dump_out_

inherited

Definition at line 1384 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_fd_

bool casadi::FunctionInternal::enable_fd_

inherited

Definition at line 1355 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), casadi::JitFunction::JitFunction(), and casadi::FunctionInternal::serialize_body().

◆ enable_fd_op_

bool casadi::FunctionInternal::enable_fd_op_

inherited

Definition at line 1356 of file function_internal.hpp.

Referenced by casadi::FmuFunction::FmuFunction(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_forward_

bool casadi::FunctionInternal::enable_forward_

inherited

Definition at line 1355 of file function_internal.hpp.

Referenced by casadi::MXFunction::ad_forward(), casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_forward_op_

bool casadi::FunctionInternal::enable_forward_op_

inherited

Definition at line 1356 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_jacobian_

bool casadi::FunctionInternal::enable_jacobian_

inherited

Definition at line 1355 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), and casadi::FunctionInternal::serialize_body().

◆ enable_jacobian_op_

bool casadi::FunctionInternal::enable_jacobian_op_

inherited

Definition at line 1356 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ enable_reverse_

bool casadi::FunctionInternal::enable_reverse_

inherited

Definition at line 1355 of file function_internal.hpp.

Referenced by casadi::MXFunction::ad_reverse(), casadi::FunctionInternal::ad_weight(), casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::get_partition(), casadi::FunctionInternal::has_derivative(), casadi::FunctionInternal::init(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::serialize_body().

◆ enable_reverse_op_

bool casadi::FunctionInternal::enable_reverse_op_

inherited

Definition at line 1356 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ eps_

double casadi::Blocksqp::eps_

Definition at line 341 of file blocksqp.hpp.

Referenced by Blocksqp(), calcBFGS(), calcSR1(), convertHessian(), init(), serialize_body(), sizeHessianCOL(), and sizeInitialHessian().

◆ equality_

std::vector<bool> casadi::Nlpsol::equality_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 102 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::init(), casadi::FatropInterface::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ error_on_fail_

bool casadi::ProtoFunction::error_on_fail_

inherited

◆ eta_

double casadi::Blocksqp::eta_

Definition at line 392 of file blocksqp.hpp.

Referenced by Blocksqp(), filterLineSearch(), init(), secondOrderCorrection(), and serialize_body().

◆ eval_

eval_t casadi::FunctionInternal::eval_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nk

Definition at line 1302 of file function_internal.hpp.

Referenced by casadi::FunctionBuffer::_eval(), casadi::GenericExternal::any_symbol_found(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), and casadi::GenericExternal::init_external().

◆ eval_errors_fatal_

bool casadi::Nlpsol::eval_errors_fatal_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 93 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ exact_hess_lag_sp_

Sparsity casadi::Blocksqp::exact_hess_lag_sp_

Definition at line 203 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdateExact(), init(), serialize_body(), and set_work().

◆ fallback_scaling_

casadi_int casadi::Blocksqp::fallback_scaling_

Definition at line 358 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdate(), calcHessianUpdateExact(), computeNextHessian(), init(), printInfo(), and serialize_body().

◆ fallback_update_

casadi_int casadi::Blocksqp::fallback_update_

Definition at line 367 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdate(), calcHessianUpdateExact(), computeNextHessian(), init(), printInfo(), and serialize_body().

◆ fcallback_

Function casadi::Nlpsol::fcallback_

inherited

Definition at line 75 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::callback(), casadi::Nlpsol::init(), casadi::SLEQPInterface::init(), casadi::BonminInterface::intermediate_callback(), casadi::IpoptInterface::intermediate_callback(), casadi::Nlpsol::Nlpsol(), casadi::Nlpsol::serialize_body(), casadi::SLEQPInterface::set_work(), casadi::SLEQPInterface::solve(), and casadi::WorhpInterface::solve().

◆ fd_method_

std::string casadi::FunctionInternal::fd_method_

inherited

Definition at line 1374 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FmuFunction::init(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ fd_options_

Dict casadi::FunctionInternal::fd_options_

inherited

Definition at line 1368 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::forward(), casadi::FunctionInternal::generate_options(), and casadi::FunctionInternal::init().

◆ fd_step_

double casadi::FunctionInternal::fd_step_

inherited

Definition at line 1371 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ forward_options_

Dict casadi::FunctionInternal::forward_options_

inherited

Definition at line 1393 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::forward(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ gamma_f_

double casadi::Blocksqp::gamma_f_

Definition at line 380 of file blocksqp.hpp.

Referenced by augmentFilter(), Blocksqp(), filterLineSearch(), init(), pairInFilter(), secondOrderCorrection(), and serialize_body().

◆ gamma_theta_

double casadi::Blocksqp::gamma_theta_

Definition at line 379 of file blocksqp.hpp.

Referenced by augmentFilter(), Blocksqp(), filterLineSearch(), init(), pairInFilter(), secondOrderCorrection(), and serialize_body().

◆ globalization_

bool casadi::Blocksqp::globalization_

Definition at line 347 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), printInfo(), run(), serialize_body(), and solveQP().

◆ has_refcount_

bool casadi::FunctionInternal::has_refcount_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_no

Definition at line 1322 of file function_internal.hpp.

Referenced by casadi::CodeGenerator::add_dependency(), casadi::FunctionInternal::FunctionInternal(), casadi::Call::has_refcount(), casadi::External::init(), casadi::MXFunction::init(), casadi::OsqpInterface::OsqpInterface(), and casadi::FunctionInternal::serialize_body().

◆ hess_damp_

casadi_int casadi::Blocksqp::hess_damp_

Definition at line 364 of file blocksqp.hpp.

Referenced by Blocksqp(), calcBFGS(), computeNextHessian(), init(), printInfo(), and serialize_body().

◆ hess_damp_fac_

double casadi::Blocksqp::hess_damp_fac_

Definition at line 365 of file blocksqp.hpp.

Referenced by Blocksqp(), calcBFGS(), init(), and serialize_body().

◆ hess_lim_mem_

casadi_int casadi::Blocksqp::hess_lim_mem_

Definition at line 368 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdateExact(), computeNextHessian(), init(), printInfo(), run(), serialize_body(), solve(), and solveQP().

◆ hess_memsize_

casadi_int casadi::Blocksqp::hess_memsize_

Definition at line 369 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdateLimitedMemory(), init(), reset_sqp(), resetHessian(), serialize_body(), set_work(), solve(), and updateDeltaGamma().

◆ hess_scaling_

casadi_int casadi::Blocksqp::hess_scaling_

Definition at line 357 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), printInfo(), run(), and serialize_body().

◆ hess_update_

casadi_int casadi::Blocksqp::hess_update_

Definition at line 366 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), printInfo(), reset_sqp(), run(), serialize_body(), set_work(), and solveQP().

◆ Hsp_

Sparsity casadi::Blocksqp::Hsp_

Definition at line 202 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

◆ infix_

const std::string casadi::Nlpsol::infix_ = "nlpsol"

staticinherited

Definition at line 290 of file nlpsol_impl.hpp.

◆ ini_hess_diag_

double casadi::Blocksqp::ini_hess_diag_

Definition at line 360 of file blocksqp.hpp.

Referenced by Blocksqp(), calcInitialHessian(), init(), and serialize_body().

◆ inputs_check_

bool casadi::FunctionInternal::inputs_check_

inherited

Definition at line 1365 of file function_internal.hpp.

Referenced by casadi::Nlpsol::check_inputs(), casadi::Conic::eval(), casadi::SqicInterface::evaluate(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), and casadi::GurobiInterface::solve().

◆ is_diff_in_

std::vector<bool> casadi::FunctionInternal::is_diff_in_

inherited

Definition at line 1264 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwd_seed(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::MapSum::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::wrap().

◆ is_diff_out_

std::vector<bool> casadi::FunctionInternal::is_diff_out_

inherited

Definition at line 1264 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::definition(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::init(), casadi::Map::init(), casadi::MapSum::init(), casadi::FunctionInternal::jac_sparsity(), casadi::FunctionInternal::serialize_body(), casadi::FunctionInternal::symbolicAdjSeed(), and casadi::FunctionInternal::wrap().

◆ iteration_callback_ignore_errors_

bool casadi::Nlpsol::iteration_callback_ignore_errors_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 95 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::callback(), casadi::Nlpsol::init(), casadi::BonminInterface::intermediate_callback(), casadi::IpoptInterface::intermediate_callback(), casadi::Nlpsol::Nlpsol(), casadi::Nlpsol::serialize_body(), and casadi::SLEQPInterface::solve().

◆ jac_penalty_

double casadi::FunctionInternal::jac_penalty_

inherited

Definition at line 1352 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::adjViaJac(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::fwdViaJac(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ jac_sparsity_

std::vector<Sparsity> casadi::FunctionInternal::jac_sparsity_[2]

mutableinherited

Definition at line 1333 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::jac_sparsity(), and casadi::FunctionInternal::set_jac_sparsity().

◆ jacobian_options_

Dict casadi::FunctionInternal::jacobian_options_

inherited

Definition at line 1393 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::init(), casadi::FunctionInternal::jacobian(), and casadi::FunctionInternal::serialize_body().

◆ jit_

bool casadi::FunctionInternal::jit_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nf

Definition at line 1275 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::JitFunction::JitFunction(), casadi::OracleFunction::OracleFunction(), casadi::FunctionInternal::serialize_body(), casadi::OracleFunction::serialize_body(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_base_name_

std::string casadi::FunctionInternal::jit_base_name_

inherited

Definition at line 1292 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ jit_cleanup_

bool casadi::FunctionInternal::jit_cleanup_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ng

Definition at line 1280 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_name_

std::string casadi::FunctionInternal::jit_name_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_ni

Definition at line 1290 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_options_

Dict casadi::FunctionInternal::jit_options_

inherited

Definition at line 1349 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::Scpgen::init(), casadi::OracleFunction::jit_dependencies(), casadi::FunctionInternal::serialize_body(), and casadi::FunctionInternal::~FunctionInternal().

◆ jit_serialize_

std::string casadi::FunctionInternal::jit_serialize_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nh

Definition at line 1285 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::OracleFunction::OracleFunction(), casadi::FunctionInternal::serialize_body(), and casadi::OracleFunction::serialize_body().

◆ jit_temp_suffix_

bool casadi::FunctionInternal::jit_temp_suffix_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nj

Definition at line 1297 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ kappa_f_

double casadi::Blocksqp::kappa_f_

Definition at line 382 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), kktErrorReduction(), and serialize_body().

◆ kappa_minus_

double casadi::Blocksqp::kappa_minus_

Definition at line 388 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

◆ kappa_plus_

double casadi::Blocksqp::kappa_plus_

Definition at line 389 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

◆ kappa_plus_max_

double casadi::Blocksqp::kappa_plus_max_

Definition at line 390 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

◆ kappa_soc_

double casadi::Blocksqp::kappa_soc_

Definition at line 381 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), secondOrderCorrection(), and serialize_body().

◆ kkt_

WeakRef casadi::Nlpsol::kkt_

mutableinherited

Definition at line 109 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::kkt().

◆ linsol_plugin_

std::string casadi::Blocksqp::linsol_plugin_

Definition at line 336 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), init_mem(), and serialize_body().

◆ max_consec_reduced_steps_

casadi_int casadi::Blocksqp::max_consec_reduced_steps_

Definition at line 350 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), run(), and serialize_body().

◆ max_consec_skipped_updates_

casadi_int casadi::Blocksqp::max_consec_skipped_updates_

Definition at line 351 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdate(), calcHessianUpdateLimitedMemory(), init(), and serialize_body().

◆ max_conv_qp_

casadi_int casadi::Blocksqp::max_conv_qp_

Definition at line 374 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and solveQP().

◆ max_io_

casadi_int casadi::FunctionInternal::max_io_

inherited

Definition at line 1381 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ max_it_qp_

casadi_int casadi::Blocksqp::max_it_qp_

Definition at line 352 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and solveQP().

◆ max_iter_

casadi_int casadi::Blocksqp::max_iter_

Definition at line 353 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and solve().

◆ max_line_search_

casadi_int casadi::Blocksqp::max_line_search_

Definition at line 349 of file blocksqp.hpp.

Referenced by Blocksqp(), filterLineSearch(), init(), and serialize_body().

◆ max_num_dir_

casadi_int casadi::FunctionInternal::max_num_dir_

inherited

Definition at line 1362 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::call_forward(), casadi::FunctionInternal::call_reverse(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::serialize_body(), casadi::FunctionInternal::wrap(), and casadi::FunctionInternal::wrap_as_needed().

◆ max_num_threads_

int casadi::OracleFunction::max_num_threads_

protectedinherited

Definition at line 93 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::calc_function(), casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::KnitroInterface::init(), casadi::OracleFunction::init_mem(), casadi::OracleFunction::join_results(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ max_soc_iter_

casadi_int casadi::Blocksqp::max_soc_iter_

Definition at line 378 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), secondOrderCorrection(), and serialize_body().

◆ max_time_qp_

double casadi::Blocksqp::max_time_qp_

Definition at line 359 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and solveQP().

◆ meta_doc

const std::string casadi::Blocksqp::meta_doc

static

Definition at line 193 of file blocksqp.hpp.

Referenced by casadi::casadi_register_nlpsol_blocksqp().

◆ mi_

bool casadi::Nlpsol::mi_

inherited

Definition at line 106 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), casadi::Nlpsol::serialize_body(), and casadi::KnitroInterface::solve().

◆ min_lam_

double casadi::Nlpsol::min_lam_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 99 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::get_forward(), casadi::Nlpsol::get_reverse(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::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 1261 of file function_internal.hpp.

◆ n_out_

size_t casadi::FunctionInternal::n_out_

inherited

Definition at line 1261 of file function_internal.hpp.

◆ name_

std::string casadi::ProtoFunction::name_

inherited

Definition at line 246 of file function_internal.hpp.

◆ name_in_

std::vector<std::string> casadi::FunctionInternal::name_in_

inherited

Definition at line 1270 of file function_internal.hpp.

◆ name_out_

std::vector<std::string> casadi::FunctionInternal::name_out_

inherited

Definition at line 1270 of file function_internal.hpp.

◆ nblocks_

casadi_int casadi::Blocksqp::nblocks_

Definition at line 196 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdate(), calcHessianUpdateExact(), calcHessianUpdateLimitedMemory(), calcInitialHessian(), computeNextHessian(), convertHessian(), init(), printProgress(), reset_sqp(), resetHessian(), serialize_body(), set_work(), solve(), and solveQP().

◆ never_inline_

bool casadi::FunctionInternal::never_inline_

inherited

Definition at line 1258 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::eval_mx(), casadi::MXFunction::eval_mx(), casadi::SXFunction::eval_mx(), casadi::FunctionInternal::eval_sx(), casadi::MXFunction::eval_sx(), casadi::SXFunction::eval_sx(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ ng_

casadi_int casadi::Nlpsol::ng_

inherited

Definition at line 69 of file nlpsol_impl.hpp.

◆ nlinfeastol_

double casadi::Blocksqp::nlinfeastol_

Definition at line 343 of file blocksqp.hpp.

Referenced by Blocksqp(), calcOptTol(), feasibilityRestorationPhase(), init(), pairInFilter(), run(), and serialize_body().

◆ nnz_H_

casadi_int casadi::Blocksqp::nnz_H_

Definition at line 199 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and set_work().

◆ no_nlp_grad_

bool casadi::Nlpsol::no_nlp_grad_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 100 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ np_

casadi_int casadi::Nlpsol::np_

inherited

Definition at line 72 of file nlpsol_impl.hpp.

Referenced by casadi::Feasiblesqpmethod::codegen_body(), casadi::Nlpsol::codegen_body_enter(), casadi::Nlpsol::codegen_body_exit(), casadi::Nlpsol::eval(), feasibilityRestorationPhase(), casadi::Nlpsol::init(), casadi::AlpaqaInterface::init(), casadi::Scpgen::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ nx_

casadi_int casadi::Nlpsol::nx_

inherited

Definition at line 66 of file nlpsol_impl.hpp.

◆ obj_lo_

double casadi::Blocksqp::obj_lo_

Definition at line 393 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), initializeFilter(), and serialize_body().

◆ obj_up_

double casadi::Blocksqp::obj_up_

Definition at line 394 of file blocksqp.hpp.

Referenced by Blocksqp(), feasibilityRestorationPhase(), filterLineSearch(), fullstep(), init(), kktErrorReduction(), secondOrderCorrection(), and serialize_body().

◆ options_

const Options casadi::Blocksqp::options_

static

Definition at line 169 of file blocksqp.hpp.

Referenced by casadi::casadi_register_nlpsol_blocksqp().

◆ opttol_

double casadi::Blocksqp::opttol_

Definition at line 342 of file blocksqp.hpp.

Referenced by Blocksqp(), calcOptTol(), feasibilityRestorationPhase(), init(), and 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(), 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().

◆ p_nlp_

casadi_nlpsol_prob<double> casadi::Nlpsol::p_nlp_

inherited

Definition at line 63 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::init(), casadi::FatropInterface::set_fatrop_prob(), casadi::MadnlpInterface::set_madnlp_prob(), and casadi::Nlpsol::set_work().

◆ post_expand_

bool casadi::OracleFunction::post_expand_

protectedinherited

Definition at line 114 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), and casadi::OracleFunction::OracleFunction().

◆ print_header_

bool casadi::Blocksqp::print_header_

Definition at line 339 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and solve().

◆ print_in_

bool casadi::FunctionInternal::print_in_

inherited

Definition at line 1377 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ print_iteration_

bool casadi::Blocksqp::print_iteration_

Definition at line 340 of file blocksqp.hpp.

Referenced by Blocksqp(), feasibilityRestorationPhase(), init(), run(), and serialize_body().

◆ print_maxit_reached_

bool casadi::Blocksqp::print_maxit_reached_

Definition at line 400 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and solve().

◆ print_out_

bool casadi::FunctionInternal::print_out_

inherited

Definition at line 1378 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), and casadi::FunctionInternal::serialize_body().

◆ print_time_

bool casadi::ProtoFunction::print_time_

inherited

Definition at line 252 of file function_internal.hpp.

Referenced by casadi::FixedStepIntegrator::create_advanced(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::FunctionInternal::init(), casadi::Nlpsol::Nlpsol(), casadi::ProtoFunction::print_time(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

◆ qp_init_

bool casadi::Blocksqp::qp_init_

Definition at line 355 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), and solve().

◆ record_time_

bool casadi::ProtoFunction::record_time_

inherited

Definition at line 255 of file function_internal.hpp.

Referenced by casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::FunctionInternal::init(), casadi::ProtoFunction::init_mem(), casadi::LinsolInternal::init_mem(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

◆ regularity_check_

bool casadi::ProtoFunction::regularity_check_

inherited

Definition at line 258 of file function_internal.hpp.

Referenced by casadi::OracleFunction::calc_function(), casadi::ProtoFunction::change_option(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::FunctionInternal(), casadi::ProtoFunction::generate_options(), casadi::ProtoFunction::init(), casadi::ProtoFunction::ProtoFunction(), and casadi::ProtoFunction::serialize_body().

◆ release_

casadi_release_t casadi::FunctionInternal::release_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nm

Definition at line 1312 of file function_internal.hpp.

Referenced by casadi::GenericExternal::any_symbol_found(), casadi::External::codegen_declarations(), casadi::External::codegen_release(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::finalize(), casadi::FunctionInternal::FunctionInternal(), casadi::GenericExternal::init_external(), and casadi::FunctionBuffer::~FunctionBuffer().

◆ restore_feas_

bool casadi::Blocksqp::restore_feas_

Definition at line 348 of file blocksqp.hpp.

Referenced by Blocksqp(), feasibilityRestorationPhase(), init(), run(), and serialize_body().

◆ reverse_options_

Dict casadi::FunctionInternal::reverse_options_

inherited

Definition at line 1393 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), casadi::FunctionInternal::init(), casadi::FunctionInternal::reverse(), and casadi::FunctionInternal::serialize_body().

◆ rho_

double casadi::Blocksqp::rho_

Definition at line 397 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

◆ rp_solver_

Function casadi::Blocksqp::rp_solver_

Definition at line 399 of file blocksqp.hpp.

Referenced by Blocksqp(), feasibilityRestorationPhase(), init(), and serialize_body().

◆ s_f_

double casadi::Blocksqp::s_f_

Definition at line 387 of file blocksqp.hpp.

Referenced by Blocksqp(), filterLineSearch(), init(), and serialize_body().

◆ s_theta_

double casadi::Blocksqp::s_theta_

Definition at line 386 of file blocksqp.hpp.

Referenced by Blocksqp(), filterLineSearch(), init(), and serialize_body().

◆ schur_

bool casadi::Blocksqp::schur_

Definition at line 346 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), init_mem(), printInfo(), serialize_body(), solve(), and solveQP().

◆ sens_linsol_

std::string casadi::Nlpsol::sens_linsol_

inherited

Definition at line 81 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::get_forward(), casadi::Nlpsol::get_reverse(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ sens_linsol_options_

Dict casadi::Nlpsol::sens_linsol_options_

inherited

Definition at line 82 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::get_forward(), casadi::Nlpsol::get_reverse(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ show_eval_warnings_

bool casadi::OracleFunction::show_eval_warnings_

protectedinherited

Definition at line 90 of file oracle_function.hpp.

◆ skip_first_globalization_

bool casadi::Blocksqp::skip_first_globalization_

Definition at line 372 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), run(), and serialize_body().

◆ solvers_

std::map< std::string, Nlpsol::Plugin > casadi::Nlpsol::solvers_

staticinherited

Definition at line 283 of file nlpsol_impl.hpp.

◆ sparsity_in_

std::vector<Sparsity> casadi::FunctionInternal::sparsity_in_

inherited

Definition at line 1267 of file function_internal.hpp.

◆ sparsity_out_

std::vector<Sparsity> casadi::FunctionInternal::sparsity_out_

inherited

◆ specific_options_

Dict casadi::OracleFunction::specific_options_

protectedinherited

Definition at line 87 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::create_function(), casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), and casadi::OracleFunction::serialize_body().

◆ stats_

Dict casadi::FunctionInternal::stats_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_nn

Definition at line 1317 of file function_internal.hpp.

◆ stride_arg_

size_t casadi::OracleFunction::stride_arg_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ stride_iw_

size_t casadi::OracleFunction::stride_iw_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ stride_res_

size_t casadi::OracleFunction::stride_res_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ stride_w_

size_t casadi::OracleFunction::stride_w_

protectedinherited

Definition at line 110 of file oracle_function.hpp.

Referenced by casadi::OracleFunction::finalize(), casadi::OracleFunction::init(), casadi::OracleFunction::OracleFunction(), casadi::OracleFunction::serialize_body(), and casadi::OracleFunction::set_temp().

◆ theta_max_

double casadi::Blocksqp::theta_max_

Definition at line 383 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), initializeFilter(), initIterate(), and serialize_body().

◆ theta_min_

double casadi::Blocksqp::theta_min_

Definition at line 384 of file blocksqp.hpp.

Referenced by Blocksqp(), filterLineSearch(), init(), secondOrderCorrection(), and serialize_body().

◆ user_data_

void* casadi::FunctionInternal::user_data_

inherited

Definition at line 1344 of file function_internal.hpp.

Referenced by casadi::FunctionInternal::FunctionInternal(), casadi::FunctionInternal::generate_options(), and casadi::FunctionInternal::init().

◆ verbose_

bool casadi::ProtoFunction::verbose_

inherited

Definition at line 249 of file function_internal.hpp.

◆ warmstart_

bool casadi::Blocksqp::warmstart_

Definition at line 354 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), serialize_body(), solve(), and solveQP().

◆ warn_initial_bounds_

bool casadi::Nlpsol::warn_initial_bounds_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1nk

Definition at line 94 of file nlpsol_impl.hpp.

Referenced by casadi::Nlpsol::check_inputs(), casadi::Nlpsol::init(), casadi::Nlpsol::Nlpsol(), and casadi::Nlpsol::serialize_body().

◆ which_second_derv_

casadi_int casadi::Blocksqp::which_second_derv_

Definition at line 370 of file blocksqp.hpp.

Referenced by Blocksqp(), calcHessianUpdate(), calcHessianUpdateLimitedMemory(), calcInitialHessian(), computeNextHessian(), init(), resetHessian(), serialize_body(), and solveQP().

◆ zeta_

double casadi::Blocksqp::zeta_

Definition at line 398 of file blocksqp.hpp.

Referenced by Blocksqp(), init(), and serialize_body().

The documentation for this class was generated from the following files:

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ Creator

◆ RegFcn

◆ weak_ref_type

Constructor & Destructor Documentation

◆ Blocksqp() [1/2]

◆ ~Blocksqp()

◆ Blocksqp() [2/2]

Member Function Documentation

◆ acceptStep() [1/2]

◆ acceptStep() [2/2]

◆ ad_weight()

◆ add_embedded()

◆ adjViaJac()

◆ all_scalar()

◆ alloc()

◆ alloc_arg()

◆ alloc_iw()

◆ alloc_mem()

◆ alloc_res()

◆ alloc_w()

◆ append_to_vec()

◆ augmentFilter()

◆ bound_consistency()

◆ cache()

◆ calc_function()

◆ calc_sp_forward()

◆ calc_sp_reverse()

◆ calcBFGS()

◆ calcHessianUpdate()

◆ calcHessianUpdateExact()

◆ calcHessianUpdateLimitedMemory()

◆ calcInitialHessian() [1/2]

◆ calcInitialHessian() [2/2]

◆ calcLagrangeGradient() [1/2]

◆ calcLagrangeGradient() [2/2]

◆ calcOptTol()

◆ calcSR1()

◆ call()

◆ call_forward() [1/2]

◆ call_forward() [2/2]

◆ call_gen() [1/2]

◆ call_gen() [2/2]

◆ call_reverse() [1/2]

◆ call_reverse() [2/2]

◆ callback()

◆ change_option()

◆ check_arg()

◆ check_inputs()

◆ check_mat()

◆ check_mem_count()

◆ check_res()

◆ checkout()

◆ class_name()

◆ clear_mem()

◆ codegen()

◆ codegen_alloc_mem()

◆ codegen_body()

◆ codegen_body_enter()

◆ codegen_body_exit()

◆ codegen_checkout()

◆ codegen_declarations()

◆ codegen_decref()

◆ codegen_free_mem()

◆ codegen_incref()

◆ codegen_init_mem()

◆ codegen_mem()

◆ codegen_mem_type()

◆ codegen_meta()

◆ codegen_name()

◆ codegen_release()

◆ codegen_sparsities()