casadi Namespace Reference

The casadi namespace. More...

Namespaces
	IndexReduction

Classes
class	Archiver
	Archiver interface. More...
class	Assertion
	Assertion. More...
class	Bilin
	Calculate quadratic form. More...
class	BinaryMX
	Represents any binary operation that involves two matrices. More...
class	BinarySX
	Represents a basic binary operation on two SXElem nodes. More...
class	Blas
	Pluggable dense BLAS backend, dispatched per-call by shorthand. More...
class	BlazingSplineFunction
class	BSplineCommon
	BSpline Node. More...
class	BSpline
class	BSplineParametric
struct	UnaryOperation
struct	BinaryOperation
struct	BinaryOperationE
struct	DerBinaryOperation
	Calculate function and derivative. More...
struct	BinaryOperationSS
	Perform a binary operation on two scalars. More...
struct	BinaryOperationVV
	Perform a binary operation on two vectors. More...
struct	BinaryOperationVS
	Perform a binary operation on a vector and a scalar. More...
struct	BinaryOperationSV
	Perform a binary operation on a scalar and a vector. More...
struct	SmoothChecker
struct	SmoothChecker< OP_LT >
struct	SmoothChecker< OP_LE >
struct	SmoothChecker< OP_FLOOR >
struct	SmoothChecker< OP_CEIL >
struct	SmoothChecker< OP_FMOD >
struct	SmoothChecker< OP_REMAINDER >
struct	SmoothChecker< OP_EQ >
struct	SmoothChecker< OP_NE >
struct	SmoothChecker< OP_SIGN >
struct	SmoothChecker< OP_COPYSIGN >
struct	SmoothChecker< OP_NOT >
struct	SmoothChecker< OP_AND >
struct	SmoothChecker< OP_OR >
struct	SmoothChecker< OP_IF_ELSE_ZERO >
struct	F0XChecker
struct	F0XChecker< OP_ASSIGN >
struct	F0XChecker< OP_MUL >
struct	F0XChecker< OP_DIV >
struct	F0XChecker< OP_NEG >
struct	F0XChecker< OP_SQRT >
struct	F0XChecker< OP_SQ >
struct	F0XChecker< OP_TWICE >
struct	F0XChecker< OP_SIN >
struct	F0XChecker< OP_TAN >
struct	F0XChecker< OP_ATAN >
struct	F0XChecker< OP_ASIN >
struct	F0XChecker< OP_FLOOR >
struct	F0XChecker< OP_CEIL >
struct	F0XChecker< OP_FMOD >
struct	F0XChecker< OP_REMAINDER >
struct	F0XChecker< OP_FABS >
struct	F0XChecker< OP_SIGN >
struct	F0XChecker< OP_COPYSIGN >
struct	F0XChecker< OP_ERF >
struct	F0XChecker< OP_SINH >
struct	F0XChecker< OP_TANH >
struct	F0XChecker< OP_ASINH >
struct	F0XChecker< OP_ATANH >
struct	F0XChecker< OP_ERFINV >
struct	F0XChecker< OP_AND >
struct	F0XChecker< OP_IF_ELSE_ZERO >
struct	F0XChecker< OP_LOG1P >
struct	F0XChecker< OP_EXPM1 >
struct	FX0Checker
struct	FX0Checker< OP_MUL >
struct	FX0Checker< OP_AND >
struct	FX0Checker< OP_IF_ELSE_ZERO >
struct	F00Checker
struct	F00Checker< OP_ADD >
struct	F00Checker< OP_SUB >
struct	F00Checker< OP_FMIN >
struct	F00Checker< OP_FMAX >
struct	F00Checker< OP_AND >
struct	F00Checker< OP_OR >
struct	F00Checker< OP_COPYSIGN >
struct	F00Checker< OP_LT >
struct	F00Checker< OP_HYPOT >
struct	CommChecker
struct	CommChecker< OP_ADD >
struct	CommChecker< OP_MUL >
struct	CommChecker< OP_EQ >
struct	CommChecker< OP_NE >
struct	CommChecker< OP_AND >
struct	CommChecker< OP_OR >
struct	CommChecker< OP_HYPOT >
struct	NonnegativeChecker
struct	NonnegativeChecker< OP_SQRT >
struct	NonnegativeChecker< OP_SQ >
struct	NonnegativeChecker< OP_EXP >
struct	NonnegativeChecker< OP_LT >
struct	NonnegativeChecker< OP_LE >
struct	NonnegativeChecker< OP_EQ >
struct	NonnegativeChecker< OP_NE >
struct	NonnegativeChecker< OP_NOT >
struct	NonnegativeChecker< OP_AND >
struct	NonnegativeChecker< OP_OR >
struct	NonnegativeChecker< OP_HYPOT >
struct	NonnegativeChecker< OP_FABS >
struct	NargChecker
struct	NargChecker< OP_ADD >
struct	NargChecker< OP_SUB >
struct	NargChecker< OP_MUL >
struct	NargChecker< OP_DIV >
struct	NargChecker< OP_POW >
struct	NargChecker< OP_CONSTPOW >
struct	NargChecker< OP_EQ >
struct	NargChecker< OP_NE >
struct	NargChecker< OP_AND >
struct	NargChecker< OP_OR >
struct	NargChecker< OP_FMIN >
struct	NargChecker< OP_FMAX >
struct	NargChecker< OP_PRINTME >
struct	NargChecker< OP_ATAN2 >
struct	NargChecker< OP_IF_ELSE_ZERO >
struct	NargChecker< OP_FMOD >
struct	NargChecker< OP_REMAINDER >
struct	NargChecker< OP_COPYSIGN >
struct	NargChecker< OP_CONST >
struct	NargChecker< OP_PARAMETER >
struct	NargChecker< OP_INPUT >
struct	NargChecker< OP_HYPOT >
struct	UnaryOperation< OP_ASSIGN >
	Simple assignment. More...
struct	BinaryOperation< OP_ADD >
	Addition. More...
struct	BinaryOperation< OP_SUB >
	Subtraction. More...
struct	BinaryOperation< OP_MUL >
	Multiplication. More...
struct	BinaryOperation< OP_DIV >
	Division. More...
struct	UnaryOperation< OP_NEG >
	Negation. More...
struct	UnaryOperation< OP_EXP >
	Natural exponent. More...
struct	UnaryOperation< OP_LOG >
	Natural logarithm. More...
struct	BinaryOperation< OP_POW >
	Power, defined only for x>=0. More...
struct	BinaryOperation< OP_CONSTPOW >
	Power, defined only for y constant. More...
struct	UnaryOperation< OP_SQRT >
	Square root. More...
struct	UnaryOperation< OP_SQ >
	Square. More...
struct	UnaryOperation< OP_TWICE >
	Times two. More...
struct	UnaryOperation< OP_SIN >
	Sine. More...
struct	UnaryOperation< OP_COS >
	Cosine. More...
struct	UnaryOperation< OP_TAN >
	Tangent. More...
struct	UnaryOperation< OP_ASIN >
	Arcus sine. More...
struct	UnaryOperation< OP_ACOS >
	Arcus cosine. More...
struct	UnaryOperation< OP_ATAN >
	Arcus tangent. More...
struct	BinaryOperation< OP_LT >
	Less than. More...
struct	BinaryOperation< OP_LE >
	Less or equal to. More...
struct	UnaryOperation< OP_FLOOR >
	Floor function. More...
struct	UnaryOperation< OP_CEIL >
	Ceil function. More...
struct	BinaryOperation< OP_FMOD >
	Remainder of division. More...
struct	BinaryOperation< OP_REMAINDER >
	Remainder of division. More...
struct	BinaryOperation< OP_EQ >
	Equal to. More...
struct	BinaryOperation< OP_NE >
	Not equal to. More...
struct	UnaryOperation< OP_NOT >
	Logical not. More...
struct	BinaryOperation< OP_AND >
	Logical and. More...
struct	BinaryOperation< OP_OR >
	Logical or. More...
struct	UnaryOperation< OP_ERF >
	Error function. More...
struct	UnaryOperation< OP_FABS >
	Absolute value. More...
struct	UnaryOperation< OP_SIGN >
	Sign. More...
struct	BinaryOperation< OP_COPYSIGN >
	Copysign. More...
struct	BinaryOperation< OP_FMIN >
	Minimum. More...
struct	BinaryOperation< OP_FMAX >
	Maximum. More...
struct	UnaryOperation< OP_INV >
	Element-wise inverse. More...
struct	UnaryOperation< OP_SINH >
	Hyperbolic sine. More...
struct	UnaryOperation< OP_COSH >
	Hyperbolic cosine. More...
struct	UnaryOperation< OP_TANH >
	Hyperbolic tangent. More...
struct	UnaryOperation< OP_ASINH >
	Inverse hyperbolic sine. More...
struct	UnaryOperation< OP_ACOSH >
	Inverse hyperbolic cosine. More...
struct	UnaryOperation< OP_ATANH >
	Inverse hyperbolic tangent. More...
struct	UnaryOperation< OP_ERFINV >
	Inverse of error function. More...
struct	UnaryOperation< OP_LOG1P >
	log1p(x) = log(1+x) More...
struct	UnaryOperation< OP_EXPM1 >
	expm1(x) = exp(x)-1 More...
struct	BinaryOperation< OP_PRINTME >
	Identity operator with the side effect of printing. More...
struct	BinaryOperation< OP_ATAN2 >
	Arctan2. More...
struct	BinaryOperation< OP_IF_ELSE_ZERO >
	Conditional assignment. More...
struct	BinaryOperation< OP_LIFT >
	Inverse of error function. More...
struct	BinaryOperation< OP_HYPOT >
	hypot(x,y) = sqrt(x^2+y^2) More...
struct	casadi_math
	Easy access to all the functions for a particular type. More...
struct	casadi_math< casadi_int >
	Specialize the class so that it can be used with integer type. More...
class	CallSX
class	Callback
	Callback function functionality. More...
class	CallbackInternal
class	Call
class	Matrix
	Sparse matrix class. SX and DM are specializations. More...
class	ThreadLocalStorage
	Thread-local storage wrapper that avoids destructor calls. More...
class	conditional_lock_guard
struct	enum_traits
	Helper class: Specify number of entries in an enum. More...
class	Find
	Finds the first nonzero element in a vector. More...
class	InterruptHandler
	Takes care of user interrupts (Ctrl+C) More...
class	casadi_limits
	casadi_limits class More...
class	Logger
	Keeps track of logging output to screen and/or files. More...
class	Low
	Lows the first nonzero element in a vector. More...
class	CasadiMeta
	Collects global CasADi meta information. More...
class	scoped_checkout
class	StreamStateGuard
struct	sortCompare
class	CodeGenerator
	Helper class for C code generation. More...
class	Concat
	Concatenation: Join multiple expressions stacking the nonzeros. More...
class	Horzcat
	Horizontal concatenation. More...
class	Vertcat
	Vertical concatenation of vectors. More...
class	Diagcat
	Diagonal concatenation of matrices. More...
struct	ConicMemory
class	Conic
	Internal class. More...
class	ConstantMX
	Represents an MX that is only composed of a constant. More...
class	ConstantDM
	A constant given as a DM. More...
class	ConstantFile
	A constant to be read from a file. More...
class	ConstantPool
	A constant to be managed by a pool. More...
class	ZeroByZero
	A zero-by-zero matrix. More...
struct	RuntimeConst
	Constant known at runtime. More...
struct	CompiletimeConst
class	Constant
	A constant with all entries identical. More...
class	ConstantSX
	Represents a constant SX. More...
class	RealtypeSX
	DERIVED CLASSES. More...
class	IntegerSX
	Represents a constant integer SX. More...
class	ZeroSX
	Represents a zero SX. More...
class	OneSX
	Represents a one SX. More...
class	MinusOneSX
	Represents a minus one SX. More...
class	InfSX
	Represents an infinity SX. More...
class	MinusInfSX
	Represents a minus infinity SX. More...
class	NanSX
	Represents a not-a-number SX. More...
class	Convexify
	Convexify a symmetric matrix. More...
class	DaeBuilder
	A symbolic representation of a differential-algebraic equations model. More...
struct	Variable
	Holds expressions and meta-data corresponding to a physical quantity evolving in time. More...
class	DaeBuilderInternal
class	Determinant
	Matrix determinant. More...
class	Dot
	Matrix dot. More...
class	Dple
	Internal class. More...
class	Dump
	Dump. More...
class	Einstein
	An MX atomic for an Einstein product,. More...
class	CasadiException
	Casadi exception class. More...
class	KeyboardInterruptException
class	Expm
	Internal class. More...
class	External
class	GenericExternal
struct	Block
struct	HBlock
class	Factory
class	Filesystem
	Filesystem interface. More...
class	FiniteDiff
class	ForwardDiff
class	BackwardDiff
class	CentralDiff
class	Smoothing
class	Fmu
	Interface to binary FMU. More...
class	Fmu2
	Interface to a binary FMU, adhering to FMI version 2.0. More...
class	Fmu3
	Interface to a binary FMU, adhering to FMI version 2.0. More...
struct	FmuMemory
struct	InputStruct
struct	OutputStruct
class	FmuFunction
struct	EventMemory
class	FmuInternal
	Interface to binary FMU. More...
class	Function
	Function object. More...
class	FunctionBuffer
	Class to achieve minimal overhead function evaluations. More...
struct	ProtoFunctionMemory
	Function memory with temporary work vectors. More...
struct	FunctionMemory
	Function memory with temporary work vectors. More...
class	ProtoFunction
	Base class for FunctionInternal and LinsolInternal. More...
class	FunctionInternal
	Internal class for Function. More...
struct	GenericExpressionCommon
	Empty Base. More...
class	GenericExpression
	Expression interface. More...
struct	GenericMatrixCommon
	Empty Base. More...
class	GenericMatrix
	Matrix base class. More...
class	GenericWeakRef
class	GenericSharedInternal
class	GenericWeakRefInternal
class	GenericShared
class	WeakCache
class	RevWeakCache
class	SimpleCache
class	GenericType
	Generic data type, can hold different types such as bool, casadi_int, std::string etc. More...
class	GenericTypeBase
class	GenericTypeInternal
class	GetNonzeros
	Get nonzeros of a matrix. More...
class	GetNonzerosVector
class	GetNonzerosSlice
class	GetNonzerosSlice2
class	GetNonzerosParam
	Get nonzeros of a matrix, parametrically. More...
class	GetNonzerosParamVector
class	GetNonzerosSliceParam
class	GetNonzerosParamSlice
class	GetNonzerosParamParam
class	GlobalOptions
	Collects global CasADi options. More...
class	GraphBuilder
	A mutable, format-neutral interface to a computational-graph model. More...
struct	Node
	Metadata for one graph tensor (graph input or output) More...
class	GraphBuilderInternal
	Internal class for GraphBuilder. More...
class	GraphModel
	Format-agnostic handle to a parsed computational-graph model. More...
class	GraphModelInternal
	Base interface for format-specific graph-model backends. More...
class	Importer
	Importer. More...
class	ImporterInternal
	Importer internal class. More...
class	DllLibrary
	Dynamically linked library. More...
struct	enum_traits< DynIn >
struct	enum_traits< DynOut >
struct	enum_traits< EventIn >
struct	enum_traits< EventOut >
struct	IntegratorMemory
	Integrator memory. More...
struct	SpForwardMem
	Memory struct, forward sparsity pattern propagation. More...
struct	SpReverseMem
	Memory struct, backward sparsity pattern propagation. More...
class	Integrator
	Internal storage for integrator related data. More...
struct	FixedStepMemory
class	FixedStepIntegrator
class	ImplicitFixedStepIntegrator
class	Interpolant
class	Inverse
	Matrix inverse. More...
class	IOInstruction
	An input or output instruction. More...
class	Input
	Input instruction. More...
class	Output
	Input instruction. More...
class	JitFunction
class	Kron
	Kronecker product. More...
class	DenseKron
	Kron specialization: both operands dense. More...
class	DenseSparseKron
	Kron specialization: dense a + sparse b. More...
class	SparseDenseKron
	Kron specialization: sparse a + dense b. More...
class	KronContract
	Kronecker contraction. More...
class	DenseKronContract
	KronContract specialization: M dense, X dense (=> Y dense) More...
class	DenseSparseKronContract
	KronContract specialization: M dense, X sparse (=> Y dense) More...
class	SparseDenseKronContract
	KronContract specialization: M sparse, X dense. More...
class	Linsol
	Linear solver. More...
struct	LinsolMemory
class	LinsolInternal
class	LogSumExp
	Calculate logsumexp update. More...
class	Map
class	OmpMap
class	ThreadMap
class	MapSum
struct	MatrixCommon
	Empty Base. More...
class	MMin
	Matrix minimum. More...
class	MMax
	Matrix maximum. More...
class	ModelicaParser
	Modelica parser. More...
class	ModelicaParserInternal
class	Monitor
	Monitor. More...
class	MultipleOutput
class	OutputNode
class	Multiplication
	An MX atomic for matrix-matrix product,. More...
class	DenseMultiplication
	Dense * Dense -> Dense matrix product. More...
class	DenseSparseMultiplication
	Dense * Sparse -> Dense matrix product. More...
class	PseudoDenseMultiplication
	Compactible * Compactible -> Compactible product. More...
struct	ConvexifyData
class	MX
	MX - Matrix expression. More...
struct	MXAlgEl
	An element of the algorithm, namely an MX node. More...
class	MXFunction
	Internal node class for MXFunction. More...
class	MXNode
	Node class for MX objects. More...
class	NlpBuilder
	A symbolic NLP representation. More...
class	NlImporter
struct	NlpsolMemory
	Integrator memory. More...
class	Nlpsol
	NLP solver storage class. More...
class	NonZeros
	Access to a set of nonzeros. More...
class	Norm
	Matrix and vector norms. More...
class	NormF
	Represents a Frobenius norm. More...
class	Norm2
	Represents a 2-norm (spectral norm) More...
class	Norm1
	1-norm More...
class	NormInf
	Represents an infinity-norm operation on a MX. More...
struct	OnnxTensorInfo
	Metadata for a single ONNX tensor (input or output); shape is resolved by the builder. More...
struct	OnnxMemory
class	OnnxFunction
	Black-box ONNX function base; backends (e.g. onnxruntime) derive from this. More...
struct	Options
	Options metadata for a class. More...
class	Opti
	A simplified interface for NLP modeling/solving. More...
struct	IndexAbstraction
struct	MetaCon
struct	MetaVar
class	OptiCallback
class	OptiAdvanced
class	OptiSol
	A simplified interface for NLP modeling/solving. More...
class	null_ptr_on_copy
	Pointer that gets set to null when copied. More...
class	OptiNode
	A simplified interface for NLP modeling/solving. More...
class	OracleCallback
struct	LocalOracleMemory
	Function memory with temporary work vectors. More...
struct	OracleMemory
	Function memory. More...
class	OracleFunction
	Base class for functions that perform calculation with an oracle. More...
class	SharedSXElem
class	WeakRefSXElem
class	OutputSX
class	PluginInterface
	Interface for accessing input and output data structures. More...
class	Polynomial
	Helper class for differentiating and integrating polynomials. More...
struct	PrintableCommon
	Empty Base. More...
class	Printable
	Base class for objects that have a natural string representation. More...
class	Project
	Change the sparsity of an expression. More...
class	Densify
	Densify. More...
class	Sparsify
	Densify. More...
class	Rank1
	Calculate rank1 update. More...
class	HorzRepmat
	Horizontal repmat. More...
class	HorzRepsum
	Horizontal repsum. More...
class	Reshape
	Reshape an expression. More...
class	Resource
	RAII class for reading from a zip file. More...
class	ResourceInternal
	RAII class base for reading from resources. More...
class	DirResource
class	TemporaryDirResource
	Base class for resources that use a temporary directory. More...
class	ZipResource
	RAII class for reading from a zip file. More...
class	ZipMemResource
	RAII class for reading from a zip held in memory. More...
struct	RootfinderMemory
	Integrator memory. More...
class	Rootfinder
	Internal class. More...
struct	casadi_newton_mem
class	SerializerBase
class	DeserializerBase
class	StringSerializer
class	FileSerializer
class	StringDeserializer
class	FileDeserializer
class	UniversalNodeOwner
class	DeserializingStream
	Helper class for Serialization. More...
class	SerializingStream
	Helper class for Serialization. More...
class	SetNonzeros
	Assign or add entries to a matrix. More...
class	SetNonzerosVector
	Add the nonzeros of a matrix to another matrix. More...
class	SetNonzerosSlice
class	SetNonzerosSlice2
class	SetNonzerosParam
	Assign or add entries to a matrix, parametrically. More...
class	SetNonzerosParamVector
	Add the nonzeros of a matrix to another matrix, parametrically. More...
class	SetNonzerosParamSlice
class	SetNonzerosSliceParam
class	SetNonzerosParamParam
class	SharedObject
	GenericShared implements a reference counting framework similar for efficient and. More...
class	WeakRef
	Weak reference type. More...
class	SharedObjectInternal
class	WeakRefInternal
class	Slice
	Class representing a Slice. More...
class	Solve
	An MX atomic for linear solver solution: x = r * A^-1 or x = r * A^-T. More...
class	LinsolCall
	Linear solve operation with a linear solver instance. More...
class	TriuSolve
	Linear solve with an upper triangular matrix. More...
class	TrilSolve
	Linear solve with an upper triangular matrix. More...
class	SolveUnity
	Linear solve with unity diagonal added. More...
class	TriuSolveUnity
	Linear solve with an upper triangular matrix, unity diagonal. More...
class	TrilSolveUnity
	Linear solve with an upper triangular matrix. More...
struct	SparsityStruct
	Compact representation of a sparsity pattern. More...
class	Sparsity
	General sparsity class. More...
class	SparsityCast
struct	SparsityInterfaceCommon
	Empty Base. More...
class	SparsityInterface
	Sparsity interface class. More...
class	SparsityInternal
class	Split
	Split: Split into multiple expressions splitting the nonzeros. More...
class	Horzsplit
	Horizontal split, x -> x0, x1, ... More...
class	Diagsplit
	Diag split, x -> x0, x1, ... More...
class	Vertsplit
	Vertical split of vectors, x -> x0, x1, ... More...
class	SubAssign
	Reference to a submatrix. More...
class	SubMatrix
class	SubIndex
class	SubRef
	Reference to a submatrix. More...
class	Switch
class	SXElem
	The basic scalar symbolic class of CasADi. More...
class	casadi_limits< SXElem >
struct	ScalarAtomic
	An atomic operation for the SXElem virtual machine. More...
class	SXFunction
	Internal node class for SXFunction. More...
class	SXNode
	Internal node class for SX. More...
class	SymbolicMX
	Represents a symbolic MX. More...
class	SymbolicSX
	Represents a scalar symbolic expression. More...
class	FStats
class	ScopedTiming
class	Transpose
	Matrix transpose. More...
class	DenseTranspose
	Matrix transpose (dense) More...
class	UnaryMX
	Represents a general unary operation on an MX. More...
class	UnarySX
	Represents a basic unary operation on an SXElem node. More...
class	XFunction
	Internal node class for the base class of SXFunction and MXFunction. More...
class	XmlFile
	XML parser. More...
class	XmlFileInternal
struct	XmlNode
struct	AlpaqaMemory
class	AlpaqaInterface
class	AlpaqaProblem
struct	AmplInterfaceMemory
class	AmplInterface
	'ampl' plugin for Nlpsol More...
class	BlasClassic
	'classic' plugin for Blas More...
class	BlasBlasfeo
	'blasfeo' plugin for Blas More...
struct	BlocksqpMemory
class	Blocksqp
	'blocksqp' plugin for Nlpsol More...
struct	BonminMemory
class	BonminInterface
	'bonmin' plugin for Nlpsol More...
class	BonminUserClass
struct	CbcMemory
class	CbcInterface
	'cbc' plugin for Conic More...
struct	MadmpecMemory
class	MadmpecInterface
	'ccopt' plugin for Nlpsol More...
class	ClangCompiler
	'clang' plugin for Importer More...
struct	ClarabelMemory
class	ClarabelInterface
	'clarabel' plugin for Conic More...
struct	ClpMemory
class	ClpInterface
	'clp' plugin for Conic More...
struct	CplexMemory
class	CplexInterface
	'cplex' plugin for Conic More...
struct	CsparseCholMemory
class	CSparseCholeskyInterface
	'csparsecholesky' plugin for Linsol More...
struct	CsparseMemory
class	CsparseInterface
	'csparse' plugin for Linsol More...
struct	DaqpMemory
class	DaqpInterface
	'daqp' plugin for Conic More...
struct	FatropConicMemory
class	FatropConicInterface
	'fatrop' plugin for Conic More...
struct	FatropMemory
class	FatropInterface
	'fatrop' plugin for Nlpsol More...
class	Ghc
	'ghc' plugin for Filesystem More...
struct	LazyCallbackMemory
struct	GurobiMemory
class	GurobiInterface
	'gurobi' plugin for Conic More...
struct	HighsMemory
class	HighsInterface
	'highs' plugin for Conic More...
struct	HpipmMemory
class	HpipmInterface
	'hpipm' plugin for Conic More...
struct	HpmpcMemory
class	HpmpcInterface
	'hpmpc' plugin for Conic More...
struct	Ma27Memory
class	Ma27Interface
	'ma27' plugin for Linsol More...
struct	IpoptMemory
class	IpoptInterface
	'ipopt' plugin for Nlpsol More...
class	IpoptUserClass
struct	KnitroMemory
class	KnitroInterface
	'knitro' plugin for Nlpsol More...
class	LaceModelica
	'lacemodelica' plugin for ModelicaParser More...
struct	LapackLuMemory
class	LapackLu
	'lapacklu' plugin for Linsol More...
struct	LapackQrMemory
class	LapackQr
	'lapackqr' plugin for Linsol More...
class	Libzip
	'libzip' plugin for Archiver More...
struct	MadnlpMemory
class	MadnlpInterface
	'madnlp' plugin for Nlpsol More...
struct	MosekMemory
class	MosekInterface
	'mosek' plugin for Conic More...
struct	MumpsMemory
class	MumpsInterface
	'mumps' plugin for Linsol More...
class	Onnx
	'onnx' plugin for GraphModel More...
struct	OpMapping
	Operation mapping between CasADi and ONNX. More...
struct	OoqpMemory
class	OoqpInterface
	'ooqp' plugin for Conic More...
struct	OnnxRuntimeMemory
	Per-checkout ONNX Runtime state (session + reusable eval scaffolding) More...
class	OnnxRuntimeInterface
	'ort' plugin for Onnx More...
struct	OsqpMemory
class	OsqpInterface
	'osqp' plugin for Conic More...
struct	PiqpMemory
class	PiqpInterface
	'piqp' plugin for Conic More...
struct	ProxqpMemory
class	ProxqpInterface
	'proxqp' plugin for Conic More...
struct	QpoasesMemory
class	QpoasesInterface
	'qpoases' plugin for Conic More...
struct	SLEQPMemory
class	SLEQPInterface
struct	SlicotDpleMemory
class	SlicotDple
	'slicot' plugin for Dple More...
struct	SlicotExpmMemory
class	SlicotExpm
	'slicot' plugin for Expm More...
struct	SnoptMemory
class	SnoptInterface
	'snopt' plugin for Nlpsol More...
class	SqicInterface
	'sqic' plugin for Conic More...
struct	CvodesMemory
class	CvodesInterface
	'cvodes' plugin for Integrator More...
struct	IdasMemory
class	IdasInterface
	'idas' plugin for Integrator More...
struct	KinsolMemory
class	KinsolInterface
	'kinsol' plugin for Rootfinder More...
struct	SundialsMemory
class	SundialsInterface
struct	SuperscsMemory
class	SuperscsInterface
	'superscs' plugin for Conic More...
class	TinyXmlInterface
	'tinyxml' plugin for XmlFile More...
struct	UnoMemory
class	UnoInterface
	'uno' plugin for Nlpsol More...
struct	WorhpMemory
class	WorhpInterface
	'worhp' plugin for Nlpsol More...
struct	XpressMemory
class	XpressInterface
	'xpress' plugin for Conic More...
class	BSplineInterpolant
	'bspline' plugin for Interpolant More...
class	Collocation
	'collocation' plugin for Integrator More...
struct	FastNewtonMemory
class	FastNewton
	'fast_newton' plugin for Rootfinder More...
struct	FeasiblesqpmethodMemory
class	Feasiblesqpmethod
	'feasiblesqpmethod' plugin for Nlpsol More...
struct	ImplicitToNlpMemory
class	ImplicitToNlp
	'nlp' plugin for Rootfinder More...
struct	IpqpMemory
class	Ipqp
	'ipqp' plugin for Conic More...
class	LinearInterpolant
	'linear' plugin for Interpolant Implements a multilinear interpolant: For 1D, the interpolating polynomial will be linear. For 2D, the interpolating polynomial will be bilinear, etc. More...
class	LinearInterpolantJac
struct	LinsolLdlMemory
class	LinsolLdl
	'ldl' plugin for Linsol More...
struct	LinsolQrMemory
class	LinsolQr
	'qr' plugin for Linsol More...
struct	LinsolTridiagMemory
class	LinsolTridiag
	'tridiag' plugin for Linsol More...
struct	LsqrMemory
	Memory for SymbolicQR More...
class	Lsqr
	'symbolicqr' plugin for Linsol More...
struct	NewtonMemory
class	Newton
	'newton' plugin for Rootfinder More...
struct	QpToNlpMemory
class	QpToNlp
	'nlpsol' plugin for Conic More...
struct	QrqpMemory
class	Qrqp
	'qrqp' plugin for Conic More...
struct	QrsqpMemory
class	Qrsqp
	'qrsqp' plugin for Nlpsol More...
class	RungeKutta
	'rk' plugin for Integrator More...
struct	ScpgenMemory
class	Scpgen
	'scpgen' plugin for Nlpsol More...
class	ShellCompiler
	'shell' plugin for Importer More...
struct	SqpmethodMemory
class	Sqpmethod
	'sqpmethod' plugin for Nlpsol More...
struct	SymbolicQrMemory
	Memory for SymbolicQR More...
class	SymbolicQr
	'symbolicqr' plugin for Linsol More...

Typedefs
typedef unsigned long long	bvec_t
typedef void *	handle_t
typedef Matrix< double >	DM
typedef std::vector< DM >	DMVector
typedef std::vector< DMVector >	DMVectorVector
typedef std::map< std::string, DM >	DMDict
typedef GenericTypeInternal< OT_STRING, std::string >	StringType
typedef GenericTypeInternal< OT_DOUBLE, double >	DoubleType
typedef GenericTypeInternal< OT_INT, casadi_int >	IntType
typedef GenericTypeInternal< OT_BOOL, bool >	BoolType
typedef GenericTypeInternal< OT_DOUBLEVECTOR, std::vector< double > >	DoubleVectorType
typedef GenericTypeInternal< OT_DOUBLEVECTORVECTOR, std::vector< std::vector< double > > >	DoubleVectorVectorType
typedef GenericTypeInternal< OT_INTVECTOR, std::vector< casadi_int > >	IntVectorType
typedef GenericTypeInternal< OT_BOOLVECTOR, std::vector< bool > >	BoolVectorType
typedef GenericTypeInternal< OT_INTVECTORVECTOR, std::vector< std::vector< casadi_int > > >	IntVectorVectorType
typedef GenericTypeInternal< OT_STRINGVECTOR, std::vector< std::string > >	StringVectorType
typedef GenericTypeInternal< OT_STRINGVECTORVECTOR, std::vector< std::vector< std::string > > >	StringVectorVectorType
typedef GenericTypeInternal< OT_FUNCTION, Function >	FunctionType
typedef GenericTypeInternal< OT_FUNCTIONVECTOR, std::vector< Function > >	FunctionVectorType
typedef GenericTypeInternal< OT_DICT, Dict >	DictType
typedef GenericTypeInternal< OT_DICTVECTOR, std::vector< Dict > >	DictVectorType
typedef GenericTypeInternal< OT_VECTORVECTOR, std::vector< std::vector< GenericType > > >	VectorVectorType
typedef GenericTypeInternal< OT_VECTOR, std::vector< GenericType > >	VectorType
typedef GenericTypeInternal< OT_VOIDPTR, void * >	VoidPointerType
typedef GenericType::Dict	Dict
	C++ equivalent of Python's dict or MATLAB's struct. More...
typedef Matrix< casadi_int >	IM
typedef DM	native_DM
typedef GenericWeakRefInternal< SharedSXElem, OutputSX >	WeakRefInternalSXElem
typedef ProtoFunction *(*	Deserialize) (DeserializingStream &)
typedef void(*	external_print_callback_t) (const char *s)
typedef const char *(*	external_transform_t) (char api_version, const char *casadi_version, const char *in, external_print_callback_t cb_stdout, external_print_callback_t cb_stderr)
using	AddNodeFn = std::function< onnx::NodeProto *()>
	Callback type for adding nodes to a container (GraphProto or FunctionProto) More...
typedef SX *	SXPtr
typedef std::vector< SXPtr >	SXPtrV
typedef int(*	config_t) (int, const char **)
	Function pointer types for the C API. More...
typedef void(*	signal_t) (void)
	Function pointer types for the C API. More...
typedef casadi_int(*	getint_t) (void)
	Function pointer types for the C API. More...
typedef double(*	default_t) (casadi_int i)
	Function pointer types for the C API. More...
typedef const char *(*	name_t) (casadi_int i)
	Function pointer types for the C API. More...
typedef const casadi_int *(*	sparsity_t) (casadi_int i)
	Function pointer types for the C API. More...
typedef int(*	diff_t) (casadi_int i)
	Function pointer types for the C API. More...
typedef int(*	casadi_checkout_t) (void)
	Function pointer types for the C API. More...
typedef void(*	casadi_release_t) (int)
	Function pointer types for the C API. More...
typedef int(*	work_t) (casadi_int *sz_arg, casadi_int *sz_res, casadi_int *sz_iw, casadi_int *sz_w)
	Function pointer types for the C API. More...
typedef int(*	eval_t) (const double **arg, double **res, casadi_int *iw, double *w, int)
	Function pointer types for the C API. More...
typedef std::vector< std::string >	StringVector
typedef std::vector< MX >	MXVector
typedef std::initializer_list< MX >	MXIList
typedef std::vector< MXVector >	MXVectorVector
typedef std::map< std::string, MX >	MXDict
typedef std::map< std::string, Sparsity >	SpDict
typedef Matrix< SXElem >	SX
typedef std::vector< SX >	SXVector
typedef std::initializer_list< SX >	SXIList
typedef std::vector< SXVector >	SXVectorVector
typedef std::map< std::string, SX >	SXDict

Enumerations
enum	{ CASADI_BLAS_NO_TRANS = 111 , CASADI_BLAS_TRANS = 112 }
enum	Operation {   OP_ASSIGN , OP_ADD , OP_SUB , OP_MUL ,   OP_DIV , OP_NEG , OP_EXP , OP_LOG ,   OP_POW , OP_CONSTPOW , OP_SQRT , OP_SQ ,   OP_TWICE , OP_SIN , OP_COS , OP_TAN ,   OP_ASIN , OP_ACOS , OP_ATAN , OP_LT ,   OP_LE , OP_EQ , OP_NE , OP_NOT ,   OP_AND , OP_OR , OP_FLOOR , OP_CEIL ,   OP_FMOD , OP_FABS , OP_SIGN , OP_COPYSIGN ,   OP_IF_ELSE_ZERO , OP_ERF , OP_FMIN , OP_FMAX ,   OP_INV , OP_SINH , OP_COSH , OP_TANH ,   OP_ASINH , OP_ACOSH , OP_ATANH , OP_ATAN2 ,   OP_CONST , OP_INPUT , OP_OUTPUT , OP_PARAMETER ,   OP_CALL , OP_FIND , OP_LOW , OP_MAP ,   OP_MTIMES , OP_SOLVE , OP_TRANSPOSE , OP_DETERMINANT ,   OP_INVERSE , OP_DOT , OP_BILIN , OP_RANK1 ,   OP_HORZCAT , OP_VERTCAT , OP_DIAGCAT , OP_HORZSPLIT ,   OP_VERTSPLIT , OP_DIAGSPLIT , OP_RESHAPE , OP_SUBREF ,   OP_SUBASSIGN , OP_GETNONZEROS , OP_GETNONZEROS_PARAM , OP_ADDNONZEROS ,   OP_ADDNONZEROS_PARAM , OP_SETNONZEROS , OP_SETNONZEROS_PARAM , OP_PROJECT ,   OP_ASSERTION , OP_MONITOR , OP_NORM2 , OP_NORM1 ,   OP_NORMINF , OP_NORMF , OP_MMIN , OP_MMAX ,   OP_HORZREPMAT , OP_HORZREPSUM , OP_ERFINV , OP_PRINTME ,   OP_LIFT , OP_EINSTEIN , OP_BSPLINE , OP_CONVEXIFY ,   OP_SPARSITY_CAST , OP_LOG1P , OP_EXPM1 , OP_HYPOT ,   OP_LOGSUMEXP , OP_REMAINDER , OP_DUMP , OP_KRON ,   OP_KRON_CONTRACT }
	Enum for quick access to any node. More...
enum	UnifiedReturnStatus {   SOLVER_RET_SUCCESS , SOLVER_RET_UNKNOWN , SOLVER_RET_LIMITED , SOLVER_RET_NAN ,   SOLVER_RET_INFEASIBLE , SOLVER_RET_EXCEPTION }
enum	ConicInput {   CONIC_H , CONIC_G , CONIC_A , CONIC_LBA ,   CONIC_UBA , CONIC_LBX , CONIC_UBX , CONIC_X0 ,   CONIC_LAM_X0 , CONIC_LAM_A0 , CONIC_Q , CONIC_P ,   CONIC_NUM_IN }
	Input arguments of a QP problem. More...
enum	ConicOutput {   CONIC_X , CONIC_COST , CONIC_LAM_A , CONIC_LAM_X ,   CONIC_NUM_OUT }
	Output arguments of an QP Solver. More...
enum class	TypeFmi2 {   REAL , INTEGER , BOOLEAN , STRING ,   ENUM , NUMEL }
	Variable type (FMI 2) More...
enum class	Type {   FLOAT32 , FLOAT64 , INT8 , UINT8 ,   INT16 , UINT16 , INT32 , UINT32 ,   INT64 , UINT64 , BOOLEAN , STRING ,   BINARY , ENUMERATION , CLOCK , NUMEL }
	Variable type (FMI 3) More...
enum class	Causality {   PARAMETER , CALCULATED_PARAMETER , INPUT , OUTPUT ,   LOCAL , INDEPENDENT , NUMEL }
	Causality: FMI 2.0 specification, section 2.2.7 or FMI 3.0 specification, section 2.4.7.4. More...
enum class	Variability {   CONSTANT , FIXED , TUNABLE , DISCRETE ,   CONTINUOUS , NUMEL }
	Variability: FMI 2.0 specification, section 2.2.7 or FMI 3.0 specification, section 2.4.7.4. More...
enum class	Category {   T , C , P , D ,   W , U , X , Z ,   Q , CALCULATED , ODE , ALG ,   QUAD , ZERO , DDEF , WDEF ,   Y , NUMEL }
enum class	Initial {   EXACT , APPROX , CALCULATED , NA ,   NUMEL }
	Initial: FMI 2.0 specification, section 2.2.7 or FMI 3.0 specification, section 2.4.7.5. More...
enum class	Attribute {   MIN , MAX , NOMINAL , START ,   VALUE , STRINGVALUE , NUMEL }
enum class	DependenciesKind {   DEPENDENT , CONSTANT , FIXED , TUNABLE ,   DISCRETE , NUMEL }
enum	DpleInput { DPLE_A , DPLE_V , DPLE_NUM_IN }
	Input arguments of a dple solver [dpleIn]. More...
enum	DpleOutput { DPLE_P , DPLE_NUM_OUT }
	Output arguments of a dple solver [dpleOut]. More...
enum class	FdMode {   FORWARD , BACKWARD , CENTRAL , SMOOTHING ,   NUMEL }
	Variable type. More...
enum class	FmuApi { FMI2 , FMI3 , NUMEL }
	Which C API. More...
enum class	Parallelization { SERIAL , OPENMP , THREAD , NUMEL }
	Type of parallelization. More...
enum class	InputType {   REG , FWD , ADJ , OUT ,   ADJ_OUT }
enum class	OutputType {   REG , FWD , ADJ , JAC ,   JAC_TRANS , JAC_ADJ_OUT , JAC_REG_ADJ , HESS }
enum	TypeID {   OT_NULL , OT_BOOL , OT_INT , OT_DOUBLE ,   OT_STRING , OT_INTVECTOR , OT_INTVECTORVECTOR , OT_BOOLVECTOR ,   OT_DOUBLEVECTOR , OT_DOUBLEVECTORVECTOR , OT_STRINGVECTOR , OT_DICT ,   OT_FUNCTION , OT_FUNCTIONVECTOR , OT_VOIDPTR , OT_UNKNOWN ,   OT_STRINGVECTORVECTOR , OT_DICTVECTOR , OT_VECTORVECTOR , OT_VECTOR }
	Types of options. More...
enum	CollocationPoints { LEGENDRE , RADAU }
enum	DynIn {   DYN_T , DYN_X , DYN_Z , DYN_P ,   DYN_U , DYN_NUM_IN }
	Inputs of the symbolic representation of the DAE. More...
enum	DynOut {   DYN_ODE , DYN_ALG , DYN_QUAD , DYN_ZERO ,   DYN_NUM_OUT }
	Outputs of the symbolic representation of the DAE. More...
enum	EventIn {   EVENT_INDEX , EVENT_T , EVENT_X , EVENT_Z ,   EVENT_P , EVENT_U , EVENT_NUM_IN }
	Inputs of an event transition function. More...
enum	EventOut { EVENT_POST_X , EVENT_POST_Z , EVENT_NUM_OUT }
	Outputs of an event transition function. More...
enum	IntegratorInput {   INTEGRATOR_X0 , INTEGRATOR_Z0 , INTEGRATOR_P , INTEGRATOR_U ,   INTEGRATOR_ADJ_XF , INTEGRATOR_ADJ_ZF , INTEGRATOR_ADJ_QF , INTEGRATOR_NUM_IN }
	Input arguments of an integrator. More...
enum	IntegratorOutput {   INTEGRATOR_XF , INTEGRATOR_ZF , INTEGRATOR_QF , INTEGRATOR_ADJ_X0 ,   INTEGRATOR_ADJ_Z0 , INTEGRATOR_ADJ_P , INTEGRATOR_ADJ_U , INTEGRATOR_NUM_OUT }
	Output arguments of an integrator. More...
enum	StepIn {   STEP_T , STEP_H , STEP_X0 , STEP_V0 ,   STEP_P , STEP_U , STEP_NUM_IN }
	Input arguments of a forward stepping function. More...
enum	StepOut { STEP_XF , STEP_VF , STEP_QF , STEP_NUM_OUT }
	Output arguments of a forward stepping function. More...
enum	BStepIn {   BSTEP_T , BSTEP_H , BSTEP_X0 , BSTEP_V0 ,   BSTEP_P , BSTEP_U , BSTEP_OUT_XF , BSTEP_OUT_VF ,   BSTEP_OUT_QF , BSTEP_ADJ_XF , BSTEP_ADJ_VF , BSTEP_ADJ_QF ,   BSTEP_NUM_IN }
	Input arguments of a backward stepping function. More...
enum	BStepOut {   BSTEP_ADJ_T , BSTEP_ADJ_H , BSTEP_ADJ_X0 , BSTEP_ADJ_V0 ,   BSTEP_ADJ_P , BSTEP_ADJ_U , BSTEP_NUM_OUT }
	Output arguments of a backward stepping function. More...
enum	NLPInput { NL_X , NL_P , NL_NUM_IN }
	Input arguments of an NLP function. More...
enum	NLPOutput { NL_F , NL_G , NL_NUM_OUT }
	Output arguments of an NLP function. More...
enum	NlpsolInput {   NLPSOL_X0 , NLPSOL_P , NLPSOL_LBX , NLPSOL_UBX ,   NLPSOL_LBG , NLPSOL_UBG , NLPSOL_LAM_X0 , NLPSOL_LAM_G0 ,   NLPSOL_NUM_IN }
	Input arguments of an NLP Solver. More...
enum	NlpsolOutput {   NLPSOL_X , NLPSOL_F , NLPSOL_G , NLPSOL_LAM_X ,   NLPSOL_LAM_G , NLPSOL_LAM_P , NLPSOL_NUM_OUT }
	Output arguments of an NLP Solver. More...
enum	ConstraintType {   OPTI_GENERIC_EQUALITY , OPTI_GENERIC_INEQUALITY , OPTI_EQUALITY , OPTI_INEQUALITY ,   OPTI_DOUBLE_INEQUALITY , OPTI_PSD , OPTI_UNKNOWN }
enum	VariableType { OPTI_VAR , OPTI_PAR , OPTI_DUAL_G }
enum	DomainType { OPTI_DOMAIN_REAL , OPTI_DOMAIN_INTEGER }
enum	RfpIn { RFP_X , RFP_P , RFP_NUM_IN }
	Inputs of the symbolic representation of the rootfinding problem. More...
enum	RfpOut { RFP_G , RFP_NUM_OUT }
	Inputs of the symbolic representation of the rootfinding problem. More...
enum	RootfinderInput { ROOTFINDER_X0 , ROOTFINDER_P , ROOTFINDER_NUM_IN }
	Input arguments of a rootfinder. More...
enum	RootfinderOutput { ROOTFINDER_X , ROOTFINDER_NUM_OUT }
	Output arguments of a rootfinder. More...

Functions
bool	has_archiver (const std::string &name)
	Check if a particular plugin is available. More...
void	load_archiver (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_archiver (const std::string &name)
	Get the documentation string for a plugin. More...
bool	has_blas (const std::string &name)
void	load_blas (const std::string &name)
std::string	doc_blas (const std::string &name)
static void	handle_pedantic (const std::string &mode, const std::string &opt_name, const std::string &msg)
static bool	is_pow2_ge8 (casadi_int n)
static void	scan_prefix_pow2 (std::vector< std::string > &offenders, const std::vector< casadi_int > &ext, const std::string &tag)
static std::vector< casadi_int >	knot_offsets (const std::vector< casadi_int > &knot_dims)
template<typename M >
static M	compute_knots_cache (const M &K, const std::vector< casadi_int > &offsets)
static MX	derivative_coeff_mx (casadi_int i, const std::vector< MX > &knots_per_dim, const std::vector< casadi_int > &degree, const std::vector< casadi_int > &coeffs_dims, const MX &coeffs)
Function	blazing_spline (const std::string &name, const std::vector< std::vector< double > > &knots, const Dict &opts=Dict())
	Construct a specialized parametric BSpline. More...
Function	blazing_spline (const std::string &name, const std::vector< casadi_int > &knot_dims, const Dict &opts=Dict())
	Construct a parametric-knots blazing_spline. More...
void	get_boor (const MX &x, const MX &knots, casadi_int degree, casadi_int lookup_mode, MX &start, MX &boor)
static casadi_int	knot_size (const std::vector< double > &k)
static casadi_int	knot_size (const MX &k)
template<typename K >
MX	do_inline (const MX &x, const std::vector< K > &knots, const MX &coeffs, casadi_int m, const std::vector< casadi_int > &degree, const std::vector< casadi_int > &lookup_mode)
template<typename T >
T	twice (const T &x)
template<typename T >
T	sq (const T &x)
template<template< casadi_int > class F, typename T >
T	operation_getter (casadi_int op)
template<template< casadi_int > class F>
bool	operation_checker (casadi_int op)
template<class T , typename SU >
T	common_simp_unary (casadi_int op, const T &x, casadi_int depth, SU &&gen_unary, bool unique, bool &hit)
template<class T , typename SU , typename SB >
T	common_simp_binary (casadi_int op, const T &x, const T &y, casadi_int depth, SU &&gen_unary, SB &&gen_binary, bool unique_x, bool unique_y, bool &hit)
template<typename T >
std::string	str (const T &v)
	String representation, any type. More...
template<typename T >
std::string	str (const T &v, bool more)
	String representation, CasADi type. More...
template<typename T >
std::string	str (const std::vector< T > &v, bool more=false)
	String representation of vector. More...
template<typename T >
std::string	str (const std::set< T > &v, bool more=false)
	String representation of set. More...
template<typename T1 , typename T2 >
std::string	str (const std::pair< T1, T2 > &p, bool more=false)
	String representation of pair. More...
template<typename T1 , typename T2 >
std::string	str (const std::map< T1, T2 > &p, bool more=false)
	String representation of a map. More...
template<typename T2 >
std::string	str (const std::map< std::string, T2 > &p, bool more=false)
	String representation of a dictionary. More...
template<typename T , size_t N>
std::string	str (const std::array< T, N > &p, bool more=false)
	String representation of an array. More...
std::vector< std::string >	strvec ()
	Create a list of strings from VA_ARGS, no argument. More...
template<typename T1 >
std::vector< std::string >	strvec (const T1 &t1)
	Create a list of strings from VA_ARGS, one argument. More...
template<typename T1 , typename T2 >
std::vector< std::string >	strvec (const T1 &t1, const T2 &t2)
	Create a list of strings from VA_ARGS, two arguments. More...
template<typename T1 , typename T2 , typename T3 >
std::vector< std::string >	strvec (const T1 &t1, const T2 &t2, const T3 &t3)
	Create a list of strings from VA_ARGS, three arguments. More...
template<typename T1 , typename T2 , typename T3 , typename T4 >
std::vector< std::string >	strvec (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4)
	Create a list of strings from VA_ARGS, four arguments. More...
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
std::vector< std::string >	strvec (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5)
	Create a list of strings from VA_ARGS, five arguments. More...
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
std::vector< std::string >	strvec (const T1 &t1, const T2 &t2, const T3 &t3, const T4 &t4, const T5 &t5, const T6 &t6)
	Create a list of strings from VA_ARGS, six arguments. More...
std::string	fmtstr (const std::string &fmt, const std::vector< std::string > &args)
	Create a string from a formatted string. More...
template<typename T >
bool	has_enum (const std::string &s)
	Helper function: Check if enum exists. More...
template<typename T >
T	to_enum (const std::string &s, const std::string &s_def="")
	Helper function: Convert string to enum. More...
template<typename T >
std::vector< std::string >	enum_names ()
	Helper function: Get all fields. More...
template<class T >
bool	is_zero (const T &x)
std::ostream &	uout ()
std::ostream &	uerr ()
int	to_int (casadi_int rhs)
std::vector< int >	to_int (const std::vector< casadi_int > &rhs)
std::vector< std::vector< int > >	to_int (const std::vector< std::vector< casadi_int > > &rhs)
bool	all (const std::vector< bool > &v)
	Check if all arguments are true. More...
bool	any (const std::vector< bool > &v)
	Check if any arguments are true. More...
bool	is_range (const std::vector< casadi_int > &v, casadi_int start, casadi_int stop, casadi_int step=1)
	Check if a vector matches a range. More...
std::vector< casadi_int >	range (casadi_int start, casadi_int stop, casadi_int step=1, casadi_int len=std::numeric_limits< casadi_int >::max())
	Range function. More...
bool	is_equally_spaced (const std::vector< double > &v)
std::vector< casadi_int >	range (casadi_int stop)
	Range function. More...
std::vector< casadi_int >	complement (const std::vector< casadi_int > &v, casadi_int size)
	Returns the list of all i in [0, size[ not found in supplied list. More...
std::vector< casadi_int >	lookupvector (const std::vector< casadi_int > &v, casadi_int size)
	Returns a vector for quickly looking up entries of supplied list. More...
std::vector< casadi_int >	lookupvector (const std::vector< casadi_int > &v)
bool	is_permutation (const std::vector< casadi_int > &order)
	Does the list represent a permutation? More...
std::vector< casadi_int >	invert_permutation (const std::vector< casadi_int > &a)
	inverse a permutation vector More...
bvec_t *	get_bvec_t (std::vector< double > &v)
const bvec_t *	get_bvec_t (const std::vector< double > &v)
	Get an pointer of sets of booleans from a double vector. More...
std::string	join (const std::vector< std::string > &l, const std::string &delim)
bool	startswith (const std::string &s, const std::string &p)
	Checks if s starts with p. More...
CASADI_EXPORT std::string	replace (const std::string &s, const std::string &p, const std::string &r)
	Replace all occurences of p with r in s. More...
bool	version_gt (const std::string &version_left, const std::string &version_right)
	Compare versions: returns true if version_left > version_right. More...
bool	version_ge (const std::string &version_left, const std::string &version_right)
	Compare versions: returns true if version_left >= version_right. More...
bool	version_lt (const std::string &version_left, const std::string &version_right)
	Compare versions: returns true if version_left < version_right. More...
bool	version_le (const std::string &version_left, const std::string &version_right)
	Compare versions: returns true if version_left <= version_right. More...
std::string	temporary_file (const std::string &prefix, const std::string &suffix, const std::string &directory)
std::vector< bool >	boolvec_not (const std::vector< bool > &v)
	Invert all entries. More...
std::vector< bool >	boolvec_and (const std::vector< bool > &lhs, const std::vector< bool > &rhs)
	And operation on boolean vector. More...
std::vector< bool >	boolvec_or (const std::vector< bool > &lhs, const std::vector< bool > &rhs)
	Or operation on boolean vector. More...
std::vector< casadi_int >	boolvec_to_index (const std::vector< bool > &v)
void	normalized_setup (std::istream &stream)
void	normalized_setup (std::ostream &stream)
std::string	str_bvec (bvec_t v)
bvec_t	bvec_or (const bvec_t *arg, casadi_int n)
	Bit-wise or operation on bvec_t array. More...
template<typename T , typename S >
std::vector< T >	vector_static_cast (const std::vector< S > &rhs)
template<typename T >
std::vector< T >	vector_slice (const std::vector< T > &v, const std::vector< casadi_int > &i)
	Slicing vector. More...
template<typename T >
std::vector< T >	vector_select (const std::vector< T > &v, const std::vector< bool > &s, bool invert=false)
	Select subset of vector. More...
template<typename T >
std::vector< T >	vector_tail (const std::vector< T > &v)
	Return all but the first element of a vector. More...
template<typename T >
std::vector< T >	vector_init (const std::vector< T > &v)
	Return all but the last element of a vector. More...
template<typename T >
std::vector< T >	reverse (const std::vector< T > &v)
	Reverse a list. More...
template<typename T >
std::vector< T >	join (const std::vector< T > &a, const std::vector< T > &b)
	Join two lists. More...
template<typename T >
std::vector< T >	join (const std::vector< T > &a, const std::vector< T > &b, const std::vector< T > &c)
	Join three lists. More...
template<typename T >
std::vector< T >	permute (const std::vector< T > &a, const std::vector< casadi_int > &order)
	permute a list More...
template<typename T >
std::vector< casadi_int >	find (const std::vector< T > &v)
	find nonzeros More...
template<typename T >
bool	in_range (const std::vector< T > &v, casadi_int upper)
	Check if for each element of v holds: v_i < upper. More...
template<typename T >
bool	in_range (const std::vector< T > &v, casadi_int lower, casadi_int upper)
	Check if for each element of v holds: lower <= v_i < upper. More...
template<class T , class S >
void	flatten_nested_vector (const std::vector< std::vector< T > > &nested, std::vector< S > &flat)
	Flatten a nested std::vector tot a single flattened vector. More...
template<class T , class S , class I >
void	flatten_nested_vector (const std::vector< std::vector< T > > &nested, std::vector< S > &flat, std::vector< I > &indices)
	Flatten a nested std::vector tot a single flattened vector. More...
template<class T >
std::vector< T >	applymap (T(*f)(const T &), const std::vector< T > &comp)
template<class T >
void	applymap (void(*f)(T &), std::vector< T > &comp)
template<typename T >
bool	is_increasing (const std::vector< T > &v)
	Check if the vector is strictly increasing. More...
template<typename T >
bool	is_decreasing (const std::vector< T > &v)
	Check if the vector is strictly decreasing. More...
template<typename T >
bool	is_nonincreasing (const std::vector< T > &v)
	Check if the vector is non-increasing. More...
template<typename T >
bool	is_nondecreasing (const std::vector< T > &v)
	Check if the vector is non-decreasing. More...
template<typename T >
bool	is_monotone (const std::vector< T > &v)
	Check if the vector is monotone. More...
template<typename T >
bool	is_strictly_monotone (const std::vector< T > &v)
	Check if the vector is strictly monotone. More...
template<typename T >
bool	has_negative (const std::vector< T > &v)
	Check if the vector has negative entries. More...
template<typename T >
void	write_matlab (std::ostream &stream, const std::vector< T > &v)
	Print vector, matlab style. More...
template<typename T >
void	write_matlab (std::ostream &stream, const std::vector< std::vector< T > > &v)
	Print matrix, matlab style. More...
template<typename T >
void	read_matlab (std::istream &stream, std::vector< T > &v)
	Read vector, matlab style. More...
template<typename T >
void	read_matlab (std::ifstream &file, std::vector< std::vector< T > > &v)
	Read matrix, matlab style. More...
template<typename T , typename F , typename L >
void	linspace (std::vector< T > &v, const F &first, const L &last)
	Matlab's linspace. More...
template<typename T >
bvec_t *	get_bvec_t (std::vector< T > &v)
	Get an pointer of sets of booleans from a double vector. More...
template<typename T >
const bvec_t *	get_bvec_t (const std::vector< T > &v)
	Get an pointer of sets of booleans from a double vector. More...
template<typename T >
T *	get_ptr (std::vector< T > &v)
	Get a pointer to the data contained in the vector. More...
template<typename T >
const T *	get_ptr (const std::vector< T > &v)
	Get a pointer to the data contained in the vector. More...
template<typename T >
void	sort (const std::vector< T > &values, std::vector< T > &sorted_values, std::vector< casadi_int > &indices, bool invert_indices=false)
	Sort the data in a vector. More...
template<typename T >
T	product (const std::vector< T > &values)
	product More...
template<typename T >
T	sum (const std::vector< T > &values)
	sum More...
template<typename T >
std::vector< T >	cumsum (const std::vector< T > &values)
	cumulative sum More...
template<typename T >
std::vector< T >	diff (const std::vector< T > &values)
	diff More...
template<typename T >
std::vector< T >	cumsum0 (const std::vector< T > &values)
	cumulative sum, starting with zero More...
template<typename T >
bool	is_regular (const std::vector< T > &v)
	Checks if array does not contain NaN or Inf. More...
void	normalized_out (std::ostream &stream, double val)
int	normalized_in (std::istream &stream, double &ret)
template<typename T >
std::ostream &	operator<< (std::ostream &stream, const std::vector< T > &v)
	Enables flushing an std::vector to a stream (prints representation) More...
template<typename T , size_t N>
std::ostream &	operator<< (std::ostream &stream, const std::array< T, N > &v)
	Enables flushing an std::array to a stream (prints representation) More...
template<typename T >
std::ostream &	operator<< (std::ostream &stream, const std::set< T > &v)
	Enables flushing an std::set to a stream (prints representation) More...
template<typename T1 , typename T2 >
std::ostream &	operator<< (std::ostream &stream, const std::pair< T1, T2 > &p)
template<typename T1 , typename T2 >
std::ostream &	operator<< (std::ostream &stream, const std::map< T1, T2 > &p)
template<typename T2 >
std::ostream &	operator<< (std::ostream &stream, const std::map< std::string, T2 > &p)
template<typename T >
bool	mul_overflows (const T &a, const T &b)
template<class S , class D >
void	copy_vector (const std::vector< S > &s, std::vector< D > &d)
template<class S , class D >
void	assign_vector (const std::vector< S > &s, std::vector< D > &d)
template<class S , class D >
void	copy_vector (const S *s, std::vector< D > &d)
template<class S , class D >
void	init_vector (std::vector< S > &d, const std::vector< D > &s)
template<typename T >
bool	isUnique (const std::vector< T > &v)
template<typename T >
T	dot (const std::vector< T > &a, const std::vector< T > &b)
template<typename T >
T	norm_inf (const std::vector< T > &x)
template<typename T >
T	norm_1 (const std::vector< T > &x)
template<typename T >
T	norm_2 (const std::vector< T > &x)
template<typename T >
size_t	hash_value (T v)
	Hash value of an integer. More...
template<typename T >
void	hash_combine (std::size_t &seed, T v)
	Generate a hash value incrementally (function taken from boost) More...
template<typename T >
void	hash_combine (std::size_t &seed, const T *v, std::size_t sz)
	Generate a hash value incrementally, array. More...
template<typename T >
void	hash_combine (std::size_t &seed, const std::vector< T > &v)
	Generate a hash value incrementally (function taken from boost) More...
template<>
size_t	hash_value (std::string v)
template<>
size_t	hash_value (double v)
	Hash value of a double. More...
char	pathsep ()
std::string	filesep ()
std::vector< std::string >	get_search_paths ()
std::unique_ptr< std::istream >	ifstream_compat (const std::string &utf8_path, std::ios::openmode mode)
std::unique_ptr< std::ostream >	ofstream_compat (const std::string &utf8_path, std::ios::openmode mode)
CASADI_EXPORT std::ifstream *	new_ifstream_compat (const std::string &utf8_path, std::ios::openmode mode=std::ios::in)
static std::string	next_quoted_token (const std::string &line, size_t &pos)
bool	has_conic (const std::string &name)
	Check if a particular plugin is available. More...
void	load_conic (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_conic (const std::string &name)
	Get the documentation string for a plugin. More...
Function	conic (const std::string &name, const std::string &solver, const SpDict &qp, const Dict &opts)
void	conic_debug (const Function &f, const std::string &filename)
void	conic_debug (const Function &f, std::ostream &file)
std::vector< std::string >	conic_in ()
	Get input scheme of QP solvers. More...
std::vector< std::string >	conic_out ()
	Get QP solver output scheme of QP solvers. More...
std::string	conic_in (casadi_int ind)
	Get QP solver input scheme name by index. More...
std::string	conic_out (casadi_int ind)
	Get output scheme name by index. More...
casadi_int	conic_n_in ()
	Get the number of QP solver inputs. More...
casadi_int	conic_n_out ()
	Get the number of QP solver outputs. More...
template<typename M >
Function	qpsol_nlp (const std::string &name, const std::string &solver, const std::map< std::string, M > &qp, const Dict &opts)
Function	qpsol (const std::string &name, const std::string &solver, const SXDict &qp, const Dict &opts)
Function	qpsol (const std::string &name, const std::string &solver, const MXDict &qp, const Dict &opts)
std::vector< std::string >	conic_options (const std::string &name)
	Get all options for a plugin. More...
std::string	conic_option_type (const std::string &name, const std::string &op)
	Get type info for a particular option. More...
std::string	conic_option_info (const std::string &name, const std::string &op)
	Get documentation for a particular option. More...
SXNode *	ConstantSX_deserialize (DeserializingStream &s)
std::string	strategy_to_string (casadi_convexify_strategy_t s)
bool	is_input_category (Category cat)
bool	is_output_category (Category cat)
bool	is_acyclic (Category cat)
Category	dependent_definition (Category cat)
std::vector< Category >	input_categories ()
std::vector< Category >	output_categories ()
static Resource	open_resource (const std::string &path)
Category	input_category (Category cat)
template<typename T >
std::vector< T >	read_list (const XmlNode &n)
template<>
void CASADI_EXPORT	mtimes_dense_dispatch< double > (const std::string &blas, const double *A, casadi_int m, casadi_int k, const double *B, casadi_int n, double *C)
bool	has_dple (const std::string &name)
	Check if a particular plugin is available. More...
void	load_dple (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_dple (const std::string &name)
	Get the documentation string for a plugin. More...
MX	dplesol (const MX &A, const MX &V, const std::string &solver, const Dict &opts)
CASADI_EXPORT MXVector	dplesol (const MXVector &A, const MXVector &V, const std::string &solver, const Dict &opts)
CASADI_EXPORT DMVector	dplesol (const DMVector &A, const DMVector &V, const std::string &solver, const Dict &opts)
Function	dplesol (const std::string &name, const std::string &solver, const SpDict &st, const Dict &opts)
std::vector< std::string >	dple_in ()
	Get input scheme of DPLE solvers. More...
std::vector< std::string >	dple_out ()
	Get output scheme of DPLE solvers. More...
std::string	dple_in (casadi_int ind)
	Get DPLE input scheme name by index. More...
std::string	dple_out (casadi_int ind)
	Get DPLE output scheme name by index. More...
casadi_int	dple_n_in ()
	Get the number of QP solver inputs. More...
casadi_int	dple_n_out ()
	Get the number of QP solver outputs. More...
void	ensure_directory_exists (const std::string &dir)
std::string	trim_path (const std::string &full_path)
std::ostream &	message_prefix (std::ostream &stream)
bool	has_expm (const std::string &name)
	Check if a particular plugin is available. More...
void	load_expm (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_expm (const std::string &name)
	Get the documentation string for a plugin. More...
Function	expmsol (const std::string &name, const std::string &solver, const Sparsity &A, const Dict &opts)
casadi_int	expm_n_in ()
	Get the number of expm solver inputs. More...
casadi_int	expm_n_out ()
	Get the number of expm solver outputs. More...
Function	external (const std::string &name, const Importer &li, const Dict &opts=Dict())
	Load a just-in-time compiled external function. More...
Function	external (const std::string &name, const Dict &opts=Dict())
	Load an external function from a shared library. More...
Function	external (const std::string &name, const std::string &bin_name, const Dict &opts=Dict())
	Load an external function from a shared library. More...
bool	has_filesystem (const std::string &name)
	Check if a particular plugin is available. More...
void	load_filesystem (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_filesystem (const std::string &name)
	Get the documentation string for a plugin. More...
std::string	to_string (FdMode v)
	Convert to string. More...
casadi_int	n_fd_points (FdMode v)
	Length of FD stencil, including unperturbed input. More...
casadi_int	fd_offset (FdMode v)
	Offset for FD stencil, i.e. index of unperturbed input. More...
template<typename T1 >
CASADI_EXPORT void	finite_diff (FdMode v, const T1 **yk, T1 *J, T1 h, casadi_int n_y, T1 smoothing)
	Calculate FD estimate. More...
std::string	to_string (FmuApi v)
	Convert to string. More...
std::string	to_string (Parallelization v)
	Convert to string. More...
bool	has_prefix (const std::string &s)
std::string	pop_prefix (const std::string &s, std::string *rem)
std::string	transform_token_str (const GenericType &g)
std::string	transform_passes_str (const std::vector< std::vector< GenericType > > &ps)
std::string	transform_stats (const Function &f)
void CASADI_EXPORT	_function_buffer_eval (void *raw)
void	bvec_toggle (bvec_t *s, casadi_int begin, casadi_int end, casadi_int j)
void	bvec_clear (bvec_t *s, casadi_int begin, casadi_int end)
void	bvec_or (const bvec_t *s, bvec_t &r, casadi_int begin, casadi_int end)
void	assert_read (std::istream &stream, const std::string &s)
template<typename T >
std::vector< std::pair< std::string, T > >	zip (const std::vector< std::string > &id, const std::vector< T > &mat)
template<typename M >
M	replace_mat (const M &arg, const Sparsity &inp, casadi_int npar)
double	index_interp1d (const std::vector< double > &x, double xq, bool equidistant)
template<class B , class S >
B	shared_cast (S &A)
	Typecast a shared object to a base class to a shared object to a derived class,. More...
template<class B , class S >
const B	shared_cast (const S &A)
	Typecast a shared object to a base class to a shared object to a derived class,. More...
template<class A >
A	getcopy (const A &a, std::map< typename A::base_type *, typename A::internal_base_type > &already_copied)
Dict	combine (const Dict &first, const Dict &second, bool recurse=false)
	Combine two dicts. First has priority. More...
void	update_dict (Dict &target, const Dict &source, bool recurse=false)
	Update the target dictionary in place with source elements. More...
void	update_dict (Dict &target, const std::string &key, const GenericType &value, bool recurse)
template<class T >
T	get_from_dict (const std::map< std::string, T > &d, const std::string &key, const T &default_value)
template<class T >
T	get_from_dict (const Dict &d, const std::string &key, const T &default_value)
template<class T >
Dict	extract_from_dict (const Dict &d, const std::string &key, T &value)
template<class T >
void	extract_from_dict_inplace (Dict &d, const std::string &key, T &value)
static std::string	format_from_path (const std::string &path)
bool	has_graphmodel (const std::string &name)
	Check if a graph-model format plugin is available. More...
void	load_graphmodel (const std::string &name)
	Explicitly load a graph-model format plugin. More...
std::string	doc_graphmodel (const std::string &name)
	Get format-specific documentation. More...
bool CASADI_EXPORT	is_slice (const IM &x, bool ind1=false)
	Is the IM a Slice. More...
Slice CASADI_EXPORT	to_slice (const IM &x, bool ind1=false)
	Convert IM to Slice. More...
template<typename T >
T	text2type (const std::string &text)
	Convert to a type. More...
template<typename T >
std::vector< T >	text2vector (const std::string &text)
	Get entry as a vector. More...
template<typename T >
std::set< T >	text2set (const std::string &text)
	Get entry as a set. More...
template<typename RealT >
std::vector< RealT >	collocation_pointsGen (casadi_int order, const std::string &scheme)
Function	simpleRK (Function f, casadi_int N=10, casadi_int order=4)
	Construct an explicit Runge-Kutta integrator. More...
void	collocation_interpolators (const std::vector< double > &tau, std::vector< std::vector< double > > &C, std::vector< double > &D)
	Obtain collocation interpolating matrices. More...
void	collocation_coeff (const std::vector< double > &tau, DM &C, DM &D, DM &B)
	Obtain collocation interpolating matrices. More...
Function	simpleIRK (Function f, casadi_int N=10, casadi_int order=4, const std::string &scheme="radau", const std::string &solver="newton", const Dict &solver_options=Dict())
	Construct an implicit Runge-Kutta integrator using a collocation scheme. More...
Function	simpleIntegrator (Function f, const std::string &integrator="cvodes", const Dict &integrator_options=Dict())
	Simplified wrapper for the Integrator class. More...
std::vector< casadi_int >	invert_lookup (const std::vector< casadi_int > &lookup)
template<class X >
std::map< std::string, X >	add_defaults (const std::map< std::string, X > &in, const std::vector< std::string > &keys)
std::vector< casadi_int >	get_orders (const std::vector< casadi_int > &map)
std::vector< casadi_int >	get_inverse (const std::vector< casadi_int > &map)
std::vector< casadi_int >	path (const std::vector< casadi_int > &map, casadi_int i_start)
template<class X >
const std::map< std::string, X >	reduce_index_gen (const std::map< std::string, X > &dae, Dict &stats, const Dict &opts)
template<class X >
std::map< std::string, X >	map_semi_expl (const std::map< std::string, X > &dae, const std::map< std::string, X > &dae_red, Function &state_to_orig, Function &phi)
template<class X >
Function	init_gen (const std::map< std::string, X > &dae, const std::map< std::string, X > &dae_red, const std::string &init_solver, const DMDict &init_strength, const Dict &init_solver_options)
bool	has_integrator (const std::string &name)
	Check if a particular plugin is available. More...
void	load_integrator (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_integrator (const std::string &name)
	Get the documentation string for a plugin. More...
Function	integrator (const std::string &name, const std::string &solver, const SXDict &dae, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const MXDict &dae, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const Function &dae, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const SXDict &dae, double t0, const std::vector< double > &tout, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const MXDict &dae, double t0, const std::vector< double > &tout, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const Function &dae, double t0, const std::vector< double > &tout, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const SXDict &dae, double t0, double tf, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const MXDict &dae, double t0, double tf, const Dict &opts)
Function	integrator (const std::string &name, const std::string &solver, const Function &dae, double t0, double tf, const Dict &opts)
std::vector< std::string >	integrator_in ()
	Get input scheme of integrators. More...
std::vector< std::string >	integrator_out ()
	Get integrator output scheme of integrators. More...
std::string	integrator_in (casadi_int ind)
	Get integrator input scheme name by index. More...
std::string	integrator_out (casadi_int ind)
	Get output scheme name by index. More...
casadi_int	integrator_n_in ()
	Get the number of integrator inputs. More...
casadi_int	integrator_n_out ()
	Get the number of integrator outputs. More...
std::vector< std::string >	dyn_in ()
	Get input scheme of a DAE function. More...
std::vector< std::string >	dyn_out ()
	Get output scheme of a DAE function. More...
std::string	dyn_in (casadi_int ind)
	Get input scheme of a DAE function by index. More...
std::string	dyn_out (casadi_int ind)
	Get output scheme of a DAE function by index. More...
casadi_int	dyn_n_in ()
	Get the number of inputs for a DAE function. More...
casadi_int	dyn_n_out ()
	Get the number of outputs for a DAE function. More...
std::vector< std::string >	event_in ()
	Get input scheme of an event transition function. More...
std::vector< std::string >	event_out ()
	Get output scheme of an event transition functions. More...
bool	has_interpolant (const std::string &name)
	Check if a particular plugin is available. More...
void	load_interpolant (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_interpolant (const std::string &name)
	Get the documentation string for a plugin. More...
Function	interpolant (const std::string &name, const std::string &solver, const std::vector< std::vector< double > > &grid, const std::vector< double > &values, const Dict &opts)
Function	interpolant (const std::string &name, const std::string &solver, const std::vector< casadi_int > &grid_dims, const std::vector< double > &values, const Dict &opts=Dict())
	Parametric variant of interpolant. More...
Function	interpolant (const std::string &name, const std::string &solver, const std::vector< std::vector< double > > &grid, casadi_int m=1, const Dict &opts=Dict())
	Parametric variant of interpolant. More...
Function	interpolant (const std::string &name, const std::string &solver, const std::vector< casadi_int > &grid_dims, casadi_int m=1, const Dict &opts=Dict())
	Parametric variant of interpolant. More...
template<bool Fwd>
static int	kron_sp_gen (const Sparsity &sp_a, const Sparsity &sp_b, typename KronSpTraits< Fwd >::arg_t arg, typename KronSpTraits< Fwd >::res_t res)
bool	has_linsol (const std::string &name)
	Check if a particular plugin is available. More...
void	load_linsol (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_linsol (const std::string &name)
	Get the documentation string for a plugin. More...
void	ThreadsWork (const Function &f, casadi_int i, const double **arg, double **res, casadi_int *iw, double *w, casadi_int ind, int &ret)
template<typename T1 >
void	casadi_add (casadi_int n, const T1 *x, T1 *y)
template<>
void	casadi_add (casadi_int n, const bvec_t *x, bvec_t *y)
bool	has_modelicaparser (const std::string &name)
	Check if a particular plugin is available. More...
void	load_modelicaparser (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_modelicaparser (const std::string &name)
	Get solver specific documentation. More...
static void	codegen_copy_z (CodeGenerator &g, casadi_int nnz, const std::vector< casadi_int > &arg, const std::vector< casadi_int > &res, const std::vector< bool > &arg_is_ref)
bool	has_empty (const std::vector< MX > &x, bool both=false)
std::vector< MX >	trim_empty (const std::vector< MX > &x, bool both=false)
bool	simplify_const_folding_order (std::vector< MX > &arg, std::vector< MX > &res, const Dict &opts)
MX	get_const (const Sparsity &sp, const double *v, std::unordered_multimap< std::size_t, std::pair< MX, DM > > &cache)
MX	register_symbol (const MX &node, std::map< MXNode *, MX > &symbol_map, std::vector< MX > &symbol_v, std::vector< MX > &parametric_v, bool extract_trivial, casadi_int v_offset, const std::string &v_prefix, const std::string &v_suffix)
MX	interpn_G (casadi_int i, const MX &v, const std::vector< MX > &xis, const std::vector< MX > &L, const std::vector< MX > &Lp, const std::vector< casadi_int > &strides, const Slice &I, const MX &offset=0)
MX	kron_contract (const MX &m, const MX &x, bool inner)
	Kronecker contraction. More...
template<class T >
void	detect_simple_bounds_gen (const T &x, const T &p, const T &g, const T &lbg, const T &ubg, std::vector< casadi_int > &gi, T &lbx, T &ubx, Function &lam_forward, Function &lam_backward)
void	detect_simple_bounds (const SX &xX, const SX &p, const SX &g, const SX &lbg, const SX &ubg, std::vector< casadi_int > &gi, SX &lbx, SX &ubx, Function &lam_forward, Function &lam_backward)
	Detect simple bounds from general constraints. More...
void	detect_simple_bounds (const MX &x, const MX &p, const MX &g, const MX &lbg, const MX &ubg, std::vector< casadi_int > &gi, MX &lbx, MX &ubx, Function &lam_forward, Function &lam_backward)
template<class T >
void	check_sos (casadi_int nx, const std::vector< std::vector< T > > &groups, std::vector< std::vector< double > > &weights, std::vector< casadi_int > &types)
	Check sos structure and generate defaults. More...
bool	has_nlpsol (const std::string &name)
	Check if a particular plugin is available. More...
void	load_nlpsol (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_nlpsol (const std::string &name)
	Get the documentation string for a plugin. More...
bool	name_has_g (const std::string &name)
template<class X >
Function	construct_nlpsol (const std::string &name, const std::string &solver, const std::map< std::string, X > &nlp, const Dict &opts)
Function	nlpsol (const std::string &name, const std::string &solver, const SXDict &nlp, const Dict &opts)
Function	nlpsol (const std::string &name, const std::string &solver, const MXDict &nlp, const Dict &opts)
Function	nlpsol (const std::string &name, const std::string &solver, const NlpBuilder &nl, const Dict &opts)
Function	nlpsol (const std::string &name, const std::string &solver, const std::string &fname, const Dict &opts)
Function	nlpsol (const std::string &name, const std::string &solver, const Importer &compiler, const Dict &opts)
Function	nlpsol (const std::string &name, const std::string &solver, const Function &nlp, const Dict &opts)
std::vector< std::string >	nlpsol_in ()
	Get input scheme of NLP solvers. More...
std::vector< std::string >	nlpsol_out ()
	Get NLP solver output scheme of NLP solvers. More...
std::string	nlpsol_in (casadi_int ind)
	Get NLP solver input scheme name by index. More...
std::string	nlpsol_out (casadi_int ind)
	Get output scheme name by index. More...
casadi_int	nlpsol_n_in ()
	Number of NLP solver inputs. More...
casadi_int	nlpsol_n_out ()
	Number of NLP solver outputs. More...
int	detect_bounds_callback (const double **arg, double **res, casadi_int *iw, double *w, void *callback_data)
std::vector< std::string >	nlpsol_options (const std::string &name)
	Get all options for a plugin. More...
std::string	nlpsol_option_type (const std::string &name, const std::string &op)
	Get type info for a particular option. More...
std::string	nlpsol_option_info (const std::string &name, const std::string &op)
	Get documentation for a particular option. More...
bool	has_onnxbackend (const std::string &solver)
	Check if a given ONNX runtime backend is available. More...
void	load_onnxbackend (const std::string &solver)
	Load an ONNX runtime backend. More...
std::vector< std::string >	onnxbackend_solvers ()
	List available ONNX runtime backends. More...
std::string	onnxbackend_doc (const std::string &solver)
	Get documentation for an ONNX runtime backend. More...
std::string	onnx_dtype_name (casadi_int elem_type)
	Human-readable name of an ONNX element-type enum (1=FLOAT, 11=DOUBLE, 7=INT64, ...) More...
casadi_int	onnx_dtype_enum (const std::string &name)
	ONNX element-type enum for a human-readable name (inverse of onnx_dtype_name; 0 if unknown) More...
static std::vector< OnnxTensorInfo >	select_tensors (const std::vector< OnnxTensorInfo > &all, const std::vector< std::string > &req)
static void	pack_tensors (SerializingStream &s, const std::string &d, const std::vector< OnnxTensorInfo > &v)
static void	unpack_tensors (DeserializingStream &s, const std::string &d, std::vector< OnnxTensorInfo > &v)
bool	override_num (const std::map< casadi_int, MX > &temp, std::vector< DM > &num, casadi_int i)
template<typename T1 >
int	calc_function (const OracleCallback *cb, casadi_oracle_data< T1 > *d)
template<typename T >
T	check_exposed (T t)
static bvec_t	Orring (bvec_t x, bvec_t y)
std::vector< std::string >	rootfinder_in ()
	Get rootfinder input scheme. More...
std::vector< std::string >	rootfinder_out ()
	Get rootfinder output scheme. More...
std::string	rootfinder_in (casadi_int ind)
	Get rootfinder input scheme name by index. More...
std::string	rootfinder_out (casadi_int ind)
	Get rootfinder output scheme name by index. More...
casadi_int	rootfinder_n_in ()
	Number of rootfinder inputs. More...
casadi_int	rootfinder_n_out ()
	Number of rootfinder outputs. More...
std::vector< std::string >	rootfinder_options (const std::string &name)
	Get all options for a plugin. More...
std::string	rootfinder_option_type (const std::string &name, const std::string &op)
	Get type info for a particular option. More...
std::string	rootfinder_option_info (const std::string &name, const std::string &op)
	Get documentation for a particular option. More...
bool	has_rootfinder (const std::string &name)
	Check if a particular plugin is available. More...
void	load_rootfinder (const std::string &name)
	Explicitly load a plugin dynamically. More...
std::string	doc_rootfinder (const std::string &name)
	Get the documentation string for a plugin. More...
Function	rootfinder (const std::string &name, const std::string &solver, const SXDict &rfp, const Dict &opts)
Function	rootfinder (const std::string &name, const std::string &solver, const MXDict &rfp, const Dict &opts)
Function	rootfinder (const std::string &name, const std::string &solver, const Function &f, const Dict &opts)
template<typename T1 >
void	casadi_copy (const T1 *x, casadi_int n, T1 *y)
	COPY: y <-x. More...
template<typename T1 >
void	casadi_swap (casadi_int n, T1 *x, casadi_int inc_x, T1 *y, casadi_int inc_y)
	SWAP: x <-> y. More...
template<typename T1 >
void	casadi_project (const T1 *x, const casadi_int *sp_x, T1 *y, const casadi_int *sp_y, T1 *w)
	Sparse copy: y <- x, w work vector (length >= number of rows) More...
template<typename T1 , typename T2 >
void	casadi_densify (const T1 *x, const casadi_int *sp_x, T2 *y, casadi_int tr)
	Convert sparse to dense. More...
template<typename T1 , typename T2 >
void	casadi_sparsify (const T1 *x, T2 *y, const casadi_int *sp_y, casadi_int tr)
	Convert dense to sparse. More...
template<typename T1 >
void	casadi_scal (casadi_int n, T1 alpha, T1 *x)
	SCAL: x <- alpha*x. More...
template<typename T1 >
void	casadi_axpy (casadi_int n, T1 alpha, const T1 *x, T1 *y)
	AXPY: y <- a*x + y. More...
template<typename T1 >
T1	casadi_dot (casadi_int n, const T1 *x, const T1 *y)
	Inner product. More...
template<typename T1 >
T1	casadi_max_viol (casadi_int n, const T1 *x, const T1 *lb, const T1 *ub)
	Largest bound violation. More...
template<typename T1 >
T1	casadi_sum_viol (casadi_int n, const T1 *x, const T1 *lb, const T1 *ub)
	Sum of bound violations. More...
template<typename T1 >
casadi_int	casadi_iamax (casadi_int n, const T1 *x, casadi_int inc_x)
	IAMAX: index corresponding to the entry with the largest absolute value. More...
template<typename T1 >
void	casadi_clear (T1 *x, casadi_int n)
	CLEAR: x <- 0. More...
template<typename T1 >
void	casadi_fill (T1 *x, casadi_int n, T1 alpha)
	FILL: x <- alpha. More...
template<typename T1 >
void	casadi_mtimes (const T1 *x, const casadi_int *sp_x, const T1 *y, const casadi_int *sp_y, T1 *z, const casadi_int *sp_z, T1 *w, casadi_int tr)
	Sparse matrix-matrix multiplication: z <- z + x*y. More...
template<typename T1 >
void	casadi_mtimes_dense (const T1 *x, casadi_int nrow_x, casadi_int ncol_x, const T1 *y, casadi_int ncol_y, T1 *z, casadi_int tr)
	Dense matrix-matrix multiplication: z <- z + x*y (column-major) More...
template<typename T1 >
void	casadi_mtimes_dense_sparse (const T1 *x, casadi_int nrow_x, const T1 *y, const casadi_int *sp_y, T1 *z)
	Dense * sparse matrix multiplication: z <- z + x*y (z, x dense col-major) More...
template<typename T1 >
void	casadi_mv (const T1 *x, const casadi_int *sp_x, const T1 *y, T1 *z, casadi_int tr)
	Sparse matrix-vector multiplication: z <- z + x*y. More...
template<typename T1 >
void	casadi_triusolve (const casadi_int *sp_a, const T1 *nz_a, T1 *x, int tr, int unity, casadi_int nrhs)
	Linear solve, upper triangular matrix, optionally transposed or unity diagonal (1 - R) More...
template<typename T1 >
void	casadi_trilsolve (const casadi_int *sp_a, const T1 *nz_a, T1 *x, int tr, int unity, casadi_int nrhs)
	Linear solve, lower triangular matrix, optionally transposed or unity diagonal (1 - L) More...
template<typename T1 >
void	casadi_trans (const T1 *x, const casadi_int *sp_x, T1 *y, const casadi_int *sp_y, casadi_int *tmp)
	TRANS: y <- trans(x) , w work vector (length >= rows x) More...
template<typename T1 >
T1	casadi_norm_1 (casadi_int n, const T1 *x)
	NORM_1: ||x||_1 -> return. More...
template<typename T1 >
T1	casadi_norm_2 (casadi_int n, const T1 *x)
	NORM_2: ||x||_2 -> return. More...
template<typename T1 >
T1	casadi_norm_inf (casadi_int n, const T1 *x)
template<typename T1 >
T1	casadi_norm_inf_mul (const T1 *x, const casadi_int *sp_x, const T1 *y, const casadi_int *sp_y, T1 *dwork, casadi_int *iwork)
template<typename T1 >
T1	casadi_bilin (const T1 *A, const casadi_int *sp_A, const T1 *x, const T1 *y)
template<typename T1 >
void	casadi_kron (const T1 *a, const casadi_int *sp_a, const T1 *b, const casadi_int *sp_b, T1 *r)
template<typename T1 >
void	casadi_kron_dense (const T1 *a, casadi_int mA, casadi_int nA, const T1 *b, casadi_int mB, casadi_int nB, T1 *r)
template<typename T1 >
void	casadi_kron_dense_sparse (const T1 *a, casadi_int mA, casadi_int nA, const T1 *b, const casadi_int *sp_b, T1 *r)
template<typename T1 >
void	casadi_kron_sparse_dense (const T1 *a, const casadi_int *sp_a, const T1 *b, casadi_int mB, casadi_int nB, T1 *r)
template<typename T1 >
void	casadi_kron_contract_inner (const T1 *m, const casadi_int *sp_m, const T1 *b, const casadi_int *sp_b, T1 *y, const casadi_int *sp_y, T1 *w)
template<typename T1 >
void	casadi_kron_contract_inner_dense (const T1 *m, casadi_int mA, casadi_int nA, const T1 *b, casadi_int mB, casadi_int nB, T1 *y)
template<typename T1 >
void	casadi_kron_contract_inner_dense_sparse (const T1 *m, casadi_int mA, casadi_int nA, const T1 *b, const casadi_int *sp_b, T1 *y)
template<typename T1 >
void	casadi_kron_contract_inner_sparse_dense (const T1 *m, const casadi_int *sp_m, const T1 *b, casadi_int mB, casadi_int nB, T1 *y, const casadi_int *sp_y)
template<typename T1 >
void	casadi_kron_contract_outer (const T1 *m, const casadi_int *sp_m, const T1 *a, const casadi_int *sp_a, T1 *y, const casadi_int *sp_y, T1 *w)
template<typename T1 >
void	casadi_kron_contract_outer_dense (const T1 *m, casadi_int mB, casadi_int nB, const T1 *a, casadi_int mA, casadi_int nA, T1 *y)
template<typename T1 >
void	casadi_kron_contract_outer_dense_sparse (const T1 *m, casadi_int mB, casadi_int nB, const T1 *a, const casadi_int *sp_a, T1 *y)
template<typename T1 >
void	casadi_kron_contract_outer_sparse_dense (const T1 *m, const casadi_int *sp_m, const T1 *a, casadi_int mA, casadi_int nA, T1 *y, const casadi_int *sp_y)
template<typename T1 >
void	casadi_rank1 (T1 *A, const casadi_int *sp_A, T1 alpha, const T1 *x)
	Adds a multiple alpha/2 of the outer product mul(x, trans(x)) to A. More...
template<typename T1 >
void	casadi_getu (const T1 *x, const casadi_int *sp_x, T1 *v)
	Get the nonzeros for the upper triangular half. More...
template<typename T1 >
T1	casadi_polyval (const T1 *p, casadi_int n, T1 x)
	Evaluate a polynomial. More...
casadi_int	casadi_flip (casadi_int *corner, casadi_int ndim)
template<typename T1 >
casadi_int	casadi_low (T1 x, const T1 *grid, casadi_int ng, casadi_int lookup_mode)
template<typename T1 >
void	casadi_interpn_weights (casadi_int ndim, const T1 *grid, const casadi_int *offset, const T1 *x, T1 *alpha, casadi_int *index)
template<typename T1 >
T1	casadi_interpn_interpolate (casadi_int ndim, const casadi_int *offset, const T1 *values, const T1 *alpha, const casadi_int *index, const casadi_int *corner, T1 *coeff)
template<typename T1 >
T1	casadi_interpn (casadi_int ndim, const T1 *grid, const casadi_int *offset, const T1 *values, const T1 *x, casadi_int *iw, T1 *w)
template<typename T1 >
void	casadi_interpn_grad (T1 *grad, casadi_int ndim, const T1 *grid, const casadi_int *offset, const T1 *values, const T1 *x, casadi_int *iw, T1 *w)
template<typename T1 >
void	casadi_de_boor (T1 x, const T1 *knots, casadi_int n_knots, casadi_int degree, T1 *boor)
template<typename T1 >
void	casadi_tensor_ttv (T1 *ret, casadi_int dim, casadi_int n_dims, const T1 *all_w, const casadi_int *w_offset, const casadi_int *starts, const casadi_int *strides, const T1 *c, casadi_int m, T1 weight, casadi_int offset)
template<typename T1 >
void	casadi_nd_boor_eval (T1 *ret, casadi_int n_dims, const T1 *knots, const casadi_int *offset, const casadi_int *degree, const casadi_int *strides, const T1 *c, casadi_int m, const T1 *x, const casadi_int *lookup_mode, casadi_int *iw, T1 *w)
template<typename T1 >
T1	casadi_mmax (const T1 *x, casadi_int n, T1 is_dense)
template<typename T1 >
T1	casadi_mmin (const T1 *x, casadi_int n, casadi_int is_dense)
template<typename T1 >
T1	casadi_vfmax (const T1 *x, casadi_int n, T1 r)
template<typename T1 >
T1	casadi_vfmin (const T1 *x, casadi_int n, T1 r)
void	casadi_fill_casadi_int (casadi_int *x, casadi_int n, casadi_int alpha)
void	casadi_clear_casadi_int (casadi_int *x, casadi_int n)
template<typename T1 >
void	casadi_bound_consistency (casadi_int n, T1 *x, T1 *lam, const T1 *lbx, const T1 *ubx)
template<typename T1 >
T1	casadi_logsumexp (const T1 *x, casadi_int n)
template<typename T1 >
int	casadi_newton (const casadi_newton_mem< T1 > *m)
template<typename T >
casadi_int	einstein_process (const T &A, const T &B, const T &C, const std::vector< casadi_int > &dim_a, const std::vector< casadi_int > &dim_b, const std::vector< casadi_int > &dim_c, const std::vector< casadi_int > &a, const std::vector< casadi_int > &b, const std::vector< casadi_int > &c, std::vector< casadi_int > &iter_dims, std::vector< casadi_int > &strides_a, std::vector< casadi_int > &strides_b, std::vector< casadi_int > &strides_c)
template<typename T >
void	Contraction (const T &a, const T &b, T &r)
template<>
void	Contraction (const bvec_t &a, const bvec_t &b, bvec_t &r)
template<typename T >
void	einstein_eval (casadi_int n_iter, const std::vector< casadi_int > &iter_dims, const std::vector< casadi_int > &strides_a, const std::vector< casadi_int > &strides_b, const std::vector< casadi_int > &strides_c, const T *a_in, const T *b_in, T *c_in)
Slice CASADI_EXPORT	to_slice (const std::vector< casadi_int > &v, bool ind1=false)
	Construct from an index vector (requires is_slice(v) to be true) More...
bool CASADI_EXPORT	is_slice (const std::vector< casadi_int > &v, bool ind1=false)
	Check if an index vector can be represented more efficiently as a slice. More...
bool CASADI_EXPORT	is_slice2 (const std::vector< casadi_int > &v)
	Check if an index vector can be represented more efficiently as two nested slices. More...
std::pair< Slice, Slice > CASADI_EXPORT	to_slice2 (const std::vector< casadi_int > &v)
	Construct nested slices from an index vector (requires is_slice2(v) to be true) More...
std::size_t	hash_sparsity (casadi_int nrow, casadi_int ncol, const std::vector< casadi_int > &colind, const std::vector< casadi_int > &row)
	Hash a sparsity pattern. More...
std::size_t	hash_sparsity (casadi_int nrow, casadi_int ncol, const casadi_int *colind, const casadi_int *row)
template<bool COMBINE_AND>
static void	mul_bvec_fwd (const bvec_t *x, const Sparsity &x_sp, const bvec_t *y, const Sparsity &y_sp, bvec_t *z, const Sparsity &z_sp, bvec_t *w)
template<>
std::string	matrixName< SXElem > ()
SXElem	register_symbol (const SXElem &node, std::map< SXNode *, SXElem > &symbol_map, std::vector< SXElem > &symbol_v, std::vector< SXElem > &parametric_v, bool extract_trivial, casadi_int v_offset, const std::string &v_prefix, const std::string &v_suffix)
SX	mtaylor_recursive (const SX &ex, const SX &x, const SX &a, casadi_int order, const std::vector< casadi_int > &order_contributions, const SXElem &current_dx=casadi_limits< SXElem >::one, double current_denom=1, casadi_int current_order=1)
void	callback_stdout (const char *s)
void	callback_stderr (const char *s)
Function	external_transform (const std::string &name, const std::string &op, const Function &f, const Dict &opts=Dict())
	Apply a transformation defined externally. More...
template<typename MatType >
Sparsity	_jacobian_sparsity (const MatType &expr, const MatType &var)
template<typename MatType >
std::vector< bool >	_which_depends (const MatType &expr, const MatType &var, casadi_int order, bool tr)
std::ostream &	operator<< (std::ostream &stream, const XmlNode &node)
int CASADI_NLPSOL_ALPAQA_EXPORT	casadi_register_nlpsol_alpaqa (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_ALPAQA_EXPORT	casadi_load_nlpsol_alpaqa ()
template<typename T1 , typename T2 >
void	copy (const T1 *x, casadi_int n, T2 *y)
int CASADI_NLPSOL_AMPL_EXPORT	casadi_register_nlpsol_ampl (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_AMPL_EXPORT	casadi_load_nlpsol_ampl ()
static void	classic_dgemm (int transa, int transb, casadi_int m, casadi_int n, casadi_int k, double alpha, const double *A, casadi_int lda, const double *B, casadi_int ldb, double beta, double *C, casadi_int ldc)
static void	classic_daxpy (casadi_int n, double alpha, const double *x, double *y)
static double	classic_ddot (casadi_int n, const double *x, const double *y)
static void	classic_dscal (casadi_int n, double alpha, double *x)
static double	classic_dnrm2 (casadi_int n, const double *x)
static double	classic_dasum (casadi_int n, const double *x)
static void	classic_dcopy (const double *x, casadi_int n, double *y)
static void	classic_codegen_mtimes (CodeGenerator &g, const std::string &A, casadi_int m, casadi_int k, const std::string &B, casadi_int n, const std::string &C)
static void	classic_codegen_axpy_aux (CodeGenerator &g, const std::vector< std::string > &inst)
static void	classic_codegen_scal_aux (CodeGenerator &g, const std::vector< std::string > &inst)
static void	classic_codegen_dot_aux (CodeGenerator &g, const std::vector< std::string > &inst)
static void	classic_codegen_nrm2_aux (CodeGenerator &g, const std::vector< std::string > &inst)
static void	classic_codegen_asum_aux (CodeGenerator &g, const std::vector< std::string > &inst)
int CASADI_BLAS_CLASSIC_EXPORT	casadi_register_blas_classic (Blas::Plugin *plugin)
void CASADI_BLAS_CLASSIC_EXPORT	casadi_load_blas_classic ()
static void	blasfeo_dgemm (int transa, int transb, casadi_int m, casadi_int n, casadi_int k, double alpha, const double *A, casadi_int lda, const double *B, casadi_int ldb, double beta, double *C, casadi_int ldc)
static void	blasfeo_daxpy (casadi_int n, double alpha, const double *x, double *y)
static double	blasfeo_ddot (casadi_int n, const double *x, const double *y)
static void	blasfeo_codegen_mtimes (CodeGenerator &g, const std::string &A, casadi_int m, casadi_int k, const std::string &B, casadi_int n, const std::string &C)
static void	blasfeo_codegen_axpy_aux (CodeGenerator &g, const std::vector< std::string > &inst)
static void	blasfeo_codegen_dot_aux (CodeGenerator &g, const std::vector< std::string > &inst)
int CASADI_BLAS_BLASFEO_EXPORT	casadi_register_blas_blasfeo (Blas::Plugin *plugin)
void CASADI_BLAS_BLASFEO_EXPORT	casadi_load_blas_blasfeo ()
int CASADI_NLPSOL_BLOCKSQP_EXPORT	casadi_register_nlpsol_blocksqp (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_BLOCKSQP_EXPORT	casadi_load_nlpsol_blocksqp ()
int CASADI_NLPSOL_BONMIN_EXPORT	casadi_register_nlpsol_bonmin (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_BONMIN_EXPORT	casadi_load_nlpsol_bonmin ()
const char *	return_status_string (Bonmin::TMINLP::SolverReturn status)
std::string	to_str (const CoinError &e)
std::string	to_str (TNLPSolver::UnsolvedError &e)
int CASADI_CONIC_CBC_EXPORT	casadi_register_conic_cbc (Conic::Plugin *plugin)
void CASADI_CONIC_CBC_EXPORT	casadi_load_conic_cbc ()
std::string	return_status_string (int status)
std::string	return_secondary_status_string (int status)
int CASADI_NLPSOL_CCOPT_EXPORT	casadi_register_nlpsol_ccopt (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_CCOPT_EXPORT	casadi_load_nlpsol_ccopt ()
void	flatten_opts (Dict &ret, const Dict &opts, const std::string &prefix)
int CASADI_IMPORTER_CLANG_EXPORT	casadi_register_importer_clang (ImporterInternal::Plugin *plugin)
void CASADI_IMPORTER_CLANG_EXPORT	casadi_load_importer_clang ()
int CASADI_CONIC_CLARABEL_EXPORT	casadi_register_conic_clarabel (Conic::Plugin *plugin)
void CASADI_CONIC_CLARABEL_EXPORT	casadi_load_conic_clarabel ()
void	codegen_local (CodeGenerator &g, const std::string &name, const std::vector< int > &v)
int CASADI_CONIC_CLP_EXPORT	casadi_register_conic_clp (Conic::Plugin *plugin)
void CASADI_CONIC_CLP_EXPORT	casadi_load_conic_clp ()
int CASADI_CONIC_CPLEX_EXPORT	casadi_register_conic_cplex (Conic::Plugin *plugin)
void CASADI_CONIC_CPLEX_EXPORT	casadi_load_conic_cplex ()
int	param_by_name (CPXENVptr env, const std::string &name)
int CASADI_LINSOL_CSPARSE_EXPORT	casadi_register_linsol_csparse (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_CSPARSE_EXPORT	casadi_load_linsol_csparse ()
int CASADI_CONIC_DAQP_EXPORT	casadi_register_conic_daqp (Conic::Plugin *plugin)
void CASADI_CONIC_DAQP_EXPORT	casadi_load_conic_daqp ()
int CASADI_CONIC_FATROP_EXPORT	casadi_register_conic_fatrop (Conic::Plugin *plugin)
void CASADI_CONIC_FATROP_EXPORT	casadi_load_conic_fatrop ()
std::vector< casadi_int >	fatrop_blocks_pack (const std::vector< casadi_ocp_block > &blocks)
fatrop_int	get_nx (const fatrop_int k, void *user_data)
fatrop_int	get_nu (const fatrop_int k, void *user_data)
fatrop_int	get_ng (const fatrop_int k, void *user_data)
fatrop_int	get_n_stage_params (const fatrop_int k, void *user_data)
fatrop_int	get_n_global_params (void *user_data)
fatrop_int	get_default_stage_params (double *stage_params, const fatrop_int k, void *user_data)
fatrop_int	get_default_global_params (double *global_params, void *user_data)
fatrop_int	get_ng_ineq (const fatrop_int k, void *user_data)
fatrop_int	get_horizon_length (void *user_data)
fatrop_int	eval_BAbt (const double *states_kp1, const double *inputs_k, const double *states_k, const double *stage_params_k, const double *global_params, MAT *res, const fatrop_int k, void *user_data)
fatrop_int	eval_Ggt (const double *inputs_k, const double *states_k, const double *stage_params_k, const double *global_params, MAT *res, const fatrop_int k, void *user_data)
fatrop_int	eval_Ggt_ineq (const double *inputs_k, const double *states_k, const double *stage_params_k, const double *global_params, MAT *res, const fatrop_int k, void *user_data)
fatrop_int	eval_RSQrqt (const double *objective_scale, const double *inputs_k, const double *states_k, const double *lam_dyn_k, const double *lam_eq_k, const double *lam_eq_ineq_k, const double *stage_params_k, const double *global_params, MAT *res, const fatrop_int k, void *user_data)
fatrop_int	eval_b (const double *states_kp1, const double *inputs_k, const double *states_k, const double *stage_params_k, const double *global_params, double *res, const fatrop_int k, void *user_data)
fatrop_int	eval_g (const double *states_k, const double *inputs_k, const double *stage_params_k, const double *global_params, double *res, const fatrop_int k, void *user_data)
fatrop_int	eval_gineq (const double *states_k, const double *inputs_k, const double *stage_params_k, const double *global_params, double *res, const fatrop_int k, void *user_data)
fatrop_int	eval_rq (const double *objective_scale, const double *inputs_k, const double *states_k, const double *stage_params_k, const double *global_params, double *res, const fatrop_int k, void *user_data)
fatrop_int	eval_L (const double *objective_scale, const double *inputs_k, const double *states_k, const double *stage_params_k, const double *global_params, double *res, const fatrop_int k, void *user_data)
fatrop_int	get_bounds (double *lower, double *upper, const fatrop_int k, void *user_data)
fatrop_int	get_initial_xk (double *xk, const fatrop_int k, void *user_data)
fatrop_int	get_initial_uk (double *uk, const fatrop_int k, void *user_data)
void	dummy_signal (void *user_data)
fatrop_int	full_eval_lag_hess (double objective_scale, const double *primal_data, const double *lam_data, const double *stageparams_p, const double *globalparams_p, MAT *RSQrqt_p, const FatropOcpCDims *s, void *user_data)
fatrop_int	full_eval_constr_jac (const double *primal_data, const double *stageparams_p, const double *globalparams_p, MAT *BAbt_p, MAT *Ggt_p, MAT *Ggt_ineq_p, const FatropOcpCDims *s, void *user_data)
fatrop_int	full_eval_contr_viol (const double *primal_data, const double *stageparams_p, const double *globalparams_p, double *cv_p, const FatropOcpCDims *s, void *user_data)
fatrop_int	full_eval_obj_grad (double objective_scale, const double *primal_data, const double *stageparams_p, const double *globalparams_p, double *grad_p, const FatropOcpCDims *s, void *user_data)
fatrop_int	full_eval_obj (double objective_scale, const double *primal_data, const double *stageparams_p, const double *globalparams_p, double *res, const FatropOcpCDims *s, void *user_data)
int CASADI_NLPSOL_FATROP_EXPORT	casadi_register_nlpsol_fatrop (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_FATROP_EXPORT	casadi_load_nlpsol_fatrop ()
void	report_issue (casadi_int i, const std::string &msg)
void	codegen_unpack_block (CodeGenerator &g, const std::string &name, const std::vector< casadi_ocp_block > &blocks)
void	unpack_block (const std::vector< casadi_int > &p, std::vector< casadi_ocp_block > &blocks)
bool	is_directory (const std::string &path)
bool	create_directories (const std::string &path)
std::vector< std::string >	iterate_directory_names (const std::string &path)
bool	remove (const std::string &path)
casadi_int	remove_all (const std::string &path)
std::string	filename (const std::string &path)
std::string	absolute (const std::string &path)
std::string	parent_path (const std::string &path)
bool	has_parent_path (const std::string &path)
int CASADI_FILESYSTEM_GHC_EXPORT	casadi_register_filesystem_ghc (Filesystem::Plugin *plugin)
void CASADI_FILESYSTEM_GHC_EXPORT	casadi_load_filesystem_ghc ()
char	sense_to_gurobi (const std::string &sense)
static int	gurobi_callback_function (GRBmodel *model, void *cbdata, int where, void *usrdata)
int CASADI_CONIC_GUROBI_EXPORT	casadi_register_conic_gurobi (Conic::Plugin *plugin)
void CASADI_CONIC_GUROBI_EXPORT	casadi_load_conic_gurobi ()
const char *	return_status_string (casadi_int status)
int CASADI_CONIC_HIGHS_EXPORT	casadi_register_conic_highs (Conic::Plugin *plugin)
void CASADI_CONIC_HIGHS_EXPORT	casadi_load_conic_highs ()
int CASADI_CONIC_HPIPM_EXPORT	casadi_register_conic_hpipm (Conic::Plugin *plugin)
void CASADI_CONIC_HPIPM_EXPORT	casadi_load_conic_hpipm ()
std::vector< casadi_int >	hpipm_blocks_pack (const std::vector< casadi_hpipm_block > &blocks)
void	codegen_unpack_block (CodeGenerator &g, const std::string &name, const std::vector< casadi_hpipm_block > &blocks)
int CASADI_CONIC_HPMPC_EXPORT	casadi_register_conic_hpmpc (Conic::Plugin *plugin)
void CASADI_CONIC_HPMPC_EXPORT	casadi_load_conic_hpmpc ()
int CASADI_LINSOL_MA27_EXPORT	casadi_register_linsol_ma27 (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_MA27_EXPORT	casadi_load_linsol_ma27 ()
int CASADI_NLPSOL_IPOPT_EXPORT	casadi_register_nlpsol_ipopt (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_IPOPT_EXPORT	casadi_load_nlpsol_ipopt ()
const char *	return_status_string (Ipopt::ApplicationReturnStatus status)
int CASADI_NLPSOL_KNITRO_EXPORT	casadi_register_nlpsol_knitro (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_KNITRO_EXPORT	casadi_load_nlpsol_knitro ()
int	casadi_KN_puts (const char *const str, void *const userParams)
int CASADI_MODELICAPARSER_LACEMODELICA_EXPORT	casadi_register_modelicaparser_lacemodelica (ModelicaParserInternal::Plugin *plugin)
void CASADI_MODELICAPARSER_LACEMODELICA_EXPORT	casadi_load_modelicaparser_lacemodelica ()
int CASADI_LINSOL_LAPACKLU_EXPORT	casadi_register_linsol_lapacklu (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_LAPACKLU_EXPORT	casadi_load_linsol_lapacklu ()
int CASADI_LINSOL_LAPACKQR_EXPORT	casadi_register_linsol_lapackqr (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_LAPACKQR_EXPORT	casadi_load_linsol_lapackqr ()
bool	extract_zip_internal (zip_t *za, const std::string &output_dir)
bool	extract_zip_from_stringstream (std::stringstream &src, const std::string &output_dir)
bool	extract_zip_from_path (const std::string &zip_path, const std::string &output_dir)
bool	add_file_to_zip (zip_t *archive, const std::string &file_path, const std::string &archive_name)
void	add_directory_recursive (zip_t *archive, const std::string &base_dir, const std::string &current_dir, const std::string &rel_prefix)
bool	zip_to_stream (const std::string &dir, std::ostream &output)
bool	zip_to_path (const std::string &dir_path, const std::string &zip_path)
bool	zip_to_path2 (const std::string &dir_path, const std::string &zip_path)
bool	zip_entries_to_path (const std::vector< std::pair< std::string, std::string > > &entries, const std::string &zip_path)
int CASADI_ARCHIVER_LIBZIP_EXPORT	casadi_register_archiver_libzip (Archiver::Plugin *plugin)
void CASADI_ARCHIVER_LIBZIP_EXPORT	casadi_load_archiver_libzip ()
int CASADI_NLPSOL_MADNLP_EXPORT	casadi_register_nlpsol_madnlp (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_MADNLP_EXPORT	casadi_load_nlpsol_madnlp ()
int CASADI_CONIC_MOSEK_EXPORT	casadi_register_conic_mosek (Conic::Plugin *plugin)
void CASADI_CONIC_MOSEK_EXPORT	casadi_load_conic_mosek ()
static void	codegen_int_field (CodeGenerator &g, const std::string &prob_field, const std::string &local_name, const std::vector< int > &v)
static void	mosek_stream_cb (void *, const char *s)
int CASADI_LINSOL_MUMPS_EXPORT	casadi_register_linsol_mumps (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_MUMPS_EXPORT	casadi_load_linsol_mumps ()
std::string	onnx_input_name (const Function &f, casadi_int i)
	Function input/output name, or a generated fallback when unnamed. More...
std::string	onnx_output_name (const Function &f, casadi_int i)
static void	prefix_graph_names (onnx::GraphProto *g, const std::string &prefix)
static std::vector< casadi_int >	constant_ints (const MX &m)
int CASADI_GRAPHMODEL_ONNX_EXPORT	casadi_register_graphmodel_onnx (GraphModelInternal::Plugin *plugin)
void CASADI_GRAPHMODEL_ONNX_EXPORT	casadi_load_graphmodel_onnx ()
static Node	io_node (const onnx::ValueInfoProto &vi, const std::string &io)
const OpMapping *	get_op_mapping (casadi_int op)
	Lookup operation mapping by CasADi opcode (for export) More...
const OpMapping *	get_op_mapping_by_name (const std::string &onnx_name)
	Lookup operation mapping by ONNX name (for import) More...
casadi_int	get_int_attribute (const onnx::NodeProto &node, const std::string &name, casadi_int default_value)
	Read an integer node attribute by name, or default_value if absent. More...
double	get_float_attribute (const onnx::NodeProto &node, const std::string &name, double default_value)
	Read a float node attribute by name, or default_value if absent. More...
std::string	get_string_attribute (const onnx::NodeProto &node, const std::string &name)
	Read a string node attribute by name, or "" if absent. More...
const onnx::GraphProto *	get_graph_attribute (const onnx::NodeProto &node, const std::string &name)
	Read a subgraph (GraphProto) node attribute by name, or nullptr if absent. More...
void	add_int_attribute (onnx::NodeProto *node, const std::string &name, casadi_int value)
	Add an integer attribute (e.g. axis) to a node. More...
void	add_ints_attribute (onnx::NodeProto *node, const std::string &name, const std::vector< casadi_int > &values)
	Add an integer-list attribute (e.g. scan_input_axes) to a node. More...
void	add_int_constant (onnx::GraphProto *graph, const std::string &name, const std::vector< casadi_int > &data, std::vector< casadi_int > dims={})
	Add a Constant node holding an INT64 tensor to a graph (default shape: 1-D) More...
onnx::NodeProto *	create_binary_node (AddNodeFn add_node, const std::string &op_type, const std::string &input1, const std::string &input2, const std::string &output)
	Create binary operation ONNX node (callback-based) More...
onnx::NodeProto *	create_unary_node (AddNodeFn add_node, const std::string &op_type, const std::string &input, const std::string &output)
	Create unary operation ONNX node (callback-based) More...
onnx::NodeProto *	create_binary_node (onnx::GraphProto *graph, const std::string &op_type, const std::string &input1, const std::string &input2, const std::string &output)
	Create binary operation ONNX node (GraphProto convenience wrapper) More...
onnx::NodeProto *	create_unary_node (onnx::GraphProto *graph, const std::string &op_type, const std::string &input, const std::string &output)
	Create unary operation ONNX node (GraphProto convenience wrapper) More...
onnx::TensorProto *	create_constant_tensor (AddNodeFn add_node, const std::string &output_name, onnx::TensorProto::DataType data_type)
void	add_int_constant (AddNodeFn add_node, const std::string &name, const std::vector< casadi_int > &data, std::vector< casadi_int > dims={})
onnx::NodeProto *	create_gather_node (AddNodeFn add_node, const std::string &data, const std::string &indices, const std::string &output, casadi_int axis=0)
onnx::NodeProto *	create_slice_node (AddNodeFn add_node, const std::string &uniq, const std::string &data, const std::vector< casadi_int > &starts, const std::vector< casadi_int > &ends, const std::vector< casadi_int > &axes, const std::vector< casadi_int > &steps, const std::string &output)
void	emit_colmajor_reshape (AddNodeFn add_node, const std::string &data, const std::vector< casadi_int > &dims, const std::string &output, const std::string &uniq)
onnx::NodeProto *	create_cast_node (AddNodeFn add_node, const std::string &input, const std::string &output, onnx::TensorProto::DataType to_type)
onnx::NodeProto *	create_gemm_node (AddNodeFn add_node, const std::string &A, const std::string &B, const std::string &C, const std::string &output, bool transA=false, bool transB=false)
onnx::NodeProto *	create_where_node (AddNodeFn add_node, const std::string &cond, const std::string &if_true, const std::string &if_false, const std::string &output)
template<typename T >
static bool	load_raw (DM &dm, casadi_int n, const onnx::TensorProto &tensor, const char *type_name)
int CASADI_CONIC_OOQP_EXPORT	casadi_register_conic_ooqp (Conic::Plugin *plugin)
void CASADI_CONIC_OOQP_EXPORT	casadi_load_conic_ooqp ()
int CASADI_ONNX_ORT_EXPORT	casadi_register_onnx_ort (OnnxFunction::Plugin *plugin)
void CASADI_ONNX_ORT_EXPORT	casadi_load_onnx_ort ()
int CASADI_CONIC_OSQP_EXPORT	casadi_register_conic_osqp (Conic::Plugin *plugin)
void CASADI_CONIC_OSQP_EXPORT	casadi_load_conic_osqp ()
int CASADI_CONIC_PIQP_EXPORT	casadi_register_conic_piqp (Conic::Plugin *plugin)
void CASADI_CONIC_PIQP_EXPORT	casadi_load_conic_piqp ()
piqp::KKTSolver	kkt_solver_from_string (const std::string &s)
int CASADI_CONIC_PROXQP_EXPORT	casadi_register_conic_proxqp (Conic::Plugin *plugin)
void CASADI_CONIC_PROXQP_EXPORT	casadi_load_conic_proxqp ()
int CASADI_CONIC_QPOASES_EXPORT	casadi_register_conic_qpoases (Conic::Plugin *plugin)
void CASADI_CONIC_QPOASES_EXPORT	casadi_load_conic_qpoases ()
static SLEQP_RETCODE	casadi_func_set (SleqpFunc *func, SleqpVec *value, SLEQP_VALUE_REASON reason, bool *reject, void *func_data)
static SLEQP_RETCODE	casadi_func_nonzeros (SleqpFunc *func, int *obj_grad_nnz, int *cons_val_nnz, int *cons_jac_nnz, int *hess_prod_nnz, void *func_data)
static SLEQP_RETCODE	casadi_func_obj_val (SleqpFunc *func, double *obj_val, void *func_data)
static SLEQP_RETCODE	casadi_func_obj_grad (SleqpFunc *func, SleqpVec *obj_grad, void *func_data)
static SLEQP_RETCODE	casadi_func_cons_val (SleqpFunc *func, SleqpVec *cons_val, void *func_data)
static SLEQP_RETCODE	casadi_func_cons_jac (SleqpFunc *func, SleqpMat *cons_jac, void *func_data)
static SLEQP_RETCODE	casadi_func_hess_prod (SleqpFunc *func, const SleqpVec *direction, const SleqpVec *cons_duals, SleqpVec *product, void *func_data)
static SLEQP_RETCODE	casadi_func_free (void *func_data)
void	casadi_sleqp_func_create (SleqpFunc **star, int num_vars, int num_cons, SLEQPMemory *m)
std::string	log_level_name (SLEQP_LOG_LEVEL level)
static void	casadi_log_output (SLEQP_LOG_LEVEL level, time_t time, const char *message)
int CASADI_NLPSOL_SLEQP_EXPORT	casadi_register_nlpsol_sleqp (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_SLEQP_EXPORT	casadi_load_nlpsol_sleqp ()
static std::string	status_string (SLEQP_STATUS status)
UnifiedReturnStatus	map_status (SLEQP_STATUS status)
static SLEQP_RETCODE	accepted_iterate (SleqpSolver *solver, SleqpIterate *iterate, void *data)
int CASADI_DPLE_SLICOT_EXPORT	casadi_register_dple_slicot (Dple::Plugin *plugin)
void CASADI_DPLE_SLICOT_EXPORT	casadi_load_dple_slicot ()
void	slicot_periodic_schur (casadi_int n, casadi_int K, const double *a, double *t, double *z, double *dwork, double *eig_real, double *eig_imag, double num_zero)
int CASADI_EXPM_SLICOT_EXPORT	casadi_register_expm_slicot (Expm::Plugin *plugin)
void CASADI_EXPM_SLICOT_EXPORT	casadi_load_expm_slicot ()
void	dense_kron_stride (casadi_int n, casadi_int m, const double *A, const double *B, double *C, casadi_int strideA, casadi_int strideB, casadi_int strideC)
void	dense_mul_nt_stride (casadi_int n, casadi_int m, casadi_int l, const double *A, const double *B, double *C, casadi_int strideA, casadi_int strideB, casadi_int strideC)
void	dense_mul_nt (casadi_int n, casadi_int m, casadi_int l, const double *A, const double *B, double *C)
void	dense_mul_nn_stride (casadi_int n, casadi_int m, casadi_int l, const double *A, const double *B, double *C, casadi_int strideA, casadi_int strideB, casadi_int strideC)
void	dense_copy_stride (casadi_int n, casadi_int m, const double *A, double *B, casadi_int strideA, casadi_int strideB)
void	dense_copy_t_stride (casadi_int n, casadi_int m, const double *A, double *B, casadi_int strideA, casadi_int strideB)
void	dense_mul_nn (casadi_int n, casadi_int m, casadi_int l, const double *A, const double *B, double *C)
void	dense_mul_nn2 (casadi_int n, casadi_int m, casadi_int l, const double *A, const double *B, double *C)
void	dense_mul_tn (casadi_int n, casadi_int m, casadi_int l, const double *A, const double *B, double *C)
int	slicot_mb03vd (int n, int p, int ilo, int ihi, double *a, int lda1, int lda2, double *tau, int ldtau, double *dwork)
int	slicot_mb03vy (int n, int p, int ilo, int ihi, double *a, int lda1, int lda2, const double *tau, int ldtau, double *dwork, int ldwork)
int	slicot_mb03wd (char job, char compz, int n, int p, int ilo, int ihi, int iloz, int ihiz, double *h, int ldh1, int ldh2, double *z, int ldz1, int ldz2, double *wr, double *wi, double *dwork, int ldwork)
int	slicot_mb05nd (int n, double delta, const double *a, int lda, double *ex, int ldex, double *exint, int ldexin, double tol, int *iwork, double *dwork, int ldwork)
int CASADI_NLPSOL_SNOPT_EXPORT	casadi_register_nlpsol_snopt (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_SNOPT_EXPORT	casadi_load_nlpsol_snopt ()
int CASADI_CONIC_SQIC_EXPORT	casadi_register_conic_sqic (Conic::Plugin *plugin)
void CASADI_CONIC_SQIC_EXPORT	casadi_load_conic_sqic ()
int CASADI_INTEGRATOR_CVODES_EXPORT	casadi_register_integrator_cvodes (Integrator::Plugin *plugin)
void CASADI_INTEGRATOR_CVODES_EXPORT	casadi_load_integrator_cvodes ()
int CASADI_INTEGRATOR_IDAS_EXPORT	casadi_register_integrator_idas (Integrator::Plugin *plugin)
void CASADI_INTEGRATOR_IDAS_EXPORT	casadi_load_integrator_idas ()
template<typename T1 >
void	casadi_copy_block (const T1 *x, const casadi_int *sp_x, T1 *y, const casadi_int *sp_y, casadi_int r_begin, casadi_int c_begin, T1 *w)
int CASADI_ROOTFINDER_KINSOL_EXPORT	casadi_register_rootfinder_kinsol (Rootfinder::Plugin *plugin)
void CASADI_ROOTFINDER_KINSOL_EXPORT	casadi_load_rootfinder_kinsol ()
bool	is_regular (N_Vector v)
int CASADI_CONIC_SUPERSCS_EXPORT	casadi_register_conic_superscs (Conic::Plugin *plugin)
void CASADI_CONIC_SUPERSCS_EXPORT	casadi_load_conic_superscs ()
int CASADI_XMLFILE_TINYXML_EXPORT	casadi_register_xmlfile_tinyxml (XmlFileInternal::Plugin *plugin)
void CASADI_XMLFILE_TINYXML_EXPORT	casadi_load_xmlfile_tinyxml ()
int CASADI_NLPSOL_UNO_EXPORT	casadi_register_nlpsol_uno (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_UNO_EXPORT	casadi_load_nlpsol_uno ()
static void	set_uno_option (void *solver, const std::string &name, const GenericType &value)
static void	insert_casadi_options (void *solver, Dict opts)
static uno_int	casadi_uno_term_cb_cpp (uno_int, uno_int, const double *primals, const double *lower_mult, const double *upper_mult, const double *constraint_mult, double, double, double, double, void *user_data)
static void	codegen_int_array (CodeGenerator &g, const std::string &name, const std::vector< uno_int > &v)
int CASADI_NLPSOL_WORHP_EXPORT	casadi_register_nlpsol_worhp (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_WORHP_EXPORT	casadi_load_nlpsol_worhp ()
void	worhp_disp (int mode, const char message[])
static void	xpress_global_init ()
int CASADI_CONIC_XPRESS_EXPORT	casadi_register_conic_xpress (Conic::Plugin *plugin)
void CASADI_CONIC_XPRESS_EXPORT	casadi_load_conic_xpress ()
static void	codegen_int_field (CodeGenerator &g, const std::string &prob_field, const std::string &local_name, const std::vector< int > &v)
int CASADI_INTERPOLANT_BSPLINE_EXPORT	casadi_register_interpolant_bspline (Interpolant::Plugin *plugin)
void CASADI_INTERPOLANT_BSPLINE_EXPORT	casadi_load_interpolant_bspline ()
int CASADI_INTEGRATOR_COLLOCATION_EXPORT	casadi_register_integrator_collocation (Integrator::Plugin *plugin)
void CASADI_INTEGRATOR_COLLOCATION_EXPORT	casadi_load_integrator_collocation ()
int CASADI_ROOTFINDER_FAST_NEWTON_EXPORT	casadi_register_rootfinder_fast_newton (Rootfinder::Plugin *plugin)
void CASADI_ROOTFINDER_FAST_NEWTON_EXPORT	casadi_load_rootfinder_fast_newton ()
std::string	return_code (casadi_int status)
int CASADI_NLPSOL_FEASIBLESQPMETHOD_EXPORT	casadi_register_nlpsol_feasiblesqpmethod (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_FEASIBLESQPMETHOD_EXPORT	casadi_load_nlpsol_feasiblesqpmethod ()
int CASADI_ROOTFINDER_NLPSOL_EXPORT	casadi_register_rootfinder_nlpsol (Rootfinder::Plugin *plugin)
void CASADI_ROOTFINDER_NLPSOL_EXPORT	casadi_load_rootfinder_nlpsol ()
int CASADI_CONIC_IPQP_EXPORT	casadi_register_conic_ipqp (Conic::Plugin *plugin)
void CASADI_CONIC_IPQP_EXPORT	casadi_load_conic_ipqp ()
void	print_vec (const std::string &str, const double *v, casadi_int n)
int CASADI_INTERPOLANT_LINEAR_EXPORT	casadi_register_interpolant_linear (Interpolant::Plugin *plugin)
void CASADI_INTERPOLANT_LINEAR_EXPORT	casadi_load_interpolant_linear ()
int CASADI_LINSOL_LDL_EXPORT	casadi_register_linsol_ldl (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_LDL_EXPORT	casadi_load_linsol_ldl ()
int CASADI_LINSOL_QR_EXPORT	casadi_register_linsol_qr (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_QR_EXPORT	casadi_load_linsol_qr ()
static double	permutation_sign (const std::vector< casadi_int > &p)
int CASADI_LINSOL_TRIDIAG_EXPORT	casadi_register_linsol_tridiag (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_TRIDIAG_EXPORT	casadi_load_linsol_tridiag ()
int CASADI_LINSOL_LSQR_EXPORT	casadi_register_linsol_lsqr (LinsolInternal::Plugin *plugin)
void CASADI_LINSOL_LSQR_EXPORT	casadi_load_linsol_lsqr ()
int CASADI_ROOTFINDER_NEWTON_EXPORT	casadi_register_rootfinder_newton (Rootfinder::Plugin *plugin)
void CASADI_ROOTFINDER_NEWTON_EXPORT	casadi_load_rootfinder_newton ()
int CASADI_CONIC_NLPSOL_EXPORT	casadi_register_conic_nlpsol (Conic::Plugin *plugin)
void CASADI_CONIC_NLPSOL_EXPORT	casadi_load_conic_nlpsol ()
int CASADI_CONIC_QRQP_EXPORT	casadi_register_conic_qrqp (Conic::Plugin *plugin)
void CASADI_CONIC_QRQP_EXPORT	casadi_load_conic_qrqp ()
int CASADI_NLPSOL_QRSQP_EXPORT	casadi_register_nlpsol_qrsqp (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_QRSQP_EXPORT	casadi_load_nlpsol_qrsqp ()
int CASADI_INTEGRATOR_RK_EXPORT	casadi_register_integrator_rk (Integrator::Plugin *plugin)
void CASADI_INTEGRATOR_RK_EXPORT	casadi_load_integrator_rk ()
int CASADI_NLPSOL_SCPGEN_EXPORT	casadi_register_nlpsol_scpgen (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_SCPGEN_EXPORT	casadi_load_nlpsol_scpgen ()
int CASADI_IMPORTER_SHELL_EXPORT	casadi_register_importer_shell (ImporterInternal::Plugin *plugin)
void CASADI_IMPORTER_SHELL_EXPORT	casadi_load_importer_shell ()
int CASADI_NLPSOL_SQPMETHOD_EXPORT	casadi_register_nlpsol_sqpmethod (Nlpsol::Plugin *plugin)
void CASADI_NLPSOL_SQPMETHOD_EXPORT	casadi_load_nlpsol_sqpmethod ()
int CASADI_LINSOL_SYMBOLICQR_EXPORT	casadi_register_linsol_symbolicqr (LinsolInternal::Plugin *plugin)
static double	permutation_sign (const std::vector< casadi_int > &p)
static SX	qr_block_det (const SX &B, bool amd)
void CASADI_LINSOL_SYMBOLICQR_EXPORT	casadi_load_linsol_symbolicqr ()
double	sign (double x)
	Sign function, note that sign(nan) == nan. More...
double	simplify (double x)
double	constpow (double x, double y)
double	printme (double x, double y)
bool	is_equal (double x, double y, casadi_int depth=0)
casadi_int	casadi_max (casadi_int x, casadi_int y)
casadi_int	casadi_min (casadi_int x, casadi_int y)
double	if_else_zero (double x, double y)
	Conditional assignment. More...
double	if_else (double x, double y, double z)
double	erfinv (double x) throw ()
Type	from_fmi2 (TypeFmi2 v)
TypeFmi2	to_fmi2 (Type v)
std::string	to_string (TypeFmi2 v)
std::string	to_string (Type v)
std::string	to_string (Causality v)
std::string	to_string (Variability v)
std::string	to_string (Initial v)
CASADI_EXPORT std::string	to_string (Attribute v)
CASADI_EXPORT std::string	to_string (DependenciesKind v)
std::string	to_string (Category v)
std::string	description (Category v)
std::vector< double >	collocation_points (casadi_int order, const std::string &scheme="radau")
	Obtain collocation points of specific order and scheme. More...
std::vector< long double >	collocation_pointsL (casadi_int order, const std::string &scheme)
	Obtain collocation points of specific order and scheme. More...
MXDict	dae_reduce_index (const MXDict &dae, Dict &stats, const Dict &opts={})
	Reduce index. More...
SXDict	dae_reduce_index (const SXDict &dae, Dict &stats, const Dict &opts)
	Reduce index. More...
MXDict	dae_map_semi_expl (const MXDict &dae, const MXDict &dae_red, Function &state_to_orig, Function &phi)
	Turn a reduced DAE into a semi explicit form suitable for CasADi integrator. More...
SXDict	dae_map_semi_expl (const SXDict &dae, const SXDict &dae_red, Function &state_to_orig, Function &phi)
	Turn a reduced DAE into a semi explicit form suitable for CasADi integrator. More...
Function	dae_init_gen (const MXDict &dae, const MXDict &dae_red, const std::string &init_solver, const DMDict &init_strength=DMDict(), const Dict &init_solver_options=Dict())
	Obtain a generator Function for producing consistent initial guesses of a reduced DAE. More...
Function	dae_init_gen (const SXDict &dae, const SXDict &dae_red, const std::string &init_solver, const DMDict &init_strength, const Dict &init_solver_options)
	Obtain a generator Function for producing consistent initial guesses of a reduced DAE. More...
std::string	to_string (DynIn v)
std::string	to_string (DynOut v)
std::string	to_string (EventIn v)
std::string	to_string (EventOut v)
template<typename Scalar >
std::string	matrixName ()
	Get typename. More...
template<>
std::string	matrixName< double > ()
	Get typename. More...
template<>
std::string	matrixName< casadi_int > ()
	Get typename. More...
double	nlpsol_default_in (casadi_int ind)
	Default input for an NLP solver. More...
std::vector< double >	nlpsol_default_in ()
	Default input for an NLP solver. More...

Variables
static const char *	REFERENCE_DOC
const double	pi = 3.14159265358979323846
	Define pi. More...
const double	inf = std::numeric_limits<double>::infinity()
	infinity More...
const double	nan = std::numeric_limits<double>::quiet_NaN()
	Not a number. More...
const double	eps = std::numeric_limits<double>::epsilon()
	Machine epsilon. More...
const int	bvec_size = CHAR_BIT*sizeof(bvec_t)
constexpr casadi_int	LOOKUP_LINEAR = 0
constexpr casadi_int	LOOKUP_EXACT = 1
constexpr casadi_int	LOOKUP_BINARY = 2
static const std::set< std::string >	empty_mutex_set_
template class CASADI_EXPORT	casadi_limits< double >
template class CASADI_EXPORT	Matrix< double >
template class CASADI_EXPORT	Matrix< casadi_int >
const long double	legendre_points1 [] = { 0.50000000000000000000 }
const long double	legendre_points2 []
const long double	legendre_points3 []
const long double	legendre_points4 []
const long double	legendre_points5 []
const long double	legendre_points6 []
const long double	legendre_points7 []
const long double	legendre_points8 []
const long double	legendre_points9 []
const long double *	legendre_points []
const long double	radau_points1 []
const long double	radau_points2 []
const long double	radau_points3 []
const long double	radau_points4 []
const long double	radau_points5 []
const long double	radau_points6 []
const long double	radau_points7 []
const long double	radau_points8 []
const long double	radau_points9 []
const long double *	radau_points []
const std::vector< std::string >	NL_INPUTS = {"x", "p"}
	Shortname for onput arguments of an NLP function. More...
const std::vector< std::string >	NL_OUTPUTS = {"f", "g"}
	Shortname for output arguments of an NLP function. More...
template class CASADI_EXPORT	GenericShared< SharedSXElem, OutputSX >
template class CASADI_EXPORT	GenericWeakRef< SharedSXElem, OutputSX >
const std::vector< std::string >	RFP_INPUTS = {"x", "p"}
	Shortnames for DAE symbolic representation inputs. More...
const std::vector< std::string >	RFP_OUTPUTS = {"g"}
	Shortnames for DAE symbolic representation outputs. More...
static casadi_int	serialization_protocol_version = 3
static casadi_int	serialization_check = 123456789012345
template class CASADI_EXPORT	GenericShared< SharedObject, SharedObjectInternal >
template class CASADI_EXPORT	GenericWeakRef< SharedObject, SharedObjectInternal >
template class CASADI_EXPORT	Matrix< SXElem >
static const char *	CLASSIC_DECL
static const char *	CLASSIC_DAXPY_DECL
static const char *	CLASSIC_DDOT_DECL
static const char *	CLASSIC_DSCAL_DECL
static const char *	CLASSIC_DNRM2_DECL
static const char *	CLASSIC_DASUM_DECL
static const char *	BLASFEO_DECL
static const char *	BLASFEO_DAXPY_DECL
static const char *	BLASFEO_DDOT_DECL
static const OpMapping	op_map []
static std::once_flag	s_xpress_init_flag
static int	s_xpress_init_rc = 0

Detailed Description

Scalar expression (which also works as a smart pointer class to this class)

C/C++.

Convenience tools for C++ Standard Library vectors.

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

Author

Joel Andersson

Date

2010-2011

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

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

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

@requires_conic("hpipm") @requires_conic("qpoases") def test_hpipm_timevarying(self): def mat(a): def fl(a): return float(a) if len(a)>0 else 0 return sparsify(DM([list(map(fl,i.split("\t"))) for i in a.split("\n") if len(i)>0])) def vec(a): return DM(list(map(float,a.split("\n")))) N = 2 A = """ 1 0.2 1 -1 0 0 0 0 0 0 0 0 -0.1 0.4 0 0 -1 0 0 0 0 0 0 0 0.3 0.2 0 0 0 -1 0 0 0 0 0 0 2 0 0.3 0 0 0 0 0 0 0 0 0 1 1 0.4 0 0 0 0 0 0 0 0 0 0 0 1 4 2 1 0.3 -1 0 0 0 0 0 3 1 0 1 0.2 0 -1 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 2 4 0 -1 0 0 0 0 0 0 0 2 3 1 0 0 0 0 0 0 0 0 0 0 0 3""" A = mat(A) nx = [2,3,2,1] nu = [1, 2,1] ng = [2, 1, 1, 1] N = 3 H = """7 0 0.2 0 0 0 0 0 0 0 0 0 7 0.3 0 0 0 0 0 0 0 0 0 0.2 0.3 1 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 1 0 0 0 0 0 0 0 2 0.1 0 0.7 0 0 0 0 0 0 0 0.1 1 0 1 0 0 0 0 0 0 0 0 0 1 0.1 0 0 0 0 0 0 1 0.7 1 0.1 2 0 0 0 0 0 0 0 0 0 0 0 6 0 1 0 0 0 0 0 0 0 0 0 6 0 0 0 0 0 0 0 0 0 1 0 4 0 0 0 0 0 0 0 0 0 0 0 9 """ H = mat(H) options = {"hpipm":{"iter_max":100,"res_g_max":1e-10,"res_b_max":1e-10,"res_d_max":1e-10,"res_m_max":1e-10}} #solver = conic('solver', 'hpipm', {"a": A.sparsity(), "h": H.sparsity()},{"N":N,"nx":nx,"nu":nu,"ng":ng,"tol":1e-12,"mu0":2,"max_iter":20}) solver = conic('solver', 'hpipm', {"a": A.sparsity(), "h": H.sparsity()},options) solver_ref = conic('solver', 'qpoases', {"a": A.sparsity(), "h": H.sparsity()})

g = vec("""1 1 0.2 0.4 1 0.5 0.3 1 0.6 1 1 0.7""") lbg = vec("""0 0 0 -2 -2 0 0 -2 0 -2 -2""")

ubg = vec("""0 0 0 2 2 0 0 2 0 2 2""")

lbx = vec("""0.5 0.2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1""") ubx = vec("""0.5 0.2 1 1 1 1 1 1 1 1 1 1""")

Typedef Documentation

AddNodeFn

using casadi::AddNodeFn = typedef std::function<onnx::NodeProto*()>

Definition at line 48 of file onnx_model.hpp.

BoolType

typedef GenericTypeInternal< OT_BOOL, bool > casadi::BoolType

Definition at line 40 of file generic_type.cpp.

BoolVectorType

typedef GenericTypeInternal<OT_BOOLVECTOR, std::vector<bool> > casadi::BoolVectorType

Definition at line 45 of file generic_type.cpp.

bvec_t

typedef unsigned long long casadi::bvec_t

Definition at line 126 of file casadi_common.hpp.

casadi_checkout_t

typedef int(* casadi::casadi_checkout_t) (void)

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

Definition at line 146 of file casadi_common.hpp.

casadi_release_t

typedef void(* casadi::casadi_release_t) (int)

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

Definition at line 147 of file casadi_common.hpp.

config_t

typedef int(* casadi::config_t) (int, const char **)

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

Definition at line 139 of file casadi_common.hpp.

default_t

typedef double(* casadi::default_t) (casadi_int i)

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

Definition at line 142 of file casadi_common.hpp.

Deserialize

typedef ProtoFunction*(* casadi::Deserialize) (DeserializingStream &)

Definition at line 45 of file plugin_interface.hpp.

Dict

typedef std::map< std::string, GenericType > casadi::Dict

Examples

Function/callback_c.cc.

Definition at line 258 of file generic_type.hpp.

DictType

typedef GenericTypeInternal< OT_DICT, Dict > casadi::DictType

Definition at line 53 of file generic_type.cpp.

DictVectorType

typedef GenericTypeInternal< OT_DICTVECTOR, std::vector< Dict > > casadi::DictVectorType

Definition at line 54 of file generic_type.cpp.

diff_t

typedef int(* casadi::diff_t) (casadi_int i)

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

Definition at line 145 of file casadi_common.hpp.

DM

typedef Matrix<double> casadi::DM

Examples

Function/callback_c.cc, and misc/all.cc.

Definition at line 33 of file dm_fwd.hpp.

DMDict

typedef std::map<std::string, DM> casadi::DMDict

Definition at line 36 of file dm_fwd.hpp.

DMVector

typedef std::vector<DM> casadi::DMVector

Definition at line 34 of file dm_fwd.hpp.

DMVectorVector

typedef std::vector<DMVector> casadi::DMVectorVector

Definition at line 35 of file dm_fwd.hpp.

DoubleType

typedef GenericTypeInternal< OT_DOUBLE, double > casadi::DoubleType

Definition at line 38 of file generic_type.cpp.

DoubleVectorType

typedef GenericTypeInternal< OT_DOUBLEVECTOR, std::vector< double > > casadi::DoubleVectorType

Definition at line 41 of file generic_type.cpp.

DoubleVectorVectorType

typedef GenericTypeInternal< OT_DOUBLEVECTORVECTOR, std::vector< std::vector< double > > > casadi::DoubleVectorVectorType

Definition at line 43 of file generic_type.cpp.

eval_t

typedef int(* casadi::eval_t) (const double **arg, double **res, casadi_int *iw, double *w, int)

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

Definition at line 150 of file casadi_common.hpp.

external_print_callback_t

typedef void(* casadi::external_print_callback_t) (const char *s)

Definition at line 47 of file tools.hpp.

external_transform_t

typedef const char*(* casadi::external_transform_t) (char api_version, const char *casadi_version, const char *in, external_print_callback_t cb_stdout, external_print_callback_t cb_stderr)

Definition at line 48 of file tools.hpp.

FunctionType

typedef GenericTypeInternal< OT_FUNCTION, Function > casadi::FunctionType

Definition at line 51 of file generic_type.cpp.

FunctionVectorType

typedef GenericTypeInternal< OT_FUNCTIONVECTOR, std::vector< Function > > casadi::FunctionVectorType

Definition at line 52 of file generic_type.cpp.

getint_t

typedef casadi_int(* casadi::getint_t) (void)

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

Definition at line 141 of file casadi_common.hpp.

handle_t

typedef void* casadi::handle_t

Definition at line 109 of file casadi_os.hpp.

IM

typedef Matrix<casadi_int> casadi::IM

Definition at line 31 of file im_fwd.hpp.

IntType

typedef GenericTypeInternal< OT_INT, casadi_int > casadi::IntType

Definition at line 39 of file generic_type.cpp.

IntVectorType

typedef GenericTypeInternal< OT_INTVECTOR, std::vector< casadi_int > > casadi::IntVectorType

Definition at line 44 of file generic_type.cpp.

IntVectorVectorType

typedef GenericTypeInternal< OT_INTVECTORVECTOR, std::vector< std::vector< casadi_int > > > casadi::IntVectorVectorType

Definition at line 47 of file generic_type.cpp.

MXDict

typedef std::map<std::string, MX> casadi::MXDict

Readability typedefs

Definition at line 1110 of file mx.hpp.

MXIList

typedef std::initializer_list<MX> casadi::MXIList

Readability typedefs

Definition at line 1108 of file mx.hpp.

MXVector

typedef std::vector<MX> casadi::MXVector

Readability typedefs

Definition at line 1107 of file mx.hpp.

MXVectorVector

typedef std::vector<MXVector> casadi::MXVectorVector

Readability typedefs

Definition at line 1109 of file mx.hpp.

name_t

typedef const char*(* casadi::name_t) (casadi_int i)

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

Definition at line 143 of file casadi_common.hpp.

native_DM

typedef DM casadi::native_DM

Definition at line 33 of file optistack.hpp.

signal_t

typedef void(* casadi::signal_t) (void)

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

Definition at line 140 of file casadi_common.hpp.

sparsity_t

typedef const casadi_int*(* casadi::sparsity_t) (casadi_int i)

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

Definition at line 144 of file casadi_common.hpp.

SpDict

typedef std::map<std::string, Sparsity> casadi::SpDict

Readability typedefs

Definition at line 1524 of file sparsity.hpp.

StringType

typedef GenericTypeInternal< OT_STRING, std::string > casadi::StringType

Definition at line 37 of file generic_type.cpp.

StringVector

typedef std::vector<std::string> casadi::StringVector

Readability typedefs

Definition at line 1027 of file casadi_misc.hpp.

StringVectorType

typedef GenericTypeInternal< OT_STRINGVECTOR, std::vector< std::string > > casadi::StringVectorType

Definition at line 48 of file generic_type.cpp.

StringVectorVectorType

typedef GenericTypeInternal<OT_STRINGVECTORVECTOR, std::vector<std::vector<std::string> > > casadi::StringVectorVectorType

Definition at line 50 of file generic_type.cpp.

SX

typedef Matrix<SXElem> casadi::SX

Readability typedefs

Examples

SX/SXaddition.cc.

Definition at line 36 of file sx_fwd.hpp.

SXDict

typedef std::map<std::string, SX> casadi::SXDict

Readability typedefs

Definition at line 40 of file sx_fwd.hpp.

SXIList

typedef std::initializer_list<SX> casadi::SXIList

Readability typedefs

Definition at line 38 of file sx_fwd.hpp.

SXPtr

typedef SX* casadi::SXPtr

Definition at line 45 of file symbolic_qr.hpp.

SXPtrV

typedef std::vector<SXPtr> casadi::SXPtrV

Definition at line 46 of file symbolic_qr.hpp.

SXVector

typedef std::vector<SX> casadi::SXVector

Readability typedefs

Definition at line 37 of file sx_fwd.hpp.

SXVectorVector

typedef std::vector<SXVector> casadi::SXVectorVector

Readability typedefs

Definition at line 39 of file sx_fwd.hpp.

VectorType

typedef GenericTypeInternal< OT_VECTOR, std::vector< GenericType > > casadi::VectorType

Definition at line 57 of file generic_type.cpp.

VectorVectorType

typedef GenericTypeInternal< OT_VECTORVECTOR, std::vector< std::vector< GenericType > > > casadi::VectorVectorType

Definition at line 56 of file generic_type.cpp.

VoidPointerType

typedef GenericTypeInternal< OT_VOIDPTR, void * > casadi::VoidPointerType

Definition at line 58 of file generic_type.cpp.

WeakRefInternalSXElem

typedef GenericWeakRefInternal<SharedSXElem, OutputSX> casadi::WeakRefInternalSXElem

Definition at line 60 of file output_sx.hpp.

work_t

typedef int(* casadi::work_t) (casadi_int *sz_arg, casadi_int *sz_res, casadi_int *sz_iw, casadi_int *sz_w)

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

Definition at line 148 of file casadi_common.hpp.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
CASADI_BLAS_NO_TRANS
CASADI_BLAS_TRANS

Definition at line 40 of file blas_impl.hpp.

       {
    CASADI_BLAS_NO_TRANS = 111,
    CASADI_BLAS_TRANS    = 112
  };

Attribute

enum casadi::Attribute

strong

Enumerator
MIN
MAX
NOMINAL
START
VALUE
STRINGVALUE
NUMEL

Definition at line 70 of file dae_builder_internal.hpp.

{MIN, MAX, NOMINAL, START, VALUE, STRINGVALUE, NUMEL};

BStepIn

enum casadi::BStepIn

Enumerator
BSTEP_T
BSTEP_H
BSTEP_X0
BSTEP_V0
BSTEP_P
BSTEP_U
BSTEP_OUT_XF
BSTEP_OUT_VF
BSTEP_OUT_QF
BSTEP_ADJ_XF
BSTEP_ADJ_VF
BSTEP_ADJ_QF
BSTEP_NUM_IN

Definition at line 528 of file integrator_impl.hpp.

             {
  BSTEP_T,
  BSTEP_H,
  BSTEP_X0,
  BSTEP_V0,
  BSTEP_P,
  BSTEP_U,
  BSTEP_OUT_XF,
  BSTEP_OUT_VF,
  BSTEP_OUT_QF,
  BSTEP_ADJ_XF,
  BSTEP_ADJ_VF,
  BSTEP_ADJ_QF,
  BSTEP_NUM_IN
};

BStepOut

enum casadi::BStepOut

Enumerator
BSTEP_ADJ_T
BSTEP_ADJ_H
BSTEP_ADJ_X0
BSTEP_ADJ_V0
BSTEP_ADJ_P
BSTEP_ADJ_U
BSTEP_NUM_OUT

Definition at line 545 of file integrator_impl.hpp.

              {
  BSTEP_ADJ_T,
  BSTEP_ADJ_H,
  BSTEP_ADJ_X0,
  BSTEP_ADJ_V0,
  BSTEP_ADJ_P,
  BSTEP_ADJ_U,
  BSTEP_NUM_OUT
};

Category

enum casadi::Category

strong

Enumerator
T
C
P
D
W
U
X
Z
Q
CALCULATED
ODE
ALG
QUAD
ZERO
DDEF
WDEF
Y
NUMEL

Definition at line 63 of file dae_builder_internal.hpp.

                    {T, C, P, D, W, U, X, Z, Q, CALCULATED,
  ODE, ALG, QUAD, ZERO, DDEF, WDEF, Y, NUMEL};

Causality

enum casadi::Causality

strong

Enumerator
PARAMETER
CALCULATED_PARAMETER
INPUT
OUTPUT
LOCAL
INDEPENDENT
NUMEL

Definition at line 49 of file dae_builder_internal.hpp.

{PARAMETER, CALCULATED_PARAMETER, INPUT, OUTPUT, LOCAL, INDEPENDENT, NUMEL};

CollocationPoints

enum casadi::CollocationPoints

Enumerator
LEGENDRE
RADAU

Definition at line 123 of file integration_tools.hpp.

{LEGENDRE, RADAU};

ConicInput

enum casadi::ConicInput

Enumerator
CONIC_H	The square matrix H: sparse, (n x n). Only the lower triangular part is actually used. The matrix is assumed to be symmetrical.
CONIC_G	The vector g: dense, (n x 1)
CONIC_A	The matrix A: sparse, (nc x n) - product with x must be dense.
CONIC_LBA	dense, (nc x 1)
CONIC_UBA	dense, (nc x 1)
CONIC_LBX	dense, (n x 1)
CONIC_UBX	dense, (n x 1)
CONIC_X0	dense, (n x 1)
CONIC_LAM_X0	dense
CONIC_LAM_A0	dense
CONIC_Q	The matrix Q: sparse symmetric, (np^2 x n)
CONIC_P	The matrix P: sparse symmetric, (np x np)
CONIC_NUM_IN

Definition at line 170 of file conic.hpp.

                {
  CONIC_H,
  CONIC_G,
  CONIC_A,
  CONIC_LBA,
  CONIC_UBA,
  CONIC_LBX,
  CONIC_UBX,
  CONIC_X0,
  CONIC_LAM_X0,
  CONIC_LAM_A0,
  CONIC_Q,
  CONIC_P,
  CONIC_NUM_IN};

ConicOutput

enum casadi::ConicOutput

Enumerator
CONIC_X	The primal solution.
CONIC_COST	The optimal cost.
CONIC_LAM_A	The dual solution corresponding to linear bounds.
CONIC_LAM_X	The dual solution corresponding to simple bounds.
CONIC_NUM_OUT

Definition at line 199 of file conic.hpp.

                 {
  CONIC_X,
  CONIC_COST,
  CONIC_LAM_A,
  CONIC_LAM_X,
  CONIC_NUM_OUT};

ConstraintType

enum casadi::ConstraintType

Enumerator
OPTI_GENERIC_EQUALITY
OPTI_GENERIC_INEQUALITY
OPTI_EQUALITY
OPTI_INEQUALITY
OPTI_DOUBLE_INEQUALITY
OPTI_PSD
OPTI_UNKNOWN

Definition at line 487 of file optistack.hpp.

                      {
    OPTI_GENERIC_EQUALITY,  // g1(x,p) == g2(x,p)
    OPTI_GENERIC_INEQUALITY,  // g1(x,p) <= g2(x,p)
    OPTI_EQUALITY, // g(x,p) == bound(p)
    OPTI_INEQUALITY,  // g(x,p) <= bound(p)
    OPTI_DOUBLE_INEQUALITY,  // lb(p) <= g(x,p) <= ub(p)
    OPTI_PSD, // A(x,p) >= b(p)
    OPTI_UNKNOWN};

DependenciesKind

enum casadi::DependenciesKind

strong

Enumerator
DEPENDENT
CONSTANT
FIXED
TUNABLE
DISCRETE
NUMEL

Definition at line 73 of file dae_builder_internal.hpp.

{DEPENDENT, CONSTANT, FIXED, TUNABLE, DISCRETE, NUMEL};

DomainType

enum casadi::DomainType

Enumerator
OPTI_DOMAIN_REAL
OPTI_DOMAIN_INTEGER

Definition at line 500 of file optistack.hpp.

                  {
    OPTI_DOMAIN_REAL,
    OPTI_DOMAIN_INTEGER
  };

DpleInput

enum casadi::DpleInput

Enumerator
DPLE_A	A matrices (horzcat when const_dim, diagcat otherwise) [a].
DPLE_V	V matrices (horzcat when const_dim, diagcat otherwise) [v].
DPLE_NUM_IN

Definition at line 119 of file dple.hpp.

               {
  DPLE_A,
  DPLE_V,
  DPLE_NUM_IN
};

DpleOutput

enum casadi::DpleOutput

Enumerator
DPLE_P	Lyapunov matrix (horzcat when const_dim, diagcat otherwise) (Cholesky of P if pos_def) [p].
DPLE_NUM_OUT	Number of arguments.

Definition at line 128 of file dple.hpp.

                {
  DPLE_P,
  DPLE_NUM_OUT
};

DynIn

enum casadi::DynIn

Enumerator
DYN_T
DYN_X
DYN_Z
DYN_P
DYN_U
DYN_NUM_IN

Definition at line 190 of file integrator.hpp.

           {
  DYN_T,
  DYN_X,
  DYN_Z,
  DYN_P,
  DYN_U,
  DYN_NUM_IN};

DynOut

enum casadi::DynOut

Enumerator
DYN_ODE
DYN_ALG
DYN_QUAD
DYN_ZERO
DYN_NUM_OUT

Definition at line 199 of file integrator.hpp.

            {
  DYN_ODE,
  DYN_ALG,
  DYN_QUAD,
  DYN_ZERO,
  DYN_NUM_OUT};

EventIn

enum casadi::EventIn

Enumerator
EVENT_INDEX
EVENT_T
EVENT_X
EVENT_Z
EVENT_P
EVENT_U
EVENT_NUM_IN

Definition at line 207 of file integrator.hpp.

             {
  EVENT_INDEX,
  EVENT_T,
  EVENT_X,
  EVENT_Z,
  EVENT_P,
  EVENT_U,
  EVENT_NUM_IN};

EventOut

enum casadi::EventOut

Enumerator
EVENT_POST_X
EVENT_POST_Z
EVENT_NUM_OUT

Definition at line 217 of file integrator.hpp.

              {
  EVENT_POST_X,
  EVENT_POST_Z,
  EVENT_NUM_OUT};

FdMode

enum casadi::FdMode

strong

Enumerator
FORWARD
BACKWARD
CENTRAL
SMOOTHING
NUMEL

Definition at line 36 of file finite_differences.hpp.

{FORWARD, BACKWARD, CENTRAL, SMOOTHING, NUMEL};

FmuApi

enum casadi::FmuApi

strong

Enumerator
FMI2
FMI3
NUMEL

Definition at line 47 of file fmu.hpp.

{FMI2, FMI3, NUMEL};

Initial

enum casadi::Initial

strong

Enumerator
EXACT
APPROX
CALCULATED
NA
NUMEL

Definition at line 67 of file dae_builder_internal.hpp.

{EXACT, APPROX, CALCULATED, NA, NUMEL};

InputType

enum casadi::InputType

strong

Enumerator
REG
FWD
ADJ
OUT
ADJ_OUT

Definition at line 91 of file fmu_function.hpp.

{REG, FWD, ADJ, OUT, ADJ_OUT};

IntegratorInput

enum casadi::IntegratorInput

Enumerator
INTEGRATOR_X0	Differential state at the initial time.
INTEGRATOR_Z0	Initial guess for the algebraic variable at the initial time.
INTEGRATOR_P	Parameters.
INTEGRATOR_U	Piecewise constant control, a new control interval starts at each output time.
INTEGRATOR_ADJ_XF	Adjoint seeds corresponding to the states at the output times.
INTEGRATOR_ADJ_ZF	Adjoint seeds corresponding to the algebraic variables at the output times.
INTEGRATOR_ADJ_QF	Adjoint seeds corresponding to the quadratures at the output times.
INTEGRATOR_NUM_IN	Number of input arguments of an integrator.

Definition at line 223 of file integrator.hpp.

                     {
  INTEGRATOR_X0,
  INTEGRATOR_Z0,
  INTEGRATOR_P,
  INTEGRATOR_U,
  INTEGRATOR_ADJ_XF,
  INTEGRATOR_ADJ_ZF,
  INTEGRATOR_ADJ_QF,
  INTEGRATOR_NUM_IN
};

IntegratorOutput

enum casadi::IntegratorOutput

Enumerator
INTEGRATOR_XF	Differential state at all output times.
INTEGRATOR_ZF	Algebraic variable at all output times.
INTEGRATOR_QF	Quadrature state at all output times.
INTEGRATOR_ADJ_X0	Adjoint sensitivities corresponding to the initial state.
INTEGRATOR_ADJ_Z0	Adjoint sensitivities corresponding to the algebraic variable guess.
INTEGRATOR_ADJ_P	Adjoint sensitivities corresponding to the parameter vector.
INTEGRATOR_ADJ_U	Adjoint sensitivities corresponding to the control vector.
INTEGRATOR_NUM_OUT	Number of output arguments of an integrator.

Definition at line 243 of file integrator.hpp.

                      {
  INTEGRATOR_XF,
  INTEGRATOR_ZF,
  INTEGRATOR_QF,
  INTEGRATOR_ADJ_X0,
  INTEGRATOR_ADJ_Z0,
  INTEGRATOR_ADJ_P,
  INTEGRATOR_ADJ_U,
  INTEGRATOR_NUM_OUT
};

NLPInput

enum casadi::NLPInput

Enumerator
NL_X	Decision variable.
NL_P	Fixed parameter.
NL_NUM_IN	Number of NLP inputs.

Definition at line 168 of file nlpsol.hpp.

              {
  NL_X,
  NL_P,
  NL_NUM_IN
};

NLPOutput

enum casadi::NLPOutput

Enumerator
NL_F	Objective function.
NL_G	Constraint function.
NL_NUM_OUT	Number of NLP outputs.

Definition at line 181 of file nlpsol.hpp.

               {
  NL_F,
  NL_G,
  NL_NUM_OUT
};

NlpsolInput

enum casadi::NlpsolInput

Enumerator
NLPSOL_X0	Decision variables, initial guess (nx x 1)
NLPSOL_P	Value of fixed parameters (np x 1)
NLPSOL_LBX	Decision variables lower bound (nx x 1), default -inf.
NLPSOL_UBX	Decision variables upper bound (nx x 1), default +inf.
NLPSOL_LBG	Constraints lower bound (ng x 1), default -inf.
NLPSOL_UBG	Constraints upper bound (ng x 1), default +inf.
NLPSOL_LAM_X0	Lagrange multipliers for bounds on X, initial guess (nx x 1)
NLPSOL_LAM_G0	Lagrange multipliers for bounds on G, initial guess (ng x 1)
NLPSOL_NUM_IN

Definition at line 194 of file nlpsol.hpp.

                 {
  NLPSOL_X0,
  NLPSOL_P,
  NLPSOL_LBX,
  NLPSOL_UBX,
  NLPSOL_LBG,
  NLPSOL_UBG,
  NLPSOL_LAM_X0,
  NLPSOL_LAM_G0,
  NLPSOL_NUM_IN
};

NlpsolOutput

enum casadi::NlpsolOutput

Enumerator
NLPSOL_X	Decision variables at the optimal solution (nx x 1)
NLPSOL_F	Cost function value at the optimal solution (1 x 1)
NLPSOL_G	Constraints function at the optimal solution (ng x 1)
NLPSOL_LAM_X	Lagrange multipliers for bounds on X at the solution (nx x 1)
NLPSOL_LAM_G	Lagrange multipliers for bounds on G at the solution (ng x 1)
NLPSOL_LAM_P	Lagrange multipliers for bounds on P at the solution (np x 1)
NLPSOL_NUM_OUT

Definition at line 215 of file nlpsol.hpp.

                  {
  NLPSOL_X,
  NLPSOL_F,
  NLPSOL_G,
  NLPSOL_LAM_X,
  NLPSOL_LAM_G,
  NLPSOL_LAM_P,
  NLPSOL_NUM_OUT
};

Operation

enum casadi::Operation

Enumerator
OP_ASSIGN
OP_ADD
OP_SUB
OP_MUL
OP_DIV
OP_NEG
OP_EXP
OP_LOG
OP_POW
OP_CONSTPOW
OP_SQRT
OP_SQ
OP_TWICE
OP_SIN
OP_COS
OP_TAN
OP_ASIN
OP_ACOS
OP_ATAN
OP_LT
OP_LE
OP_EQ
OP_NE
OP_NOT
OP_AND
OP_OR
OP_FLOOR
OP_CEIL
OP_FMOD
OP_FABS
OP_SIGN
OP_COPYSIGN
OP_IF_ELSE_ZERO
OP_ERF
OP_FMIN
OP_FMAX
OP_INV
OP_SINH
OP_COSH
OP_TANH
OP_ASINH
OP_ACOSH
OP_ATANH
OP_ATAN2
OP_CONST
OP_INPUT
OP_OUTPUT
OP_PARAMETER
OP_CALL
OP_FIND
OP_LOW
OP_MAP
OP_MTIMES
OP_SOLVE
OP_TRANSPOSE
OP_DETERMINANT
OP_INVERSE
OP_DOT
OP_BILIN
OP_RANK1
OP_HORZCAT
OP_VERTCAT
OP_DIAGCAT
OP_HORZSPLIT
OP_VERTSPLIT
OP_DIAGSPLIT
OP_RESHAPE
OP_SUBREF
OP_SUBASSIGN
OP_GETNONZEROS
OP_GETNONZEROS_PARAM
OP_ADDNONZEROS
OP_ADDNONZEROS_PARAM
OP_SETNONZEROS
OP_SETNONZEROS_PARAM
OP_PROJECT
OP_ASSERTION
OP_MONITOR
OP_NORM2
OP_NORM1
OP_NORMINF
OP_NORMF
OP_MMIN
OP_MMAX
OP_HORZREPMAT
OP_HORZREPSUM
OP_ERFINV
OP_PRINTME
OP_LIFT
OP_EINSTEIN
OP_BSPLINE
OP_CONVEXIFY
OP_SPARSITY_CAST
OP_LOG1P
OP_EXPM1
OP_HYPOT
OP_LOGSUMEXP
OP_REMAINDER
OP_DUMP
OP_KRON
OP_KRON_CONTRACT

Definition at line 60 of file calculus.hpp.

                 {
    // Simple assignment
    OP_ASSIGN,
 
    // Standard unary and binary functions
    OP_ADD,  OP_SUB,  OP_MUL,  OP_DIV,
    OP_NEG,  OP_EXP,  OP_LOG,  OP_POW, OP_CONSTPOW,
    OP_SQRT,  OP_SQ,  OP_TWICE,
    OP_SIN,  OP_COS,  OP_TAN,
    OP_ASIN,  OP_ACOS,  OP_ATAN,
    OP_LT, OP_LE, OP_EQ, OP_NE, OP_NOT, OP_AND, OP_OR,
    OP_FLOOR,  OP_CEIL,  OP_FMOD, OP_FABS, OP_SIGN, OP_COPYSIGN, OP_IF_ELSE_ZERO,
    OP_ERF,  OP_FMIN,  OP_FMAX,
    OP_INV,
    OP_SINH,  OP_COSH,  OP_TANH,
    OP_ASINH, OP_ACOSH, OP_ATANH,
    OP_ATAN2,
 
    // Double constant
    OP_CONST,
 
    // Function input and output
    OP_INPUT, OP_OUTPUT,
 
    // Free parameter
    OP_PARAMETER,
 
    // Embedded function call
    OP_CALL,
 
    // Find first nonzero in a vector
    OP_FIND,
 
    // Find first nonzero in a vector
    OP_LOW,
 
    // Embedded function call in parallel
    OP_MAP,
 
    // Matrix multiplication
    OP_MTIMES,
 
    // Solve linear system of equations
    OP_SOLVE,
 
    // Matrix transpose
    OP_TRANSPOSE,
 
    // Matrix determinant
    OP_DETERMINANT,
 
    // Matrix inverse
    OP_INVERSE,
 
    // Inner product
    OP_DOT,
 
    // Bilinear form
    OP_BILIN,
 
    // Rank-1 update
    OP_RANK1,
 
    // Horizontal concatenation
    OP_HORZCAT,
 
    // Vertical concatenation of vectors
    OP_VERTCAT,
 
    // Diagonal concatenation
    OP_DIAGCAT,
 
    // Horizontal split
    OP_HORZSPLIT,
 
    // Vertical split of vectors
    OP_VERTSPLIT,
 
    // Diagonal split
    OP_DIAGSPLIT,
 
    // Reshape an expression
    OP_RESHAPE,
 
    // Submatrix reference
    OP_SUBREF,
 
    // Submatrix assignment
    OP_SUBASSIGN,
 
    // Nonzero reference
    OP_GETNONZEROS,
 
    // Parametric nonzero reference
    OP_GETNONZEROS_PARAM,
 
    // Nonzero addition
    OP_ADDNONZEROS,
 
    // parametric nonzero addition
    OP_ADDNONZEROS_PARAM,
 
    // Nonzero assignment
    OP_SETNONZEROS,
 
    // Parametric nonzero assignment
    OP_SETNONZEROS_PARAM,
 
    // Set sparse
    OP_PROJECT,
 
    // Assertion
    OP_ASSERTION,
 
    // Monitor
    OP_MONITOR,
 
    // Norms
    OP_NORM2, OP_NORM1, OP_NORMINF, OP_NORMF,
 
    // min/max
    OP_MMIN, OP_MMAX,
 
    // Horizontal repeat
    OP_HORZREPMAT,
 
    // Horizontal repeat sum
    OP_HORZREPSUM,
 
    OP_ERFINV,
    OP_PRINTME,
    OP_LIFT,
 
    OP_EINSTEIN,
 
    OP_BSPLINE,
 
    OP_CONVEXIFY,
 
    // Sparsity cast
    OP_SPARSITY_CAST,
 
    OP_LOG1P,
 
    OP_EXPM1,
 
    OP_HYPOT,
 
    OP_LOGSUMEXP,
 
    OP_REMAINDER,
 
    OP_DUMP,
 
    OP_KRON,
 
    OP_KRON_CONTRACT,
 
  };

OutputType

enum casadi::OutputType

strong

Enumerator
REG
FWD
ADJ
JAC
JAC_TRANS
JAC_ADJ_OUT
JAC_REG_ADJ
HESS

Definition at line 106 of file fmu_function.hpp.

{REG, FWD, ADJ, JAC, JAC_TRANS, JAC_ADJ_OUT, JAC_REG_ADJ, HESS};

Parallelization

enum casadi::Parallelization

strong

Enumerator
SERIAL
OPENMP
THREAD
NUMEL

Definition at line 85 of file fmu_function.hpp.

{SERIAL, OPENMP, THREAD, NUMEL};

StepIn

enum casadi::StepIn

Enumerator
STEP_T	Current time.
STEP_H	Step size.
STEP_X0	State vector.
STEP_V0	Dependent variables.
STEP_P	Parameter.
STEP_U	Controls.
STEP_NUM_IN	Number of arguments.

Definition at line 498 of file integrator_impl.hpp.

            {
  STEP_T,
  STEP_H,
  STEP_X0,
  STEP_V0,
  STEP_P,
  STEP_U,
  STEP_NUM_IN
};

StepOut

enum casadi::StepOut

Enumerator
STEP_XF	State vector at next time.
STEP_VF	Dependent variables at next time.
STEP_QF	Quadrature state contribution.
STEP_NUM_OUT	Number of arguments.

Definition at line 516 of file integrator_impl.hpp.

             {
  STEP_XF,
  STEP_VF,
  STEP_QF,
  STEP_NUM_OUT
};

Type

enum casadi::Type

strong

Enumerator
FLOAT32
FLOAT64
INT8
UINT8
INT16
UINT16
INT32
UINT32
INT64
UINT64
BOOLEAN
STRING
BINARY
ENUMERATION
CLOCK
NUMEL

Definition at line 45 of file dae_builder_internal.hpp.

                {FLOAT32, FLOAT64, INT8, UINT8, INT16, UINT16, INT32, UINT32, INT64, UINT64,
  BOOLEAN, STRING, BINARY, ENUMERATION, CLOCK, NUMEL};

TypeFmi2

enum casadi::TypeFmi2

strong

Enumerator
REAL
INTEGER
BOOLEAN
STRING
ENUM
NUMEL

Definition at line 42 of file dae_builder_internal.hpp.

{REAL, INTEGER, BOOLEAN, STRING, ENUM, NUMEL};

TypeID

enum casadi::TypeID

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

Enumerator
OT_NULL
OT_BOOL
OT_INT
OT_DOUBLE
OT_STRING
OT_INTVECTOR
OT_INTVECTORVECTOR
OT_BOOLVECTOR
OT_DOUBLEVECTOR
OT_DOUBLEVECTORVECTOR
OT_STRINGVECTOR
OT_DICT
OT_FUNCTION
OT_FUNCTIONVECTOR
OT_VOIDPTR
OT_UNKNOWN
OT_STRINGVECTORVECTOR
OT_DICTVECTOR
OT_VECTORVECTOR
OT_VECTOR

Definition at line 43 of file generic_type.hpp.

              {
    OT_NULL,
    OT_BOOL,
    OT_INT,
    OT_DOUBLE,
    OT_STRING,
    OT_INTVECTOR,
    OT_INTVECTORVECTOR,
    OT_BOOLVECTOR,
    OT_DOUBLEVECTOR,
    OT_DOUBLEVECTORVECTOR,
    OT_STRINGVECTOR,
    OT_DICT,
    OT_FUNCTION,
    OT_FUNCTIONVECTOR,
    OT_VOIDPTR,
    OT_UNKNOWN,
    OT_STRINGVECTORVECTOR,
    OT_DICTVECTOR,
    OT_VECTORVECTOR,
    OT_VECTOR};

UnifiedReturnStatus

enum casadi::UnifiedReturnStatus

Unified return status for solvers

Enumerator
SOLVER_RET_SUCCESS
SOLVER_RET_UNKNOWN
SOLVER_RET_LIMITED
SOLVER_RET_NAN
SOLVER_RET_INFEASIBLE
SOLVER_RET_EXCEPTION

Definition at line 55 of file casadi_types.hpp.

                             {
        SOLVER_RET_SUCCESS,
        SOLVER_RET_UNKNOWN,
        SOLVER_RET_LIMITED, // Out of time
        SOLVER_RET_NAN,
        SOLVER_RET_INFEASIBLE,
        SOLVER_RET_EXCEPTION
    };

Variability

enum casadi::Variability

strong

Enumerator
CONSTANT
FIXED
TUNABLE
DISCRETE
CONTINUOUS
NUMEL

Definition at line 52 of file dae_builder_internal.hpp.

{CONSTANT, FIXED, TUNABLE, DISCRETE, CONTINUOUS, NUMEL};

VariableType

enum casadi::VariableType

Enumerator
OPTI_VAR
OPTI_PAR
OPTI_DUAL_G

Definition at line 495 of file optistack.hpp.

                    {
    OPTI_VAR, // variable
    OPTI_PAR,  // parameter
    OPTI_DUAL_G // dual
  };

Function Documentation

_function_buffer_eval()

void CASADI_EXPORT casadi::_function_buffer_eval

(

void *

raw

)

Definition at line 2227 of file function.cpp.

                                                      {
    static_cast<FunctionBuffer*>(raw)->_eval();
  }

_jacobian_sparsity()

template<typename MatType >

Sparsity casadi::_jacobian_sparsity	(	const MatType &	expr,
		const MatType &	var
	)

Definition at line 1346 of file x_function.hpp.

                                                                       {
    Dict opts{{"max_io", 0}, {"allow_free", true}};
    Function f = Function("tmp_jacobian_sparsity", {var}, {expr}, opts);
    return f.jac_sparsity(0, 0, false);
  }

References casadi::Function::jac_sparsity().

Referenced by casadi::MX::jacobian_sparsity().

_which_depends()

template<typename MatType >

std::vector<bool> casadi::_which_depends	(	const MatType &	expr,
		const MatType &	var,
		casadi_int	order,
		bool	tr
	)

Definition at line 1353 of file x_function.hpp.

                                 {
    // Short-circuit
    if (expr.is_empty() || var.is_empty()) {
      return std::vector<bool>(tr? expr.numel() : var.numel(), false);
    }
 
    MatType e = expr;
 
    // Create a function for calculating a forward-mode derivative
    casadi_assert(order==1 || order==2,
      "which_depends: order argument must be 1 or 2, got " + str(order) + " instead.");
 
    MatType v = MatType::sym("v", var.sparsity());
    for (casadi_int i=1;i<order;++i) {
      e = jtimes(e, var, v);
    }
 
    Dict opts{{"max_io", 0}, {"allow_free", true}};
    Function f = Function("tmp_which_depends", {var}, {e}, opts);
    // Propagate sparsities backwards seeding all outputs
    std::vector<bvec_t> seed(tr? f.nnz_in(0) : f.nnz_out(0), 1);
    std::vector<bvec_t> sens(tr? f.nnz_out(0) : f.nnz_in(0), 0);
 
    if (tr)
      f({get_ptr(seed)}, {get_ptr(sens)});
    else
      f.rev({get_ptr(sens)}, {get_ptr(seed)});
    // Temporaries for evaluation
    std::vector<bool> ret(sens.size());
    std::copy(sens.begin(), sens.end(), ret.begin());
 
    // Project the result back on the original sparsity
    if (tr && e.sparsity()!=expr.sparsity()) {
      // std::vector<bool> is not accessible as bool*
      // bool -> casadi_int
      std::vector<casadi_int> source(sens.size());
      std::copy(ret.begin(), ret.end(), source.begin());
      std::vector<casadi_int> target(expr.nnz());
 
      // project
      std::vector<casadi_int> scratch(expr.size1());
      casadi_project(get_ptr(source), e.sparsity(), get_ptr(target), expr.sparsity(),
        get_ptr(scratch));
 
      // casadi_int -> bool
      ret.resize(expr.nnz());
      std::copy(target.begin(), target.end(), ret.begin());
    }
 
    return ret;
  }

References casadi_project(), get_ptr(), casadi::Function::nnz_in(), casadi::Function::nnz_out(), casadi::Function::rev(), and str().

Referenced by casadi::MX::which_depends().

absolute()

std::string casadi::absolute

(

const std::string &

path

)

Definition at line 59 of file ghc.cpp.

                                              {
        return ghc::filesystem::absolute(ghc::filesystem::path(path)).string();
    }

References path().

Referenced by casadi_register_filesystem_ghc().

accepted_iterate()

static SLEQP_RETCODE casadi::accepted_iterate ( SleqpSolver *  solver, SleqpIterate *  iterate, void *  data  )

static

Definition at line 501 of file sleqp_interface.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(data);
 
    const SLEQPInterface* interface = m->interface;
    const Function& fcallback_ = interface->fcallback_;
 
    std::fill_n(m->arg, fcallback_.n_in(), nullptr);
 
    double ret_double;
    m->res[0] = &ret_double;
 
    casadi_nlpsol_data<double>& d_nlp = m->d_nlp;
 
    double obj_val = sleqp_iterate_obj_val(iterate);
 
    m->arg[NLPSOL_F] = &obj_val;
 
    SleqpVec* primal = sleqp_iterate_primal(iterate);
    SLEQP_CALL(sleqp_vec_to_raw(primal, m->cb_xk));
    m->arg[NLPSOL_X] = m->cb_xk;
 
    SleqpVec* cons_val = sleqp_iterate_cons_val(iterate);
    SLEQP_CALL(sleqp_vec_to_raw(cons_val, m->gk));
    m->arg[NLPSOL_G] = m->gk;
 
    SleqpVec* vars_dual = sleqp_iterate_vars_dual(iterate);
    SLEQP_CALL(sleqp_vec_to_raw(vars_dual, m->cb_lam_xk));
    m->arg[NLPSOL_LAM_X] = m->cb_lam_xk;
 
    SleqpVec* cons_dual = sleqp_iterate_cons_dual(iterate);
    SLEQP_CALL(sleqp_vec_to_raw(cons_dual, m->cb_lam_gk));
    m->arg[NLPSOL_LAM_G] = m->cb_lam_gk;
 
    try {
      fcallback_(m->arg, m->res, m->iw, m->w, 0);
    } catch(KeyboardInterruptException& ex) {
      sleqp_raise(SLEQP_CALLBACK_ERROR, "Interrupt caught in callback...");
    } catch(std::exception& ex) {
      casadi_warning("intermediate_callback: " + std::string(ex.what()));
      if (m->iteration_callback_ignore_errors) return SLEQP_OKAY;
      sleqp_raise(SLEQP_CALLBACK_ERROR, "Exception caught in callback...");
    }
 
    casadi_int ret = static_cast<casadi_int>(ret_double);
 
    if(ret != 0 && !m->iteration_callback_ignore_errors)
    {
      sleqp_raise(SLEQP_CALLBACK_ERROR, "Error in callback...");
    }
 
    return SLEQP_OKAY;
  }

References casadi::OracleMemory::arg, casadi::SLEQPMemory::cb_lam_gk, casadi::SLEQPMemory::cb_lam_xk, casadi::SLEQPMemory::cb_xk, casadi::NlpsolMemory::d_nlp, casadi::SLEQPMemory::gk, casadi::SLEQPMemory::iteration_callback_ignore_errors, casadi::OracleMemory::iw, NLPSOL_F, NLPSOL_G, NLPSOL_LAM_G, NLPSOL_LAM_X, NLPSOL_X, casadi::OracleMemory::res, casadi::OracleMemory::w, and casadi::CasadiException::what().

Referenced by casadi::SLEQPInterface::solve().

add_defaults()

template<class X >

std::map<std::string, X> casadi::add_defaults	(	const std::map< std::string, X > &	in,
		const std::vector< std::string > &	keys
	)

Definition at line 762 of file integration_tools.cpp.

                                      {
  std::map<std::string, X> ret;
  for (const std::string& k : keys) {
    auto it = in.find(k);
    if (it==in.end()) {
      ret[k] = X(0, 1);
    } else {
      ret[k] = it->second;
    }
  }
  return ret;
}

References X.

add_directory_recursive()

void casadi::add_directory_recursive	(	zip_t *	archive,
		const std::string &	base_dir,
		const std::string &	current_dir,
		const std::string &	rel_prefix
	)

Definition at line 170 of file libzip.cpp.

                                     {
        auto filesystem = Filesystem::getPlugin("ghc");
        std::vector<std::string> entries = filesystem.exposed.iterate_directory_names(current_dir);
 
        for (const std::string& full_path : entries) {
            std::string rel_path = full_path.substr(base_dir.size() + 1);
 
            if (filesystem.exposed.is_directory(full_path)) {
                zip_dir_add(archive, (rel_path + "/").c_str(), ZIP_FL_ENC_UTF_8);
                add_directory_recursive(archive, base_dir, full_path, rel_path);
            } else {
                add_file_to_zip(archive, full_path, rel_path);
            }
        }
    }

References add_file_to_zip(), and casadi::PluginInterface< Filesystem >::getPlugin().

Referenced by zip_to_path2(), and zip_to_stream().

add_file_to_zip()

bool casadi::add_file_to_zip	(	zip_t *	archive,
		const std::string &	file_path,
		const std::string &	archive_name
	)

Definition at line 126 of file libzip.cpp.

                                           {
        auto file_ptr = Filesystem::ifstream_ptr(file_path, std::ios::binary | std::ios::ate);
        std::istream& file = *file_ptr;
        if (!file) {
            uerr() << "Error: Cannot open file: " << file_path << std::endl;
            return false;
        }
 
        std::streamsize size = file.tellg();
        file.seekg(0, std::ios::beg);
 
        char* data = static_cast<char*>(malloc(size));  // ← use malloc
        if (!data) {
            uerr() << "Error: Memory allocation failed for file: " << file_path << std::endl;
            return false;
        }
 
        if (!file.read(data, size)) {
            uerr() << "Error: Cannot read file: " << file_path << std::endl;
            free(data);
            return false;
        }
 
        zip_error_t ziperr;
        zip_source_t* source = zip_source_buffer_create(data, size, 1, &ziperr); // ← freep = 1
        if (!source) {
            uerr() << "Error: Cannot create zip source for file: " << file_path
                   << ": " << zip_error_strerror(&ziperr) << std::endl;
            free(data); // not strictly needed, but safe
            zip_error_fini(&ziperr);
            return false;
        }
 
        zip_int64_t idx = zip_file_add(archive, archive_name.c_str(), source, ZIP_FL_ENC_UTF_8);
        if (idx < 0) {
            zip_source_free(source);  // Only needed if not added
            uerr() << "Error: Cannot add file to archive: " << archive_name << std::endl;
            return false;
        }
 
        return true;
    }

References casadi::Filesystem::ifstream_ptr(), and uerr().

Referenced by add_directory_recursive(), and zip_entries_to_path().

add_int_attribute()

void casadi::add_int_attribute	(	onnx::NodeProto *	node,
		const std::string &	name,
		casadi_int	value
	)

Definition at line 176 of file onnx_operations.cpp.

                                                                                       {
    onnx::AttributeProto* attr = node->add_attribute();
    attr->set_name(name);
    attr->set_type(onnx::AttributeProto::INT);
    attr->set_i(value);
  }

Referenced by create_gather_node(), create_gemm_node(), and casadi::Onnx::load().

add_int_constant() [1/2]

void casadi::add_int_constant	(	AddNodeFn	add_node,
		const std::string &	name,
		const std::vector< casadi_int > &	data,
		std::vector< casadi_int >	dims = {}
	)

Definition at line 110 of file onnx_operations.cpp.

                                                     {}) {
    onnx::TensorProto* t = create_constant_tensor(add_node, name, onnx::TensorProto::INT64);
    if (dims.empty()) dims = {static_cast<casadi_int>(data.size())};
    for (casadi_int d : dims) t->add_dims(d);
    for (casadi_int v : data) t->add_int64_data(v);
  }

add_int_constant() [2/2]

void casadi::add_int_constant	(	onnx::GraphProto *	graph,
		const std::string &	name,
		const std::vector< casadi_int > &	data,
		std::vector< casadi_int >	dims = {}
	)

Definition at line 193 of file onnx_operations.cpp.

                                                                                       {
    add_int_constant([graph]() { return graph->add_node(); }, name, data, dims);
  }

Referenced by create_slice_node(), and emit_colmajor_reshape().

add_ints_attribute()

void casadi::add_ints_attribute	(	onnx::NodeProto *	node,
		const std::string &	name,
		const std::vector< casadi_int > &	values
	)

Definition at line 184 of file onnx_operations.cpp.

                                                               {
    onnx::AttributeProto* attr = node->add_attribute();
    attr->set_name(name);
    attr->set_type(onnx::AttributeProto::INTS);
    for (casadi_int v : values) attr->add_ints(v);
  }

all()

CASADI_EXPORT bool casadi::all

(

const std::vector< bool > &

v

)

Examples

misc/all.cc.

Definition at line 81 of file casadi_misc.cpp.

                                     {
    for (auto && e : v) {
      if (!e) return false;
    }
    return true;
  }

Referenced by casadi::SetNonzeros< Add >::ad_forward(), casadi::SetNonzeros< Add >::ad_reverse(), casadi::DaeBuilder::c(), casadi::FunctionInternal::codegen_meta(), casadi::DaeBuilder::d(), casadi::SetNonzeros< Add >::eval_mx(), casadi::SetNonzeros< Add >::mapping(), override_num(), casadi::DaeBuilder::p(), casadi::DaeBuilder::q(), reduce_index_gen(), select_tensors(), casadi::DaeBuilder::t_new(), casadi::DaeBuilder::u(), casadi::DaeBuilder::w(), casadi::DaeBuilder::x(), casadi::DaeBuilder::y(), and casadi::DaeBuilder::z().

any()

CASADI_EXPORT bool casadi::any

(

const std::vector< bool > &

v

)

Examples

misc/all.cc.

Definition at line 88 of file casadi_misc.cpp.

                                     {
    for (auto && e : v) {
      if (e) return true;
    }
    return false;
  }

Referenced by casadi::MX::graph_substitute(), casadi::OnnxFunction::has_jacobian(), casadi::GenericMatrix< MatType >::is_linear(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), casadi::ProxqpInterface::solve(), and casadi::OptiNode::stats().

applymap() [1/2]

template<class T >

std::vector< T > casadi::applymap	(	T(*)(const T &)	f,
		const std::vector< T > &	comp
	)

Apply a function f to each element in a vector

Definition at line 653 of file casadi_misc.hpp.

                                                                     {
    std::vector<T> ret(comp.size());
    std::transform(comp.begin(), comp.end(), ret.begin(), f);
    return ret;
  }

applymap() [2/2]

template<class T >

void casadi::applymap	(	void(*)(T &)	f,
		std::vector< T > &	comp
	)

Apply a function f to each element in a vector

Definition at line 660 of file casadi_misc.hpp.

                                                    {
    std::for_each(comp.begin(), comp.end(), f);
  }

assert_read()

void casadi::assert_read	(	std::istream &	stream,
		const std::string &	s
	)

Definition at line 2351 of file function_internal.cpp.

                                                           {
    casadi_int n = s.size();
    char c;
    std::stringstream ss;
    for (casadi_int i=0;i<n;++i) {
      stream >> c;
      ss << c;
    }
    casadi_assert_dev(s==ss.str());
  }

assign_vector()

template<class S , class D >

void casadi::assign_vector	(	const std::vector< S > &	s,
		std::vector< D > &	d
	)

Definition at line 671 of file casadi_misc.hpp.

                                                             {
    casadi_assert(d.empty(), "Receiving vector must be empty");
    d.resize(s.size());
    std::copy(s.begin(), s.end(), d.begin());
  }

Referenced by casadi::Nlpsol::get_stats(), casadi::Nlpsol::init(), casadi::KnitroInterface::solve(), and casadi::OptiNode::to_function().

blasfeo_codegen_axpy_aux()

static void casadi::blasfeo_codegen_axpy_aux ( CodeGenerator &  g, const std::vector< std::string > &  inst  )

static

Definition at line 117 of file blas_blasfeo.cpp.

                                        {
    static const char* SRC =
        "// SYMBOL \"axpy\"\n"
        "void casadi_axpy(casadi_int n, casadi_real alpha,\n"
        "    const casadi_real* x, casadi_real* y) {\n"
        "  int n_ = (int)n, inc = 1;\n"
        "  blasfeo_blas_daxpy(&n_, &alpha, (double*)x, &inc, y, &inc);\n"
        "}\n";
    g.auxiliaries << BLASFEO_DAXPY_DECL << "\n";
    g.auxiliaries << g.sanitize_source(SRC, inst);
  }

References casadi::CodeGenerator::auxiliaries, BLASFEO_DAXPY_DECL, and casadi::CodeGenerator::sanitize_source().

Referenced by casadi_register_blas_blasfeo().

blasfeo_codegen_dot_aux()

static void casadi::blasfeo_codegen_dot_aux ( CodeGenerator &  g, const std::vector< std::string > &  inst  )

static

Definition at line 134 of file blas_blasfeo.cpp.

                                        {
    static const char* SRC =
        "// SYMBOL \"dot\"\n"
        "casadi_real casadi_dot(casadi_int n,\n"
        "    const casadi_real* x, const casadi_real* y) {\n"
        "  int n_ = (int)n, inc = 1;\n"
        "  return blasfeo_blas_ddot(&n_, (double*)x, &inc, (double*)y, &inc);\n"
        "}\n";
    g.auxiliaries << BLASFEO_DDOT_DECL << "\n";
    g.auxiliaries << g.sanitize_source(SRC, inst);
  }

References casadi::CodeGenerator::auxiliaries, BLASFEO_DDOT_DECL, and casadi::CodeGenerator::sanitize_source().

Referenced by casadi_register_blas_blasfeo().

blasfeo_codegen_mtimes()

static void casadi::blasfeo_codegen_mtimes ( CodeGenerator &  g, const std::string &  A, casadi_int  m, casadi_int  k, const std::string &  B, casadi_int  n, const std::string &  C  )

static

Definition at line 98 of file blas_blasfeo.cpp.

                                                            {
    g.add_external(BLASFEO_DECL);
    g.local("blas_tn", "char");      g.init_local("blas_tn", "'N'");
    g.local("blas_one", "double");   g.init_local("blas_one", "1.0");
    g.local("blas_m", "int");
    g.local("blas_n", "int");
    g.local("blas_k", "int");
    g << "blas_m = " << m << "; blas_n = " << n << "; blas_k = " << k << ";\n";
    g << "blasfeo_blas_dgemm(&blas_tn, &blas_tn, &blas_m, &blas_n, &blas_k, "
         "&blas_one, (double*)" << A << ", &blas_m, (double*)" << B
      << ", &blas_k, &blas_one, " << C << ", &blas_m);\n";
  }

References casadi::CodeGenerator::add_external(), BLASFEO_DECL, C, casadi::CodeGenerator::init_local(), and casadi::CodeGenerator::local().

Referenced by casadi_register_blas_blasfeo().

blasfeo_daxpy()

static void casadi::blasfeo_daxpy ( casadi_int  n, double  alpha, const double *  x, double *  y  )

static

Definition at line 59 of file blas_blasfeo.cpp.

                                                        {
    casadi_assert(n <= INT_MAX,
        "BLAS 'blasfeo' plugin: vector length exceeds 32-bit BLAS ABI.");
    int n_ = static_cast<int>(n), inc = 1;
    blasfeo_blas_daxpy(&n_, &alpha,
                       const_cast<double*>(x), &inc, y, &inc);
  }

Referenced by casadi_register_blas_blasfeo().

blasfeo_ddot()

static double casadi::blasfeo_ddot ( casadi_int  n, const double *  x, const double *  y  )

static

Definition at line 68 of file blas_blasfeo.cpp.

                                                               {
    casadi_assert(n <= INT_MAX,
        "BLAS 'blasfeo' plugin: vector length exceeds 32-bit BLAS ABI.");
    int n_ = static_cast<int>(n), inc = 1;
    return blasfeo_blas_ddot(&n_,
                             const_cast<double*>(x), &inc,
                             const_cast<double*>(y), &inc);
  }

Referenced by casadi_register_blas_blasfeo(), and eval_L().

blasfeo_dgemm()

static void casadi::blasfeo_dgemm ( int  transa, int  transb, casadi_int  m, casadi_int  n, casadi_int  k, double  alpha, const double *  A, casadi_int  lda, const double *  B, casadi_int  ldb, double  beta, double *  C, casadi_int  ldc  )

static

Definition at line 33 of file blas_blasfeo.cpp.

                                                       {
    casadi_assert(m   <= INT_MAX && n   <= INT_MAX && k   <= INT_MAX
               && lda <= INT_MAX && ldb <= INT_MAX && ldc <= INT_MAX,
        "BLAS 'blasfeo' plugin: matrix dimension exceeds 32-bit BLAS ABI.");
 
    char ta = (transa == CASADI_BLAS_TRANS) ? 'T' : 'N';
    char tb = (transb == CASADI_BLAS_TRANS) ? 'T' : 'N';
    int m_ = static_cast<int>(m), n_ = static_cast<int>(n), k_ = static_cast<int>(k);
    int lda_ = static_cast<int>(lda), ldb_ = static_cast<int>(ldb), ldc_ = static_cast<int>(ldc);
 
    // BLASFEO header takes non-const pointers; semantics are still read-only
    // for A, B, alpha, beta. const_cast is safe here.
    blasfeo_blas_dgemm(&ta, &tb, &m_, &n_, &k_, &alpha,
                       const_cast<double*>(A), &lda_,
                       const_cast<double*>(B), &ldb_,
                       &beta, C, &ldc_);
  }

References C, and CASADI_BLAS_TRANS.

Referenced by casadi_register_blas_blasfeo().

blazing_spline() [1/2]

CASADI_EXPORT Function casadi::blazing_spline	(	const std::string &	name,
		const std::vector< casadi_int > &	knot_dims,
		const Dict &	opts = Dict()
	)

Like blazing_spline, but the knot values are provided as a symbolic input at evaluation time instead of being fixed at construction time. Only knot vector sizes (per dimension) are needed at construction.

The resulting Function has inputs (x, C, knots) where knots is the stacked knot vector. Supports the same precompute_coeff and precompute_grid options as the fixed-knots variant.

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

Definition at line 181 of file blazing_spline.cpp.

                        {
    bool precompute_coeff = false, precompute_grid = false;
    auto it = opts.find("precompute_coeff");
    if (it != opts.end()) precompute_coeff = it->second;
    it = opts.find("precompute_grid");
    if (it != opts.end()) precompute_grid = it->second;
    bool use_inv = precompute_grid;
    Function F_inner = Function::create(
      new BlazingSplineFunction(name, knot_dims, 0,
        precompute_coeff, precompute_grid, use_inv), opts);
    if (!use_inv) return F_inner;
 
    // Wrap: user sees (x, C, knots), wrapper computes inv and calls inner
    std::vector<casadi_int> offsets = knot_offsets(knot_dims);
    casadi_int nd = knot_dims.size();
    casadi_int nk = offsets.back();
    MX x = MX::sym("x", nd);
    MX C = MX::sym("C", F_inner.size_in(1));
    MX knots = MX::sym("knots", nk);
    MX inv = compute_knots_cache(knots, offsets);
    std::vector<MX> ret = F_inner(std::vector<MX>{x, C, knots, inv});
    return Function(name, {x, C, knots}, ret,
                    {"x", "C", "knots"}, F_inner.name_out(),
                    {{"always_inline", true}});
  }

References C, compute_knots_cache(), casadi::Function::create(), casadi::FunctionInternal::find(), knot_offsets(), casadi::Function::name_out(), casadi::Function::size_in(), and casadi::GenericMatrix< MX >::sym().

blazing_spline() [2/2]

CASADI_EXPORT Function casadi::blazing_spline	(	const std::string &	name,
		const std::vector< std::vector< double > > &	knots,
		const Dict &	opts = Dict()
	)

Specialized in these ways:

• order 3 is assumed
• up to dimension 5 supported
• a single scalar output (m=1)

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

Definition at line 175 of file blazing_spline.cpp.

                        {
    return Function::create(new BlazingSplineFunction(name, knots, 0), opts);
  }

References casadi::Function::create().

boolvec_and()

CASADI_EXPORT std::vector< bool > casadi::boolvec_and	(	const std::vector< bool > &	lhs,
		const std::vector< bool > &	rhs
	)

Definition at line 395 of file casadi_misc.cpp.

                                                                                      {
    casadi_assert(lhs.size()==rhs.size(), "Size mismatch.");
    std::vector<bool> ret(lhs.size());
    std::transform(lhs.begin(), lhs.end(), rhs.begin(), ret.begin(),
                   [](bool a, bool b) -> bool { return a && b; });
    return ret;
  }

boolvec_not()

CASADI_EXPORT std::vector< bool > casadi::boolvec_not

(

const std::vector< bool > &

v

)

Definition at line 388 of file casadi_misc.cpp.

                                                        {
    std::vector<bool> ret(v.size());
    std::transform(v.begin(), v.end(), ret.begin(),
                   [](bool v) -> bool { return !v; });
    return ret;
  }

Referenced by construct_nlpsol(), and detect_simple_bounds_gen().

boolvec_or()

CASADI_EXPORT std::vector< bool > casadi::boolvec_or	(	const std::vector< bool > &	lhs,
		const std::vector< bool > &	rhs
	)

Definition at line 403 of file casadi_misc.cpp.

                                                                                     {
    casadi_assert(lhs.size()==rhs.size(), "Size mismatch.");
    std::vector<bool> ret(lhs.size());
    std::transform(lhs.begin(), lhs.end(), rhs.begin(), ret.begin(),
                   [](bool a, bool b) -> bool { return a || b; });
    return ret;
  }

boolvec_to_index()

CASADI_EXPORT std::vector< casadi_int > casadi::boolvec_to_index

(

const std::vector< bool > &

v

)

Definition at line 412 of file casadi_misc.cpp.

                                                                   {
    std::vector<casadi_int> ret;
    for (casadi_int i=0;i<v.size();++i) {
      if (v[i]) ret.push_back(i);
    }
    return ret;
  }

Referenced by construct_nlpsol(), and detect_simple_bounds_gen().

bvec_clear()

void casadi::bvec_clear	(	bvec_t *	s,
		casadi_int	begin,
		casadi_int	end
	)

Definition at line 1219 of file function_internal.cpp.

                                                               {
    for (casadi_int i=begin; i<end; ++i) {
      s[i] = 0;
    }
  }

bvec_or() [1/2]

CASADI_EXPORT bvec_t casadi::bvec_or	(	const bvec_t *	arg,
		casadi_int	n
	)

Definition at line 453 of file casadi_misc.cpp.

                                                  {
    bvec_t acc = 0;
    // vacuous truth
    if (n==0) {
      return~acc;
    }
    for (casadi_int i=0;i<n;++i) {
      acc |= arg[i];
    }
    return acc;
  }

Referenced by casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::GetNonzerosParam::sp_forward(), casadi::SetNonzerosParam< Add >::sp_forward(), casadi::GetNonzerosParam::sp_reverse(), and casadi::SetNonzerosParam< Add >::sp_reverse().

bvec_or() [2/2]

void casadi::bvec_or	(	const bvec_t *	s,
		bvec_t &	r,
		casadi_int	begin,
		casadi_int	end
	)

Definition at line 1226 of file function_internal.cpp.

                                                                              {
    r = 0;
    for (casadi_int i=begin; i<end; ++i) r |= s[i];
  }

bvec_toggle()

void casadi::bvec_toggle	(	bvec_t *	s,
		casadi_int	begin,
		casadi_int	end,
		casadi_int	j
	)

Definition at line 1213 of file function_internal.cpp.

                                                                              {
    for (casadi_int i=begin; i<end; ++i) {
      s[i] ^= (bvec_t(1) << j);
    }
  }

Referenced by casadi::FunctionInternal::get_jac_sparsity_hierarchical(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm().

calc_function()

template<typename T1 >

int casadi::calc_function	(	const OracleCallback *	cb,
		casadi_oracle_data< T1 > *	d
	)

Definition at line 280 of file oracle_function.hpp.

                                                                         {
    OracleMemory* m = static_cast<OracleMemory*>(d->m);
    try {
      return cb->oracle_->calc_function(m, cb->name);
    }
    catch (const std::exception& e) {
      uerr() << e.what() << std::endl;
      return 1;
    }
  }

References casadi::OracleFunction::calc_function(), casadi_oracle_data< T1 >::m, casadi::OracleCallback::name, casadi::OracleCallback::oracle_, and uerr().

callback_stderr()

void casadi::callback_stderr

(

const char *

s

)

Definition at line 40 of file tools.cpp.

                                    {
    uerr() << s << std::flush;
}

References uerr().

Referenced by external_transform().

callback_stdout()

void casadi::callback_stdout

(

const char *

s

)

Definition at line 36 of file tools.cpp.

                                    {
    uout() << s << std::flush;
}

References uout().

Referenced by external_transform().

casadi_add() [1/2]

template<>

void casadi::casadi_add	(	casadi_int	n,
		const bvec_t *	x,
		bvec_t *	y
	)

Definition at line 148 of file mapsum.cpp.

                                                            {
    casadi_int i;
    if (!x || !y) return;
    for (i=0; i<n; ++i) *y++ |= *x++;
  }

casadi_add() [2/2]

template<typename T1 >

void casadi::casadi_add	(	casadi_int	n,
		const T1 *	x,
		T1 *	y
	)

Definition at line 141 of file mapsum.cpp.

                                                    {
    casadi_int i;
    if (!x || !y) return;
    for (i=0; i<n; ++i) *y++ += *x++;
  }

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

casadi_axpy()

template<typename T1 >

void casadi::casadi_axpy	(	casadi_int	n,
		T1	alpha,
		const T1 *	x,
		T1 *	y
	)

Referenced by casadi::FixedStepIntegrator::advance_noevent(), casadi::Feasiblesqpmethod::anderson_acc_step_update(), casadi::Blocksqp::calcLagrangeGradient(), casadi::FiniteDiff::eval(), casadi::Integrator::eval(), casadi::Scpgen::eval_mat(), casadi::Scpgen::eval_vec(), casadi::Feasiblesqpmethod::feasibility_iterations(), casadi::FixedStepIntegrator::impulseB(), casadi::SundialsInterface::impulseB(), casadi::IdasInterface::jtimesB(), casadi::IdasInterface::jtimesF(), casadi::Scpgen::line_search(), casadi::CvodesInterface::psolveB(), casadi::CvodesInterface::psolveF(), casadi::IdasInterface::psolveF(), casadi::IdasInterface::resB(), casadi::IdasInterface::resF(), casadi::FixedStepIntegrator::retreat(), casadi::SuperscsInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Newton::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), casadi::Scpgen::solve_qp(), casadi::IdasInterface::solve_transposed(), casadi::Integrator::trigger_event(), and casadi::IdasInterface::z_impulseB().

casadi_bilin()

template<typename T1 >

T1 casadi::casadi_bilin	(	const T1 *	A,
		const casadi_int *	sp_A,
		const T1 *	x,
		const T1 *	y
	)

Calculates dot(x, mul(A, y))

Referenced by casadi::Bilin::eval_gen(), casadi::Feasiblesqpmethod::eval_m_k(), casadi::Scpgen::line_search(), casadi::HpmpcInterface::solve(), casadi::SuperscsInterface::solve(), casadi::Ipqp::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), and casadi::Sqpmethod::solve().

casadi_bound_consistency()

template<typename T1 >

void casadi::casadi_bound_consistency	(	casadi_int	n,
		T1 *	x,
		T1 *	lam,
		const T1 *	lbx,
		const T1 *	ubx
	)

casadi_clear()

template<typename T1 >

void casadi::casadi_clear	(	T1 *	x,
		casadi_int	n
	)

Referenced by casadi::Feasiblesqpmethod::anderson_acc_init_memory(), casadi::SundialsInterface::calc_daeB(), casadi::SundialsInterface::calc_quadB(), casadi_clear_casadi_int(), casadi_copy_block(), casadi::BSpline::eval(), casadi::BSplineParametric::eval(), casadi::Integrator::eval(), casadi::MapSum::eval_gen(), casadi::Scpgen::eval_mat(), casadi::CvodesInterface::psolveB(), casadi::CvodesInterface::psolveF(), casadi::IdasInterface::psolveF(), casadi::FixedStepIntegrator::resetB(), casadi::SundialsInterface::resetB(), casadi::FixedStepIntegrator::retreat(), casadi::Scpgen::set_work(), casadi::GurobiInterface::solve(), casadi::OoqpInterface::solve(), casadi::SuperscsInterface::solve(), casadi::SnoptInterface::solve(), casadi::WorhpInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), casadi::Scpgen::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_elastic_mode(), casadi::IdasInterface::solve_transposed(), casadi::FunctionInternal::sp_forward(), casadi::FunctionInternal::sp_reverse(), casadi::FixedStepIntegrator::stepB(), casadi::SnoptInterface::userfun(), and casadi::IdasInterface::z_impulseB().

casadi_clear_casadi_int()

void casadi::casadi_clear_casadi_int ( casadi_int *  x, casadi_int  n  )

inline

Definition at line 336 of file casadi_runtime.hpp.

                                                                   {
    casadi_clear(x, n);
  }

References casadi_clear().

casadi_copy()

template<typename T1 >

void casadi::casadi_copy	(	const T1 *	x,
		casadi_int	n,
		T1 *	y
	)

Referenced by casadi::FixedStepIntegrator::advance_noevent(), casadi::CvodesInterface::advance_noevent(), casadi::IdasInterface::advance_noevent(), casadi::Feasiblesqpmethod::anderson_acc_init_memory(), casadi::Feasiblesqpmethod::anderson_acc_step_update(), casadi::Feasiblesqpmethod::anderson_acc_update_memory(), casadi::Blocksqp::calcLagrangeGradient(), casadi_uno_term_cb_cpp(), casadi::Blocksqp::computeNextHessian(), casadi::FunctionInternal::eval(), casadi::Nlpsol::eval(), casadi::FiniteDiff::eval(), casadi::FmuFunction::eval(), casadi::FmuInternal::eval_fd(), casadi::Rank1::eval_gen(), casadi::Scpgen::eval_mat(), casadi::CallSX::eval_sx(), casadi::Feasiblesqpmethod::feasibility_iterations(), casadi::FmuFunction::finalize_hessian(), casadi::BonminInterface::finalize_solution(), casadi::IpoptInterface::finalize_solution(), casadi::BonminInterface::get_bounds_info(), casadi::IpoptInterface::get_bounds_info(), get_initial_uk(), get_initial_xk(), casadi::Integrator::get_q(), casadi::BonminInterface::get_starting_point(), casadi::IpoptInterface::get_starting_point(), casadi::Integrator::get_x(), casadi::Integrator::get_z(), casadi::BonminInterface::intermediate_callback(), casadi::IpoptInterface::intermediate_callback(), casadi::LinsolQr::nfact(), casadi::Integrator::predict_events(), casadi::CvodesInterface::psolveB(), casadi::CvodesInterface::psolveF(), casadi::IdasInterface::psolveF(), casadi::FixedStepIntegrator::reset(), casadi::SundialsInterface::reset(), casadi::Collocation::reset(), casadi::FixedStepIntegrator::retreat(), casadi::CvodesInterface::retreat(), casadi::IdasInterface::retreat(), casadi::Integrator::set_p(), casadi::Integrator::set_q(), casadi::Integrator::set_u(), casadi::Integrator::set_x(), casadi::Integrator::set_z(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::OoqpInterface::solve(), casadi::OsqpInterface::solve(), casadi::PiqpInterface::solve(), casadi::ProxqpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::SuperscsInterface::solve(), casadi::Qrqp::solve(), casadi::AlpaqaInterface::solve(), casadi::Blocksqp::solve(), casadi::BonminInterface::solve(), casadi::IpoptInterface::solve(), casadi::KnitroInterface::solve(), casadi::SnoptInterface::solve(), casadi::KinsolInterface::solve(), casadi::WorhpInterface::solve(), casadi::FastNewton::solve(), casadi::Feasiblesqpmethod::solve(), casadi::ImplicitToNlp::solve(), casadi::Newton::solve(), casadi::Qrsqp::solve(), casadi::Scpgen::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_elastic_mode(), casadi::Scpgen::solve_qp(), casadi::IdasInterface::solve_transposed(), casadi::MapSum::sp_reverse(), casadi::Feasiblesqpmethod::step_update(), casadi::Integrator::trigger_event(), and casadi::IdasInterface::z_impulseB().

casadi_copy_block()

template<typename T1 >

void casadi::casadi_copy_block	(	const T1 *	x,
		const casadi_int *	sp_x,
		T1 *	y,
		const casadi_int *	sp_y,
		casadi_int	r_begin,
		casadi_int	c_begin,
		T1 *	w
	)

Definition at line 799 of file idas_interface.cpp.

                                                   {
  // x and y should be distinct
  casadi_int nrow_x, ncol_x, ncol_y, i_x, i_y, j, el, r_end;
  const casadi_int *colind_x, *row_x, *colind_y, *row_y;
  nrow_x = sp_x[0];
  ncol_x = sp_x[1];
  colind_x = sp_x+2; row_x = sp_x + 2 + ncol_x+1;
  ncol_y = sp_y[1];
  colind_y = sp_y+2; row_y = sp_y + 2 + ncol_y+1;
  // End of the rows to be copied
  r_end = r_begin + nrow_x;
  // w will correspond to a column of x, initialize to zero
  casadi_clear(w, nrow_x);
  // Loop over columns in x
  for (i_x = 0; i_x < ncol_x; ++i_x) {
    // Corresponding row in y
    i_y = i_x + c_begin;
    // Copy x entries to w
    for (el=colind_x[i_x]; el<colind_x[i_x + 1]; ++el) w[row_x[el]] = x[el];
    // Copy entries to y, if in interval
    for (el=colind_y[i_y]; el<colind_y[i_y + 1]; ++el) {
      j = row_y[el];
      if (j >= r_begin && j < r_end) y[el] = w[j - r_begin];
    }
    // Restore w
    for (el=colind_x[i_x]; el<colind_x[i_x + 1]; ++el) w[row_x[el]] = 0;
  }
}

References casadi_clear().

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

casadi_de_boor()

template<typename T1 >

void casadi::casadi_de_boor	(	T1	x,
		const T1 *	knots,
		casadi_int	n_knots,
		casadi_int	degree,
		T1 *	boor
	)

casadi_densify()

template<typename T1 , typename T2 >

void casadi::casadi_densify	(	const T1 *	x,
		const casadi_int *	sp_x,
		T2 *	y,
		casadi_int	tr
	)

Referenced by casadi::Densify::eval_gen(), casadi::LapackLu::nfact(), casadi::LapackQr::nfact(), and casadi::QpoasesInterface::solve().

casadi_dot()

template<typename T1 >

T1 casadi::casadi_dot	(	casadi_int	n,
		const T1 *	x,
		const T1 *	y
	)

Referenced by casadi::Feasiblesqpmethod::anderson_acc_step_update(), casadi::Blocksqp::calcHessianUpdate(), casadi::Blocksqp::calcHessianUpdateLimitedMemory(), casadi::Dot::eval_gen(), casadi::Feasiblesqpmethod::eval_m_k(), casadi::Scpgen::line_search(), casadi::Blocksqp::sizeInitialHessian(), casadi::HpmpcInterface::solve(), casadi::SuperscsInterface::solve(), casadi::Ipqp::solve(), casadi::Qrsqp::solve(), and casadi::Sqpmethod::solve().

casadi_fill()

template<typename T1 >

void casadi::casadi_fill	(	T1 *	x,
		casadi_int	n,
		T1	alpha
	)

Referenced by casadi::Blocksqp::calcInitialHessian(), casadi::Blocksqp::calcLagrangeGradient(), casadi_fill_casadi_int(), casadi::Nlpsol::eval(), casadi::BonminInterface::finalize_solution(), casadi::Sparsity::mul_sparsityR(), casadi::FixedStepIntegrator::reset(), casadi::Blocksqp::reset_sqp(), casadi::Blocksqp::resetHessian(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::Qrqp::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_elastic_mode(), and casadi::Blocksqp::solveQP().

casadi_fill_casadi_int()

void casadi::casadi_fill_casadi_int ( casadi_int *  x, casadi_int  n, casadi_int  alpha  )

inline

Definition at line 331 of file casadi_runtime.hpp.

                                                                                    {
    casadi_fill(x, n, alpha);
  }

References casadi_fill().

casadi_flip()

casadi_int casadi::casadi_flip	(	casadi_int *	corner,
		casadi_int	ndim
	)

casadi_func_cons_jac()

static SLEQP_RETCODE casadi::casadi_func_cons_jac ( SleqpFunc *  func, SleqpMat *  cons_jac, void *  func_data  )

static

Definition at line 132 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
 
    m->arg[0] = m->xk;
    m->arg[1] = m->d_nlp.p;
    m->res[0] = nullptr;
    m->res[1] = m->jac_gk;
 
    try {
 
      if(m->interface->calc_function(m, "nlp_jac_g") != 0) {
        return SLEQP_ERROR;
      }
 
    } catch (std::exception& ex) {
      uerr() << "Error \""
             << ex.what()
             << "\" evaluating constraint Jacobian"
             << std::endl;
 
      sleqp_raise(SLEQP_FUNC_EVAL_ERROR, "%s", ex.what());
    }
 
    casadi_int ncol = m->interface->jac_sparsity().size2();
    const casadi_int* colind = m->interface->jac_sparsity().colind();
    const casadi_int* row = m->interface->jac_sparsity().row();
 
    const casadi_int nnz = colind[ncol];
 
    SLEQP_CALL(sleqp_mat_reserve(cons_jac, nnz));
 
    double* cons_jac_data = sleqp_mat_data(cons_jac);
    int* cons_jac_rows = sleqp_mat_rows(cons_jac);
    int* cons_jac_cols = sleqp_mat_cols(cons_jac);
 
    for(int k = 0; k < nnz; ++k) {
      cons_jac_data[k] = m->jac_gk[k];
      cons_jac_rows[k] = row[k];
    }
 
    for(int k = 0; k <= ncol; ++k) {
      cons_jac_cols[k] = colind[k];
    }
 
    SLEQP_CALL(sleqp_mat_set_nnz(cons_jac, nnz));
 
    return SLEQP_OKAY;
  }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::Sparsity::colind(), casadi::NlpsolMemory::d_nlp, casadi::SLEQPMemory::interface, casadi::SLEQPMemory::jac_gk, casadi::SLEQPInterface::jac_sparsity(), casadi_nlpsol_data< T1 >::p, casadi::OracleMemory::res, casadi::Sparsity::row(), casadi::Sparsity::size2(), uerr(), and casadi::SLEQPMemory::xk.

Referenced by casadi_sleqp_func_create().

casadi_func_cons_val()

static SLEQP_RETCODE casadi::casadi_func_cons_val ( SleqpFunc *  func, SleqpVec *  cons_val, void *  func_data  )

static

Definition at line 97 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
 
    m->arg[0] = m->xk;
    m->arg[1] = m->d_nlp.p;
    m->res[0] = m->gk;
 
    try {
 
      if(m->interface->calc_function(m, "nlp_g") != 0) {
        return SLEQP_ERROR;
      }
 
      const int num_cons = sleqp_func_num_cons(func);
 
      SLEQP_CALL(sleqp_vec_set_from_raw(cons_val,
                                        m->gk,
                                        num_cons,
                                        0.));
 
    } catch (std::exception& ex) {
      uerr() << "Error \""
             << ex.what()
             << "\" evaluating constraint value"
             << std::endl;
 
      sleqp_raise(SLEQP_FUNC_EVAL_ERROR, "%s", ex.what());
    }
 
    return SLEQP_OKAY;
  }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::NlpsolMemory::d_nlp, casadi::SLEQPMemory::gk, casadi::SLEQPMemory::interface, casadi_nlpsol_data< T1 >::p, casadi::OracleMemory::res, uerr(), and casadi::SLEQPMemory::xk.

Referenced by casadi_sleqp_func_create().

casadi_func_free()

static SLEQP_RETCODE casadi::casadi_func_free ( void *  func_data )

static

Definition at line 231 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
    return SLEQP_OKAY;
  }

Referenced by casadi_sleqp_func_create().

casadi_func_hess_prod()

static SLEQP_RETCODE casadi::casadi_func_hess_prod ( SleqpFunc *  func, const SleqpVec *  direction, const SleqpVec *  cons_duals, SleqpVec *  product, void *  func_data  )

static

Definition at line 184 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
 
    SLEQP_CALL(sleqp_vec_to_raw(direction, m->h_dk));
    SLEQP_CALL(sleqp_vec_to_raw(cons_duals, m->h_mk));
 
    double one = 1.;
 
    m->arg[0] = m->xk;           // x
    m->arg[1] = m->d_nlp.p;      // p
    m->arg[2] = &one;            // lam:f
    m->arg[3] = m->h_mk;         // lam:g
    m->arg[4] = nullptr;         // out:grad:gamma:x
    m->arg[5] = m->h_dk;         // fwd:x
    m->arg[6] = nullptr;         // fwd:p
    m->arg[7] = nullptr;         // fwd:lam:x
    m->arg[8] = nullptr;         // fwd:lam:g
 
    m->res[0] = m->h_pk;         // fwd:grad:gamma:x
 
    try {
 
      if(m->interface->calc_function(m, "fwd1_nlp_grad_l") != 0) {
        return SLEQP_ERROR;
      }
 
    } catch (std::exception& ex) {
      uerr() << "Error \""
             << ex.what()
             << "\" evaluating constraint Hessian product"
             << std::endl;
 
      sleqp_raise(SLEQP_FUNC_EVAL_ERROR, "%s", ex.what());
    }
 
    const int num_vars = sleqp_func_num_vars(func);
 
    SLEQP_CALL(sleqp_vec_set_from_raw(product, m->h_pk, num_vars, 0.));
 
    return SLEQP_OKAY;
  }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::NlpsolMemory::d_nlp, casadi::SLEQPMemory::h_dk, casadi::SLEQPMemory::h_mk, casadi::SLEQPMemory::h_pk, casadi::SLEQPMemory::interface, casadi_nlpsol_data< T1 >::p, product(), casadi::OracleMemory::res, uerr(), and casadi::SLEQPMemory::xk.

Referenced by casadi_sleqp_func_create().

casadi_func_nonzeros()

static SLEQP_RETCODE casadi::casadi_func_nonzeros ( SleqpFunc *  func, int *  obj_grad_nnz, int *  cons_val_nnz, int *  cons_jac_nnz, int *  hess_prod_nnz, void *  func_data  )

static

Definition at line 22 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
    return SLEQP_OKAY;
  }

Referenced by casadi_sleqp_func_create().

casadi_func_obj_grad()

static SLEQP_RETCODE casadi::casadi_func_obj_grad ( SleqpFunc *  func, SleqpVec *  obj_grad, void *  func_data  )

static

Definition at line 61 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
 
    m->arg[0] = m->xk;
    m->arg[1] = m->d_nlp.p;
    m->res[0] = nullptr;
    m->res[1] = m->grad_fk;
 
    try {
 
      if(m->interface->calc_function(m, "nlp_grad_f") != 0) {
        return SLEQP_ERROR;
      }
 
      const int num_vars = sleqp_func_num_vars(func);
 
      SLEQP_CALL(sleqp_vec_set_from_raw(obj_grad,
                                        m->grad_fk,
                                        num_vars,
                                        0.));
 
    } catch (std::exception& ex) {
      uerr() << "Error \""
             << ex.what()
             << "\" evaluating objective gradient"
             << std::endl;
 
      sleqp_raise(SLEQP_FUNC_EVAL_ERROR, "%s", ex.what());
    }
 
    return SLEQP_OKAY;
  }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::NlpsolMemory::d_nlp, casadi::SLEQPMemory::grad_fk, casadi::SLEQPMemory::interface, casadi_nlpsol_data< T1 >::p, casadi::OracleMemory::res, uerr(), and casadi::SLEQPMemory::xk.

Referenced by casadi_sleqp_func_create().

casadi_func_obj_val()

static SLEQP_RETCODE casadi::casadi_func_obj_val ( SleqpFunc *  func, double *  obj_val, void *  func_data  )

static

Definition at line 33 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
 
    m->arg[0] = m->xk;
    m->arg[1] = m->d_nlp.p;
    m->res[0] = obj_val;
 
    try {
 
      if(m->interface->calc_function(m, "nlp_f") == 0) {
        return SLEQP_OKAY;
      }
 
    } catch (std::exception& ex) {
      uerr() << "Error \""
             << ex.what()
             << "\" evaluating objective value"
             << std::endl;
 
      sleqp_raise(SLEQP_FUNC_EVAL_ERROR, "%s", ex.what());
    }
 
    return SLEQP_ERROR;
  }

References casadi::OracleMemory::arg, casadi::OracleFunction::calc_function(), casadi::NlpsolMemory::d_nlp, casadi::SLEQPMemory::interface, casadi_nlpsol_data< T1 >::p, casadi::OracleMemory::res, uerr(), and casadi::SLEQPMemory::xk.

Referenced by casadi_sleqp_func_create().

casadi_func_set()

static SLEQP_RETCODE casadi::casadi_func_set ( SleqpFunc *  func, SleqpVec *  value, SLEQP_VALUE_REASON  reason, bool *  reject, void *  func_data  )

static

Definition at line 9 of file sleqp_func.cpp.

  {
    SLEQPMemory* m = static_cast<SLEQPMemory*>(func_data);
 
    SLEQP_CALL(sleqp_vec_to_raw(value, m->xk));
 
    return SLEQP_OKAY;
  }

References casadi::SLEQPMemory::xk.

Referenced by casadi_sleqp_func_create().

casadi_getu()

template<typename T1 >

void casadi::casadi_getu	(	const T1 *	x,
		const casadi_int *	sp_x,
		T1 *	v
	)

casadi_iamax()

template<typename T1 >

casadi_int casadi::casadi_iamax	(	casadi_int	n,
		const T1 *	x,
		casadi_int	inc_x
	)

casadi_interpn()

template<typename T1 >

T1 casadi::casadi_interpn	(	casadi_int	ndim,
		const T1 *	grid,
		const casadi_int *	offset,
		const T1 *	values,
		const T1 *	x,
		casadi_int *	iw,
		T1 *	w
	)

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

casadi_interpn_grad()

template<typename T1 >

void casadi::casadi_interpn_grad	(	T1 *	grad,
		casadi_int	ndim,
		const T1 *	grid,
		const casadi_int *	offset,
		const T1 *	values,
		const T1 *	x,
		casadi_int *	iw,
		T1 *	w
	)

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

casadi_interpn_interpolate()

template<typename T1 >

T1 casadi::casadi_interpn_interpolate	(	casadi_int	ndim,
		const casadi_int *	offset,
		const T1 *	values,
		const T1 *	alpha,
		const casadi_int *	index,
		const casadi_int *	corner,
		T1 *	coeff
	)

casadi_interpn_weights()

template<typename T1 >

void casadi::casadi_interpn_weights	(	casadi_int	ndim,
		const T1 *	grid,
		const casadi_int *	offset,
		const T1 *	x,
		T1 *	alpha,
		casadi_int *	index
	)

casadi_KN_puts()

int casadi::casadi_KN_puts	(	const char *const	str,
		void *const	userParams
	)

Definition at line 204 of file knitro_interface.cpp.

                                                                      {
    std::string s(str);
    uout() << s << std::flush;
    return s.size();
  }

References str(), and uout().

Referenced by casadi::KnitroInterface::solve().

casadi_kron()

template<typename T1 >

void casadi::casadi_kron	(	const T1 *	a,
		const casadi_int *	sp_a,
		const T1 *	b,
		const casadi_int *	sp_b,
		T1 *	r
	)

Calculates Calculates nonzeros of kronecker product

Referenced by casadi::Kron::eval_kernel().

casadi_kron_contract_inner()

template<typename T1 >

void casadi::casadi_kron_contract_inner	(	const T1 *	m,
		const casadi_int *	sp_m,
		const T1 *	b,
		const casadi_int *	sp_b,
		T1 *	y,
		const casadi_int *	sp_y,
		T1 *	w
	)

Kron contraction (inner): contract M's inner block axes against b

Referenced by casadi::KronContract::eval_kernel().

casadi_kron_contract_inner_dense()

template<typename T1 >

void casadi::casadi_kron_contract_inner_dense	(	const T1 *	m,
		casadi_int	mA,
		casadi_int	nA,
		const T1 *	b,
		casadi_int	mB,
		casadi_int	nB,
		T1 *	y
	)

Kron contraction (inner), all dense

Referenced by casadi::DenseKronContract::eval_kernel().

casadi_kron_contract_inner_dense_sparse()

template<typename T1 >

void casadi::casadi_kron_contract_inner_dense_sparse	(	const T1 *	m,
		casadi_int	mA,
		casadi_int	nA,
		const T1 *	b,
		const casadi_int *	sp_b,
		T1 *	y
	)

Kron contraction (inner), m dense + b sparse

Referenced by casadi::DenseSparseKronContract::eval_kernel().

casadi_kron_contract_inner_sparse_dense()

template<typename T1 >

void casadi::casadi_kron_contract_inner_sparse_dense	(	const T1 *	m,
		const casadi_int *	sp_m,
		const T1 *	b,
		casadi_int	mB,
		casadi_int	nB,
		T1 *	y,
		const casadi_int *	sp_y
	)

Kron contraction (inner), m sparse + b dense

Referenced by casadi::SparseDenseKronContract::eval_kernel().

casadi_kron_contract_outer()

template<typename T1 >

void casadi::casadi_kron_contract_outer	(	const T1 *	m,
		const casadi_int *	sp_m,
		const T1 *	a,
		const casadi_int *	sp_a,
		T1 *	y,
		const casadi_int *	sp_y,
		T1 *	w
	)

Kron contraction (outer): contract M's outer block axes against a

Referenced by casadi::KronContract::eval_kernel().

casadi_kron_contract_outer_dense()

template<typename T1 >

void casadi::casadi_kron_contract_outer_dense	(	const T1 *	m,
		casadi_int	mB,
		casadi_int	nB,
		const T1 *	a,
		casadi_int	mA,
		casadi_int	nA,
		T1 *	y
	)

Kron contraction (outer), all dense

Referenced by casadi::DenseKronContract::eval_kernel().

casadi_kron_contract_outer_dense_sparse()

template<typename T1 >

void casadi::casadi_kron_contract_outer_dense_sparse	(	const T1 *	m,
		casadi_int	mB,
		casadi_int	nB,
		const T1 *	a,
		const casadi_int *	sp_a,
		T1 *	y
	)

Kron contraction (outer), m dense + a sparse

Referenced by casadi::DenseSparseKronContract::eval_kernel().

casadi_kron_contract_outer_sparse_dense()

template<typename T1 >

void casadi::casadi_kron_contract_outer_sparse_dense	(	const T1 *	m,
		const casadi_int *	sp_m,
		const T1 *	a,
		casadi_int	mA,
		casadi_int	nA,
		T1 *	y,
		const casadi_int *	sp_y
	)

Kron contraction (outer), m sparse + a dense

Referenced by casadi::SparseDenseKronContract::eval_kernel().

casadi_kron_dense()

template<typename T1 >

void casadi::casadi_kron_dense	(	const T1 *	a,
		casadi_int	mA,
		casadi_int	nA,
		const T1 *	b,
		casadi_int	mB,
		casadi_int	nB,
		T1 *	r
	)

Kron, both operands dense

Referenced by casadi::DenseKron::eval_kernel().

casadi_kron_dense_sparse()

template<typename T1 >

void casadi::casadi_kron_dense_sparse	(	const T1 *	a,
		casadi_int	mA,
		casadi_int	nA,
		const T1 *	b,
		const casadi_int *	sp_b,
		T1 *	r
	)

Kron, dense a + sparse b

Referenced by casadi::DenseSparseKron::eval_kernel().

casadi_kron_sparse_dense()

template<typename T1 >

void casadi::casadi_kron_sparse_dense	(	const T1 *	a,
		const casadi_int *	sp_a,
		const T1 *	b,
		casadi_int	mB,
		casadi_int	nB,
		T1 *	r
	)

Kron, sparse a + dense b

Referenced by casadi::SparseDenseKron::eval_kernel().

casadi_load_archiver_libzip()

void CASADI_ARCHIVER_LIBZIP_EXPORT casadi::casadi_load_archiver_libzip

(

)

Definition at line 382 of file libzip.cpp.

                                                                    {
     Archiver::registerPlugin(casadi_register_archiver_libzip);
   }

References casadi_register_archiver_libzip(), and casadi::PluginInterface< Archiver >::registerPlugin().

casadi_load_blas_blasfeo()

void CASADI_BLAS_BLASFEO_EXPORT casadi::casadi_load_blas_blasfeo

(

)

Definition at line 171 of file blas_blasfeo.cpp.

                                                                        {
    Blas::registerPlugin(casadi_register_blas_blasfeo);
  }

References casadi_register_blas_blasfeo(), and casadi::PluginInterface< Blas >::registerPlugin().

casadi_load_blas_classic()

void CASADI_BLAS_CLASSIC_EXPORT casadi::casadi_load_blas_classic

(

)

Definition at line 257 of file blas_classic.cpp.

                                                                        {
    Blas::registerPlugin(casadi_register_blas_classic);
  }

References casadi_register_blas_classic(), and casadi::PluginInterface< Blas >::registerPlugin().

Referenced by casadi::Blas::shorthand_for().

casadi_load_conic_cbc()

void CASADI_CONIC_CBC_EXPORT casadi::casadi_load_conic_cbc

(

)

Definition at line 45 of file cbc_interface.cpp.

                                                       {
    Conic::registerPlugin(casadi_register_conic_cbc);
  }

References casadi_register_conic_cbc(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_clarabel()

void CASADI_CONIC_CLARABEL_EXPORT casadi::casadi_load_conic_clarabel

(

)

Definition at line 45 of file clarabel_interface.cpp.

                                                               {
  Conic::registerPlugin(casadi_register_conic_clarabel);
}

References casadi_register_conic_clarabel(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_clp()

void CASADI_CONIC_CLP_EXPORT casadi::casadi_load_conic_clp

(

)

Definition at line 42 of file clp_interface.cpp.

                                                       {
    Conic::registerPlugin(casadi_register_conic_clp);
  }

References casadi_register_conic_clp(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_cplex()

void CASADI_CONIC_CPLEX_EXPORT casadi::casadi_load_conic_cplex

(

)

Definition at line 56 of file cplex_interface.cpp.

                                                           {
    Conic::registerPlugin(casadi_register_conic_cplex);
  }

References casadi_register_conic_cplex(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_daqp()

void CASADI_CONIC_DAQP_EXPORT casadi::casadi_load_conic_daqp

(

)

Definition at line 44 of file daqp_interface.cpp.

                                                         {
    Conic::registerPlugin(casadi_register_conic_daqp);
  }

References casadi_register_conic_daqp(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_fatrop()

void CASADI_CONIC_FATROP_EXPORT casadi::casadi_load_conic_fatrop

(

)

Definition at line 46 of file fatrop_conic_interface.cpp.

                                                             {
    Conic::registerPlugin(casadi_register_conic_fatrop);
  }

References casadi_register_conic_fatrop(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_gurobi()

void CASADI_CONIC_GUROBI_EXPORT casadi::casadi_load_conic_gurobi

(

)

Definition at line 126 of file gurobi_interface.cpp.

                                                             {
    Conic::registerPlugin(casadi_register_conic_gurobi);
  }

References casadi_register_conic_gurobi(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_highs()

void CASADI_CONIC_HIGHS_EXPORT casadi::casadi_load_conic_highs

(

)

Definition at line 44 of file highs_interface.cpp.

                                                           {
    Conic::registerPlugin(casadi_register_conic_highs);
  }

References casadi_register_conic_highs(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_hpipm()

void CASADI_CONIC_HPIPM_EXPORT casadi::casadi_load_conic_hpipm

(

)

Definition at line 45 of file hpipm_interface.cpp.

                                                           {
    Conic::registerPlugin(casadi_register_conic_hpipm);
  }

References casadi_register_conic_hpipm(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_hpmpc()

void CASADI_CONIC_HPMPC_EXPORT casadi::casadi_load_conic_hpmpc

(

)

Definition at line 42 of file hpmpc_interface.cpp.

                                                           {
    Conic::registerPlugin(casadi_register_conic_hpmpc);
  }

References casadi_register_conic_hpmpc(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_ipqp()

void CASADI_CONIC_IPQP_EXPORT casadi::casadi_load_conic_ipqp

(

)

Definition at line 44 of file ipqp.cpp.

                                                         {
    Conic::registerPlugin(casadi_register_conic_ipqp);
  }

References casadi_register_conic_ipqp(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_mosek()

void CASADI_CONIC_MOSEK_EXPORT casadi::casadi_load_conic_mosek

(

)

Definition at line 57 of file mosek_interface.cpp.

                                                           {
    Conic::registerPlugin(casadi_register_conic_mosek);
  }

References casadi_register_conic_mosek(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_nlpsol()

void CASADI_CONIC_NLPSOL_EXPORT casadi::casadi_load_conic_nlpsol

(

)

Definition at line 45 of file qp_to_nlp.cpp.

                                                             {
    Conic::registerPlugin(casadi_register_conic_nlpsol);
  }

References casadi_register_conic_nlpsol(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_ooqp()

void CASADI_CONIC_OOQP_EXPORT casadi::casadi_load_conic_ooqp

(

)

Definition at line 53 of file ooqp_interface.cpp.

                                                         {
    Conic::registerPlugin(casadi_register_conic_ooqp);
  }

References casadi_register_conic_ooqp(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_osqp()

void CASADI_CONIC_OSQP_EXPORT casadi::casadi_load_conic_osqp

(

)

Definition at line 61 of file osqp_interface.cpp.

                                                         {
    Conic::registerPlugin(casadi_register_conic_osqp);
  }

References casadi_register_conic_osqp(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_piqp()

void CASADI_CONIC_PIQP_EXPORT casadi::casadi_load_conic_piqp

(

)

Definition at line 46 of file piqp_interface.cpp.

                                                         {
    Conic::registerPlugin(casadi_register_conic_piqp);
  }

References casadi_load_conic_piqp(), and casadi_register_conic_piqp().

Referenced by casadi_load_conic_piqp().

casadi_load_conic_proxqp()

void CASADI_CONIC_PROXQP_EXPORT casadi::casadi_load_conic_proxqp

(

)

Definition at line 47 of file proxqp_interface.cpp.

                                                             {
    Conic::registerPlugin(casadi_register_conic_proxqp);
  }

References casadi_load_conic_proxqp(), and casadi_register_conic_proxqp().

Referenced by casadi_load_conic_proxqp().

casadi_load_conic_qpoases()

void CASADI_CONIC_QPOASES_EXPORT casadi::casadi_load_conic_qpoases

(

)

Definition at line 47 of file qpoases_interface.cpp.

                                                               {
    Conic::registerPlugin(casadi_register_conic_qpoases);
  }

References casadi_register_conic_qpoases(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_qrqp()

void CASADI_CONIC_QRQP_EXPORT casadi::casadi_load_conic_qrqp

(

)

Definition at line 44 of file qrqp.cpp.

                                                         {
    Conic::registerPlugin(casadi_register_conic_qrqp);
  }

References casadi_register_conic_qrqp(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_sqic()

void CASADI_CONIC_SQIC_EXPORT casadi::casadi_load_conic_sqic

(

)

Definition at line 48 of file sqic_interface.cpp.

                                                         {
    Conic::registerPlugin(casadi_register_conic_sqic);
  }

References casadi_register_conic_sqic(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_superscs()

void CASADI_CONIC_SUPERSCS_EXPORT casadi::casadi_load_conic_superscs

(

)

Definition at line 48 of file superscs_interface.cpp.

                                                                 {
    Conic::registerPlugin(casadi_register_conic_superscs);
  }

References casadi_register_conic_superscs(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_conic_xpress()

void CASADI_CONIC_XPRESS_EXPORT casadi::casadi_load_conic_xpress

(

)

Definition at line 57 of file xpress_interface.cpp.

                                                             {
    Conic::registerPlugin(casadi_register_conic_xpress);
  }

References casadi_register_conic_xpress(), and casadi::PluginInterface< Conic >::registerPlugin().

casadi_load_dple_slicot()

void CASADI_DPLE_SLICOT_EXPORT casadi::casadi_load_dple_slicot

(

)

Definition at line 52 of file slicot_dple.cpp.

                                                           {
    Dple::registerPlugin(casadi_register_dple_slicot);
  }

References casadi_register_dple_slicot(), and casadi::PluginInterface< Dple >::registerPlugin().

casadi_load_expm_slicot()

void CASADI_EXPM_SLICOT_EXPORT casadi::casadi_load_expm_slicot

(

)

Definition at line 52 of file slicot_expm.cpp.

                                                           {
    Expm::registerPlugin(casadi_register_expm_slicot);
  }

References casadi_register_expm_slicot(), and casadi::PluginInterface< Expm >::registerPlugin().

casadi_load_filesystem_ghc()

void CASADI_FILESYSTEM_GHC_EXPORT casadi::casadi_load_filesystem_ghc

(

)

Definition at line 90 of file ghc.cpp.

                                                                   {
        Filesystem::registerPlugin(casadi_register_filesystem_ghc);
    }

References casadi_register_filesystem_ghc(), and casadi::PluginInterface< Filesystem >::registerPlugin().

casadi_load_graphmodel_onnx()

void CASADI_GRAPHMODEL_ONNX_EXPORT casadi::casadi_load_graphmodel_onnx

(

)

Definition at line 45 of file onnx_model.cpp.

                                                                   {
    GraphModelInternal::registerPlugin(casadi_register_graphmodel_onnx);
  }

References casadi_register_graphmodel_onnx(), and casadi::PluginInterface< GraphModelInternal >::registerPlugin().

casadi_load_importer_clang()

void CASADI_IMPORTER_CLANG_EXPORT casadi::casadi_load_importer_clang

(

)

Definition at line 56 of file clang_compiler.cpp.

                                                                 {
    ImporterInternal::registerPlugin(casadi_register_importer_clang);
  }

References casadi_register_importer_clang(), and casadi::PluginInterface< ImporterInternal >::registerPlugin().

casadi_load_importer_shell()

void CASADI_IMPORTER_SHELL_EXPORT casadi::casadi_load_importer_shell

(

)

Definition at line 53 of file shell_compiler.cpp.

                                                                 {
    ImporterInternal::registerPlugin(casadi_register_importer_shell);
  }

References casadi_register_importer_shell(), and casadi::PluginInterface< ImporterInternal >::registerPlugin().

casadi_load_integrator_collocation()

void CASADI_INTEGRATOR_COLLOCATION_EXPORT casadi::casadi_load_integrator_collocation

(

)

Definition at line 45 of file collocation.cpp.

                                                                                 {
    Integrator::registerPlugin(casadi_register_integrator_collocation);
  }

References casadi_register_integrator_collocation(), and casadi::PluginInterface< Integrator >::registerPlugin().

casadi_load_integrator_cvodes()

void CASADI_INTEGRATOR_CVODES_EXPORT casadi::casadi_load_integrator_cvodes

(

)

Definition at line 47 of file cvodes_interface.cpp.

                                                                     {
  Integrator::registerPlugin(casadi_register_integrator_cvodes);
}

References casadi_register_integrator_cvodes(), and casadi::PluginInterface< Integrator >::registerPlugin().

casadi_load_integrator_idas()

void CASADI_INTEGRATOR_IDAS_EXPORT casadi::casadi_load_integrator_idas

(

)

Definition at line 48 of file idas_interface.cpp.

                                                                 {
  Integrator::registerPlugin(casadi_register_integrator_idas);
}

References casadi_register_integrator_idas(), and casadi::PluginInterface< Integrator >::registerPlugin().

casadi_load_integrator_rk()

void CASADI_INTEGRATOR_RK_EXPORT casadi::casadi_load_integrator_rk

(

)

Definition at line 43 of file runge_kutta.cpp.

                                                               {
    Integrator::registerPlugin(casadi_register_integrator_rk);
  }

References casadi_register_integrator_rk(), and casadi::PluginInterface< Integrator >::registerPlugin().

casadi_load_interpolant_bspline()

void CASADI_INTERPOLANT_BSPLINE_EXPORT casadi::casadi_load_interpolant_bspline

(

)

Definition at line 45 of file bspline_interpolant.cpp.

                                                                           {
    Interpolant::registerPlugin(casadi_register_interpolant_bspline);
  }

References casadi_register_interpolant_bspline(), and casadi::PluginInterface< Interpolant >::registerPlugin().

casadi_load_interpolant_linear()

void CASADI_INTERPOLANT_LINEAR_EXPORT casadi::casadi_load_interpolant_linear

(

)

Definition at line 44 of file linear_interpolant.cpp.

                                                                         {
    Interpolant::registerPlugin(casadi_register_interpolant_linear);
  }

References casadi_register_interpolant_linear(), and casadi::PluginInterface< Interpolant >::registerPlugin().

casadi_load_linsol_csparse()

void CASADI_LINSOL_CSPARSE_EXPORT casadi::casadi_load_linsol_csparse

(

)

Definition at line 45 of file csparse_interface.cpp.

                                                                 {
    LinsolInternal::registerPlugin(casadi_register_linsol_csparse);
  }

References casadi_register_linsol_csparse(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_lapacklu()

void CASADI_LINSOL_LAPACKLU_EXPORT casadi::casadi_load_linsol_lapacklu

(

)

Definition at line 44 of file lapack_lu.cpp.

                                                                   {
    LinsolInternal::registerPlugin(casadi_register_linsol_lapacklu);
  }

References casadi_register_linsol_lapacklu(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_lapackqr()

void CASADI_LINSOL_LAPACKQR_EXPORT casadi::casadi_load_linsol_lapackqr

(

)

Definition at line 44 of file lapack_qr.cpp.

                                                                   {
    LinsolInternal::registerPlugin(casadi_register_linsol_lapackqr);
  }

References casadi_register_linsol_lapackqr(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_ldl()

void CASADI_LINSOL_LDL_EXPORT casadi::casadi_load_linsol_ldl

(

)

Definition at line 44 of file linsol_ldl.cpp.

                                                         {
    LinsolInternal::registerPlugin(casadi_register_linsol_ldl);
  }

References casadi_register_linsol_ldl(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_lsqr()

void CASADI_LINSOL_LSQR_EXPORT casadi::casadi_load_linsol_lsqr

(

)

Definition at line 47 of file lsqr.cpp.

                                                           {
    LinsolInternal::registerPlugin(casadi_register_linsol_lsqr);
  }

References casadi_register_linsol_lsqr(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_ma27()

void CASADI_LINSOL_MA27_EXPORT casadi::casadi_load_linsol_ma27

(

)

Definition at line 45 of file ma27_interface.cpp.

                                                           {
    LinsolInternal::registerPlugin(casadi_register_linsol_ma27);
  }

References casadi_register_linsol_ma27(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_mumps()

void CASADI_LINSOL_MUMPS_EXPORT casadi::casadi_load_linsol_mumps

(

)

Definition at line 45 of file mumps_interface.cpp.

                                                             {
    LinsolInternal::registerPlugin(casadi_register_linsol_mumps);
  }

References casadi_register_linsol_mumps(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_qr()

void CASADI_LINSOL_QR_EXPORT casadi::casadi_load_linsol_qr

(

)

Definition at line 44 of file linsol_qr.cpp.

                                                       {
    LinsolInternal::registerPlugin(casadi_register_linsol_qr);
  }

References casadi_register_linsol_qr(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_symbolicqr()

void CASADI_LINSOL_SYMBOLICQR_EXPORT casadi::casadi_load_linsol_symbolicqr

(

)

Definition at line 100 of file symbolic_qr.cpp.

                                                                       {
    LinsolInternal::registerPlugin(casadi_register_linsol_symbolicqr);
  }

References casadi_register_linsol_symbolicqr(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_linsol_tridiag()

void CASADI_LINSOL_TRIDIAG_EXPORT casadi::casadi_load_linsol_tridiag

(

)

Definition at line 44 of file linsol_tridiag.cpp.

                                                                 {
    LinsolInternal::registerPlugin(casadi_register_linsol_tridiag);
  }

References casadi_register_linsol_tridiag(), and casadi::PluginInterface< LinsolInternal >::registerPlugin().

casadi_load_modelicaparser_lacemodelica()

void CASADI_MODELICAPARSER_LACEMODELICA_EXPORT casadi::casadi_load_modelicaparser_lacemodelica

(

)

Definition at line 42 of file lace_modelica.cpp.

                                                                                         {
  ModelicaParserInternal::registerPlugin(casadi_register_modelicaparser_lacemodelica);
}

References casadi_register_modelicaparser_lacemodelica(), and casadi::PluginInterface< ModelicaParserInternal >::registerPlugin().

casadi_load_nlpsol_alpaqa()

void CASADI_NLPSOL_ALPAQA_EXPORT casadi::casadi_load_nlpsol_alpaqa

(

)

Definition at line 45 of file alpaqa_interface.cpp.

                                                               {
    Nlpsol::registerPlugin(casadi_register_nlpsol_alpaqa);
  }

References casadi_register_nlpsol_alpaqa(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_ampl()

void CASADI_NLPSOL_AMPL_EXPORT casadi::casadi_load_nlpsol_ampl

(

)

Definition at line 46 of file ampl_interface.cpp.

                                                           {
    Nlpsol::registerPlugin(casadi_register_nlpsol_ampl);
  }

References casadi_register_nlpsol_ampl(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_blocksqp()

void CASADI_NLPSOL_BLOCKSQP_EXPORT casadi::casadi_load_nlpsol_blocksqp

(

)

Definition at line 45 of file blocksqp.cpp.

                                                                   {
    Nlpsol::registerPlugin(casadi_register_nlpsol_blocksqp);
  }

References casadi_register_nlpsol_blocksqp(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_bonmin()

void CASADI_NLPSOL_BONMIN_EXPORT casadi::casadi_load_nlpsol_bonmin

(

)

Definition at line 53 of file bonmin_interface.cpp.

                                                               {
    Nlpsol::registerPlugin(casadi_register_nlpsol_bonmin);
  }

References casadi_register_nlpsol_bonmin(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_ccopt()

void CASADI_NLPSOL_CCOPT_EXPORT casadi::casadi_load_nlpsol_ccopt

(

)

Definition at line 57 of file ccopt_interface.cpp.

                                                           {
  Nlpsol::registerPlugin(casadi_register_nlpsol_ccopt);
}

References casadi_register_nlpsol_ccopt(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_fatrop()

void CASADI_NLPSOL_FATROP_EXPORT casadi::casadi_load_nlpsol_fatrop

(

)

Definition at line 64 of file fatrop_interface.cpp.

                                                               {
    Nlpsol::registerPlugin(casadi_register_nlpsol_fatrop);
  }

References casadi_register_nlpsol_fatrop(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_feasiblesqpmethod()

void CASADI_NLPSOL_FEASIBLESQPMETHOD_EXPORT casadi::casadi_load_nlpsol_feasiblesqpmethod

(

)

Definition at line 57 of file feasiblesqpmethod.cpp.

                                                                                     {
    Nlpsol::registerPlugin(casadi_register_nlpsol_feasiblesqpmethod);
  }

References casadi_register_nlpsol_feasiblesqpmethod(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_ipopt()

void CASADI_NLPSOL_IPOPT_EXPORT casadi::casadi_load_nlpsol_ipopt

(

)

Definition at line 58 of file ipopt_interface.cpp.

                                                             {
    Nlpsol::registerPlugin(casadi_register_nlpsol_ipopt);
  }

References casadi_register_nlpsol_ipopt(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_knitro()

void CASADI_NLPSOL_KNITRO_EXPORT casadi::casadi_load_nlpsol_knitro

(

)

Definition at line 55 of file knitro_interface.cpp.

                                                               {
    Nlpsol::registerPlugin(casadi_register_nlpsol_knitro);
  }

References casadi_register_nlpsol_knitro(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_madnlp()

void CASADI_NLPSOL_MADNLP_EXPORT casadi::casadi_load_nlpsol_madnlp

(

)

Definition at line 57 of file madnlp_interface.cpp.

                                                             {
  Nlpsol::registerPlugin(casadi_register_nlpsol_madnlp);
}

References casadi_register_nlpsol_madnlp(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_qrsqp()

void CASADI_NLPSOL_QRSQP_EXPORT casadi::casadi_load_nlpsol_qrsqp

(

)

Definition at line 52 of file qrsqp.cpp.

                                                             {
    Nlpsol::registerPlugin(casadi_register_nlpsol_qrsqp);
  }

References casadi_register_nlpsol_qrsqp(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_scpgen()

void CASADI_NLPSOL_SCPGEN_EXPORT casadi::casadi_load_nlpsol_scpgen

(

)

Definition at line 49 of file scpgen.cpp.

                                                               {
    Nlpsol::registerPlugin(casadi_register_nlpsol_scpgen);
  }

References casadi_register_nlpsol_scpgen(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_sleqp()

void CASADI_NLPSOL_SLEQP_EXPORT casadi::casadi_load_nlpsol_sleqp

(

)

Definition at line 84 of file sleqp_interface.cpp.

                                                             {
    Nlpsol::registerPlugin(casadi_register_nlpsol_sleqp);
  }

References casadi_register_nlpsol_sleqp(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_snopt()

void CASADI_NLPSOL_SNOPT_EXPORT casadi::casadi_load_nlpsol_snopt

(

)

Definition at line 51 of file snopt_interface.cpp.

                                                             {
    Nlpsol::registerPlugin(casadi_register_nlpsol_snopt);
  }

References casadi_register_nlpsol_snopt(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_sqpmethod()

void CASADI_NLPSOL_SQPMETHOD_EXPORT casadi::casadi_load_nlpsol_sqpmethod

(

)

Definition at line 54 of file sqpmethod.cpp.

                                                                   {
  Nlpsol::registerPlugin(casadi_register_nlpsol_sqpmethod);
}

References casadi_register_nlpsol_sqpmethod(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_uno()

void CASADI_NLPSOL_UNO_EXPORT casadi::casadi_load_nlpsol_uno

(

)

Definition at line 50 of file uno_interface.cpp.

                                                         {
    Nlpsol::registerPlugin(casadi_register_nlpsol_uno);
  }

References casadi_register_nlpsol_uno(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_nlpsol_worhp()

void CASADI_NLPSOL_WORHP_EXPORT casadi::casadi_load_nlpsol_worhp

(

)

Definition at line 47 of file worhp_interface.cpp.

                                                             {
    Nlpsol::registerPlugin(casadi_register_nlpsol_worhp);
  }

References casadi_register_nlpsol_worhp(), and casadi::PluginInterface< Nlpsol >::registerPlugin().

casadi_load_onnx_ort()

void CASADI_ONNX_ORT_EXPORT casadi::casadi_load_onnx_ort

(

)

Definition at line 42 of file ort_interface.cpp.

                                                     {
    OnnxFunction::registerPlugin(casadi_register_onnx_ort);
  }

References casadi_register_onnx_ort(), and casadi::PluginInterface< OnnxFunction >::registerPlugin().

casadi_load_rootfinder_fast_newton()

void CASADI_ROOTFINDER_FAST_NEWTON_EXPORT casadi::casadi_load_rootfinder_fast_newton

(

)

Definition at line 45 of file fast_newton.cpp.

                                                                                 {
    Rootfinder::registerPlugin(casadi_register_rootfinder_fast_newton);
  }

References casadi_register_rootfinder_fast_newton(), and casadi::PluginInterface< Rootfinder >::registerPlugin().

casadi_load_rootfinder_kinsol()

void CASADI_ROOTFINDER_KINSOL_EXPORT casadi::casadi_load_rootfinder_kinsol

(

)

Definition at line 42 of file kinsol_interface.cpp.

                                                                       {
    Rootfinder::registerPlugin(casadi_register_rootfinder_kinsol);
  }

References casadi_register_rootfinder_kinsol(), and casadi::PluginInterface< Rootfinder >::registerPlugin().

casadi_load_rootfinder_newton()

void CASADI_ROOTFINDER_NEWTON_EXPORT casadi::casadi_load_rootfinder_newton

(

)

Definition at line 44 of file newton.cpp.

                                                                       {
    Rootfinder::registerPlugin(casadi_register_rootfinder_newton);
  }

References casadi_register_rootfinder_newton(), and casadi::PluginInterface< Rootfinder >::registerPlugin().

casadi_load_rootfinder_nlpsol()

void CASADI_ROOTFINDER_NLPSOL_EXPORT casadi::casadi_load_rootfinder_nlpsol

(

)

Definition at line 44 of file implicit_to_nlp.cpp.

                                                                       {
    Rootfinder::registerPlugin(casadi_register_rootfinder_nlpsol);
  }

References casadi_register_rootfinder_nlpsol(), and casadi::PluginInterface< Rootfinder >::registerPlugin().

casadi_load_xmlfile_tinyxml()

void CASADI_XMLFILE_TINYXML_EXPORT casadi::casadi_load_xmlfile_tinyxml

(

)

Definition at line 41 of file tinyxml_interface.cpp.

                                                                 {
  XmlFileInternal::registerPlugin(casadi_register_xmlfile_tinyxml);
}

References casadi_register_xmlfile_tinyxml(), and casadi::PluginInterface< XmlFileInternal >::registerPlugin().

casadi_log_output()

static void casadi::casadi_log_output ( SLEQP_LOG_LEVEL  level, time_t  time, const char *  message  )

static

Definition at line 51 of file sleqp_interface.cpp.

  {
    switch(level)
    {
    case SLEQP_LOG_WARN:
      casadi_warning(message);
      break;
    case SLEQP_LOG_ERROR:
      casadi_error(message);
      break;
    default:
      uout() << "[" << log_level_name(level) << "] " << message << std::endl;
    }
  }

References log_level_name(), and uout().

Referenced by casadi_register_nlpsol_sleqp().

casadi_logsumexp()

template<typename T1 >

T1 casadi::casadi_logsumexp	(	const T1 *	x,
		casadi_int	n
	)

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

casadi_low()

template<typename T1 >

casadi_int casadi::casadi_low	(	T1	x,
		const T1 *	grid,
		casadi_int	ng,
		casadi_int	lookup_mode
	)

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

casadi_max()

casadi_int casadi::casadi_max ( casadi_int  x, casadi_int  y  )

inline

CasADi additions

Definition at line 291 of file calculus.hpp.

{ return std::max(x, y);}

casadi_max_viol()

template<typename T1 >

T1 casadi::casadi_max_viol	(	casadi_int	n,
		const T1 *	x,
		const T1 *	lb,
		const T1 *	ub
	)

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

casadi_min()

casadi_int casadi::casadi_min ( casadi_int  x, casadi_int  y  )

inline

CasADi additions

Definition at line 292 of file calculus.hpp.

{ return std::min(x, y);}

casadi_mmax()

template<typename T1 >

T1 casadi::casadi_mmax	(	const T1 *	x,
		casadi_int	n,
		T1	is_dense
	)

Referenced by casadi::MMax::eval(), and casadi::MMax::eval_sx().

casadi_mmin()

template<typename T1 >

T1 casadi::casadi_mmin	(	const T1 *	x,
		casadi_int	n,
		casadi_int	is_dense
	)

Referenced by casadi::MMin::eval(), and casadi::MMin::eval_sx().

casadi_mtimes()

template<typename T1 >

void casadi::casadi_mtimes	(	const T1 *	x,
		const casadi_int *	sp_x,
		const T1 *	y,
		const casadi_int *	sp_y,
		T1 *	z,
		const casadi_int *	sp_z,
		T1 *	w,
		casadi_int	tr
	)

Referenced by casadi::Multiplication::eval_kernel(), and casadi::Scpgen::eval_mat().

casadi_mtimes_dense()

template<typename T1 >

void casadi::casadi_mtimes_dense	(	const T1 *	x,
		casadi_int	nrow_x,
		casadi_int	ncol_x,
		const T1 *	y,
		casadi_int	ncol_y,
		T1 *	z,
		casadi_int	tr
	)

Referenced by casadi::DenseMultiplication::eval_kernel(), and casadi::PseudoDenseMultiplication::eval_kernel().

casadi_mtimes_dense_sparse()

template<typename T1 >

void casadi::casadi_mtimes_dense_sparse	(	const T1 *	x,
		casadi_int	nrow_x,
		const T1 *	y,
		const casadi_int *	sp_y,
		T1 *	z
	)

Referenced by casadi::DenseSparseMultiplication::eval_kernel().

casadi_mv()

template<typename T1 >

void casadi::casadi_mv	(	const T1 *	x,
		const casadi_int *	sp_x,
		const T1 *	y,
		T1 *	z,
		casadi_int	tr
	)

Referenced by casadi::Scpgen::eval_mat(), casadi::Feasiblesqpmethod::feasibility_iterations(), casadi::Ipqp::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_elastic_mode(), and casadi::Blocksqp::solveQP().

casadi_nd_boor_eval()

template<typename T1 >

void casadi::casadi_nd_boor_eval	(	T1 *	ret,
		casadi_int	n_dims,
		const T1 *	knots,
		const casadi_int *	offset,
		const casadi_int *	degree,
		const casadi_int *	strides,
		const T1 *	c,
		casadi_int	m,
		const T1 *	x,
		const casadi_int *	lookup_mode,
		casadi_int *	iw,
		T1 *	w
	)

Referenced by casadi::BSpline::eval(), and casadi::BSplineParametric::eval().

casadi_newton()

template<typename T1 >

int casadi::casadi_newton

(

const casadi_newton_mem< T1 > *

m

)

Referenced by casadi::FastNewton::solve().

casadi_norm_1()

template<typename T1 >

T1 casadi::casadi_norm_1	(	casadi_int	n,
		const T1 *	x
	)

Referenced by casadi::Scpgen::dualInfeasibility(), casadi::Norm1::eval_gen(), casadi::Scpgen::line_search(), casadi::Scpgen::primalInfeasibility(), and casadi::Blocksqp::printProgress().

casadi_norm_2()

template<typename T1 >

T1 casadi::casadi_norm_2	(	casadi_int	n,
		const T1 *	x
	)

Referenced by casadi::Blocksqp::calcSR1(), casadi::NormF::eval_gen(), and casadi::Feasiblesqpmethod::feasibility_iterations().

casadi_norm_inf()

template<typename T1 >

T1 casadi::casadi_norm_inf	(	casadi_int	n,
		const T1 *	x
	)

Inf-norm of a vector * Returns the largest element in absolute value

Referenced by casadi::Sqpmethod::calc_gamma_1(), casadi::Blocksqp::calcOptTol(), casadi::NormInf::eval_gen(), casadi::Blocksqp::kktErrorReduction(), casadi::Blocksqp::printProgress(), casadi::Feasiblesqpmethod::solve(), casadi::Newton::solve(), casadi::Qrsqp::solve(), casadi::Sqpmethod::solve(), and casadi::Scpgen::solve_qp().

casadi_norm_inf_mul()

template<typename T1 >

T1 casadi::casadi_norm_inf_mul	(	const T1 *	x,
		const casadi_int *	sp_x,
		const T1 *	y,
		const casadi_int *	sp_y,
		T1 *	dwork,
		casadi_int *	iwork
	)

Inf-norm of a Matrix-matrix product,*

Parameters

dwork	A real work vector that you must allocate Minimum size: y.size1()
iwork	A integer work vector that you must allocate Minimum size: y.size1()+x.size2()+1

casadi_polyval()

template<typename T1 >

T1 casadi::casadi_polyval	(	const T1 *	p,
		casadi_int	n,
		T1	x
	)

casadi_project()

template<typename T1 >

void casadi::casadi_project	(	const T1 *	x,
		const casadi_int *	sp_x,
		T1 *	y,
		const casadi_int *	sp_y,
		T1 *	w
	)

Referenced by _which_depends(), casadi::Switch::eval(), casadi::Project::eval_gen(), casadi::SXFunction::eval_mx(), casadi::Switch::eval_sx(), casadi::HpmpcInterface::mproject(), casadi::CvodesInterface::psetupF(), and casadi::HpmpcInterface::solve().

casadi_rank1()

template<typename T1 >

void casadi::casadi_rank1	(	T1 *	A,
		const casadi_int *	sp_A,
		T1	alpha,
		const T1 *	x
	)

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

casadi_register_archiver_libzip()

int CASADI_ARCHIVER_LIBZIP_EXPORT casadi::casadi_register_archiver_libzip

(

Archiver::Plugin *

plugin

)

Definition at line 369 of file libzip.cpp.

                                                           {
     plugin->name = "libzip";
     plugin->doc = Libzip::meta_doc.c_str();
     plugin->version = CASADI_VERSION;
     plugin->exposed.unpack = &extract_zip_from_path;
     plugin->exposed.unpack_from_stringstream = &extract_zip_from_stringstream;
     plugin->exposed.pack = &zip_to_path;
     plugin->exposed.pack_to_stream = &zip_to_stream;
     plugin->exposed.pack_entries = &zip_entries_to_path;
     return 0;
   }

References extract_zip_from_path(), extract_zip_from_stringstream(), casadi::Libzip::meta_doc, zip_entries_to_path(), zip_to_path(), and zip_to_stream().

Referenced by casadi_load_archiver_libzip().

casadi_register_blas_blasfeo()

int CASADI_BLAS_BLASFEO_EXPORT casadi::casadi_register_blas_blasfeo

(

Blas::Plugin *

plugin

)

Definition at line 148 of file blas_blasfeo.cpp.

                                                   {
    plugin->name = "blasfeo";
    plugin->doc = BlasBlasfeo::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->exposed.dgemm = &blasfeo_dgemm;
    plugin->exposed.codegen_mtimes = &blasfeo_codegen_mtimes;
    plugin->exposed.daxpy = &blasfeo_daxpy;
    plugin->exposed.ddot  = &blasfeo_ddot;
    plugin->exposed.dscal = nullptr;
    plugin->exposed.dnrm2 = nullptr;
    plugin->exposed.dasum = nullptr;
    plugin->exposed.dcopy = nullptr;
    plugin->exposed.codegen_axpy_aux = &blasfeo_codegen_axpy_aux;
    plugin->exposed.codegen_dot_aux  = &blasfeo_codegen_dot_aux;
    plugin->exposed.codegen_scal_aux = nullptr;
    plugin->exposed.codegen_nrm2_aux = nullptr;
    plugin->exposed.codegen_asum_aux = nullptr;
    plugin->options = nullptr;
    plugin->deserialize = nullptr;
    plugin->creator = nullptr;
    return 0;
  }

References blasfeo_codegen_axpy_aux(), blasfeo_codegen_dot_aux(), blasfeo_codegen_mtimes(), blasfeo_daxpy(), blasfeo_ddot(), blasfeo_dgemm(), and casadi::BlasBlasfeo::meta_doc.

Referenced by casadi_load_blas_blasfeo().

casadi_register_blas_classic()

int CASADI_BLAS_CLASSIC_EXPORT casadi::casadi_register_blas_classic

(

Blas::Plugin *

plugin

)

Definition at line 234 of file blas_classic.cpp.

                                                   {
    plugin->name = "classic";
    plugin->doc = BlasClassic::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->exposed.dgemm = &classic_dgemm;
    plugin->exposed.codegen_mtimes = &classic_codegen_mtimes;
    plugin->exposed.daxpy = &classic_daxpy;
    plugin->exposed.ddot  = &classic_ddot;
    plugin->exposed.dscal = &classic_dscal;
    plugin->exposed.dnrm2 = &classic_dnrm2;
    plugin->exposed.dasum = &classic_dasum;
    plugin->exposed.dcopy = &classic_dcopy;
    plugin->exposed.codegen_axpy_aux = &classic_codegen_axpy_aux;
    plugin->exposed.codegen_dot_aux  = &classic_codegen_dot_aux;
    plugin->exposed.codegen_scal_aux = &classic_codegen_scal_aux;
    plugin->exposed.codegen_nrm2_aux = &classic_codegen_nrm2_aux;
    plugin->exposed.codegen_asum_aux = &classic_codegen_asum_aux;
    plugin->options = nullptr;
    plugin->deserialize = nullptr;
    plugin->creator = nullptr;
    return 0;
  }

References classic_codegen_asum_aux(), classic_codegen_axpy_aux(), classic_codegen_dot_aux(), classic_codegen_mtimes(), classic_codegen_nrm2_aux(), classic_codegen_scal_aux(), classic_dasum(), classic_daxpy(), classic_dcopy(), classic_ddot(), classic_dgemm(), classic_dnrm2(), classic_dscal(), and casadi::BlasClassic::meta_doc.

Referenced by casadi_load_blas_classic().

casadi_register_conic_cbc()

int CASADI_CONIC_CBC_EXPORT casadi::casadi_register_conic_cbc

(

Conic::Plugin *

plugin

)

Definition at line 34 of file cbc_interface.cpp.

                                                 {
    plugin->creator = CbcInterface::creator;
    plugin->name = "cbc";
    plugin->doc = CbcInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &CbcInterface::options_;
    plugin->deserialize = &CbcInterface::deserialize;
    return 0;
  }

References casadi::CbcInterface::creator(), casadi::CbcInterface::deserialize(), casadi::CbcInterface::meta_doc, and casadi::CbcInterface::options_.

Referenced by casadi_load_conic_cbc().

casadi_register_conic_clarabel()

int CASADI_CONIC_CLARABEL_EXPORT casadi::casadi_register_conic_clarabel

(

Conic::Plugin *

plugin

)

Definition at line 34 of file clarabel_interface.cpp.

                                                    {
  plugin->creator = ClarabelInterface::creator;
  plugin->name = "clarabel";
  plugin->doc = ClarabelInterface::meta_doc.c_str();
  plugin->version = CASADI_VERSION;
  plugin->options = &ClarabelInterface::options_;
  plugin->deserialize = &ClarabelInterface::deserialize;
  return 0;
}

References casadi::ClarabelInterface::creator(), casadi::ClarabelInterface::deserialize(), casadi::ClarabelInterface::meta_doc, and casadi::ClarabelInterface::options_.

Referenced by casadi_load_conic_clarabel().

casadi_register_conic_clp()

int CASADI_CONIC_CLP_EXPORT casadi::casadi_register_conic_clp

(

Conic::Plugin *

plugin

)

Definition at line 31 of file clp_interface.cpp.

                                                 {
    plugin->creator = ClpInterface::creator;
    plugin->name = "clp";
    plugin->doc = ClpInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &ClpInterface::options_;
    plugin->deserialize = &ClpInterface::deserialize;
    return 0;
  }

References casadi::ClpInterface::creator(), casadi::ClpInterface::deserialize(), casadi::ClpInterface::meta_doc, and casadi::ClpInterface::options_.

Referenced by casadi_load_conic_clp().

casadi_register_conic_cplex()

int CASADI_CONIC_CPLEX_EXPORT casadi::casadi_register_conic_cplex

(

Conic::Plugin *

plugin

)

Definition at line 37 of file cplex_interface.cpp.

                                                   {
    plugin->creator = CplexInterface::creator;
    plugin->name = "cplex";
    plugin->doc = CplexInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &CplexInterface::options_;
    plugin->deserialize = &CplexInterface::deserialize;
    #ifdef CPLEX_ADAPTOR
      char buffer[400];
      int ret = cplex_adaptor_load(buffer, sizeof(buffer));
      if (ret!=0) {
        casadi_warning("Failed to load CPLEX adaptor: " + std::string(buffer) + ".");
        return 1;
      }
    #endif
    return 0;
  }

References casadi::CplexInterface::creator(), casadi::CplexInterface::deserialize(), casadi::CplexInterface::meta_doc, and casadi::CplexInterface::options_.

Referenced by casadi_load_conic_cplex().

casadi_register_conic_daqp()

int CASADI_CONIC_DAQP_EXPORT casadi::casadi_register_conic_daqp

(

Conic::Plugin *

plugin

)

Definition at line 33 of file daqp_interface.cpp.

                                                  {
    plugin->creator = DaqpInterface::creator;
    plugin->name = "daqp";
    plugin->doc = DaqpInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &DaqpInterface::options_;
    plugin->deserialize = &DaqpInterface::deserialize;
    return 0;
  }

References casadi::DaqpInterface::creator(), casadi::DaqpInterface::deserialize(), casadi::DaqpInterface::meta_doc, and casadi::DaqpInterface::options_.

Referenced by casadi_load_conic_daqp().

casadi_register_conic_fatrop()

int CASADI_CONIC_FATROP_EXPORT casadi::casadi_register_conic_fatrop

(

Conic::Plugin *

plugin

)

Definition at line 36 of file fatrop_conic_interface.cpp.

                                                    {
    plugin->creator = FatropConicInterface::creator;
    plugin->name = "fatrop";
    plugin->doc = FatropConicInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &FatropConicInterface::options_;
    return 0;
  }

References casadi::FatropConicInterface::creator(), casadi::FatropConicInterface::meta_doc, and casadi::FatropConicInterface::options_.

Referenced by casadi_load_conic_fatrop().

casadi_register_conic_gurobi()

int CASADI_CONIC_GUROBI_EXPORT casadi::casadi_register_conic_gurobi

(

Conic::Plugin *

plugin

)

Definition at line 107 of file gurobi_interface.cpp.

                                                    {
    plugin->creator = GurobiInterface::creator;
    plugin->name = "gurobi";
    plugin->doc = GurobiInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &GurobiInterface::options_;
    plugin->deserialize = &GurobiInterface::deserialize;
    #ifdef GUROBI_ADAPTOR
      char buffer[400];
      int ret = gurobi_adaptor_load(buffer, sizeof(buffer));
      if (ret!=0) {
        casadi_warning("Failed to load Gurobi adaptor: " + std::string(buffer) + ".");
        return 1;
      }
    #endif
    return 0;
  }

References casadi::GurobiInterface::creator(), casadi::GurobiInterface::deserialize(), casadi::GurobiInterface::meta_doc, and casadi::GurobiInterface::options_.

Referenced by casadi_load_conic_gurobi().

casadi_register_conic_highs()

int CASADI_CONIC_HIGHS_EXPORT casadi::casadi_register_conic_highs

(

Conic::Plugin *

plugin

)

Definition at line 33 of file highs_interface.cpp.

                                                   {
    plugin->creator = HighsInterface::creator;
    plugin->name = "highs";
    plugin->doc = HighsInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &HighsInterface::options_;
    plugin->deserialize = &HighsInterface::deserialize;
    return 0;
  }

References casadi::HighsInterface::creator(), casadi::HighsInterface::deserialize(), casadi::HighsInterface::meta_doc, and casadi::HighsInterface::options_.

Referenced by casadi_load_conic_highs().

casadi_register_conic_hpipm()

int CASADI_CONIC_HPIPM_EXPORT casadi::casadi_register_conic_hpipm

(

Conic::Plugin *

plugin

)

Definition at line 35 of file hpipm_interface.cpp.

                                                   {
    plugin->creator = HpipmInterface::creator;
    plugin->name = "hpipm";
    plugin->doc = HpipmInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &HpipmInterface::options_;
    return 0;
  }

References casadi::HpipmInterface::creator(), casadi::HpipmInterface::meta_doc, and casadi::HpipmInterface::options_.

Referenced by casadi_load_conic_hpipm().

casadi_register_conic_hpmpc()

int CASADI_CONIC_HPMPC_EXPORT casadi::casadi_register_conic_hpmpc

(

Conic::Plugin *

plugin

)

Definition at line 32 of file hpmpc_interface.cpp.

                                                   {
    plugin->creator = HpmpcInterface::creator;
    plugin->name = "hpmpc";
    plugin->doc = HpmpcInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &HpmpcInterface::options_;
    return 0;
  }

References casadi::HpmpcInterface::creator(), casadi::HpmpcInterface::meta_doc, and casadi::HpmpcInterface::options_.

Referenced by casadi_load_conic_hpmpc().

casadi_register_conic_ipqp()

int CASADI_CONIC_IPQP_EXPORT casadi::casadi_register_conic_ipqp

(

Conic::Plugin *

plugin

)

Definition at line 33 of file ipqp.cpp.

                                                  {
    plugin->creator = Ipqp::creator;
    plugin->name = "ipqp";
    plugin->doc = Ipqp::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Ipqp::options_;
    plugin->deserialize = &Ipqp::deserialize;
    return 0;
  }

References casadi::Ipqp::creator(), casadi::Ipqp::deserialize(), casadi::Ipqp::meta_doc, and casadi::Ipqp::options_.

Referenced by casadi_load_conic_ipqp().

casadi_register_conic_mosek()

int CASADI_CONIC_MOSEK_EXPORT casadi::casadi_register_conic_mosek

(

Conic::Plugin *

plugin

)

Definition at line 38 of file mosek_interface.cpp.

                                                   {
    plugin->creator = MosekInterface::creator;
    plugin->name = "mosek";
    plugin->doc = MosekInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &MosekInterface::options_;
    plugin->deserialize = &MosekInterface::deserialize;
    #ifdef MOSEK_ADAPTOR
      char buffer[400];
      int ret = mosek_adaptor_load(buffer, sizeof(buffer));
      if (ret!=0) {
        casadi_warning("Failed to load Mosek adaptor: " + std::string(buffer) + ".");
        return 1;
      }
    #endif
    return 0;
  }

References casadi::MosekInterface::creator(), casadi::MosekInterface::deserialize(), casadi::MosekInterface::meta_doc, and casadi::MosekInterface::options_.

Referenced by casadi_load_conic_mosek().

casadi_register_conic_nlpsol()

int CASADI_CONIC_NLPSOL_EXPORT casadi::casadi_register_conic_nlpsol

(

Conic::Plugin *

plugin

)

Definition at line 34 of file qp_to_nlp.cpp.

                                                    {
    plugin->creator = QpToNlp::creator;
    plugin->name = "nlpsol";
    plugin->doc = QpToNlp::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &QpToNlp::options_;
    plugin->deserialize = &QpToNlp::deserialize;
    return 0;
  }

References casadi::QpToNlp::creator(), casadi::QpToNlp::deserialize(), casadi::QpToNlp::meta_doc, and casadi::QpToNlp::options_.

Referenced by casadi_load_conic_nlpsol().

casadi_register_conic_ooqp()

int CASADI_CONIC_OOQP_EXPORT casadi::casadi_register_conic_ooqp

(

Conic::Plugin *

plugin

)

Definition at line 42 of file ooqp_interface.cpp.

                                                  {
    plugin->creator = OoqpInterface::creator;
    plugin->name = "ooqp";
    plugin->doc = OoqpInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &OoqpInterface::options_;
    plugin->deserialize = &OoqpInterface::deserialize;
    return 0;
  }

References casadi::OoqpInterface::creator(), casadi::OoqpInterface::deserialize(), casadi::OoqpInterface::meta_doc, and casadi::OoqpInterface::options_.

Referenced by casadi_load_conic_ooqp().

casadi_register_conic_osqp()

int CASADI_CONIC_OSQP_EXPORT casadi::casadi_register_conic_osqp

(

Conic::Plugin *

plugin

)

Definition at line 50 of file osqp_interface.cpp.

                                                  {
    plugin->creator = OsqpInterface::creator;
    plugin->name = "osqp";
    plugin->doc = OsqpInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &OsqpInterface::options_;
    plugin->deserialize = &OsqpInterface::deserialize;
    return 0;
  }

References casadi::OsqpInterface::creator(), casadi::OsqpInterface::deserialize(), casadi::OsqpInterface::meta_doc, and casadi::OsqpInterface::options_.

Referenced by casadi_load_conic_osqp().

casadi_register_conic_piqp()

int CASADI_CONIC_PIQP_EXPORT casadi::casadi_register_conic_piqp

(

Conic::Plugin *

plugin

)

Definition at line 35 of file piqp_interface.cpp.

                                                  {
    plugin->creator = PiqpInterface::creator;
    plugin->name = "piqp";
    plugin->doc = PiqpInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &PiqpInterface::options_;
    plugin->deserialize = &PiqpInterface::deserialize;
    return 0;
  }

References casadi_register_conic_piqp().

Referenced by casadi_load_conic_piqp(), and casadi_register_conic_piqp().

casadi_register_conic_proxqp()

int CASADI_CONIC_PROXQP_EXPORT casadi::casadi_register_conic_proxqp

(

Conic::Plugin *

plugin

)

Definition at line 36 of file proxqp_interface.cpp.

                                                    {
    plugin->creator = ProxqpInterface::creator;
    plugin->name = "proxqp";
    plugin->doc = ProxqpInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &ProxqpInterface::options_;
    plugin->deserialize = &ProxqpInterface::deserialize;
    return 0;
  }

References casadi_register_conic_proxqp().

Referenced by casadi_load_conic_proxqp(), and casadi_register_conic_proxqp().

casadi_register_conic_qpoases()

int CASADI_CONIC_QPOASES_EXPORT casadi::casadi_register_conic_qpoases

(

Conic::Plugin *

plugin

)

Definition at line 36 of file qpoases_interface.cpp.

                                                     {
    plugin->creator = QpoasesInterface::creator;
    plugin->name = "qpoases";
    plugin->doc = QpoasesInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &QpoasesInterface::options_;
    plugin->deserialize = &QpoasesInterface::deserialize;
    return 0;
  }

References casadi::QpoasesInterface::creator(), casadi::QpoasesInterface::deserialize(), casadi::QpoasesInterface::meta_doc, and casadi::QpoasesInterface::options_.

Referenced by casadi_load_conic_qpoases().

casadi_register_conic_qrqp()

int CASADI_CONIC_QRQP_EXPORT casadi::casadi_register_conic_qrqp

(

Conic::Plugin *

plugin

)

Definition at line 33 of file qrqp.cpp.

                                                  {
    plugin->creator = Qrqp::creator;
    plugin->name = "qrqp";
    plugin->doc = Qrqp::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Qrqp::options_;
    plugin->deserialize = &Qrqp::deserialize;
    return 0;
  }

References casadi::Qrqp::creator(), casadi::Qrqp::deserialize(), casadi::Qrqp::meta_doc, and casadi::Qrqp::options_.

Referenced by casadi_load_conic_qrqp().

casadi_register_conic_sqic()

int CASADI_CONIC_SQIC_EXPORT casadi::casadi_register_conic_sqic

(

Conic::Plugin *

plugin

)

Definition at line 38 of file sqic_interface.cpp.

                                                  {
    plugin->creator = SqicInterface::creator;
    plugin->name = "sqic";
    plugin->doc = SqicInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &SqicInterface::options_;
    return 0;
  }

References casadi::SqicInterface::creator(), casadi::SqicInterface::meta_doc, and casadi::Conic::options_.

Referenced by casadi_load_conic_sqic().

casadi_register_conic_superscs()

int CASADI_CONIC_SUPERSCS_EXPORT casadi::casadi_register_conic_superscs

(

Conic::Plugin *

plugin

)

Definition at line 37 of file superscs_interface.cpp.

                                                      {
    plugin->creator = SuperscsInterface::creator;
    plugin->name = "superscs";
    plugin->doc = SuperscsInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &SuperscsInterface::options_;
    plugin->deserialize = &SuperscsInterface::deserialize;
    return 0;
  }

References casadi::SuperscsInterface::creator(), casadi::SuperscsInterface::deserialize(), casadi::SuperscsInterface::meta_doc, and casadi::SuperscsInterface::options_.

Referenced by casadi_load_conic_superscs().

casadi_register_conic_xpress()

int CASADI_CONIC_XPRESS_EXPORT casadi::casadi_register_conic_xpress

(

Conic::Plugin *

plugin

)

Definition at line 46 of file xpress_interface.cpp.

                                                    {
    plugin->creator = XpressInterface::creator;
    plugin->name = "xpress";
    plugin->doc = XpressInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &XpressInterface::options_;
    plugin->deserialize = &XpressInterface::deserialize;
    return 0;
  }

References casadi::XpressInterface::creator(), casadi::XpressInterface::deserialize(), casadi::XpressInterface::meta_doc, and casadi::XpressInterface::options_.

Referenced by casadi_load_conic_xpress().

casadi_register_dple_slicot()

int CASADI_DPLE_SLICOT_EXPORT casadi::casadi_register_dple_slicot

(

Dple::Plugin *

plugin

)

Definition at line 42 of file slicot_dple.cpp.

                                                  {
    plugin->creator = SlicotDple::creator;
    plugin->name = "slicot";
    plugin->doc = SlicotDple::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &SlicotDple::options_;
    return 0;
  }

References casadi::SlicotDple::creator(), casadi::SlicotDple::meta_doc, and casadi::SlicotDple::options_.

Referenced by casadi_load_dple_slicot().

casadi_register_expm_slicot()

int CASADI_EXPM_SLICOT_EXPORT casadi::casadi_register_expm_slicot

(

Expm::Plugin *

plugin

)

Definition at line 42 of file slicot_expm.cpp.

                                                  {
    plugin->creator = SlicotExpm::creator;
    plugin->name = "slicot";
    plugin->doc = SlicotExpm::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &SlicotExpm::options_;
    return 0;
  }

References casadi::SlicotExpm::creator(), casadi::SlicotExpm::meta_doc, and casadi::Expm::options_.

Referenced by casadi_load_expm_slicot().

casadi_register_filesystem_ghc()

int CASADI_FILESYSTEM_GHC_EXPORT casadi::casadi_register_filesystem_ghc

(

Filesystem::Plugin *

plugin

)

Definition at line 73 of file ghc.cpp.

                                                             {
        plugin->name = "ghc";
        plugin->doc = Ghc::meta_doc.c_str();
        plugin->version = CASADI_VERSION;
        plugin->exposed.is_directory = &is_directory;
        plugin->exposed.create_directories = &create_directories;
        plugin->exposed.remove = &remove;
        plugin->exposed.remove_all = &remove_all;
        plugin->exposed.filename = &filename;
        plugin->exposed.has_parent_path = &has_parent_path;
        plugin->exposed.parent_path = &parent_path;
        plugin->exposed.iterate_directory_names = &iterate_directory_names;
        plugin->exposed.absolute = &absolute;
        return 0;
    }

References absolute(), create_directories(), filename(), has_parent_path(), is_directory(), iterate_directory_names(), casadi::Ghc::meta_doc, parent_path(), remove(), and remove_all().

Referenced by casadi_load_filesystem_ghc().

casadi_register_graphmodel_onnx()

int CASADI_GRAPHMODEL_ONNX_EXPORT casadi::casadi_register_graphmodel_onnx

(

GraphModelInternal::Plugin *

plugin

)

Definition at line 35 of file onnx_model.cpp.

                                                                    {
    plugin->creator = Onnx::creator;
    plugin->name = "onnx";
    plugin->doc = Onnx::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Onnx::options_;
    return 0;
  }

References casadi::Onnx::creator(), casadi::Onnx::meta_doc, and casadi::Onnx::options_.

Referenced by casadi_load_graphmodel_onnx().

casadi_register_importer_clang()

int CASADI_IMPORTER_CLANG_EXPORT casadi::casadi_register_importer_clang

(

ImporterInternal::Plugin *

plugin

)

Definition at line 46 of file clang_compiler.cpp.

                                                                 {
    plugin->creator = ClangCompiler::creator;
    plugin->name = "clang";
    plugin->doc = ClangCompiler::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &ClangCompiler::options_;
    return 0;
  }

References casadi::ClangCompiler::creator(), casadi::ClangCompiler::meta_doc, and casadi::ClangCompiler::options_.

Referenced by casadi_load_importer_clang(), and casadi::ClangCompiler::init().

casadi_register_importer_shell()

int CASADI_IMPORTER_SHELL_EXPORT casadi::casadi_register_importer_shell

(

ImporterInternal::Plugin *

plugin

)

Definition at line 43 of file shell_compiler.cpp.

                                                                 {
    plugin->creator = ShellCompiler::creator;
    plugin->name = "shell";
    plugin->doc = ShellCompiler::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &ShellCompiler::options_;
    return 0;
  }

References casadi::ShellCompiler::creator(), casadi::ShellCompiler::meta_doc, and casadi::ShellCompiler::options_.

Referenced by casadi_load_importer_shell().

casadi_register_integrator_collocation()

int CASADI_INTEGRATOR_COLLOCATION_EXPORT casadi::casadi_register_integrator_collocation

(

Integrator::Plugin *

plugin

)

Definition at line 34 of file collocation.cpp.

                                                                       {
    plugin->creator = Collocation::creator;
    plugin->name = "collocation";
    plugin->doc = Collocation::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Collocation::options_;
    plugin->deserialize = &Collocation::deserialize;
    return 0;
  }

References casadi::Collocation::creator(), casadi::Collocation::deserialize(), casadi::Collocation::meta_doc, and casadi::Collocation::options_.

Referenced by casadi_load_integrator_collocation().

casadi_register_integrator_cvodes()

int CASADI_INTEGRATOR_CVODES_EXPORT casadi::casadi_register_integrator_cvodes

(

Integrator::Plugin *

plugin

)

Definition at line 36 of file cvodes_interface.cpp.

                                                            {
  plugin->creator = CvodesInterface::creator;
  plugin->name = "cvodes";
  plugin->doc = CvodesInterface::meta_doc.c_str();;
  plugin->version = CASADI_VERSION;
  plugin->options = &CvodesInterface::options_;
  plugin->deserialize = &CvodesInterface::deserialize;
  return 0;
}

References casadi::CvodesInterface::creator(), casadi::CvodesInterface::deserialize(), casadi::CvodesInterface::meta_doc, and casadi::CvodesInterface::options_.

Referenced by casadi_load_integrator_cvodes().

casadi_register_integrator_idas()

int CASADI_INTEGRATOR_IDAS_EXPORT casadi::casadi_register_integrator_idas

(

Integrator::Plugin *

plugin

)

Definition at line 37 of file idas_interface.cpp.

                                                              {
  plugin->creator = IdasInterface::creator;
  plugin->name = "idas";
  plugin->doc = IdasInterface::meta_doc.c_str();
  plugin->version = CASADI_VERSION;
  plugin->options = &IdasInterface::options_;
  plugin->deserialize = &IdasInterface::deserialize;
  return 0;
}

References casadi::IdasInterface::creator(), casadi::IdasInterface::deserialize(), casadi::IdasInterface::meta_doc, and casadi::IdasInterface::options_.

Referenced by casadi_load_integrator_idas().

casadi_register_integrator_rk()

int CASADI_INTEGRATOR_RK_EXPORT casadi::casadi_register_integrator_rk

(

Integrator::Plugin *

plugin

)

Definition at line 32 of file runge_kutta.cpp.

                                                              {
    plugin->creator = RungeKutta::creator;
    plugin->name = "rk";
    plugin->doc = RungeKutta::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &RungeKutta::options_;
    plugin->deserialize = &RungeKutta::deserialize;
    return 0;
  }

References casadi::RungeKutta::creator(), casadi::RungeKutta::deserialize(), casadi::RungeKutta::meta_doc, and casadi::FixedStepIntegrator::options_.

Referenced by casadi_load_integrator_rk().

casadi_register_interpolant_bspline()

int CASADI_INTERPOLANT_BSPLINE_EXPORT casadi::casadi_register_interpolant_bspline

(

Interpolant::Plugin *

plugin

)

Definition at line 33 of file bspline_interpolant.cpp.

                                                                 {
    plugin->creator = BSplineInterpolant::creator;
    plugin->name = "bspline";
    plugin->doc = BSplineInterpolant::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &BSplineInterpolant::options_;
    plugin->deserialize = &BSplineInterpolant::deserialize;
    plugin->exposed.do_inline = nullptr;
    return 0;
  }

References casadi::BSplineInterpolant::creator(), casadi::BSplineInterpolant::deserialize(), casadi::BSplineInterpolant::meta_doc, and casadi::BSplineInterpolant::options_.

Referenced by casadi_load_interpolant_bspline().

casadi_register_interpolant_linear()

int CASADI_INTERPOLANT_LINEAR_EXPORT casadi::casadi_register_interpolant_linear

(

Interpolant::Plugin *

plugin

)

Definition at line 32 of file linear_interpolant.cpp.

                                                                {
    plugin->creator = LinearInterpolant::creator;
    plugin->name = "linear";
    plugin->doc = LinearInterpolant::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &LinearInterpolant::options_;
    plugin->deserialize = &LinearInterpolant::deserialize;
    plugin->exposed.do_inline = &LinearInterpolant::do_inline;
    return 0;
  }

References casadi::LinearInterpolant::creator(), casadi::LinearInterpolant::deserialize(), casadi::LinearInterpolant::do_inline(), casadi::LinearInterpolant::meta_doc, and casadi::LinearInterpolant::options_.

Referenced by casadi_load_interpolant_linear().

casadi_register_linsol_csparse()

int CASADI_LINSOL_CSPARSE_EXPORT casadi::casadi_register_linsol_csparse

(

LinsolInternal::Plugin *

plugin

)

Definition at line 34 of file csparse_interface.cpp.

                                                               {
    plugin->creator = CsparseInterface::creator;
    plugin->name = "csparse";
    plugin->doc = CsparseInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &CsparseInterface::options_;
    plugin->deserialize = &CsparseInterface::deserialize;
    return 0;
  }

References casadi::CsparseInterface::creator(), casadi::CsparseInterface::deserialize(), casadi::CsparseInterface::meta_doc, and casadi::ProtoFunction::options_.

Referenced by casadi_load_linsol_csparse().

casadi_register_linsol_lapacklu()

int CASADI_LINSOL_LAPACKLU_EXPORT casadi::casadi_register_linsol_lapacklu

(

LinsolInternal::Plugin *

plugin

)

Definition at line 33 of file lapack_lu.cpp.

                                                                {
    plugin->creator = LapackLu::creator;
    plugin->name = "lapacklu";
    plugin->doc = LapackLu::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &LapackLu::options_;
    plugin->deserialize = &LapackLu::deserialize;
    return 0;
  }

References casadi::LapackLu::creator(), casadi::LapackLu::deserialize(), casadi::LapackLu::meta_doc, and casadi::LapackLu::options_.

Referenced by casadi_load_linsol_lapacklu().

casadi_register_linsol_lapackqr()

int CASADI_LINSOL_LAPACKQR_EXPORT casadi::casadi_register_linsol_lapackqr

(

LinsolInternal::Plugin *

plugin

)

Definition at line 33 of file lapack_qr.cpp.

                                                                {
    plugin->creator = LapackQr::creator;
    plugin->name = "lapackqr";
    plugin->doc = LapackQr::meta_doc.c_str();;
    plugin->version = CASADI_VERSION;
    plugin->options = &LapackQr::options_;
    plugin->deserialize = &LapackQr::deserialize;
    return 0;
  }

References casadi::LapackQr::creator(), casadi::LapackQr::deserialize(), casadi::LapackQr::meta_doc, and casadi::LapackQr::options_.

Referenced by casadi_load_linsol_lapackqr().

casadi_register_linsol_ldl()

int CASADI_LINSOL_LDL_EXPORT casadi::casadi_register_linsol_ldl

(

LinsolInternal::Plugin *

plugin

)

Definition at line 33 of file linsol_ldl.cpp.

                                                           {
    plugin->creator = LinsolLdl::creator;
    plugin->name = "ldl";
    plugin->doc = LinsolLdl::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &LinsolLdl::options_;
    plugin->deserialize = &LinsolLdl::deserialize;
    return 0;
  }

References casadi::LinsolLdl::creator(), casadi::LinsolLdl::deserialize(), casadi::LinsolLdl::meta_doc, and casadi::LinsolLdl::options_.

Referenced by casadi_load_linsol_ldl().

casadi_register_linsol_lsqr()

int CASADI_LINSOL_LSQR_EXPORT casadi::casadi_register_linsol_lsqr

(

LinsolInternal::Plugin *

plugin

)

Definition at line 36 of file lsqr.cpp.

                                                            {
    plugin->creator = Lsqr::creator;
    plugin->name = "lsqr";
    plugin->doc = Lsqr::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Lsqr::options_;
    plugin->deserialize = &Lsqr::deserialize;
    return 0;
  }

References casadi::Lsqr::creator(), casadi::Lsqr::deserialize(), casadi::Lsqr::meta_doc, and casadi::ProtoFunction::options_.

Referenced by casadi_load_linsol_lsqr().

casadi_register_linsol_ma27()

int CASADI_LINSOL_MA27_EXPORT casadi::casadi_register_linsol_ma27

(

LinsolInternal::Plugin *

plugin

)

Definition at line 34 of file ma27_interface.cpp.

                                                            {
    plugin->creator = Ma27Interface::creator;
    plugin->name = "ma27";
    plugin->doc = Ma27Interface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Ma27Interface::options_;
    plugin->deserialize = &Ma27Interface::deserialize;
    return 0;
  }

References casadi::Ma27Interface::creator(), casadi::Ma27Interface::deserialize(), casadi::Ma27Interface::meta_doc, and casadi::ProtoFunction::options_.

Referenced by casadi_load_linsol_ma27().

casadi_register_linsol_mumps()

int CASADI_LINSOL_MUMPS_EXPORT casadi::casadi_register_linsol_mumps

(

LinsolInternal::Plugin *

plugin

)

Definition at line 34 of file mumps_interface.cpp.

                                                             {
    plugin->creator = MumpsInterface::creator;
    plugin->name = "mumps";
    plugin->doc = MumpsInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &MumpsInterface::options_;
    plugin->deserialize = &MumpsInterface::deserialize;
    return 0;
  }

References casadi::MumpsInterface::creator(), casadi::MumpsInterface::deserialize(), casadi::MumpsInterface::meta_doc, and casadi::MumpsInterface::options_.

Referenced by casadi_load_linsol_mumps().

casadi_register_linsol_qr()

int CASADI_LINSOL_QR_EXPORT casadi::casadi_register_linsol_qr

(

LinsolInternal::Plugin *

plugin

)

Definition at line 33 of file linsol_qr.cpp.

                                                          {
    plugin->creator = LinsolQr::creator;
    plugin->name = "qr";
    plugin->doc = LinsolQr::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &LinsolQr::options_;
    plugin->deserialize = &LinsolQr::deserialize;
    return 0;
  }

References casadi::LinsolQr::creator(), casadi::LinsolQr::deserialize(), casadi::LinsolQr::meta_doc, and casadi::LinsolQr::options_.

Referenced by casadi_load_linsol_qr().

casadi_register_linsol_symbolicqr()

int CASADI_LINSOL_SYMBOLICQR_EXPORT casadi::casadi_register_linsol_symbolicqr

(

LinsolInternal::Plugin *

plugin

)

Definition at line 36 of file symbolic_qr.cpp.

                                                                  {
    plugin->creator = SymbolicQr::creator;
    plugin->name = "symbolicqr";
    plugin->doc = SymbolicQr::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &SymbolicQr::options_;
    plugin->deserialize = &SymbolicQr::deserialize;
    plugin->exposed.det = &SymbolicQr::det;
    return 0;
  }

References casadi::SymbolicQr::creator(), casadi::SymbolicQr::deserialize(), casadi::SymbolicQr::det(), casadi::SymbolicQr::meta_doc, and casadi::SymbolicQr::options_.

Referenced by casadi_load_linsol_symbolicqr().

casadi_register_linsol_tridiag()

int CASADI_LINSOL_TRIDIAG_EXPORT casadi::casadi_register_linsol_tridiag

(

LinsolInternal::Plugin *

plugin

)

Definition at line 34 of file linsol_tridiag.cpp.

                                                               {
    plugin->creator = LinsolTridiag::creator;
    plugin->name = "tridiag";
    plugin->doc = LinsolTridiag::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &LinsolTridiag::options_;
    return 0;
  }

References casadi::LinsolTridiag::creator(), casadi::LinsolTridiag::meta_doc, and casadi::ProtoFunction::options_.

Referenced by casadi_load_linsol_tridiag().

casadi_register_modelicaparser_lacemodelica()

int CASADI_MODELICAPARSER_LACEMODELICA_EXPORT casadi::casadi_register_modelicaparser_lacemodelica

(

ModelicaParserInternal::Plugin *

plugin

)

Definition at line 33 of file lace_modelica.cpp.

                                                                                  {
  plugin->creator = LaceModelica::creator;
  plugin->name = "lacemodelica";
  plugin->doc = LaceModelica::meta_doc.c_str();
  plugin->version = CASADI_VERSION;
  return 0;
}

References casadi::LaceModelica::creator(), and casadi::LaceModelica::meta_doc.

Referenced by casadi_load_modelicaparser_lacemodelica().

casadi_register_nlpsol_alpaqa()

int CASADI_NLPSOL_ALPAQA_EXPORT casadi::casadi_register_nlpsol_alpaqa

(

Nlpsol::Plugin *

plugin

)

Definition at line 34 of file alpaqa_interface.cpp.

                                                      {
    plugin->creator = AlpaqaInterface::creator;
    plugin->name = "alpaqa";
    plugin->doc = AlpaqaInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &AlpaqaInterface::options_;
    plugin->deserialize = &AlpaqaInterface::deserialize;
    return 0;
  }

References casadi::AlpaqaInterface::creator(), casadi::AlpaqaInterface::deserialize(), casadi::AlpaqaInterface::meta_doc, and casadi::AlpaqaInterface::options_.

Referenced by casadi_load_nlpsol_alpaqa().

casadi_register_nlpsol_ampl()

int CASADI_NLPSOL_AMPL_EXPORT casadi::casadi_register_nlpsol_ampl

(

Nlpsol::Plugin *

plugin

)

Definition at line 36 of file ampl_interface.cpp.

                                                    {
    plugin->creator = AmplInterface::creator;
    plugin->name = "ampl";
    plugin->doc = AmplInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &AmplInterface::options_;
    return 0;
  }

References casadi::AmplInterface::creator(), casadi::AmplInterface::meta_doc, and casadi::AmplInterface::options_.

Referenced by casadi_load_nlpsol_ampl().

casadi_register_nlpsol_blocksqp()

int CASADI_NLPSOL_BLOCKSQP_EXPORT casadi::casadi_register_nlpsol_blocksqp

(

Nlpsol::Plugin *

plugin

)

Definition at line 34 of file blocksqp.cpp.

                                                        {
    plugin->creator = Blocksqp::creator;
    plugin->name = "blocksqp";
    plugin->doc = Blocksqp::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Blocksqp::options_;
    plugin->deserialize = &Blocksqp::deserialize;
    return 0;
  }

References casadi::Blocksqp::creator(), casadi::Blocksqp::deserialize(), casadi::Blocksqp::meta_doc, and casadi::Blocksqp::options_.

Referenced by casadi_load_nlpsol_blocksqp().

casadi_register_nlpsol_bonmin()

int CASADI_NLPSOL_BONMIN_EXPORT casadi::casadi_register_nlpsol_bonmin

(

Nlpsol::Plugin *

plugin

)

Definition at line 42 of file bonmin_interface.cpp.

                                                      {
    plugin->creator = BonminInterface::creator;
    plugin->name = "bonmin";
    plugin->doc = BonminInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &BonminInterface::options_;
    plugin->deserialize = &BonminInterface::deserialize;
    return 0;
  }

References casadi::BonminInterface::creator(), casadi::BonminInterface::deserialize(), casadi::BonminInterface::meta_doc, and casadi::BonminInterface::options_.

Referenced by casadi_load_nlpsol_bonmin().

casadi_register_nlpsol_ccopt()

int CASADI_NLPSOL_CCOPT_EXPORT casadi::casadi_register_nlpsol_ccopt

(

Nlpsol::Plugin *

plugin

)

Definition at line 46 of file ccopt_interface.cpp.

                                                   {
  plugin->creator = MadmpecInterface::creator;
  plugin->name = "ccopt";
  plugin->doc = MadmpecInterface::meta_doc.c_str();
  plugin->version = CASADI_VERSION;
  plugin->options = &MadmpecInterface::options_;
  plugin->deserialize = &MadmpecInterface::deserialize;
  return 0;
}

References casadi::MadmpecInterface::creator(), casadi::MadmpecInterface::deserialize(), casadi::MadmpecInterface::meta_doc, and casadi::MadmpecInterface::options_.

Referenced by casadi_load_nlpsol_ccopt().

casadi_register_nlpsol_fatrop()

int CASADI_NLPSOL_FATROP_EXPORT casadi::casadi_register_nlpsol_fatrop

(

Nlpsol::Plugin *

plugin

)

Definition at line 53 of file fatrop_interface.cpp.

                                                      {
    plugin->creator = FatropInterface::creator;
    plugin->name = "fatrop";
    plugin->doc = FatropInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &FatropInterface::options_;
    plugin->deserialize = &FatropInterface::deserialize;
    return 0;
  }

References casadi::FatropInterface::creator(), casadi::FatropInterface::deserialize(), casadi::FatropInterface::meta_doc, and casadi::FatropInterface::options_.

Referenced by casadi_load_nlpsol_fatrop().

casadi_register_nlpsol_feasiblesqpmethod()

int CASADI_NLPSOL_FEASIBLESQPMETHOD_EXPORT casadi::casadi_register_nlpsol_feasiblesqpmethod

(

Nlpsol::Plugin *

plugin

)

Definition at line 46 of file feasiblesqpmethod.cpp.

                                                                     {
    plugin->creator = Feasiblesqpmethod::creator;
    plugin->name = "feasiblesqpmethod";
    plugin->doc = Feasiblesqpmethod::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Feasiblesqpmethod::options_;
    plugin->deserialize = &Feasiblesqpmethod::deserialize;
    return 0;
  }

References casadi::Feasiblesqpmethod::creator(), casadi::Feasiblesqpmethod::deserialize(), casadi::Feasiblesqpmethod::meta_doc, and casadi::Feasiblesqpmethod::options_.

Referenced by casadi_load_nlpsol_feasiblesqpmethod().

casadi_register_nlpsol_ipopt()

int CASADI_NLPSOL_IPOPT_EXPORT casadi::casadi_register_nlpsol_ipopt

(

Nlpsol::Plugin *

plugin

)

Definition at line 47 of file ipopt_interface.cpp.

                                                     {
    plugin->creator = IpoptInterface::creator;
    plugin->name = "ipopt";
    plugin->doc = IpoptInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &IpoptInterface::options_;
    plugin->deserialize = &IpoptInterface::deserialize;
    return 0;
  }

References casadi::IpoptInterface::creator(), casadi::IpoptInterface::deserialize(), casadi::IpoptInterface::meta_doc, and casadi::IpoptInterface::options_.

Referenced by casadi_load_nlpsol_ipopt().

casadi_register_nlpsol_knitro()

int CASADI_NLPSOL_KNITRO_EXPORT casadi::casadi_register_nlpsol_knitro

(

Nlpsol::Plugin *

plugin

)

Definition at line 44 of file knitro_interface.cpp.

                                                      {
    plugin->creator = KnitroInterface::creator;
    plugin->name = "knitro";
    plugin->doc = KnitroInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &KnitroInterface::options_;
    plugin->deserialize = &KnitroInterface::deserialize;
    return 0;
  }

References casadi::KnitroInterface::creator(), casadi::KnitroInterface::deserialize(), casadi::KnitroInterface::meta_doc, and casadi::KnitroInterface::options_.

Referenced by casadi_load_nlpsol_knitro().

casadi_register_nlpsol_madnlp()

int CASADI_NLPSOL_MADNLP_EXPORT casadi::casadi_register_nlpsol_madnlp

(

Nlpsol::Plugin *

plugin

)

Definition at line 46 of file madnlp_interface.cpp.

                                                    {
  plugin->creator = MadnlpInterface::creator;
  plugin->name = "madnlp";
  plugin->doc = MadnlpInterface::meta_doc.c_str();
  plugin->version = CASADI_VERSION;
  plugin->options = &MadnlpInterface::options_;
  plugin->deserialize = &MadnlpInterface::deserialize;
  return 0;
}

References casadi::MadnlpInterface::creator(), casadi::MadnlpInterface::deserialize(), casadi::MadnlpInterface::meta_doc, and casadi::MadnlpInterface::options_.

Referenced by casadi_load_nlpsol_madnlp().

casadi_register_nlpsol_qrsqp()

int CASADI_NLPSOL_QRSQP_EXPORT casadi::casadi_register_nlpsol_qrsqp

(

Nlpsol::Plugin *

plugin

)

Definition at line 42 of file qrsqp.cpp.

                                                         {
    plugin->creator = Qrsqp::creator;
    plugin->name = "qrsqp";
    plugin->doc = Qrsqp::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Qrsqp::options_;
    return 0;
  }

References casadi::Qrsqp::creator(), casadi::Qrsqp::meta_doc, and casadi::Qrsqp::options_.

Referenced by casadi_load_nlpsol_qrsqp().

casadi_register_nlpsol_scpgen()

int CASADI_NLPSOL_SCPGEN_EXPORT casadi::casadi_register_nlpsol_scpgen

(

Nlpsol::Plugin *

plugin

)

Definition at line 39 of file scpgen.cpp.

                                                          {
    plugin->creator = Scpgen::creator;
    plugin->name = "scpgen";
    plugin->doc = Scpgen::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Scpgen::options_;
    return 0;
  }

References casadi::Scpgen::creator(), casadi::Scpgen::meta_doc, and casadi::Scpgen::options_.

Referenced by casadi_load_nlpsol_scpgen().

casadi_register_nlpsol_sleqp()

int CASADI_NLPSOL_SLEQP_EXPORT casadi::casadi_register_nlpsol_sleqp

(

Nlpsol::Plugin *

plugin

)

Definition at line 70 of file sleqp_interface.cpp.

                                                     {
    plugin->creator = SLEQPInterface::creator;
    plugin->name = "sleqp";
    plugin->doc = SLEQPInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &SLEQPInterface::options_;
    plugin->deserialize = &SLEQPInterface::deserialize;
 
    sleqp_log_set_handler(casadi_log_output);
 
    return 0;
  }

References casadi_log_output(), casadi::SLEQPInterface::creator(), casadi::SLEQPInterface::deserialize(), casadi::SLEQPInterface::meta_doc, and casadi::SLEQPInterface::options_.

Referenced by casadi_load_nlpsol_sleqp().

casadi_register_nlpsol_snopt()

int CASADI_NLPSOL_SNOPT_EXPORT casadi::casadi_register_nlpsol_snopt

(

Nlpsol::Plugin *

plugin

)

Definition at line 40 of file snopt_interface.cpp.

                                                     {
    plugin->creator = SnoptInterface::creator;
    plugin->name = "snopt";
    plugin->doc = SnoptInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &SnoptInterface::options_;
    plugin->deserialize = &SnoptInterface::deserialize;
    return 0;
  }

References casadi::SnoptInterface::creator(), casadi::SnoptInterface::deserialize(), casadi::SnoptInterface::meta_doc, and casadi::SnoptInterface::options_.

Referenced by casadi_load_nlpsol_snopt().

casadi_register_nlpsol_sqpmethod()

int CASADI_NLPSOL_SQPMETHOD_EXPORT casadi::casadi_register_nlpsol_sqpmethod

(

Nlpsol::Plugin *

plugin

)

Definition at line 43 of file sqpmethod.cpp.

                                                           {
  plugin->creator = Sqpmethod::creator;
  plugin->name = "sqpmethod";
  plugin->doc = Sqpmethod::meta_doc.c_str();
  plugin->version = CASADI_VERSION;
  plugin->options = &Sqpmethod::options_;
  plugin->deserialize = &Sqpmethod::deserialize;
  return 0;
}

References casadi::Sqpmethod::creator(), casadi::Sqpmethod::deserialize(), casadi::Sqpmethod::meta_doc, and casadi::Sqpmethod::options_.

Referenced by casadi_load_nlpsol_sqpmethod().

casadi_register_nlpsol_uno()

int CASADI_NLPSOL_UNO_EXPORT casadi::casadi_register_nlpsol_uno

(

Nlpsol::Plugin *

plugin

)

Definition at line 39 of file uno_interface.cpp.

                                                   {
    plugin->creator = UnoInterface::creator;
    plugin->name = "uno";
    plugin->doc = UnoInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &UnoInterface::options_;
    plugin->deserialize = &UnoInterface::deserialize;
    return 0;
  }

References casadi::UnoInterface::creator(), casadi::UnoInterface::deserialize(), casadi::UnoInterface::meta_doc, and casadi::UnoInterface::options_.

Referenced by casadi_load_nlpsol_uno().

casadi_register_nlpsol_worhp()

int CASADI_NLPSOL_WORHP_EXPORT casadi::casadi_register_nlpsol_worhp

(

Nlpsol::Plugin *

plugin

)

Definition at line 36 of file worhp_interface.cpp.

                                                     {
    plugin->creator = WorhpInterface::creator;
    plugin->name = "worhp";
    plugin->doc = WorhpInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &WorhpInterface::options_;
    plugin->deserialize = &WorhpInterface::deserialize;
    return 0;
  }

References casadi::WorhpInterface::creator(), casadi::WorhpInterface::deserialize(), casadi::WorhpInterface::meta_doc, and casadi::WorhpInterface::options_.

Referenced by casadi_load_nlpsol_worhp().

casadi_register_onnx_ort()

int CASADI_ONNX_ORT_EXPORT casadi::casadi_register_onnx_ort

(

OnnxFunction::Plugin *

plugin

)

Definition at line 31 of file ort_interface.cpp.

                                                       {
    plugin->creator = OnnxRuntimeInterface::creator;
    plugin->name = "ort";
    plugin->doc = OnnxRuntimeInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &OnnxRuntimeInterface::options_;
    plugin->deserialize = &OnnxRuntimeInterface::deserialize;
    return 0;
  }

References casadi::OnnxRuntimeInterface::creator(), casadi::OnnxRuntimeInterface::deserialize(), casadi::OnnxRuntimeInterface::meta_doc, and casadi::OnnxRuntimeInterface::options_.

Referenced by casadi_load_onnx_ort().

casadi_register_rootfinder_fast_newton()

int CASADI_ROOTFINDER_FAST_NEWTON_EXPORT casadi::casadi_register_rootfinder_fast_newton

(

Rootfinder::Plugin *

plugin

)

Definition at line 34 of file fast_newton.cpp.

                                                                   {
    plugin->creator = FastNewton::creator;
    plugin->name = "fast_newton";
    plugin->doc = FastNewton::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &FastNewton::options_;
    plugin->deserialize = &FastNewton::deserialize;
    return 0;
  }

References casadi::FastNewton::creator(), casadi::FastNewton::deserialize(), casadi::FastNewton::meta_doc, and casadi::FastNewton::options_.

Referenced by casadi_load_rootfinder_fast_newton().

casadi_register_rootfinder_kinsol()

int CASADI_ROOTFINDER_KINSOL_EXPORT casadi::casadi_register_rootfinder_kinsol

(

Rootfinder::Plugin *

plugin

)

Definition at line 32 of file kinsol_interface.cpp.

                                                              {
    plugin->creator = KinsolInterface::creator;
    plugin->name = "kinsol";
    plugin->doc = KinsolInterface::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &KinsolInterface::options_;
    return 0;
  }

References casadi::KinsolInterface::creator(), casadi::KinsolInterface::meta_doc, and casadi::KinsolInterface::options_.

Referenced by casadi_load_rootfinder_kinsol().

casadi_register_rootfinder_newton()

int CASADI_ROOTFINDER_NEWTON_EXPORT casadi::casadi_register_rootfinder_newton

(

Rootfinder::Plugin *

plugin

)

Definition at line 33 of file newton.cpp.

                                                              {
    plugin->creator = Newton::creator;
    plugin->name = "newton";
    plugin->doc = Newton::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &Newton::options_;
    plugin->deserialize = &Newton::deserialize;
    return 0;
  }

References casadi::Newton::creator(), casadi::Newton::deserialize(), casadi::Newton::meta_doc, and casadi::Newton::options_.

Referenced by casadi_load_rootfinder_newton().

casadi_register_rootfinder_nlpsol()

int CASADI_ROOTFINDER_NLPSOL_EXPORT casadi::casadi_register_rootfinder_nlpsol

(

Rootfinder::Plugin *

plugin

)

Definition at line 34 of file implicit_to_nlp.cpp.

                                                              {
    plugin->creator = ImplicitToNlp::creator;
    plugin->name = "nlpsol";
    plugin->doc = ImplicitToNlp::meta_doc.c_str();
    plugin->version = CASADI_VERSION;
    plugin->options = &ImplicitToNlp::options_;
    return 0;
  }

References casadi::ImplicitToNlp::creator(), casadi::ImplicitToNlp::meta_doc, and casadi::ImplicitToNlp::options_.

Referenced by casadi_load_rootfinder_nlpsol().

casadi_register_xmlfile_tinyxml()

int CASADI_XMLFILE_TINYXML_EXPORT casadi::casadi_register_xmlfile_tinyxml

(

XmlFileInternal::Plugin *

plugin

)

Definition at line 32 of file tinyxml_interface.cpp.

                                                               {
  plugin->creator = TinyXmlInterface::creator;
  plugin->name = "tinyxml";
  plugin->doc = TinyXmlInterface::meta_doc.c_str();
  plugin->version = CASADI_VERSION;
  return 0;
}

References casadi::TinyXmlInterface::creator(), and casadi::TinyXmlInterface::meta_doc.

Referenced by casadi_load_xmlfile_tinyxml().

casadi_scal()

template<typename T1 >

void casadi::casadi_scal	(	casadi_int	n,
		T1	alpha,
		T1 *	x
	)

Referenced by casadi::Blocksqp::calcLagrangeGradient(), casadi::Nlpsol::eval(), casadi::Scpgen::eval_vec(), casadi::HpmpcInterface::mproject(), casadi::CvodesInterface::rhsB(), casadi::CvodesInterface::rhsQB(), casadi::IdasInterface::rhsQB(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::QpoasesInterface::solve(), casadi::Blocksqp::solve(), casadi::SnoptInterface::solve(), casadi::WorhpInterface::solve(), casadi::Qrsqp::solve(), and casadi::Sqpmethod::solve().

casadi_sleqp_func_create()

void casadi::casadi_sleqp_func_create	(	SleqpFunc **	star,
		int	num_vars,
		int	num_cons,
		SLEQPMemory *	m
	)

Definition at line 237 of file sleqp_func.cpp.

  {
    SleqpFuncCallbacks callbacks{};
 
    callbacks.set_value = casadi_func_set;
    callbacks.nonzeros  = casadi_func_nonzeros;
    callbacks.obj_val   = casadi_func_obj_val;
    callbacks.obj_grad  = casadi_func_obj_grad;
    callbacks.cons_val  = casadi_func_cons_val;
    callbacks.cons_jac  = casadi_func_cons_jac;
    callbacks.hess_prod = casadi_func_hess_prod;
    callbacks.func_free = casadi_func_free;
 
 
    SLEQP_CALL_EXC(sleqp_func_create(star,
                                     &callbacks,
                                     num_vars,
                                     num_cons,
                                     static_cast<void*>(m)));
  }

References casadi_func_cons_jac(), casadi_func_cons_val(), casadi_func_free(), casadi_func_hess_prod(), casadi_func_nonzeros(), casadi_func_obj_grad(), casadi_func_obj_val(), and casadi_func_set().

Referenced by casadi::SLEQPInterface::set_work().

casadi_sparsify()

template<typename T1 , typename T2 >

void casadi::casadi_sparsify	(	const T1 *	x,
		T2 *	y,
		const casadi_int *	sp_y,
		casadi_int	tr
	)

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

casadi_sum_viol()

template<typename T1 >

T1 casadi::casadi_sum_viol	(	casadi_int	n,
		const T1 *	x,
		const T1 *	lb,
		const T1 *	ub
	)

Referenced by casadi::Scpgen::primalInfeasibility(), and casadi::Sqpmethod::solve().

casadi_swap()

template<typename T1 >

void casadi::casadi_swap	(	casadi_int	n,
		T1 *	x,
		casadi_int	inc_x,
		T1 *	y,
		casadi_int	inc_y
	)

casadi_tensor_ttv()

template<typename T1 >

void casadi::casadi_tensor_ttv	(	T1 *	ret,
		casadi_int	dim,
		casadi_int	n_dims,
		const T1 *	all_w,
		const casadi_int *	w_offset,
		const casadi_int *	starts,
		const casadi_int *	strides,
		const T1 *	c,
		casadi_int	m,
		T1	weight,
		casadi_int	offset
	)

casadi_trans()

template<typename T1 >

void casadi::casadi_trans	(	const T1 *	x,
		const casadi_int *	sp_x,
		T1 *	y,
		const casadi_int *	sp_y,
		casadi_int *	tmp
	)

Referenced by casadi::FmuFunction::eval(), casadi::SlicotDple::eval(), and casadi::OoqpInterface::solve().

casadi_trilsolve()

template<typename T1 >

void casadi::casadi_trilsolve	(	const casadi_int *	sp_a,
		const T1 *	nz_a,
		T1 *	x,
		int	tr,
		int	unity,
		casadi_int	nrhs
	)

Referenced by casadi::TrilSolve< Tr >::eval(), casadi::TrilSolveUnity< Tr >::eval(), casadi::TrilSolve< Tr >::eval_sx(), and casadi::TrilSolveUnity< Tr >::eval_sx().

casadi_triusolve()

template<typename T1 >

void casadi::casadi_triusolve	(	const casadi_int *	sp_a,
		const T1 *	nz_a,
		T1 *	x,
		int	tr,
		int	unity,
		casadi_int	nrhs
	)

Referenced by casadi::TriuSolve< Tr >::eval(), casadi::TriuSolveUnity< Tr >::eval(), casadi::TriuSolve< Tr >::eval_sx(), and casadi::TriuSolveUnity< Tr >::eval_sx().

casadi_uno_term_cb_cpp()

static uno_int casadi::casadi_uno_term_cb_cpp ( uno_int  , uno_int  , const double *  primals, const double *  lower_mult, const double *  upper_mult, const double *  constraint_mult, double  , double  , double  , double  , void *  user_data  )

static

Definition at line 187 of file uno_interface.cpp.

                                                       {
    constexpr uno_int CONTINUE = 1;
    constexpr uno_int TERMINATE = 0;
    auto* m = static_cast<UnoMemory*>(user_data);  // wired in init_mem
    const UnoInterface& self = m->self;
    if (self.fcallback_.is_null()) return CONTINUE;
 
    auto* d_nlp = &m->d_nlp;
    casadi_copy(primals, self.nx_, d_nlp->z);
    for (casadi_int i = 0; i < self.nx_; ++i) {
      // Negative sign convention: bound multipliers are added (cf casadi_uno_solve).
      d_nlp->lam[i] = lower_mult[i] + upper_mult[i];
    }
    if (self.ng_ > 0) {
      casadi_copy(constraint_mult, self.ng_, d_nlp->lam + self.nx_);
    }
    std::fill_n(m->arg, self.fcallback_.n_in(), nullptr);
    m->arg[NLPSOL_X]     = d_nlp->z;
    m->arg[NLPSOL_LAM_X] = d_nlp->lam;
    m->arg[NLPSOL_LAM_G] = d_nlp->lam + self.nx_;
    std::fill_n(m->res, self.fcallback_.n_out(), nullptr);
    double ret_double = 0;
    m->res[0] = &ret_double;
    try {
      self.fcallback_(m->arg, m->res, m->iw, m->w, 0);
    } catch (KeyboardInterruptException&) {
      return TERMINATE;
    } catch (std::exception& ex) {
      casadi_warning(std::string("intermediate_callback: ") + ex.what());
      return self.iteration_callback_ignore_errors_ ? CONTINUE : TERMINATE;
    }
    return static_cast<casadi_int>(ret_double) ? TERMINATE : CONTINUE;
  }

References casadi_copy(), NLPSOL_LAM_G, NLPSOL_LAM_X, NLPSOL_X, and casadi::FunctionInternal::self().

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

casadi_vfmax()

template<typename T1 >

T1 casadi::casadi_vfmax	(	const T1 *	x,
		casadi_int	n,
		T1	r
	)

casadi_vfmin()

template<typename T1 >

T1 casadi::casadi_vfmin	(	const T1 *	x,
		casadi_int	n,
		T1	r
	)

check_exposed()

template<typename T >

T casadi::check_exposed

(

T

t

)

Definition at line 40 of file plugin_interface.hpp.

                       {
    casadi_assert(t!=0, "Static function not implemented for plugin");
    return t;
  }

References T.

check_sos()

template<class T >

void casadi::check_sos	(	casadi_int	nx,
		const std::vector< std::vector< T > > &	groups,
		std::vector< std::vector< double > > &	weights,
		std::vector< casadi_int > &	types
	)

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

Definition at line 79 of file nlp_tools.hpp.

                                                  {
    // Checks on presence
    if (groups.empty()) {
      casadi_assert(weights.empty(), "Missing sos_groups.");
      casadi_assert(types.empty(),   "Missing sos_groups.");
    }
 
    // Checks on dimensions
    casadi_int sos_num = groups.size();
 
    casadi_assert(weights.empty() || weights.size()==sos_num,
      "sos_weights has incorrect size");
 
    // Set default types
    if (!groups.empty() && types.empty())
      types.resize(sos_num, 1);
 
    // Set default weights
    if (weights.empty()) {
      for (const auto& e : groups) {
        std::vector<double> w(e.size());
        for (casadi_int i=0;i<w.size();++i) w[i] = i;
        weights.push_back(w);
      }
    }
 
    casadi_assert(types.size()==sos_num,
      "sos_types has incorrect size");
 
    // Group-wise dimension check
    for (casadi_int i=0;i<weights.size();++i) {
      casadi_assert(weights[i].size()==groups[i].size(),
        "Dimension mismatch in weights for group " + str(i) + ": "
        "Expected " + str(groups[i].size()) + ", got " + str(weights[i].size()));
    }
 
    // Checks on contents
    for (casadi_int t : types) casadi_assert(t==1 || t==2, "SOS type must be either 1 or 2.");
    for (const auto& v : groups) casadi_assert(in_range(v, 0, nx), "Index out of bound");
  }

References in_range(), and str().

Referenced by casadi::CbcInterface::init(), casadi::CplexInterface::init(), casadi::GurobiInterface::init(), and casadi::XpressInterface::init().

classic_codegen_asum_aux()

static void casadi::classic_codegen_asum_aux ( CodeGenerator &  g, const std::vector< std::string > &  inst  )

static

Definition at line 219 of file blas_classic.cpp.

                                        {
    // Match casadi_norm_1<T>'s null-pointer semantics: returns 0 on x==NULL.
    static const char* SRC =
        "// SYMBOL \"norm_1\"\n"
        "casadi_real casadi_norm_1(casadi_int n, const casadi_real* x) {\n"
        "  int n_ = (int)n, inc = 1;\n"
        "  if (!x) return 0;\n"
        "  return CASADI_BLAS_DASUM(&n_, x, &inc);\n"
        "}\n";
    g.auxiliaries << CLASSIC_DASUM_DECL << "\n";
    g.auxiliaries << g.sanitize_source(SRC, inst);
  }

References casadi::CodeGenerator::auxiliaries, CLASSIC_DASUM_DECL, and casadi::CodeGenerator::sanitize_source().

Referenced by casadi_register_blas_classic().

classic_codegen_axpy_aux()

static void casadi::classic_codegen_axpy_aux ( CodeGenerator &  g, const std::vector< std::string > &  inst  )

static

Definition at line 169 of file blas_classic.cpp.

                                        {
    static const char* SRC =
        "// SYMBOL \"axpy\"\n"
        "void casadi_axpy(casadi_int n, casadi_real alpha,\n"
        "    const casadi_real* x, casadi_real* y) {\n"
        "  int n_ = (int)n, inc = 1;\n"
        "  CASADI_BLAS_DAXPY(&n_, &alpha, x, &inc, y, &inc);\n"
        "}\n";
    g.auxiliaries << CLASSIC_DAXPY_DECL << "\n";
    g.auxiliaries << g.sanitize_source(SRC, inst);
  }

References casadi::CodeGenerator::auxiliaries, CLASSIC_DAXPY_DECL, and casadi::CodeGenerator::sanitize_source().

Referenced by casadi_register_blas_classic().

classic_codegen_dot_aux()

static void casadi::classic_codegen_dot_aux ( CodeGenerator &  g, const std::vector< std::string > &  inst  )

static

Definition at line 194 of file blas_classic.cpp.

                                        {
    static const char* SRC =
        "// SYMBOL \"dot\"\n"
        "casadi_real casadi_dot(casadi_int n,\n"
        "    const casadi_real* x, const casadi_real* y) {\n"
        "  int n_ = (int)n, inc = 1;\n"
        "  return CASADI_BLAS_DDOT(&n_, x, &inc, y, &inc);\n"
        "}\n";
    g.auxiliaries << CLASSIC_DDOT_DECL << "\n";
    g.auxiliaries << g.sanitize_source(SRC, inst);
  }

References casadi::CodeGenerator::auxiliaries, CLASSIC_DDOT_DECL, and casadi::CodeGenerator::sanitize_source().

Referenced by casadi_register_blas_classic().

classic_codegen_mtimes()

static void casadi::classic_codegen_mtimes ( CodeGenerator &  g, const std::string &  A, casadi_int  m, casadi_int  k, const std::string &  B, casadi_int  n, const std::string &  C  )

static

Definition at line 150 of file blas_classic.cpp.

                                                            {
    g.add_external(CLASSIC_DECL);
    // Locals shared with other Fortran-ABI BLAS plugins. g.local is
    // idempotent on (name,type) match, so multiple plugins coexisting in
    // the same Function reuse the same locals safely.
    g.local("blas_tn", "char");      g.init_local("blas_tn", "'N'");
    g.local("blas_one", "double");   g.init_local("blas_one", "1.0");
    g.local("blas_m", "int");
    g.local("blas_n", "int");
    g.local("blas_k", "int");
    g << "blas_m = " << m << "; blas_n = " << n << "; blas_k = " << k << ";\n";
    g << "CASADI_BLAS_DGEMM(&blas_tn, &blas_tn, &blas_m, &blas_n, &blas_k, "
         "&blas_one, " << A << ", &blas_m, " << B << ", &blas_k, "
         "&blas_one, " << C << ", &blas_m);\n";
  }

References casadi::CodeGenerator::add_external(), C, CLASSIC_DECL, casadi::CodeGenerator::init_local(), and casadi::CodeGenerator::local().

Referenced by casadi_register_blas_classic().

classic_codegen_nrm2_aux()

static void casadi::classic_codegen_nrm2_aux ( CodeGenerator &  g, const std::vector< std::string > &  inst  )

static

Definition at line 207 of file blas_classic.cpp.

                                        {
    static const char* SRC =
        "// SYMBOL \"norm_2\"\n"
        "casadi_real casadi_norm_2(casadi_int n, const casadi_real* x) {\n"
        "  int n_ = (int)n, inc = 1;\n"
        "  return CASADI_BLAS_DNRM2(&n_, x, &inc);\n"
        "}\n";
    g.auxiliaries << CLASSIC_DNRM2_DECL << "\n";
    g.auxiliaries << g.sanitize_source(SRC, inst);
  }

References casadi::CodeGenerator::auxiliaries, CLASSIC_DNRM2_DECL, and casadi::CodeGenerator::sanitize_source().

Referenced by casadi_register_blas_classic().

classic_codegen_scal_aux()

static void casadi::classic_codegen_scal_aux ( CodeGenerator &  g, const std::vector< std::string > &  inst  )

static

Definition at line 182 of file blas_classic.cpp.

                                        {
    static const char* SRC =
        "// SYMBOL \"scal\"\n"
        "void casadi_scal(casadi_int n, casadi_real alpha, casadi_real* x) {\n"
        "  int n_ = (int)n, inc = 1;\n"
        "  CASADI_BLAS_DSCAL(&n_, &alpha, x, &inc);\n"
        "}\n";
    g.auxiliaries << CLASSIC_DSCAL_DECL << "\n";
    g.auxiliaries << g.sanitize_source(SRC, inst);
  }

References casadi::CodeGenerator::auxiliaries, CLASSIC_DSCAL_DECL, and casadi::CodeGenerator::sanitize_source().

Referenced by casadi_register_blas_classic().

classic_dasum()

static double casadi::classic_dasum ( casadi_int  n, const double *  x  )

static

Definition at line 88 of file blas_classic.cpp.

                                                             {
    casadi_assert(n <= INT_MAX,
        "BLAS 'classic' plugin: vector length exceeds 32-bit BLAS ABI.");
    int n_ = static_cast<int>(n), inc = 1;
    return dasum_(&n_, x, &inc);
  }

Referenced by casadi_register_blas_classic().

classic_daxpy()

static void casadi::classic_daxpy ( casadi_int  n, double  alpha, const double *  x, double *  y  )

static

Definition at line 58 of file blas_classic.cpp.

                                                        {
    casadi_assert(n <= INT_MAX,
        "BLAS 'classic' plugin: vector length exceeds 32-bit BLAS ABI.");
    int n_ = static_cast<int>(n), inc = 1;
    daxpy_(&n_, &alpha, x, &inc, y, &inc);
  }

Referenced by casadi_register_blas_classic().

classic_dcopy()

static void casadi::classic_dcopy ( const double *  x, casadi_int  n, double *  y  )

static

Definition at line 95 of file blas_classic.cpp.

                                                                      {
    if (!y) return;
    if (x) std::memcpy(y, x, n * sizeof(double));
    else   std::memset(y, 0, n * sizeof(double));
  }

Referenced by casadi_register_blas_classic().

classic_ddot()

static double casadi::classic_ddot ( casadi_int  n, const double *  x, const double *  y  )

static

Definition at line 66 of file blas_classic.cpp.

                                                               {
    casadi_assert(n <= INT_MAX,
        "BLAS 'classic' plugin: vector length exceeds 32-bit BLAS ABI.");
    int n_ = static_cast<int>(n), inc = 1;
    return ddot_(&n_, x, &inc, y, &inc);
  }

Referenced by casadi_register_blas_classic().

classic_dgemm()

static void casadi::classic_dgemm ( int  transa, int  transb, casadi_int  m, casadi_int  n, casadi_int  k, double  alpha, const double *  A, casadi_int  lda, const double *  B, casadi_int  ldb, double  beta, double *  C, casadi_int  ldc  )

static

Definition at line 35 of file blas_classic.cpp.

                                                       {
    // Fortran BLAS-32 takes int by reference. Guard against ILP64 / huge
    // problems before silently truncating.
    casadi_assert(m   <= INT_MAX && n   <= INT_MAX && k   <= INT_MAX
               && lda <= INT_MAX && ldb <= INT_MAX && ldc <= INT_MAX,
        "BLAS 'classic' plugin: matrix dimension exceeds 32-bit BLAS ABI. "
        "Rebuild against an ILP64 BLAS or use the \"reference\" plugin.");
 
    const char ta = (transa == CASADI_BLAS_TRANS) ? 'T' : 'N';
    const char tb = (transb == CASADI_BLAS_TRANS) ? 'T' : 'N';
    int m_ = static_cast<int>(m), n_ = static_cast<int>(n), k_ = static_cast<int>(k);
    int lda_ = static_cast<int>(lda), ldb_ = static_cast<int>(ldb), ldc_ = static_cast<int>(ldc);
 
    dgemm_(&ta, &tb, &m_, &n_, &k_, &alpha,
           A, &lda_, B, &ldb_, &beta, C, &ldc_);
  }

References C, and CASADI_BLAS_TRANS.

Referenced by casadi_register_blas_classic().

classic_dnrm2()

static double casadi::classic_dnrm2 ( casadi_int  n, const double *  x  )

static

Definition at line 81 of file blas_classic.cpp.

                                                             {
    casadi_assert(n <= INT_MAX,
        "BLAS 'classic' plugin: vector length exceeds 32-bit BLAS ABI.");
    int n_ = static_cast<int>(n), inc = 1;
    return dnrm2_(&n_, x, &inc);
  }

Referenced by casadi_register_blas_classic().

classic_dscal()

static void casadi::classic_dscal ( casadi_int  n, double  alpha, double *  x  )

static

Definition at line 74 of file blas_classic.cpp.

                                                                   {
    casadi_assert(n <= INT_MAX,
        "BLAS 'classic' plugin: vector length exceeds 32-bit BLAS ABI.");
    int n_ = static_cast<int>(n), inc = 1;
    dscal_(&n_, &alpha, x, &inc);
  }

Referenced by casadi_register_blas_classic().

codegen_copy_z()

static void casadi::codegen_copy_z ( CodeGenerator &  g, casadi_int  nnz, const std::vector< casadi_int > &  arg, const std::vector< casadi_int > &  res, const std::vector< bool > &  arg_is_ref  )

static

Definition at line 142 of file multiplication.cpp.

                                                                {
    if (arg[0]!=res[0] || arg_is_ref[0]) {
      g << g.copy(g.work(arg[0], nnz, arg_is_ref[0]),
                  nnz,
                  g.work(res[0], nnz, false)) << '\n';
    }
  }

References casadi::CodeGenerator::copy(), and casadi::CodeGenerator::work().

Referenced by casadi::Multiplication::generate(), casadi::DenseMultiplication::generate(), casadi::DenseSparseMultiplication::generate(), and casadi::PseudoDenseMultiplication::generate().

codegen_int_array()

static void casadi::codegen_int_array ( CodeGenerator &  g, const std::string &  name, const std::vector< uno_int > &  v  )

static

Definition at line 398 of file uno_interface.cpp.

                                   {
    if (v.empty()) {
      g << "p." << name << " = 0;\n";
      return;
    }
    g << g.array("static const int", "p_" + name, v.size(),
                 g.initializer(vector_static_cast<casadi_int>(v)));
    g << "p." << name << " = p_" << name << ";\n";
  }

References casadi::CodeGenerator::array(), and casadi::CodeGenerator::initializer().

codegen_int_field() [1/2]

static void casadi::codegen_int_field ( CodeGenerator &  g, const std::string &  prob_field, const std::string &  local_name, const std::vector< int > &  v  )

static

Definition at line 165 of file mosek_interface.cpp.

                                                            {
    if (v.empty()) {
      g << "p." << prob_field << " = 0;\n";
    } else {
      g.constant_copy(local_name, vector_static_cast<casadi_int>(v), "int");
      g << "p." << prob_field << " = " << local_name << ";\n";
    }
  }

References casadi::CodeGenerator::constant_copy().

Referenced by casadi::MosekInterface::set_mosek_prob(), and casadi::XpressInterface::set_xpress_prob().

codegen_int_field() [2/2]

static void casadi::codegen_int_field ( CodeGenerator &  g, const std::string &  prob_field, const std::string &  local_name, const std::vector< int > &  v  )

static

Definition at line 226 of file xpress_interface.cpp.

                                                            {
    if (v.empty()) {
      g << "p." << prob_field << " = 0;\n";
    } else {
      g.constant_copy(local_name, vector_static_cast<casadi_int>(v), "int");
      g << "p." << prob_field << " = " << local_name << ";\n";
    }
  }

References casadi::CodeGenerator::constant_copy().

codegen_local()

void casadi::codegen_local	(	CodeGenerator &	g,
		const std::string &	name,
		const std::vector< int > &	v
	)

Definition at line 105 of file clarabel_interface.cpp.

                                                                                     {
  std::string n = name + "[]";
  g.local(n, "static const int");
  std::stringstream init;
  init << "{";
  for (casadi_int i = 0; i < v.size(); ++i) {
    init << v[i];
    if (i < v.size()-1) init << ", ";
  }
  if (v.empty()) init << "0"; // ISO C forbids empty initializer braces
  init << "}";
  g.init_local(n, init.str());
}

References casadi::CodeGenerator::init_local(), and casadi::CodeGenerator::local().

Referenced by casadi::ClarabelInterface::set_clarabel_prob(), casadi::DaqpInterface::set_daqp_prob(), casadi::HighsInterface::set_highs_prob(), and casadi::HpipmInterface::set_hpipm_prob().

codegen_unpack_block() [1/2]

void casadi::codegen_unpack_block	(	CodeGenerator &	g,
		const std::string &	name,
		const std::vector< casadi_hpipm_block > &	blocks
	)

Definition at line 490 of file hpipm_interface.cpp.

                                                   {
    std::string n = "block_" + name + "[" + str(blocks.size()) + "]";
    g.local(n, "static struct casadi_hpipm_block");
    g << "p." << name << " = block_" + name + ";\n";
    g << "casadi_hpipm_unpack_blocks(" << blocks.size()
    << ", p." << name
    << ", " << g.constant(hpipm_blocks_pack(blocks)) << ");\n";
  }

References casadi::CodeGenerator::constant(), hpipm_blocks_pack(), casadi::CodeGenerator::local(), and str().

codegen_unpack_block() [2/2]

void casadi::codegen_unpack_block	(	CodeGenerator &	g,
		const std::string &	name,
		const std::vector< casadi_ocp_block > &	blocks
	)

Definition at line 813 of file fatrop_interface.cpp.

                                                 {
    casadi_int sz = blocks.size();
    if (sz==0) sz++;
    std::string n = "block_" + name + "[" + str(sz) + "]";
    g.local(n, "static struct casadi_ocp_block");
    g << "p." << name << " = block_" + name + ";\n";
    g << "casadi_unpack_ocp_blocks(" << "p." << name
    << ", " << g.constant(fatrop_blocks_pack(blocks)) << ");\n";
  }

References casadi::CodeGenerator::constant(), fatrop_blocks_pack(), casadi::CodeGenerator::local(), and str().

Referenced by casadi::FatropInterface::set_fatrop_prob(), and casadi::HpipmInterface::set_hpipm_prob().

collocation_coeff()

CASADI_EXPORT void casadi::collocation_coeff	(	const std::vector< double > &	tau,
		DM &	C,
		DM &	D,
		DM &	B
	)

A collocation method poses a polynomial Pi that interpolates exactly through an initial state (0,X_0) and helper states at collocation points (tau_j,Xc_j) with j=1..degree.

This function computes the linear mapping between dPi/dt and coefficients Z=[X_0 Xc].

Parameters

	tau	location of collocation points (length: degree), as obtained from collocation_points
[out]	C	interpolating coefficients to obtain derivatives. Size: (degree+1)-by-degree

You may find the slopes of Pi at the collocation points as

    dPi/dt @ Xc = (1/h) Z*C,

with h the length of the integration interval.

Parameters

[out]

D

interpolating coefficients to obtain end state. Size: (degree+1)-by-1

You may find the end point of Pi as

    Pi @X_f = Z*D

Parameters

[out]

B

quadrature coefficients Size: degree-by-1

Given quadrature righ-hand-sides 'quad' evaluated at the collocation points, you may find the integrated quadratures as

    q = quad*B*h

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

Definition at line 233 of file integration_tools.cpp.

                                                   {
  // Find the degree of the interpolation
  casadi_int deg = tau.size();
 
  // Include zero
  std::vector<double> etau_root = tau;
  etau_root.insert(etau_root.begin(), 0);
 
  // Check if tau ends with '1' (cfr. radau scheme)
  bool has_end = tau.back()==1;
 
  // Coefficients of the collocation equation
  std::vector<std::vector<double> > C_(deg+1, std::vector<double>(deg+1, 0));
 
  // Coefficients of the continuity equation
  std::vector<double> D_(deg+1, 0);
 
  // Coefficients of the quadratures
  std::vector<double> B_(deg+1, 0);
 
  // For all collocation points
  for (casadi_int j=0; j<deg+1; ++j) {
 
    // Construct Lagrange polynomials to get the polynomial basis at the collocation point
    Polynomial p = 1;
    for (casadi_int r=0; r<deg+1; ++r) {
      if (r!=j) {
        p *= Polynomial(-etau_root[r], 1)/(etau_root[j]-etau_root[r]);
      }
    }
 
    // Evaluate the polynomial at the final time to get the
    // coefficients of the continuity equation
    if (has_end) {
      D_[j] = j==deg ? 1 : 0;
    } else {
      D_[j] = p(1.0);
    }
    // Evaluate the time derivative of the polynomial at all collocation points to
    // get the coefficients of the continuity equation
    Polynomial dp = p.derivative();
    for (casadi_int r=0; r<deg+1; ++r) {
      C_[j][r] = dp(etau_root[r]);
    }
 
    // Integrate polynomial to get the coefficients of the quadratures
    Polynomial ip = p.anti_derivative();
    B_[j] = ip(1.0);
  }
  C = DM(C_);
  C = C(Slice(), Slice(1, deg+1)); // NOLINT(cppcoreguidelines-slicing)
  D = DM(D_);
  B = DM(std::vector<double>(B_.begin()+1, B_.end()));
}

References casadi::Polynomial::anti_derivative(), C, D, and casadi::Polynomial::derivative().

collocation_interpolators()

CASADI_EXPORT void casadi::collocation_interpolators	(	const std::vector< double > &	tau,
		std::vector< std::vector< double > > &	C,
		std::vector< double > &	D
	)

A collocation method poses a polynomial Pi that interpolates exactly through an initial state (0,X_0) and helper states at collocation points (tau_j,X:collPoint(j)).

This function computes the linear mapping between dPi/dt and coefficients Z=[X_0 X:collPoints].

Parameters

	tau	location of collocation points, as obtained from collocation_points
[out]	C	interpolating coefficients to obtain derivatives. Length: order+1, order+1

    dPi/dt @Z_j = (1/h) Sum_i C[j][i]*Z_i,

with h the length of the integration interval.

Parameters

[out]

D

interpolating coefficients to obtain end state. Length: order+1

    Pi @X_f = Sum_i D[i]*Z_i

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

Definition at line 189 of file integration_tools.cpp.

                                                                                         {
  // Find the degree of the interpolation
  casadi_int deg = tau.size();
 
  // Include zero
  std::vector<double> etau_root = tau;
  etau_root.insert(etau_root.begin(), 0);
 
  // Allocate storage space for resulting coefficients
  C.resize(deg+1);
  for (casadi_int i=0;i<deg+1;++i) {
    C[i].resize(deg+1);
  }
  D.resize(deg+1);
 
  // Collocation point
  SX tau_sym = SX::sym("tau");
 
  // For all collocation points
  for (casadi_int j=0; j<deg+1; ++j) {
    // Construct Lagrange polynomials to get the polynomial basis at the collocation point
    SX L = 1;
    for (casadi_int j2=0; j2<deg+1; ++j2) {
      if (j2 != j) {
        L *= (tau_sym-etau_root[j2])/(etau_root[j]-etau_root[j2]);
      }
    }
 
    Function lfcn("lfcn", {tau_sym}, {L});
 
    // Evaluate the polynomial at the final time to get the
    // coefficients of the continuity equation
    D[j] = lfcn(std::vector<DM>{1.}).at(0)->front();
 
    // Evaluate the time derivative of the polynomial at all collocation points to
    // get the coefficients of the continuity equation
    Function tfcn("tfcn", {tau_sym}, {tangent(L, tau_sym)});
    for (casadi_int j2=0; j2<deg+1; ++j2) {
      C[j2][j] =  tfcn(std::vector<DM>{etau_root[j2]}).at(0)->front();
    }
  }
}

References C, D, and casadi::GenericMatrix< Matrix< Scalar > >::sym().

Referenced by simpleIRK().

collocation_points()

CASADI_EXPORT std::vector< double > casadi::collocation_points	(	casadi_int	order,
		const std::string &	scheme = "radau"
	)

Parameters

order	Which order (1 to 9 supported)
scheme	'radau' or 'legendre'

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

Definition at line 120 of file integration_tools.cpp.

                                                                                {
  return collocation_pointsGen<double>(order, scheme);
}

Referenced by casadi::Collocation::setup_step(), and simpleIRK().

collocation_pointsGen()

template<typename RealT >

std::vector<RealT> casadi::collocation_pointsGen	(	casadi_int	order,
		const std::string &	scheme
	)

Definition at line 103 of file integration_tools.cpp.

                                                                                  {
  if (scheme=="radau") {
    casadi_assert(order>0 && order<10,
      "Error in collocationPoints(order, scheme): "
      "only order up to 9 supported for scheme 'radau', but got " + str(order) + ".");
    return std::vector<RealT>(radau_points[order], radau_points[order]+order);
  } else if (scheme=="legendre") {
    casadi_assert(order>0 && order<10,
      "Error in collocationPoints(order, scheme): "
      "only order up to 9 supported for scheme 'legendre', but got " + str(order) + ".");
    return std::vector<RealT>(legendre_points[order], legendre_points[order]+order);
  } else {
    casadi_error("Error in collocationPoints(order, scheme): unknown scheme '"
                  + scheme + "'. Select one of 'radau', 'legendre'.");
  }
}

References legendre_points, radau_points, and str().

collocation_pointsL()

CASADI_EXPORT std::vector< long double > casadi::collocation_pointsL	(	casadi_int	order,
		const std::string &	scheme
	)

Parameters

order	Which order (1 to 9 supported)
scheme	'radau' or 'legendre'

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

Definition at line 124 of file integration_tools.cpp.

                                                                                      {
  return collocation_pointsGen<long double>(order, scheme);
}

combine()

CASADI_EXPORT Dict casadi::combine	(	const Dict &	first,
		const Dict &	second,
		bool	recurse = false
	)

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

Definition at line 827 of file generic_type.cpp.

                                                                    {
    if (first.empty()) return second;
    if (second.empty()) return first;
    Dict ret = second;
    update_dict(ret, first, recurse);
    return ret;
  }

References update_dict().

Referenced by casadi::OracleFunction::create_function(), casadi::FunctionInternal::forward(), casadi::BlazingSplineFunction::get_jacobian(), casadi::FunctionInternal::jacobian(), casadi::FunctionInternal::reverse(), and casadi::MX::stop_diff().

common_simp_binary()

template<class T , typename SU , typename SB >

T casadi::common_simp_binary	(	casadi_int	op,
		const T &	x,
		const T &	y,
		casadi_int	depth,
		SU &&	gen_unary,
		SB &&	gen_binary,
		bool	unique_x,
		bool	unique_y,
		bool &	hit
	)

Definition at line 1871 of file calculus.hpp.

                 {
    hit = true;
    switch (op) {
      case OP_ADD:
        if (x.is_zero())
          return y;
        else if (y->is_zero()) // term2 is zero
          return x;
        else if (y.is_op(OP_NEG))  // x + (-y) -> x - y
          return x - (-y);
        else if (x.is_op(OP_NEG)) // (-x) + y -> y - x
          return y - x.dep();
        else if (is_equal(x, y, depth))
          return 2*x; // x+x -> 2*x
        else if (x.is_op(OP_MUL) && y.is_op(OP_MUL) &&
                x.dep(0).is_constant() && static_cast<double>(x.dep(0))==0.5 &&
                y.dep(0).is_constant() && static_cast<double>(y.dep(0))==0.5 &&
                is_equal(y.dep(1), x.dep(1), depth)) // 0.5x+0.5x = x
          return x.dep(1);
        else if (x.is_op(OP_DIV) && y.is_op(OP_DIV) &&
                x.dep(1).is_constant() && static_cast<double>(x.dep(1))==2 &&
                y.dep(1).is_constant() && static_cast<double>(y.dep(1))==2 &&
                is_equal(y.dep(0), x.dep(0), depth)) // x/2+x/2 = x
          return x.dep(0);
        else if (x.is_op(OP_MUL) && y.is_op(OP_MUL) &&
          x.dep(0).is_constant() && y.dep(0).is_constant() &&
          static_cast<double>(x.dep(0))+static_cast<double>(y.dep(0))==1 &&
          is_equal(y.dep(1), x.dep(1), depth)
          )
          return x.dep(1);
        else if (x.is_op(OP_SUB) && is_equal(x.dep(1), y, depth))
          return x.dep(0);
        else if (y.is_op(OP_SUB) && is_equal(x, y.dep(1), depth))
          return y.dep(0);
        else if (x.is_op(OP_SQ) && y.is_op(OP_SQ) &&
                ((x.dep().is_op(OP_SIN) && y.dep().is_op(OP_COS))
                  || (x.dep().is_op(OP_COS) && y.dep().is_op(OP_SIN)))
                && is_equal(x.dep().dep(), y.dep().dep(), depth))
          return 1; // sin^2 + cos^2 -> 1
        else if (x.is_doubled() && is_equal(x.dep(0), y, depth))
          return 3*x.dep(0);
        else if (y.is_doubled() && is_equal(y.dep(0), x, depth))
          return 3*y.dep(0);
        else if (x.is_op(OP_MUL) && y.is_op(OP_MUL) &&
            is_equal(x.dep(0), y.dep(0), depth) && (x.dep(1)+y.dep(1)).is_one())
          return x.dep(0);
        break;
      case OP_SUB:
        if (y.is_zero()) // term2 is zero
          return x;
        if (x.is_zero()) // term1 is zero
          return -y;
        if (is_equal(x, y, depth)) // the terms are equal
          return 0;
        else if (y.is_op(OP_NEG)) // x - (-y) -> x + y
          return x + y.dep();
        else if (x.is_op(OP_ADD) && is_equal(x.dep(1), y, depth))
          return x.dep(0);
        else if (x.is_op(OP_ADD) && is_equal(x.dep(0), y, depth))
          return x.dep(1);
        else if (y.is_op(OP_ADD) && is_equal(x, y.dep(1), depth))
          return -y.dep(0);
        else if (y.is_op(OP_ADD) && is_equal(x, y.dep(0), depth))
          return -y.dep(1);
        else if (x.is_op(OP_NEG))
          return -(x.dep() + y);
        else if (x.is_op(OP_MUL) && y.is_op(OP_MUL) &&
          x.dep(0).is_constant() && y.dep(0).is_constant() &&
          static_cast<double>(x.dep(0))-static_cast<double>(y.dep(0))==1 &&
          is_equal(y.dep(1), x.dep(1), depth)
          )
          return x.dep(1);
        else if (x.is_doubled() && is_equal(x.dep(0), y, depth))
          return y;
        else if (y.is_doubled() && is_equal(y.dep(0), x, depth))
          return -x;
        break;
      case OP_MUL:
        if (is_equal(y, x, depth))
          return sq(x);
        else if (!x.is_constant() && y.is_constant())
          return y * x;
        else if (x.is_zero() || y->is_zero()) // one of the terms is zero
          return 0;
        else if (x.is_one()) // term1 is one
          return y;
        else if (y.is_one()) // term2 is one
          return x;
        else if (y.is_minus_one())
          return -x;
        else if (x.is_minus_one())
          return -y;
        else if (y.is_op(OP_INV))
          return x/y.inv();
        else if (x.is_op(OP_INV))
          return y / x.inv();
        else if (x.is_constant() && y.is_op(OP_MUL) && y.dep(0).is_constant() &&
                static_cast<double>(x)*static_cast<double>(y.dep(0))==1) // 5*(0.2*x) = x
          return y.dep(1);
        else if (x.is_constant() && y.is_doubled() &&
          static_cast<double>(x)*2==1) // 0.5*(2*x) = x
          return y.dep(0);
        else if (x.is_constant() && y.is_op(OP_DIV) && y.dep(1).is_constant() &&
                static_cast<double>(x)==static_cast<double>(y.dep(1))) // 5*(x/5) = x
          return y.dep(0);
        else if (x.is_constant() && static_cast<double>(x)==2)
          return gen_unary(OP_TWICE, y);
        else if (y.is_constant() && static_cast<double>(y)==2)
          return gen_unary(OP_TWICE, x);
        else if (x.is_op(OP_DIV) && is_equal(x.dep(1), y, depth)) // ((2/x)*x)
          return x.dep(0);
        else if (y.is_op(OP_DIV) &&
                is_equal(y.dep(1), x, depth)) // ((2/x)*x)
          return y.dep(0);
        else if (x.is_op(OP_NEG))
          return -(x.dep() * y);
        else if (y.is_op(OP_NEG))
          return -(x * y.dep());
        else if (unique_x && x.is_op(OP_ADD) && x.dep(1).is_op(OP_DIV) &&
            is_equal(x.dep(1).dep(1), y, depth))
          return x.dep(0)*y + x.dep(1).dep(0); // (a + b/c)*c -> a*c + b
        else if (unique_x && x.is_op(OP_ADD) && x.dep(0).is_op(OP_DIV) &&
            is_equal(x.dep(0).dep(1), y, depth))
          return x.dep(0).dep(0)+x.dep(1)*y; // (a/c + b)*c -> a*c + b
        else if (unique_y && y.is_op(OP_ADD) && y.dep(1).is_op(OP_DIV) &&
            is_equal(y.dep(1).dep(1), x, depth))
          return x*y.dep(0) + y.dep(1).dep(0); // c*(a + b/c) -> c*a + b
        else if (unique_y && y.is_op(OP_ADD) && y.dep(0).is_op(OP_DIV) &&
            is_equal(y.dep(0).dep(1), x, depth))
          return y.dep(0).dep(0) + x*y.dep(1); // c*(a/c + b) -> a + c*b
        else if (unique_x && x.is_op(OP_SUB) && x.dep(1).is_op(OP_DIV) &&
            is_equal(x.dep(1).dep(1), y, depth))
          return x.dep(0)*y - x.dep(1).dep(0); // (a - b/c)*c -> a*c - b
        else if (unique_x && x.is_op(OP_SUB) && x.dep(0).is_op(OP_DIV) &&
            is_equal(x.dep(0).dep(1), y, depth))
          return x.dep(0).dep(0)-x.dep(1)*y; // (a/c - b)*c -> a*c - b
        else if (unique_y && y.is_op(OP_SUB) && y.dep(1).is_op(OP_DIV) &&
            is_equal(y.dep(1).dep(1), x, depth))
          return x*y.dep(0) - y.dep(1).dep(0); // c*(a - b/c) -> c*a - b
        else if (unique_y && y.is_op(OP_SUB) && y.dep(0).is_op(OP_DIV) &&
            is_equal(y.dep(0).dep(1), x, depth))
          return y.dep(0).dep(0) - x*y.dep(1); // c*(a/c - b) -> a - c*b
        else if (x.is_constant() && y.is_op(OP_MUL) && y.dep(0).is_constant())
          return x*y.dep(0)*y.dep(1); // a*(b*x) -> (a*b)*x
        else if (y.is_constant() && x.is_op(OP_MUL) && x.dep(0).is_constant())
          return y*x.dep(0)*x.dep(1); // (a*x)*b -> (a*b)*x
        break;
      case OP_DIV:
        if (y.is_zero()) // term2 is zero
          return std::numeric_limits<double>::infinity();
        else if (x.is_zero()) // term1 is zero
          return 0;
        else if (y.is_one()) // term2 is one
          return x;
        else if (y.is_minus_one())
          return -x;
        else if (y.is_half())
          return 2*x;
        else if (is_equal(x, y, depth)) // terms are equal
          return 1;
        else if (x.is_doubled() && y.is_constant() && static_cast<double>(y)==2)
          return x.dep(0);
        else if (x.is_doubled() && is_equal(y, x.dep(0), depth))
          return 2;
        else if (x.is_op(OP_MUL) && is_equal(y, x.dep(0), depth))
          return x.dep(1);
        else if (x.is_op(OP_MUL) && is_equal(y, x.dep(1), depth))
          return x.dep(0);
        else if (x.is_one())
          return y.inv();
        else if (y.is_op(OP_INV))
          return x*y.inv();
        else if (x.is_doubled() && y.is_doubled())
          return x.dep(0) / y->dep(0);
        else if (y.is_constant() && x.is_op(OP_DIV) && x.dep(1).is_constant() &&
                static_cast<double>(y)*static_cast<double>(x.dep(1))==1) // (x/5)/0.2
          return x.dep(0);
        else if (y.is_op(OP_MUL) &&
                is_equal(y.dep(1), x, depth)) // x/(2*x) = 1/2
          return 1/y.dep(0); //BinarySX::create(OP_DIV, 1, y.dep(0));
        else if (y.is_doubled() &&
          is_equal(y.dep(0), x, depth)) // x/(2*x) = 1/2
          return 0.5;
        else if (x.is_op(OP_NEG) &&
                is_equal(x.dep(0), y, depth))      // (-x)/x = -1
          return -1;
        else if (y.is_op(OP_NEG) &&
                is_equal(y.dep(0), x, depth))      // x/(-x) = 1
          return -1;
        else if (y.is_op(OP_NEG) && x.is_op(OP_NEG) &&
                is_equal(x.dep(0), y.dep(0), depth))  // (-x)/(-x) = 1
          return 1;
        else if (x.is_op(OP_DIV) && is_equal(y, x.dep(0), depth))
          return x.dep(1).inv();
        else if (x.is_op(OP_NEG))
          return -(x.dep() / y);
        else if (y.is_op(OP_NEG))
          return -(x / y.dep());
        break;
      case OP_POW:
        if (y.is_constant()) {
          if (y.is_integer()) {
            casadi_int nn = y->to_int();
            if (nn == 0) {
              return 1;
            } else if (nn>100 || nn<-100) { // maximum depth
              return gen_binary(OP_CONSTPOW, x, nn);
            } else if (nn<0) { // negative power
              return 1/pow(x, -nn);
            } else if (nn%2 == 1) { // odd power
              return x*pow(x, nn-1);
            } else { // even power
              T rt = pow(x, static_cast<casadi_int>(nn/2));
              return rt*rt;
            }
          } else if (y->to_double()==0.5) {
            return sqrt(x);
          } else {
            return gen_binary(OP_CONSTPOW, x, y);
          }
        }
        break;
      case OP_LE:
        if ((y-x).is_nonnegative())
          return 1;
        break;
      case OP_FMIN:
        if (x.is_inf()) return y;
        if (y.is_inf()) return x;
        if (x.is_minus_inf() || y.is_minus_inf()) return -std::numeric_limits<double>::infinity();
        if (is_equal(x, y, depth)) return x;
        break;
      case OP_FMAX:
        if (x.is_minus_inf()) return y;
        if (y.is_minus_inf()) return x;
        if (x.is_inf() || y.is_inf()) return std::numeric_limits<double>::infinity();
        if (is_equal(x, y, depth)) return x;
        break;
      case OP_LT:
        if (((x)-y).is_nonnegative())
          return 0;
        break;
      case OP_EQ:
        if (is_equal(x, y, depth))
          return 1;
        break;
      case OP_NE:
        if (is_equal(x, y, depth))
          return 0;
        break;
      case OP_IF_ELSE_ZERO:
        if (y.is_zero()) {
          return y;
        } else if (x.is_constant()) {
          if (static_cast<double>(x)!=0) {
            return y;
          } else {
            return 0;
          }
        }
    }
    hit = false;
    return 0;
  }

References is_equal(), OP_ADD, OP_CONSTPOW, OP_COS, OP_DIV, OP_EQ, OP_FMAX, OP_FMIN, OP_IF_ELSE_ZERO, OP_INV, OP_LE, OP_LT, OP_MUL, OP_NE, OP_NEG, OP_POW, OP_SIN, OP_SQ, OP_SUB, OP_TWICE, sq(), and T.

Referenced by casadi::MXNode::_get_binary(), and casadi::SXElem::binary().

common_simp_unary()

template<class T , typename SU >

T casadi::common_simp_unary	(	casadi_int	op,
		const T &	x,
		casadi_int	depth,
		SU &&	gen_unary,
		bool	unique,
		bool &	hit
	)

Definition at line 1813 of file calculus.hpp.

                 {
    hit = true;
    switch (op) {
      case OP_TWICE:
        if (x.is_op(OP_MUL) && x.dep(0).is_constant() &&
            x.dep(0).is_half())
          return x.dep(1); // 2*(0.5*x) = x
        else if (x.is_op(OP_MUL) && x.dep(1).is_constant() &&
            x.dep(1).is_half())
          return x.dep(0); // 2*(x*0.5) = x
        break;
      case OP_SQ:
        if (x.is_op(OP_SQRT))
          return x.dep(); // sqrt(x)^2 = x
        else if (x.is_op(OP_NEG))
          return sq(x.dep()); // (-x)^2 = x^2
        else if (x.is_op(OP_FABS))
          return sq(x.dep()); // |x|^2 = x^2
        break;
      case OP_FABS:
        if (x.is_nonnegative())
          return x;
        else if (x.is_op(OP_NEG))
          return fabs(x.dep()); // fabs(-x) = fabs(x)
        break;
      case OP_LOG:
        if (x.is_op(OP_EXP))
          return x.dep(); // log(exp(x)) = x
        break;
      case OP_INV:
        if (x.is_op(OP_INV))
          return x.dep(); // 1/(1/x) = x
        break;
      case OP_SQRT:
        if (x.is_op(OP_SQ))
          return fabs(x.dep()); // sqrt(x^2) = x
        break;
      case OP_COS:
        if (x.is_op(OP_NEG))
          return cos(x.dep()); // cos(-x) = cos(x)
        else if (x.is_op(OP_FABS))
          return cos(x.dep()); // cos(|x|) = cos(x)
        break;
      case OP_NEG:
        if (x.is_op(OP_NEG))
          return x.dep(); // -(-x) = x
        else if (unique && x.is_op(OP_SUB))
          return x.dep(1) - x.dep(0); // -(x-y) = y-x
    }
    hit = false;
    return 0;
  }

References OP_COS, OP_EXP, OP_FABS, OP_INV, OP_LOG, OP_MUL, OP_NEG, OP_SQ, OP_SQRT, OP_SUB, OP_TWICE, sq(), and T.

Referenced by casadi::MXNode::get_unary(), and casadi::SXElem::unary().

complement()

CASADI_EXPORT std::vector< casadi_int > casadi::complement	(	const std::vector< casadi_int > &	v,
		casadi_int	size
	)

The supplied vector may contain duplicates and may be non-monotonous The supplied vector will be checked for bounds The result vector is guaranteed to be monotonously increasing

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

Definition at line 141 of file casadi_misc.cpp.

                                                                                    {
    casadi_assert(in_range(v, size),
                          "complement: out of bounds. Some elements in v fall out of [0, size[");
    std::vector<casadi_int> lookup(size, 0);
    std::vector<casadi_int> ret;
 
    for (casadi_int i=0;i<v.size();i++) {
      lookup[v[i]] = 1;
    }
 
    for (casadi_int i=0;i<size;i++) {
      if (lookup[i]==0) ret.push_back(i);
    }
 
    return ret;
 
  }

References in_range().

Referenced by casadi::Function::mapaccum(), and reduce_index_gen().

compute_knots_cache()

template<typename M >

static M casadi::compute_knots_cache ( const M &  K, const std::vector< casadi_int > &  offsets  )

static

Definition at line 92 of file blazing_spline.cpp.

                                                                                 {
    casadi_int nd = offsets.size() - 1;
    casadi_int degree = 3;
    std::vector<M> parts;
    for (casadi_int d = 0; d < nd; ++d) {
      casadi_int off = offsets[d];
      casadi_int n_k = offsets[d + 1] - off;
      M t = K(Slice(off, off + n_k));
 
      // {intercept, slope} for 'exact' lookup. ng is the length of the
      // searched grid (K[degree : n_k-degree]).
      casadi_int ng = n_k - 2*degree;
      M slope, intercept;
      if (ng >= 2) {
        M g0 = t(degree);
        M dg = t(n_k - degree - 1) - g0;
        // dg=0 would mean a degenerate grid; guard the divide.
        slope     = if_else_zero(dg, static_cast<double>(ng-1) / (dg + 1e-100));
        intercept = -g0 * slope;
      } else {
        slope     = M::zeros(1, 1);
        intercept = M::zeros(1, 1);
      }
      parts.push_back(intercept);
      parts.push_back(slope);
 
      // Existing inv1/inv2/inv3 spans.
      for (casadi_int span = 1; span <= 3; ++span) {
        M inv_span;
        if (span < n_k) {
          M diff = t(Slice(span, n_k)) - t(Slice(0, n_k - span));
          diff = vertcat(diff, M::zeros(span, 1));
          inv_span = if_else_zero(diff, 1.0 / (diff + 1e-100));
        } else {
          inv_span = M::zeros(n_k, 1);
        }
        parts.push_back(inv_span);
      }
    }
    return vertcat(parts);
  }

References diff(), and if_else_zero().

Referenced by blazing_spline(), casadi::BlazingSplineFunction::get_jacobian(), and casadi::BlazingSplineFunction::init_derived_members().

constant_ints()

static std::vector<casadi_int> casadi::constant_ints ( const MX &  m )

static

Definition at line 472 of file onnx_import.cpp.

                                                          {
    casadi_assert(m.is_constant(), "Expected a constant integer tensor");
    DM dm = static_cast<DM>(m);
    std::vector<casadi_int> v;
    for (casadi_int k = 0; k < dm.numel(); ++k)
      v.push_back(static_cast<casadi_int>(dm(k).scalar()));
    return v;
  }

References casadi::MX::is_constant(), and casadi::GenericMatrix< MatType >::numel().

ConstantSX_deserialize()

SXNode* casadi::ConstantSX_deserialize ( DeserializingStream &  s )

inline

Definition at line 506 of file constant_sx.hpp.

                                                              {
  char type;
  s.unpack("ConstantSX::type", type);
  switch (type) {
    case '1': return casadi_limits<SXElem>::one.get();
    case '0': return casadi_limits<SXElem>::zero.get();
    case 'r': {
      double value;
      s.unpack("ConstantSX::value", value);
      return RealtypeSX::create(value);
    }
    case 'i': {
      int value;
      s.unpack("ConstantSX::value", value);
      if (value==2) return casadi_limits<SXElem>::two.get();
      return IntegerSX::create(value);
    }
    case 'n': return casadi_limits<SXElem>::nan.get();
    case 'f': return casadi_limits<SXElem>::minus_inf.get();
    case 'F': return casadi_limits<SXElem>::inf.get();
    case 'm': return casadi_limits<SXElem>::minus_one.get();
    default: casadi_error("ConstantSX::deserialize error");
  }
}

References casadi::IntegerSX::create(), casadi::RealtypeSX::create(), and casadi::DeserializingStream::unpack().

constpow()

double casadi::constpow ( double  x, double  y  )

inline

CasADi additions

Definition at line 278 of file calculus.hpp.

{ return pow(x, y);}

construct_nlpsol()

template<class X >

Function casadi::construct_nlpsol	(	const std::string &	name,
		const std::string &	solver,
		const std::map< std::string, X > &	nlp,
		const Dict &	opts
	)

Definition at line 63 of file nlpsol.cpp.

                                                                     {
 
    if (get_from_dict(opts, "detect_simple_bounds", false)) {
      X x = get_from_dict(nlp, "x", X(0, 1));
      X p = get_from_dict(nlp, "p", X(0, 1));
      X f = get_from_dict(nlp, "f", X(0));
      X g = get_from_dict(nlp, "g", X(0, 1));
 
      if (g.size1()>0 || g.size2()>0) {
        // Dimension checks
        casadi_assert(g.is_dense() && g.is_vector(),
          "Expected a dense vector 'g', but got " + g.dim(true) + ".");
      }
 
      // Read dimensions
      casadi_int ng = g.size1();
      casadi_int nx = x.size1();
 
      // Get constraint Jacobian sparsity
      Sparsity sp = jacobian_sparsity(g, x).T();
 
      // Reset result vector
      std::vector<bool> is_simple(ng, true);
 
      // Check nonlinearity
      std::vector<bool> is_nonlin = which_depends(g, x, 2, true);
 
      const casadi_int* row = sp.colind();
      for (casadi_int i=0;i<ng;++i) {
        // Check if each row of jac_g_x only depends on one column
        bool single_dependency = row[i+1]-row[i]==1;
        is_simple[i] = single_dependency && !is_nonlin[i];
      }
 
      // Full-indices of all simple constraints
      std::vector<casadi_int> sgi = boolvec_to_index(is_simple);
      std::vector<casadi_int> gi = boolvec_to_index(boolvec_not(is_simple));
      X g_bounds = g(sgi);
 
      // Detect  f2(p)x+f1(p)==0
      Function gf = Function("gf", std::vector<X>{x, p},
        std::vector<X>{jtimes(g_bounds, x, X::ones(nx, 1)), g_bounds});
      casadi_assert_dev(!gf.has_free());
 
      std::vector<casadi_int> target_x;
      // Loop over all constraints
      for (casadi_int i=0;i<ng;++i) {
        // Only treat simple ones
        if (!is_simple[i]) continue;
        target_x.push_back(sp.row()[row[i]]);
      }
 
      Dict nlpsol_opts = opts;
      nlpsol_opts["detect_simple_bounds_is_simple"] = is_simple;
      nlpsol_opts["detect_simple_bounds_parts"] = gf;
      nlpsol_opts["detect_simple_bounds_target_x"] = target_x;
 
      // Check for cache entries
      Dict cache = get_from_dict(opts, "cache", Dict());
      for (auto&& e : cache) {
        const Function& f = e.second;
 
        // Check for cached Functions where g appears in in/out
        bool needs_update = false;
        for (casadi_int i=0;i<f.n_in();++i) {
          // Does name contain 'g'?
          if (name_has_g(f.name_in(i))) {
            // Already has compated size
            if (f.size1_in(i)==gi.size()) continue;
            // Needs to be compacted
            if (f.size1_in(i)==ng) needs_update = true;
            // Structure not understood, fallback to higher-level sanity checking
          }
        }
        for (casadi_int i=0;i<f.n_out();++i) {
          if (name_has_g(f.name_out(i))) {
            if (f.size1_out(i)==gi.size()) continue;
            // Needs to be compacted
            if (f.size1_out(i)==ng) needs_update = true;
            // Structure not understood, fallback to higher-level sanity checking
          }
        }
 
        if (!needs_update) continue;
 
        // Arguments to create a wrapper
        std::vector<X> args = f.sym_in<X>();
        // Arguments to pass to the cached function
        std::vector<X> f_args = args;
 
        for (casadi_int i=0;i<f.n_in();++i) {
          if (name_has_g(f.name_in(i))) {
            // Needs a compacted symbol
            args[i] = X::sym(f.name_in(i), gi.size());
 
            // Perform projects
            f_args[i] = X::zeros(ng);
            f_args[i](gi) = args[i];
          }
        }
 
        // Peform call
        std::vector<X> res;
        f.call(f_args, res, false, false);
 
        for (casadi_int i=0;i<f.n_out();++i) {
          if (name_has_g(f.name_out(i))) {
            // Select compacted rows out of result
            res[i] = res[i](gi, casadi::Slice());
          }
        }
 
        // Create wrapper
        cache[e.first] = Function(f.name(), args, res, f.name_in(), f.name_out());
      }
      // Pass along potentially updated cache
      nlpsol_opts["cache"] = cache;
 
      if (opts.find("equality")!=opts.end()) {
        std::vector<bool> equality = opts.find("equality")->second;
        nlpsol_opts["equality"] = vector_select(equality, is_simple, true);
      }
 
      std::map<std::string, X> nlpsol_nlp = nlp;
      nlpsol_nlp["g"] = g(gi);
      return nlpsol(name, solver, Nlpsol::create_oracle(nlpsol_nlp, opts), nlpsol_opts);
    } else {
      return nlpsol(name, solver, Nlpsol::create_oracle(nlp, opts), opts);
    }
  }

References boolvec_not(), boolvec_to_index(), casadi::Function::call(), casadi::Sparsity::colind(), casadi::Nlpsol::create_oracle(), get_from_dict(), casadi::Function::has_free(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name(), name_has_g(), casadi::Function::name_in(), casadi::Function::name_out(), nlpsol(), casadi::Sparsity::row(), casadi::Function::size1_in(), casadi::Function::size1_out(), casadi::Function::sym_in(), casadi::Sparsity::T(), vector_select(), and X.

Referenced by nlpsol().

Contraction() [1/2]

template<>

void casadi::Contraction ( const bvec_t &  a, const bvec_t &  b, bvec_t &  r  )

inline

Definition at line 156 of file shared.hpp.

                                                               {
    r|= a | b;
  }

Contraction() [2/2]

template<typename T >

void casadi::Contraction	(	const T &	a,
		const T &	b,
		T &	r
	)

Definition at line 151 of file shared.hpp.

                                                {
    r+= a*b;
  }

copy()

template<typename T1 , typename T2 >

void casadi::copy	(	const T1 *	x,
		casadi_int	n,
		T2 *	y
	)

Definition at line 65 of file alpaqa_problem.cpp.

                                            {
  casadi_int i;
  if (y) {
    if (x) {
      for (i=0; i<n; ++i) *y++ = *x++;
    } else {
      for (i=0; i<n; ++i) *y++ = 0.;
    }
  }
}

Referenced by casadi::OptiNode::baked_copy(), casadi::AlpaqaProblem::eval_hess_L(), casadi::AlpaqaProblem::eval_hess_ψ(), and casadi::AlpaqaProblem::eval_jac_g().

copy_vector() [1/2]

template<class S , class D >

void casadi::copy_vector	(	const S *	s,
		std::vector< D > &	d
	)

Definition at line 678 of file casadi_misc.hpp.

                                                {
    for (casadi_int i=0;i<d.size();++i) {
      d[i] = static_cast<D>(s[i]);
    }
  }

References D.

copy_vector() [2/2]

template<class S , class D >

void casadi::copy_vector	(	const std::vector< S > &	s,
		std::vector< D > &	d
	)

Definition at line 665 of file casadi_misc.hpp.

                                                           {
    casadi_assert(s.size()==d.size(), "Dimension mismatch.");
    std::copy(s.begin(), s.end(), d.begin());
  }

Referenced by casadi::DaqpInterface::init(), casadi::ClarabelInterface::init_dependent(), casadi::HighsInterface::init_dependent(), casadi::MosekInterface::init_dependent(), casadi::XpressInterface::init_dependent(), casadi::CplexInterface::init_mem(), casadi::CsparseInterface::init_mem(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::SnoptInterface::solve(), and casadi::Blocksqp::solveQP().

create_binary_node() [1/2]

onnx::NodeProto * casadi::create_binary_node	(	AddNodeFn	add_node,
		const std::string &	op_type,
		const std::string &	input1,
		const std::string &	input2,
		const std::string &	output
	)

Definition at line 245 of file onnx_operations.cpp.

                               {
    onnx::NodeProto* node = add_node();
    node->set_op_type(op_type);
    node->add_input(input1);
    node->add_input(input2);
    node->add_output(output);
    return node;
  }

Referenced by create_binary_node().

create_binary_node() [2/2]

onnx::NodeProto * casadi::create_binary_node	(	onnx::GraphProto *	graph,
		const std::string &	op_type,
		const std::string &	input1,
		const std::string &	input2,
		const std::string &	output
	)

Definition at line 324 of file onnx_operations.cpp.

                               {
    return create_binary_node([graph]() { return graph->add_node(); },
                               op_type, input1, input2, output);
  }

References create_binary_node().

create_cast_node()

onnx::NodeProto* casadi::create_cast_node	(	AddNodeFn	add_node,
		const std::string &	input,
		const std::string &	output,
		onnx::TensorProto::DataType	to_type
	)

Definition at line 272 of file onnx_operations.cpp.

                                       {
    onnx::NodeProto* node = add_node();
    node->set_op_type("Cast");
    node->add_input(input);
    node->add_output(output);
    onnx::AttributeProto* attr = node->add_attribute();
    attr->set_name("to");
    attr->set_type(onnx::AttributeProto::INT);
    attr->set_i(to_type);
    return node;
  }

create_constant_tensor()

onnx::TensorProto* casadi::create_constant_tensor	(	AddNodeFn	add_node,
		const std::string &	output_name,
		onnx::TensorProto::DataType	data_type
	)

Definition at line 94 of file onnx_operations.cpp.

                                         {
    onnx::NodeProto* node = add_node();
    node->set_op_type("Constant");
    node->add_output(output_name);
    onnx::AttributeProto* attr = node->add_attribute();
    attr->set_name("value");
    attr->set_type(onnx::AttributeProto::TENSOR);  // Required for ONNX Runtime
    onnx::TensorProto* tensor = attr->mutable_t();
    tensor->set_data_type(data_type);
    return tensor;
  }

create_directories()

bool casadi::create_directories

(

const std::string &

path

)

Definition at line 35 of file ghc.cpp.

                                                   {
      return ghc::filesystem::create_directories(path);
    }

References path().

Referenced by casadi_register_filesystem_ghc().

create_gather_node()

onnx::NodeProto* casadi::create_gather_node	(	AddNodeFn	add_node,
		const std::string &	data,
		const std::string &	indices,
		const std::string &	output,
		casadi_int	axis = 0
	)

Definition at line 199 of file onnx_operations.cpp.

                                                           {
    onnx::NodeProto* node = add_node();
    node->set_op_type("Gather");
    node->add_input(data);
    node->add_input(indices);
    node->add_output(output);
    add_int_attribute(node, "axis", axis);
    return node;
  }

References add_int_attribute().

create_gemm_node()

onnx::NodeProto* casadi::create_gemm_node	(	AddNodeFn	add_node,
		const std::string &	A,
		const std::string &	B,
		const std::string &	C,
		const std::string &	output,
		bool	transA = false,
		bool	transB = false
	)

Definition at line 292 of file onnx_operations.cpp.

                                                                         {
    onnx::NodeProto* node = add_node();
    node->set_op_type("Gemm");
    node->add_input(B);
    node->add_input(A);
    if (!C.empty()) node->add_input(C);
    node->add_output(output);
    if (transB) add_int_attribute(node, "transA", 1);
    if (transA) add_int_attribute(node, "transB", 1);
    return node;
  }

References add_int_attribute(), and C.

create_slice_node()

onnx::NodeProto* casadi::create_slice_node	(	AddNodeFn	add_node,
		const std::string &	uniq,
		const std::string &	data,
		const std::vector< casadi_int > &	starts,
		const std::vector< casadi_int > &	ends,
		const std::vector< casadi_int > &	axes,
		const std::vector< casadi_int > &	steps,
		const std::string &	output
	)

Definition at line 212 of file onnx_operations.cpp.

                                                                   {
    add_int_constant(add_node, uniq + "_starts", starts);
    add_int_constant(add_node, uniq + "_ends", ends);
    add_int_constant(add_node, uniq + "_axes", axes);
    // before the Slice node
    if (!steps.empty()) add_int_constant(add_node, uniq + "_steps", steps);
    onnx::NodeProto* node = add_node();
    node->set_op_type("Slice");
    node->add_input(data);
    node->add_input(uniq + "_starts");
    node->add_input(uniq + "_ends");
    node->add_input(uniq + "_axes");
    if (!steps.empty()) node->add_input(uniq + "_steps");  // omit -> ONNX defaults steps to 1
    node->add_output(output);
    return node;
  }

References add_int_constant().

create_unary_node() [1/2]

onnx::NodeProto * casadi::create_unary_node	(	AddNodeFn	add_node,
		const std::string &	op_type,
		const std::string &	input,
		const std::string &	output
	)

Definition at line 259 of file onnx_operations.cpp.

                               {
    onnx::NodeProto* node = add_node();
    node->set_op_type(op_type);
    node->add_input(input);
    node->add_output(output);
    return node;
  }

Referenced by create_unary_node(), and emit_colmajor_reshape().

create_unary_node() [2/2]

onnx::NodeProto * casadi::create_unary_node	(	onnx::GraphProto *	graph,
		const std::string &	op_type,
		const std::string &	input,
		const std::string &	output
	)

Definition at line 334 of file onnx_operations.cpp.

                               {
    return create_unary_node([graph]() { return graph->add_node(); },
                              op_type, input, output);
  }

References create_unary_node().

create_where_node()

onnx::NodeProto* casadi::create_where_node	(	AddNodeFn	add_node,
		const std::string &	cond,
		const std::string &	if_true,
		const std::string &	if_false,
		const std::string &	output
	)

Definition at line 308 of file onnx_operations.cpp.

                               {
    onnx::NodeProto* node = add_node();
    node->set_op_type("Where");
    node->add_input(cond);
    node->add_input(if_true);
    node->add_input(if_false);
    node->add_output(output);
    return node;
  }

cumsum()

template<typename T >

std::vector< T > casadi::cumsum

(

const std::vector< T > &

values

)

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

Definition at line 948 of file casadi_misc.hpp.

                                                  {
    std::vector<T> ret(values.size());
    T acc = 0;
    for (casadi_int i=0;i<values.size();++i) {
      acc+= values[i];
      ret[i] = acc;
    }
    return ret;
  }

References T.

cumsum0()

template<typename T >

std::vector< T > casadi::cumsum0

(

const std::vector< T > &

values

)

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

Definition at line 959 of file casadi_misc.hpp.

                                                   {
    std::vector<T> ret(values.size()+1, 0);
    T acc = 0;
    for (casadi_int i=0;i<values.size();++i) {
      acc+= values[i];
      ret[i+1] = acc;
    }
    return ret;
  }

References T.

Referenced by interpolant().

dae_init_gen() [1/2]

CASADI_EXPORT Function casadi::dae_init_gen	(	const MXDict &	dae,
		const MXDict &	dae_red,
		const std::string &	init_solver,
		const DMDict &	init_strength = DMDict(),
		const Dict &	init_solver_options = Dict()
	)

Parameters

[in]	dae	Original (unreduced) DAE structure
[in]	dae_red	Reduced DAE (see dae_reduce_index)
[in]	init_solver	NLP solver plugin name for nlpsol used to construct an initial guess
[in]	init_strength	Influence the nature of the NLP Structure with keys x_impl, dx_impl, z corresponding to inputs of init_gen Each key maps to a DM that should match the variable size corresponding to that key. For each variable the meaning of the corresponding DM value is as follows: When >=0, indicates that the provided initial guess is used in a quadratic penalty (value used as weight) When -1, indicates that the provided initial guess must be observed (simple bound on variable)
[in]	init_solver_options	NLP solver options to be passed to nlpsol

Returns

init_gen A function to generate a consistent initial guess that can be used to pass to an integrator constructed from a semi explict reduced DAE Inputs:

• x_impl, dx_impl, z: initial guesses in the original DAE space
• p: parameters
• t: time Outputs:
• x0, z0: (semi explicit) integrator states and algebraic variables; typically used as input for integrators

See also

dae_reduce_index

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

Definition at line 1221 of file integration_tools.cpp.

                                                                                              {
    return init_gen(dae, dae_red, init_solver, init_strength, init_solver_options);
}

References init_gen().

dae_init_gen() [2/2]

CASADI_EXPORT Function casadi::dae_init_gen	(	const SXDict &	dae,
		const SXDict &	dae_red,
		const std::string &	init_solver,
		const DMDict &	init_strength,
		const Dict &	init_solver_options
	)

Parameters

[in]	dae	Original (unreduced) DAE structure
[in]	dae_red	Reduced DAE (see dae_reduce_index)
[in]	init_solver	NLP solver plugin name for nlpsol used to construct an initial guess
[in]	init_strength	Influence the nature of the NLP Structure with keys x_impl, dx_impl, z corresponding to inputs of init_gen Each key maps to a DM that should match the variable size corresponding to that key. For each variable the meaning of the corresponding DM value is as follows: When >=0, indicates that the provided initial guess is used in a quadratic penalty (value used as weight) When -1, indicates that the provided initial guess must be observed (simple bound on variable)
[in]	init_solver_options	NLP solver options to be passed to nlpsol

Returns

init_gen A function to generate a consistent initial guess that can be used to pass to an integrator constructed from a semi explict reduced DAE Inputs:

• x_impl, dx_impl, z: initial guesses in the original DAE space
• p: parameters
• t: time Outputs:
• x0, z0: (semi explicit) integrator states and algebraic variables; typically used as input for integrators

See also

dae_reduce_index

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

Definition at line 1226 of file integration_tools.cpp.

                                                                                              {
    return init_gen(dae, dae_red, init_solver, init_strength, init_solver_options);
}

References init_gen().

dae_map_semi_expl() [1/2]

CASADI_EXPORT MXDict casadi::dae_map_semi_expl	(	const MXDict &	dae,
		const MXDict &	dae_red,
		Function &	state_to_orig,
		Function &	phi
	)

Parameters

[in]	dae	Original (unreduced) DAE structure
[in]	dae_red	Reduced DAE (see dae_reduce_index)
[out]	state_to_orig	A mapping of integrator (semi explicit) states to states of the original DAE
[out]	phi	A function to compute the invariants of the reduced DAE Inputs: x and z: (semi explicit) integrator states; typically integrator outputs xf and zf p: parameters t: time

Returns

Semi explicit DAE dictionary, suitable to pass to a CasADi integrator

See also

dae_reduce_index

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

Definition at line 1211 of file integration_tools.cpp.

                                          {
    return map_semi_expl(dae, dae_red, state_to_orig, phi);
}

References map_semi_expl().

dae_map_semi_expl() [2/2]

CASADI_EXPORT SXDict casadi::dae_map_semi_expl	(	const SXDict &	dae,
		const SXDict &	dae_red,
		Function &	state_to_orig,
		Function &	phi
	)

Parameters

[in]	dae	Original (unreduced) DAE structure
[in]	dae_red	Reduced DAE (see dae_reduce_index)
[out]	state_to_orig	A mapping of integrator (semi explicit) states to states of the original DAE
[out]	phi	A function to compute the invariants of the reduced DAE Inputs: x and z: (semi explicit) integrator states; typically integrator outputs xf and zf p: parameters t: time

Returns

Semi explicit DAE dictionary, suitable to pass to a CasADi integrator

See also

dae_reduce_index

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

Definition at line 1216 of file integration_tools.cpp.

                                          {
    return map_semi_expl(dae, dae_red, state_to_orig, phi);
}

References map_semi_expl().

dae_reduce_index() [1/2]

CASADI_EXPORT MXDict casadi::dae_reduce_index	(	const MXDict &	dae,
		Dict &	stats,
		const Dict &	opts = {}
	)

Index reduction leads to a new set of variables and equations.

In the process, a set of constraints (algebraic equations or derivatives) a.k.a invariants is constructed that are invariant to the problem: whenever an initial point satisfies these constraints, the boundary-value-problem outcome will keep satisfying those constraints automatically, even though they are not part of the reduced DAE.

For any practical numerical integration method, there will be numerical drift away from satisfaction of those constraints. In other words, you will see the value of invariants slowly moving away from original zero.

A classic mitigation technique is Baumgarte stabilization: you add these invariants to the reduced DAE as a correction term that acts in a way to make small (numerical) perturbations to the invariants decay to the origin as a dampened linear system.

in which a certain set of constraints (algebraic equations or derivatives) has been dropped in favour of

Parameters

dae	Expression dictionary describing the DAE

Each value must be a dense column vector.

keys:

• x_impl: symbol for implicit differential states
• dx_impl: symbol for implicit differential state derivatives
• z: symbol for algebraic variables
• alg: expression for algebraic equations
• t: symbol for time
• p: symbol for parameters

  Parameters

  opts	Option dictionary

  'baumgarte_pole': double Poles (inverse time constants) of the Baumgarte invariant correction term. Must be <0 to dampen out perturbations 0 (default) amounts to no correction. Corresponds to -gamma of equation (1.5) in Ascher, Uri M., Hongsheng Chin, and Sebastian Reich. "Stabilization of DAEs and invariant manifolds." Numerische Mathematik 67.2 (1994): 131-149.

Parameters

stats

Statistics

Returns

Expression dictionary describing the reduced DAE

In addition the fields allowed in the input DAE, the following keys occur:

• x: symbol for explicit differential states
• ode: expression for right-hand-side of explicit differential states
• I: expression for invariants

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

Definition at line 1067 of file integration_tools.cpp.

                                                                          {
  return reduce_index_gen(dae, stats, opts);
}

References reduce_index_gen().

dae_reduce_index() [2/2]

CASADI_EXPORT SXDict casadi::dae_reduce_index	(	const SXDict &	dae,
		Dict &	stats,
		const Dict &	opts
	)

Index reduction leads to a new set of variables and equations.

In the process, a set of constraints (algebraic equations or derivatives) a.k.a invariants is constructed that are invariant to the problem: whenever an initial point satisfies these constraints, the boundary-value-problem outcome will keep satisfying those constraints automatically, even though they are not part of the reduced DAE.

For any practical numerical integration method, there will be numerical drift away from satisfaction of those constraints. In other words, you will see the value of invariants slowly moving away from original zero.

A classic mitigation technique is Baumgarte stabilization: you add these invariants to the reduced DAE as a correction term that acts in a way to make small (numerical) perturbations to the invariants decay to the origin as a dampened linear system.

in which a certain set of constraints (algebraic equations or derivatives) has been dropped in favour of

Parameters

dae	Expression dictionary describing the DAE

Each value must be a dense column vector.

keys:

• x_impl: symbol for implicit differential states
• dx_impl: symbol for implicit differential state derivatives
• z: symbol for algebraic variables
• alg: expression for algebraic equations
• t: symbol for time
• p: symbol for parameters

  Parameters

  opts	Option dictionary

  'baumgarte_pole': double Poles (inverse time constants) of the Baumgarte invariant correction term. Must be <0 to dampen out perturbations 0 (default) amounts to no correction. Corresponds to -gamma of equation (1.5) in Ascher, Uri M., Hongsheng Chin, and Sebastian Reich. "Stabilization of DAEs and invariant manifolds." Numerische Mathematik 67.2 (1994): 131-149.

Parameters

stats

Statistics

Returns

Expression dictionary describing the reduced DAE

In addition the fields allowed in the input DAE, the following keys occur:

• x: symbol for explicit differential states
• ode: expression for right-hand-side of explicit differential states
• I: expression for invariants

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

Definition at line 1071 of file integration_tools.cpp.

                                                                          {
  return reduce_index_gen(dae, stats, opts);
}

References reduce_index_gen().

dense_copy_stride()

void casadi::dense_copy_stride ( casadi_int  n, casadi_int  m, const double *  A, double *  B, casadi_int  strideA, casadi_int  strideB  )

inline

Definition at line 73 of file slicot_la.hpp.

                                              {
    for (casadi_int i=0;i<n;++i) {
      for (casadi_int j=0;j<m;++j) {
        B[strideB*i + j] = A[strideA*i+j];
      }
    }
  }

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

dense_copy_t_stride()

void casadi::dense_copy_t_stride ( casadi_int  n, casadi_int  m, const double *  A, double *  B, casadi_int  strideA, casadi_int  strideB  )

inline

Definition at line 82 of file slicot_la.hpp.

                                              {
    for (casadi_int i=0;i<n;++i) {
      for (casadi_int j=0;j<m;++j) {
        B[strideB*j + i] = A[strideA*i+j];
      }
    }
  }

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

dense_kron_stride()

void casadi::dense_kron_stride ( casadi_int  n, casadi_int  m, const double *  A, const double *  B, double *  C, casadi_int  strideA, casadi_int  strideB, casadi_int  strideC  )

inline

Definition at line 32 of file slicot_la.hpp.

                                                                  {
    for (casadi_int i=0;i<n;++i) {
      for (casadi_int j=0;j<n;++j) {
        C[strideC*i + j] = -A[strideA*(i/m) + (j/m)]*B[strideB*(i%m) + (j%m)];
      }
    }
  }

References C.

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

dense_mul_nn()

void casadi::dense_mul_nn ( casadi_int  n, casadi_int  m, casadi_int  l, const double *  A, const double *  B, double *  C  )

inline

Definition at line 93 of file slicot_la.hpp.

                                                   {
    dense_mul_nn_stride(n, m, l, A, B, C, n, l, n);
  }

References C, and dense_mul_nn_stride().

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

dense_mul_nn2()

void casadi::dense_mul_nn2 ( casadi_int  n, casadi_int  m, casadi_int  l, const double *  A, const double *  B, double *  C  )

inline

Definition at line 100 of file slicot_la.hpp.

                                                   {
    for (casadi_int i=0;i<n;++i) {
      for (casadi_int j=0;j<m;++j) {
        for (casadi_int k=0;k<l;++k) {
          C[i + n*j] += A[i + n*k]*B[k + l*j];
        }
      }
    }
    //dense_mul_nn_stride(m, n, l, B, A, C, l, n, n);
  }

References C.

dense_mul_nn_stride()

void casadi::dense_mul_nn_stride ( casadi_int  n, casadi_int  m, casadi_int  l, const double *  A, const double *  B, double *  C, casadi_int  strideA, casadi_int  strideB, casadi_int  strideC  )

inline

Definition at line 61 of file slicot_la.hpp.

                                                                  {
    for (casadi_int i=0;i<n;++i) {
      for (casadi_int j=0;j<m;++j) {
        for (casadi_int k=0;k<l;++k) {
          C[strideC*i + j] += A[strideA*i + k]*B[strideB*k + j];
        }
      }
    }
  }

References C.

Referenced by dense_mul_nn(), and casadi::SlicotDple::eval().

dense_mul_nt()

void casadi::dense_mul_nt ( casadi_int  n, casadi_int  m, casadi_int  l, const double *  A, const double *  B, double *  C  )

inline

Definition at line 56 of file slicot_la.hpp.

                                                   {
    dense_mul_nt_stride(n, m, l, A, B, C, n, m, n);
  }

References C, and dense_mul_nt_stride().

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

dense_mul_nt_stride()

void casadi::dense_mul_nt_stride ( casadi_int  n, casadi_int  m, casadi_int  l, const double *  A, const double *  B, double *  C, casadi_int  strideA, casadi_int  strideB, casadi_int  strideC  )

inline

Definition at line 42 of file slicot_la.hpp.

                                                                  {
    for (casadi_int i=0;i<n;++i) {
      for (casadi_int j=0;j<m;++j) {
        for (casadi_int k=0;k<l;++k) {
          C[strideC*i + j] += A[strideA*i + k]*B[strideB*j + k];
        }
      }
    }
  }

References C.

Referenced by dense_mul_nt(), and casadi::SlicotDple::eval().

dense_mul_tn()

void casadi::dense_mul_tn ( casadi_int  n, casadi_int  m, casadi_int  l, const double *  A, const double *  B, double *  C  )

inline

Definition at line 114 of file slicot_la.hpp.

                                                   {
    for (casadi_int i=0;i<n;++i) {
      for (casadi_int j=0;j<m;++j) {
        for (casadi_int k=0;k<l;++k) {
          C[n*i + j] += A[l*k + i]*B[l*k + j];
        }
      }
    }
  }

References C.

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

dependent_definition()

CASADI_EXPORT Category casadi::dependent_definition

(

Category

cat

)

Definition at line 280 of file dae_builder_internal.cpp.

                                            {
  switch (cat) {
    case Category::D:
      return Category::DDEF;
    case Category::W:
      return Category::WDEF;
    default:
      break;
  }
  casadi_error("No dependent definition category for: " + to_string(cat));
}

References D, DDEF, to_string(), W, and WDEF.

Referenced by casadi::DaeBuilderInternal::eliminate(), and casadi::DaeBuilderInternal::sort().

derivative_coeff_mx()

static MX casadi::derivative_coeff_mx ( casadi_int  i, const std::vector< MX > &  knots_per_dim, const std::vector< casadi_int > &  degree, const std::vector< casadi_int > &  coeffs_dims, const MX &  coeffs  )

static

Definition at line 137 of file blazing_spline.cpp.

                        {
    casadi_int n_k = knots_per_dim[i].size1();
    casadi_int n = n_k - degree[i] - 1;
 
    MX K_i = knots_per_dim[i];
    MX delta_knots = K_i(range(1+degree[i], n_k-1))
          - K_i(range(1, n_k-degree[i]-1));
    MX d = static_cast<double>(degree[i]) / delta_knots;    // length n-1
 
    // T = diag(-d) + upper_band(+d) is a scaled finite-difference operator.
    // Apply via slice-subtract + broadcast-multiply — no T, no kron, no densify.
    std::vector<casadi_int> coeffs_dims_new = coeffs_dims;
    coeffs_dims_new[i+1] = n - 1;
 
    casadi_int L = 1, R = 1;
    for (casadi_int k=0; k<=i; ++k) L *= coeffs_dims[k];
    for (casadi_int k=i+2; k<(casadi_int)coeffs_dims.size(); ++k) R *= coeffs_dims[k];
    casadi_int K = coeffs_dims[i+1];
    casadi_int Kp = n - 1;
 
    MX M_coeffs = reshape(coeffs, L*K, R);
    MX top = M_coeffs(Slice(L,   L*K),    Slice());
    MX bot = M_coeffs(Slice(0, L*(K-1)),  Slice());
    MX diffed = top - bot;
 
    std::vector<casadi_int> dims{L, Kp, R};
    std::vector<casadi_int> a{-1, -2, -3};
    std::vector<casadi_int> b{-2};
    std::vector<casadi_int> c{-1, -2, -3};
    return MX::einstein(vec(diffed), d,
      dims, std::vector<casadi_int>{Kp}, dims,
      a, b, c);
  }

References casadi::MX::einstein(), range(), and casadi::GenericMatrix< MatType >::size1().

Referenced by casadi::BlazingSplineFunction::get_jacobian().

description()

CASADI_EXPORT std::string casadi::description

(

Category

v

)

Get description

Definition at line 217 of file dae_builder_internal.cpp.

                                  {
  switch (v) {
  case Category::T: return "independent variable";
  case Category::P: return "parameter";
  case Category::U: return "control";
  case Category::X: return "differential state";
  case Category::Z: return "algebraic variable";
  case Category::Q: return "quadrature state";
  case Category::C: return "constant";
  case Category::D: return "dependent parameter";
  case Category::W: return "dependent variable";
  case Category::CALCULATED: return "calculated variable";
  default: break;
  }
  return "";
}

References C, CALCULATED, D, P, Q, T, U, W, X, and Z.

Referenced by casadi::DaeBuilderInternal::add(), casadi::OptiNode::describe(), casadi::DaeBuilderInternal::disp(), casadi::OptiNode::g_describe(), casadi::DaeBuilderInternal::generate_model_description(), casadi::DaeBuilderInternal::import_model_variables(), and casadi::OptiNode::x_describe().

detect_bounds_callback()

int casadi::detect_bounds_callback	(	const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w,
		void *	callback_data
	)

Definition at line 665 of file nlpsol.cpp.

                                                      {
    Function* f = static_cast<Function*>(callback_data);
    return f->operator()(arg, res, iw, w);
  }

detect_simple_bounds() [1/2]

CASADI_EXPORT void casadi::detect_simple_bounds	(	const MX &	x,
		const MX &	p,
		const MX &	g,
		const MX &	lbg,
		const MX &	ubg,
		std::vector< casadi_int > &	gi,
		MX &	lbx,
		MX &	ubx,
		Function &	lam_forward,
		Function &	lam_backward
	)

Definition at line 227 of file nlp_tools.cpp.

                              {
  detect_simple_bounds_gen(x, p, g, lbg, ubg,
    gi, lbx, ubx, lam_forward, lam_backward);
}

References detect_simple_bounds_gen().

detect_simple_bounds() [2/2]

CASADI_EXPORT void casadi::detect_simple_bounds	(	const SX &	xX,
		const SX &	p,
		const SX &	g,
		const SX &	lbg,
		const SX &	ubg,
		std::vector< casadi_int > &	gi,
		SX &	lbx,
		SX &	ubx,
		Function &	lam_forward,
		Function &	lam_backward
	)

Given parametric constraints:

*   subject to lbg(p) <= g(x,p) <= ubg(p)
* 

Returns an equivalent set

*   subject to  lbg(p)(gi) <= g(x,p)(gi) <= ubg(p)(gi)
*               lbx(p) <= x                 <= ubx(p)
* 

Parameters

[out]	lam_forward	(lam_g,p)->(lam_sg,lam_x)
[out]	lam_backward	(lam_sg,lam_x,p)->(lam_g)

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

Definition at line 217 of file nlp_tools.cpp.

                              {
  detect_simple_bounds_gen(x, p, g, lbg, ubg,
    gi, lbx, ubx, lam_forward, lam_backward);
}

References detect_simple_bounds_gen().

detect_simple_bounds_gen()

template<class T >

void casadi::detect_simple_bounds_gen	(	const T &	x,
		const T &	p,
		const T &	g,
		const T &	lbg,
		const T &	ubg,
		std::vector< casadi_int > &	gi,
		T &	lbx,
		T &	ubx,
		Function &	lam_forward,
		Function &	lam_backward
	)

Definition at line 33 of file nlp_tools.cpp.

                              {
 
    // Read dimensions
    casadi_int ng = g.size1();
    casadi_int nx = x.size1();
 
    casadi_assert(lbg.size1()==ng, "Dimension mismatch");
    casadi_assert(ubg.size1()==ng, "Dimension mismatch");
    casadi_assert(g.is_column(), "Dimension mismatch");
    casadi_assert(lbg.is_column(), "Dimension mismatch");
    casadi_assert(ubg.is_column(), "Dimension mismatch");
    casadi_assert(x.is_column(), "Dimension mismatch");
 
    // Get constraint Jacobian sparsity
    Function temp("temp_detect_simple_bounds_gen", {x, p}, {g});
    Sparsity sp = temp.jac_sparsity().at(0);
    Sparsity spT = sp.T();
 
    // Reset result vector
    std::vector<bool> is_simple(ng, true);
 
    // Check nonlinearity
    std::vector<bool> is_nonlin = which_depends(g, x, 2, true);
 
    const casadi_int* row = spT.colind();
    for (casadi_int i=0;i<ng;++i) {
      // Check if each row of jac_g_x only depends on one column
      bool single_dependency = row[i+1]-row[i]==1;
      is_simple[i] = single_dependency && !is_nonlin[i];
    }
 
    // Full-indices of all simple constraints
    std::vector<casadi_int> sgi = boolvec_to_index(is_simple);
    gi = boolvec_to_index(boolvec_not(is_simple));
    T g_bounds = g(sgi);
    std::vector<casadi_int> sgi_to_sgsi = lookupvector(sgi, ng);
 
    // Detect  f2(p)x+f1(p)==0
    Function gf = Function("gf", std::vector<T>{x, p},
                                  std::vector<T>{g_bounds, jtimes(g_bounds, x, T::ones(nx, 1))});
 
    std::vector<T> res;
    gf.call(std::vector<T>{0, p}, res, true, false);
    T f1 = res[0];
    T f2 = res[1];
 
    T f2_inv = 1/f2;
 
    T lb_pre = (lbg(sgi)-f1)*f2_inv;
    T ub_pre = (ubg(sgi)-f1)*f2_inv;
 
    T pos_f2 = f2>=0;
    T neg_f2 = !pos_f2;
 
    T lb = lb_pre*pos_f2+ub_pre*neg_f2;
    T ub = ub_pre*pos_f2+lb_pre*neg_f2;
 
 
 
    // Start without simple bounds
    lbx = -T::inf(nx);
    ubx = T::inf(nx);
 
    const casadi_int* xi = spT.row();
 
 
    /* We will process in groups
     *  (=collection of bounds that have been re-defined a certain number of times)
     *  instead of element-wise to keep the MX graph size minimal.
    */
 
    std::vector< std::vector<casadi_int> > sgsi_groups, sgi_groups, sxi_groups;
    casadi_int n_groups = 0;
 
    // How often has a certain variable been encountered?
    std::vector<casadi_int> group_count(nx);
 
    // Loop over all constraints
    for (casadi_int i=0;i<ng;++i) {
      // Only treat simple ones
      if (!is_simple[i]) continue;
 
      casadi_int j = xi[row[i]];
      casadi_int& k = group_count[j];
      // Grow as needed
      if (k==n_groups) {
        sgsi_groups.emplace_back();
        sgi_groups.emplace_back();
        sxi_groups.emplace_back();
        n_groups++;
      }
      sxi_groups[k].push_back(j);
      sgi_groups[k].push_back(i);
      sgsi_groups[k].push_back(sgi_to_sgsi[i]);
      k++;
    }
 
    casadi_assert(n_groups>=1, "mismatch");
    // Take min/max group-wise to determine simple bounds
    for (casadi_int i=0;i<n_groups;++i) {
      lbx(sxi_groups[i]) = fmax(lbx(sxi_groups[i]), lb(sgsi_groups[i]));
      ubx(sxi_groups[i]) = fmin(ubx(sxi_groups[i]), ub(sgsi_groups[i]));
    }
 
 
    // Choose the first group as reference
    const std::vector<casadi_int>& sxi_ref = sxi_groups[0];
    // Indices into the first group that reproduce the contents of other groups
    std::vector< std::vector<casadi_int> > xsub(n_groups);
    // Identity map for first entry of xsub
    xsub[0] = range(sxi_ref.size());
 
    // Computations for other xsub entries
    std::vector<casadi_int> lookup = lookupvector(sxi_ref, nx);
    for (casadi_int i=1;i<n_groups;++i) {
      const std::vector<casadi_int>& sxi = sxi_groups[i];
      for (casadi_int j=0;j<sxi.size();++j) {
        xsub[i].push_back(lookup[sxi[j]]);
      }
    }
 
    // Determine multiplier maps
 
    // Symbols
    T lam_g_forward = T::sym("lam_g", ng);
    T lam_sg_backward = T::sym("lam_g", gi.size());
    T lam_x_backward = T::sym("lam_x", nx);
 
 
    T lam_sg_forward = lam_g_forward(sgi); // NOLINT(cppcoreguidelines-slicing)
    T lam_x_forward = T::zeros(nx, 1);
    T lam_g_backward = T::zeros(ng, 1);
    lam_g_backward(gi) = lam_sg_backward;
 
    // Comparison expression per group
    std::vector<T> lcomp, ucomp;
    for (casadi_int i=0;i<n_groups;++i) {
      lcomp.push_back(lbx(sxi_groups[i])==lb(sgsi_groups[i]));
      ucomp.push_back(ubx(sxi_groups[i])==ub(sgsi_groups[i]));
    }
 
    // How many lb/ub are active?
    T count_lb = T::zeros(nx);
    T count_ub = T::zeros(nx);
    for (casadi_int i=0;i<n_groups;++i) {
      count_lb(sxi_groups[i]) += lcomp[i];
      count_ub(sxi_groups[i]) += ucomp[i];
    }
 
    // Compute lam_x from lam_g
    for (casadi_int i=0;i<n_groups;++i) {
      T l = lam_sg_forward(sgsi_groups[i]); // NOLINT(cppcoreguidelines-slicing)
      T lt = (l<0);
      T gt = !lt;
      lam_x_forward(sxi_groups[i]) += l*(lt*lcomp[i]+gt*ucomp[i]);
    }
 
    // Compute lam_g from lam_x
    T l = lam_x_backward(sxi_ref); // NOLINT(cppcoreguidelines-slicing)
    T lt = (l<0);
    T gt = !lt;
    T lam_xl = l*lt/count_lb(sxi_ref);
    T lam_xu = l*gt/count_ub(sxi_ref);
 
    for (casadi_int i=0;i<n_groups;++i) {
      lam_g_backward(sgi_groups[i]) = lam_xl(xsub[i])*lcomp[i]+lam_xu(xsub[i])*ucomp[i];
    }
 
    // Construct Functions for mappings
    lam_forward = Function("lam_forward",
      {lam_g_forward, p}, {lam_g_forward(gi), lam_x_forward},// NOLINT(cppcoreguidelines-slicing)
      {"lam_g", "p"}, {"lam_sg", "lam_x"});
    casadi_assert_dev(!lam_forward.has_free());
    lam_backward = Function("lam_backward",
      {lam_sg_backward, lam_x_backward, p}, {lam_g_backward},
      {"lam_sg", "lam_x", "p"}, {"lam_g"});
    casadi_assert_dev(!lam_backward.has_free());
  }

References boolvec_not(), boolvec_to_index(), casadi::Function::call(), casadi::Sparsity::colind(), casadi::Function::has_free(), lookupvector(), range(), casadi::Sparsity::row(), T, and casadi::Sparsity::T().

Referenced by detect_simple_bounds().

diff()

template<typename T >

std::vector< T > casadi::diff

(

const std::vector< T > &

values

)

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

Definition at line 970 of file casadi_misc.hpp.

                                                {
    casadi_assert(!values.empty(), "Array must be non-empty");
    std::vector<T> ret(values.size()-1);
    for (casadi_int i=0;i<values.size()-1;++i) {
      ret[i] = values[i+1]-values[i];
    }
    return ret;
  }

Referenced by compute_knots_cache(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), and casadi::SuperscsInterface::init_mem().

do_inline()

template<typename K >

MX casadi::do_inline	(	const MX &	x,
		const std::vector< K > &	knots,
		const MX &	coeffs,
		casadi_int	m,
		const std::vector< casadi_int > &	degree,
		const std::vector< casadi_int > &	lookup_mode
	)

Definition at line 216 of file bspline.cpp.

                                                          {
 
    casadi_int batch_x = x.size2();
 
    // Number of grid points
    casadi_int N = knots.size();
    std::vector<MX> xs = vertsplit(x);
 
    // Compute De Boor vector in each direction
    std::vector<MX> starts(N);
    std::vector< std::vector<MX> > boors(N);
    for (casadi_int i=0;i<N;++i) {
      MX boor;
      get_boor(xs[i], knots[i], degree[i], lookup_mode[i], starts[i], boor);
      boors[i] = horzsplit(boor.T());
    }
 
    // Compute strides
    std::vector<casadi_int> strides = {m};
    for (casadi_int i=0;i<N-1;++i) {
      strides.push_back(strides.back()*(knot_size(knots[i])-degree[i]-1));
    }
 
    // Start index of subtensor: row vector
    MX start = mtimes(DM(strides).T(), vertcat(starts));
 
    // Elements of subtensor
    DM core = DM(range(m));
    for (casadi_int i=0;i<N;++i) {
      casadi_int n = degree[i]+1;
      core = vec(repmat(core, 1, n)+repmat(strides[i]*DM(range(n)).T(), core.size1(), 1));
    }
 
    std::vector<MX> res;
 
    for (casadi_int k=0;k<batch_x;++k) {
 
      // Flattened subtensor of coefficients
      MX c = reshape(coeffs(start(k)+core), m, -1);
 
      // Compute outer product of De Boor vectors
      MX boor = 1;
      for (casadi_int i=0;i<N;++i) {
        boor = vec(mtimes(boor, boors[i][k].T()));
      }
 
      res.push_back(mtimes(c, boor));
    }
 
    return horzcat(res);
  }

References get_boor(), knot_size(), range(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), T, and casadi::MX::T().

Referenced by casadi::Interpolant::construct(), casadi::BSplineInterpolant::construct_graph(), casadi::BSplineParametric::create(), and casadi::BSpline::create().

doc_archiver()

CASADI_EXPORT std::string casadi::doc_archiver

(

const std::string &

name

)

Definition at line 46 of file archiver.cpp.

                                                {
    return Archiver::getPlugin(name).doc;
  }

References casadi::PluginInterface< Archiver >::getPlugin().

doc_blas()

CASADI_EXPORT std::string casadi::doc_blas

(

const std::string &

name

)

Definition at line 260 of file blas.cpp.

                                          {
  if (name == "reference") return REFERENCE_DOC;
  return Blas::getPlugin(name).doc;
}

References casadi::PluginInterface< Blas >::getPlugin(), and REFERENCE_DOC.

doc_filesystem()

CASADI_EXPORT std::string casadi::doc_filesystem

(

const std::string &

name

)

Definition at line 100 of file filesystem.cpp.

                                                {
  return Filesystem::getPlugin(name).doc;
}

References casadi::PluginInterface< Filesystem >::getPlugin().

doc_graphmodel()

CASADI_EXPORT std::string casadi::doc_graphmodel

(

const std::string &

name

)

Definition at line 79 of file graph_model.cpp.

{ return GraphModel::doc(name); }

References casadi::GraphModel::doc().

doc_linsol()

CASADI_EXPORT std::string casadi::doc_linsol

(

const std::string &

name

)

Definition at line 237 of file linsol.cpp.

                                              {
    return Linsol::doc(name);
  }

References casadi::Linsol::doc().

doc_modelicaparser()

CASADI_EXPORT std::string casadi::doc_modelicaparser

(

const std::string &

name

)

Definition at line 68 of file modelica_parser.cpp.

                                                    {
  return ModelicaParser::doc(name);
}

References casadi::ModelicaParser::doc().

dot()

template<typename T >

T casadi::dot	(	const std::vector< T > &	a,
		const std::vector< T > &	b
	)

Definition at line 980 of file casadi_misc.hpp.

                                                      {
    T ret = 0;
    for (casadi_int k=0; k<a.size(); ++k) {
      ret += a[k]*b[k];
    }
    return ret;
  }

References T.

Referenced by casadi::Determinant::ad_forward(), casadi::LogSumExp::ad_forward(), casadi::MMin::ad_forward(), casadi::MMax::ad_forward(), casadi::NormInf::ad_forward(), casadi::BinaryMX< ScX, ScY >::ad_reverse(), casadi::Factory< MatType >::add_dual(), casadi::Dot::eval_linear(), format_from_path(), casadi::ConstantMX::get_dot(), casadi::AlpaqaInterface::init(), casadi::Blocksqp::init(), casadi::Scpgen::init(), and casadi::DaeBuilderInternal::sort_dependent().

dummy_signal()

void casadi::dummy_signal

(

void *

user_data

)

Definition at line 1022 of file fatrop_conic_interface.cpp.

                                     {
 
  }

einstein_eval()

template<typename T >

void casadi::einstein_eval	(	casadi_int	n_iter,
		const std::vector< casadi_int > &	iter_dims,
		const std::vector< casadi_int > &	strides_a,
		const std::vector< casadi_int > &	strides_b,
		const std::vector< casadi_int > &	strides_c,
		const T *	a_in,
		const T *	b_in,
		T *	c_in
	)

Definition at line 161 of file shared.hpp.

                                             {
 
    if (!n_iter) return;
 
    casadi_int iter_dim1 = 1, iter_dim2 = 1, iter_dim3 = 1;
 
    casadi_int n = iter_dims.size();
 
    casadi_int stridea1=0, strideb1=0, stridec1=0;
    casadi_int stridea2=0, strideb2=0, stridec2=0;
    casadi_int stridea3=0, strideb3=0, stridec3=0;
    if (n>0) {
      iter_dim3 = iter_dims[n-1];
      stridea3 = strides_a[n];
      strideb3 = strides_b[n];
      stridec3 = strides_c[n];
    }
    if (n>1) {
      iter_dim2 = iter_dims[n-2];
      stridea2 = strides_a[n-1];
      strideb2 = strides_b[n-1];
      stridec2 = strides_c[n-1];
    }
    if (n>2) {
      iter_dim1 = iter_dims[n-3];
      stridea1 = strides_a[n-2];
      strideb1 = strides_b[n-2];
      stridec1 = strides_c[n-2];
    }
 
 
    const casadi_int* ptr_iter_dims = get_ptr(iter_dims);
 
    const casadi_int *ptr_strides_a = get_ptr(strides_a)+1;
    const casadi_int *ptr_strides_b = get_ptr(strides_b)+1;
    const casadi_int *ptr_strides_c = get_ptr(strides_c)+1;
 
    // Data pointers
    const T* a_perm = a_in+strides_a[0];
    const T* b_perm = b_in+strides_b[0];
    T* c_perm = c_in+strides_c[0];
 
    n_iter/= iter_dim1*iter_dim2*iter_dim3;
 
    // Main loop
    for (casadi_int i=0;i<n_iter;++i) {
 
      // Data pointers
      const T* a = a_perm;
      const T* b = b_perm;
      T* c = c_perm;
 
      // Construct indices
      casadi_int sub = i;
      for (casadi_int j=0;j<n-3;++j) {
        casadi_int ind = sub % ptr_iter_dims[j];
        a+= ptr_strides_a[j]*ind;
        b+= ptr_strides_b[j]*ind;
        c+= ptr_strides_c[j]*ind;
        sub/= ptr_iter_dims[j];
      }
 
      const T* a1 = a;
      const T* b1 = b;
      T* c1 = c;
      for (casadi_int i1=0;i1<iter_dim1;++i1) {
        const T* a2 = a1;
        const T* b2 = b1;
        T* c2 = c1;
        for (casadi_int i2=0;i2<iter_dim2;++i2) {
          const T* a3 = a2;
          const T* b3 = b2;
          T* c3 = c2;
          for (casadi_int i3=0;i3<iter_dim3;++i3) {
            // Perform the actual multiplication
            Contraction<T>(*a3, *b3, *c3);
 
            a3+= stridea3;
            b3+= strideb3;
            c3+= stridec3;
          }
          a2+= stridea2;
          b2+= strideb2;
          c2+= stridec2;
        }
        a1+= stridea1;
        b1+= strideb1;
        c1+= stridec1;
      }
 
 
    }
 
  }

References get_ptr(), and T.

Referenced by casadi::Matrix< Scalar >::einstein(), and casadi::Einstein::eval_gen().

einstein_process()

template<typename T >

casadi_int casadi::einstein_process	(	const T &	A,
		const T &	B,
		const T &	C,
		const std::vector< casadi_int > &	dim_a,
		const std::vector< casadi_int > &	dim_b,
		const std::vector< casadi_int > &	dim_c,
		const std::vector< casadi_int > &	a,
		const std::vector< casadi_int > &	b,
		const std::vector< casadi_int > &	c,
		std::vector< casadi_int > &	iter_dims,
		std::vector< casadi_int > &	strides_a,
		std::vector< casadi_int > &	strides_b,
		std::vector< casadi_int > &	strides_c
	)

Definition at line 35 of file shared.hpp.

  {
 
    casadi_assert_dev(A.is_vector() && A.is_dense());
    casadi_assert_dev(B.is_vector() && B.is_dense());
    casadi_assert_dev(C.is_vector() && C.is_dense());
 
    // Dimension check
    casadi_assert_dev(A.numel()==product(dim_a));
    casadi_assert_dev(B.numel()==product(dim_b));
    casadi_assert_dev(C.numel()==product(dim_c));
 
    casadi_assert_dev(dim_a.size()==a.size());
    casadi_assert_dev(dim_b.size()==b.size());
 
    casadi_assert_dev(c.size()<=a.size()+b.size());
 
    std::map<casadi_int, casadi_int> dim_map;
 
    // Check if shared nodes dimensions match up
    for (casadi_int i=0;i<a.size();++i) {
      casadi_int ai = a[i];
      if (ai>=0) continue;
      auto al = dim_map.find(ai);
      if (al==dim_map.end()) {
        dim_map[ai] = dim_a[i];
      } else {
        casadi_assert_dev(al->second==dim_a[i]);
      }
    }
 
    for (casadi_int i=0;i<b.size();++i) {
      casadi_int bi = b[i];
      if (bi>=0) continue;
      auto bl = dim_map.find(bi);
      if (bl==dim_map.end()) {
        dim_map[bi] = dim_b[i];
      } else {
        casadi_assert_dev(bl->second==dim_b[i]);
      }
    }
 
    for (casadi_int i=0;i<c.size();++i) {
      casadi_int ci = c[i];
      if (ci>=0) continue;
      auto cl = dim_map.find(ci);
      if (cl==dim_map.end()) {
        dim_map[ci] = dim_c[i];
      } else {
        casadi_assert_dev(cl->second==dim_c[i]);
      }
    }
 
    std::vector< std::pair<casadi_int, casadi_int> > dim_map_pair;
    for (const auto & i : dim_map) dim_map_pair.push_back(i);
 
    std::sort(dim_map_pair.begin(), dim_map_pair.end(),
      [](const std::pair<casadi_int, casadi_int>& a, const std::pair<casadi_int, casadi_int>& b) { return a.second < b.second;});
 
    std::vector<casadi_int> dim_map_keys;
    // Compute the total number of iterations needed
    casadi_int n_iter = 1;
    for (const auto& e : dim_map_pair) {
      n_iter*= e.second;
      dim_map_keys.push_back(-e.first);
      iter_dims.push_back(e.second);
    }
 
    strides_a.clear();
    strides_a.resize(iter_dims.size()+1);
    strides_b.clear();
    strides_b.resize(iter_dims.size()+1);
    strides_c.clear();
    strides_c.resize(iter_dims.size()+1);
 
    std::vector<casadi_int> lu;
 
    if (!dim_map_keys.empty()) lu = lookupvector(dim_map_keys);
 
    // Update data pointers to match indices
    casadi_int cumprod = 1;
    for (casadi_int j=0;j<a.size();++j) {
      if (a[j]<0) {
        strides_a[1+lu[-a[j]]] = cumprod;
      } else {
        strides_a[0]+=a[j]*cumprod;
      }
      cumprod*= dim_a[j];
    }
    cumprod = 1;
    for (casadi_int j=0;j<b.size();++j) {
      if (b[j]<0) {
        strides_b[1+lu[-b[j]]] = cumprod;
      } else {
        strides_b[0]+=b[j]*cumprod;
      }
      cumprod*= dim_b[j];
    }
    cumprod = 1;
    for (casadi_int j=0;j<c.size();++j) {
      if (c[j]<0) {
        strides_c[1+lu[-c[j]]] = cumprod;
      } else {
        strides_c[0]+=c[j]*cumprod;
      }
      cumprod*= dim_c[j];
    }
 
    return n_iter;
  }

References C, lookupvector(), and product().

Referenced by casadi::Matrix< Scalar >::einstein(), and casadi::Einstein::Einstein().

emit_colmajor_reshape()

void casadi::emit_colmajor_reshape	(	AddNodeFn	add_node,
		const std::string &	data,
		const std::vector< casadi_int > &	dims,
		const std::string &	output,
		const std::string &	uniq
	)

Definition at line 236 of file onnx_operations.cpp.

                                                    {
    std::vector<casadi_int> rev(dims.rbegin(), dims.rend());
    add_int_constant(add_node, uniq + "_s", rev);
    create_unary_node(add_node, "Reshape", data, output)->add_input(uniq + "_s");
  }

References add_int_constant(), and create_unary_node().

ensure_directory_exists()

void casadi::ensure_directory_exists

(

const std::string &

dir

)

Definition at line 46 of file dump.cpp.

                                                     {
    if (Filesystem::is_enabled()) {
      std::string effective_dir = Filesystem::ensure_trailing_slash(dir);
      casadi_assert(Filesystem::ensure_directory_exists(effective_dir),
        "Unable to create the required directory for '" + effective_dir + "'.");
    }
  }

References casadi::Filesystem::ensure_directory_exists(), casadi::Filesystem::ensure_trailing_slash(), and casadi::Filesystem::is_enabled().

Referenced by casadi::Dump::add_dependency(), and casadi::Dump::finalize().

enum_names()

template<typename T >

std::vector<std::string> casadi::enum_names

(

)

Definition at line 80 of file casadi_enum.hpp.

                                  {
  std::vector<std::string> r(enum_traits<T>::n_enum);
  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i)
    r[i] = to_string(static_cast<T>(i));
  return r;
}

References T, and to_string().

erfinv()

double casadi::erfinv ( double  x ) throw ( )

inline

CasADi additions

Definition at line 300 of file calculus.hpp.

                                         {
    // Approximation found in Sourceforge and modified: Not very efficient
    if (x>=1) {
      return x==1 ? inf : nan;
    } else if (x<=-1) {
      return x==-1 ? -inf : nan;
    } else if (x<-0.7) {
      double z = sqrt(-log((1.0+x)/2.0));
      return -(((1.641345311*z+3.429567803)*z-1.624906493)*z-1.970840454)/
          ((1.637067800*z+3.543889200)*z+1.0);
    } else {
      double y;
      if (x<0.7) {
        double z = x*x;
        y = x*(((-0.140543331*z+0.914624893)*z-1.645349621)*z+0.886226899)/
            ((((-0.329097515*z+0.012229801)*z+1.442710462)*z-2.118377725)*z+1.0);
      } else {
        double z = sqrt(-log((1.0-x)/2.0));
        y = (((1.641345311*z+3.429567803)*z-1.624906493)*z-1.970840454)/
            ((1.637067800*z+3.543889200)*z+1.0);
      }
 
      //polish x to full accuracy
      y = y - (erf(y) - x) / (2.0/sqrt(pi) * exp(-y*y));
      y = y - (erf(y) - x) / (2.0/sqrt(pi) * exp(-y*y));
      return y;
    }
  }

References inf, nan, and pi.

Referenced by casadi::UnaryOperation< OP_ERFINV >::fcn().

eval_b()

fatrop_int casadi::eval_b	(	const double *	states_kp1,
		const double *	inputs_k,
		const double *	states_k,
		const double *	stage_params_k,
		const double *	global_params,
		double *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 787 of file fatrop_conic_interface.cpp.

                                           {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    auto d = &m->d;
    auto p = d->prob;
 
    blasfeo_dmat BAbtk;
    blasfeo_allocate_dmat(p->nx[k]+p->nu[k]+1, p->nx[k+1], &BAbtk);
    eval_BAbt(states_kp1, inputs_k, states_k, stage_params_k, global_params, &BAbtk, k, user_data);
    blasfeo_unpack_dmat(1, p->nx[k+1], &BAbtk, p->nx[k]+p->nu[k], 0, res, 1);
    blasfeo_free_dmat(&BAbtk);
 
    return 0;
 
  }

References eval_BAbt().

Referenced by casadi::FatropConicInterface::solve().

eval_BAbt()

fatrop_int casadi::eval_BAbt	(	const double *	states_kp1,
		const double *	inputs_k,
		const double *	states_k,
		const double *	stage_params_k,
		const double *	global_params,
		MAT *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 482 of file fatrop_conic_interface.cpp.

                                                                                  {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    double one = 1.0;
    auto d = &m->d;
    auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
    blasfeo_pack_tran_dmat(p->nx[k+1], p->nx[k],
      d->AB+p->AB_offsets[k], p->nx[k+1], res, p->nu[k], 0);
    blasfeo_pack_tran_dmat(p->nx[k+1], p->nu[k],
      d->AB+p->AB_offsets[k]+p->nx[k]*p->nx[k+1], p->nx[k+1], res, 0, 0);
    blasfeo_pack_dmat(1, p->nx[k+1], const_cast<double*>(d_qp->lba+p->AB[k].offset_r),
      1, res, p->nx[k]+p->nu[k], 0);
 
    blasfeo_dvec v, r;
    blasfeo_allocate_dvec(p->nx[k]+p->nu[k]+1, &v);
    blasfeo_allocate_dvec(p->nx[k+1], &r);
    // Fill v with [u;x;1]
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(inputs_k), 1, &v, 0);
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(states_k), 1, &v, p->nu[k]);
    blasfeo_pack_dvec(1, &one, 1, &v, p->nu[k]+p->nx[k]);
 
    blasfeo_dgemv_t(p->nx[k]+p->nu[k]+1, p->nx[k+1], 1.0, res, 0, 0,
      &v, 0,
      0.0, &r, 0,
      &r, 0);
 
    std::vector<double> mem(p->nx[k+1]);
    blasfeo_unpack_dvec(p->nx[k+1], &r, 0, get_ptr(mem), 1);
 
    if (states_kp1) {
      for (int i=0;i<p->nx[k+1];++i) {
        mem[i] -= states_kp1[i];
      }
    }
 
    blasfeo_pack_dmat(1, p->nx[k+1], get_ptr(mem), 1, res, p->nx[k]+p->nu[k], 0);
 
    blasfeo_free_dvec(&v);
    blasfeo_free_dvec(&r);
 
    return 0;
  }

References get_ptr(), and casadi_qp_data< T1 >::lba.

Referenced by eval_b(), eval_RSQrqt(), and casadi::FatropConicInterface::solve().

eval_g()

fatrop_int casadi::eval_g	(	const double *	states_k,
		const double *	inputs_k,
		const double *	stage_params_k,
		const double *	global_params,
		double *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 810 of file fatrop_conic_interface.cpp.

                                         {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
 
    auto m = data->mem;
    auto d = &m->d;
    auto p = d->prob;
 
    int n_a_eq = d->a_eq_idx[k+1]-d->a_eq_idx[k];
    int n_x_eq = d->x_eq_idx[k+1]-d->x_eq_idx[k];
    int ng_eq = n_a_eq+n_x_eq;
 
    blasfeo_dmat Ggtk;
    blasfeo_allocate_dmat(p->nx[k]+p->nu[k]+1, ng_eq, &Ggtk);
    eval_Ggt(states_k, inputs_k, stage_params_k, global_params, &Ggtk, k, user_data);
    blasfeo_unpack_dmat(1, ng_eq, &Ggtk, p->nx[k]+p->nu[k], 0, res, 1);
    blasfeo_free_dmat(&Ggtk);
 
    return 0;
  }

References eval_Ggt().

Referenced by casadi::FatropConicInterface::solve().

eval_Ggt()

fatrop_int casadi::eval_Ggt	(	const double *	inputs_k,
		const double *	states_k,
		const double *	stage_params_k,
		const double *	global_params,
		MAT *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 529 of file fatrop_conic_interface.cpp.

                                           {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
casadi_int i, column;
    double one = 1;
    auto d = &m->d;
    auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
 
    int n_a_eq = d->a_eq_idx[k+1]-d->a_eq_idx[k];
    int n_x_eq = d->x_eq_idx[k+1]-d->x_eq_idx[k];
    int ng_eq = n_a_eq+n_x_eq;
 
    blasfeo_dgese(p->nx[k]+p->nu[k]+1, ng_eq, 0.0, res, 0, 0);
 
    column = 0;
    for (i=d->a_eq_idx[k];i<d->a_eq_idx[k+1];++i) {
      blasfeo_pack_tran_dmat(1, p->nx[k],
        d->CD+p->CD_offsets[k]+(d->a_eq[i]-p->CD[k].offset_r),
        p->CD[k].rows, res, p->nu[k], column);
      blasfeo_pack_tran_dmat(1, p->nu[k],
        d->CD+p->CD_offsets[k]+(d->a_eq[i]-p->CD[k].offset_r)+p->nx[k]*p->CD[k].rows,
        p->CD[k].rows, res, 0,        column);
      double v = -d_qp->lba[d->a_eq[i]];
      blasfeo_pack_tran_dmat(1, 1, &v, 1, res, p->nx[k]+p->nu[k], column);
      column++;
    }
    for (i=d->x_eq_idx[k];i<d->x_eq_idx[k+1];++i) {
      int j = d->x_eq[i]-p->CD[k].offset_c;
      if (j>=p->nx[k]) {
        j -= p->nx[k];
      } else {
        j += p->nu[k];
      }
      blasfeo_pack_tran_dmat(1, 1, &one, 1, res, j, column);
      double v = -d_qp->lbx[d->x_eq[i]];
      blasfeo_pack_tran_dmat(1, 1, &v, 1, res, p->nx[k]+p->nu[k], column);
      column++;
    }
 
    // Second part
    blasfeo_dvec v, r;
    blasfeo_allocate_dvec(p->nx[k]+p->nu[k]+1, &v);
    blasfeo_allocate_dvec(ng_eq, &r);
    // Fill v with [u;x;1]
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(inputs_k), 1, &v, 0);
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(states_k), 1, &v, p->nu[k]);
    blasfeo_pack_dvec(1, &one, 1, &v, p->nu[k]+p->nx[k]);
 
    blasfeo_dgemv_t(p->nx[k]+p->nu[k]+1, ng_eq, 1.0, res, 0, 0,
      &v, 0,
      0.0, &r, 0,
      &r, 0);
 
    std::vector<double> mem(ng_eq);
    blasfeo_unpack_dvec(ng_eq, &r, 0, get_ptr(mem), 1);
 
    blasfeo_pack_dmat(1, ng_eq, get_ptr(mem), 1, res, p->nx[k]+p->nu[k], 0);
 
    blasfeo_free_dvec(&v);
    blasfeo_free_dvec(&r);
 
    return 0;
  }

References get_ptr(), casadi_qp_data< T1 >::lba, and casadi_qp_data< T1 >::lbx.

Referenced by eval_g(), eval_RSQrqt(), and casadi::FatropConicInterface::solve().

eval_Ggt_ineq()

fatrop_int casadi::eval_Ggt_ineq	(	const double *	inputs_k,
		const double *	states_k,
		const double *	stage_params_k,
		const double *	global_params,
		MAT *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 600 of file fatrop_conic_interface.cpp.

                                           {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    casadi_int i, column;
    double one = 1;
    double zero = 0;
    auto d = &m->d;
    auto p = d->prob;
    //casadi_qp_data<double>* d_qp = d->qp;
 
    int n_a_ineq = d->a_ineq_idx[k+1]-d->a_ineq_idx[k];
    int n_x_ineq = d->x_ineq_idx[k+1]-d->x_ineq_idx[k];
    int ng_ineq = n_a_ineq+n_x_ineq;
 
    blasfeo_dgese(p->nx[k]+p->nu[k]+1, ng_ineq, 0.0, res, 0, 0);
 
    column = 0;
    for (i=d->a_ineq_idx[k];i<d->a_ineq_idx[k+1];++i) {
      blasfeo_pack_tran_dmat(1, p->nx[k],
        d->CD+p->CD_offsets[k]+(d->a_ineq[i]-p->CD[k].offset_r),
        p->CD[k].rows, res, p->nu[k], column);
      blasfeo_pack_tran_dmat(1, p->nu[k],
        d->CD+p->CD_offsets[k]+(d->a_ineq[i]-p->CD[k].offset_r)+p->nx[k]*p->CD[k].rows,
        p->CD[k].rows, res, 0,        column);
      blasfeo_pack_tran_dmat(1, 1, &zero, 1, res, p->nx[k]+p->nu[k], column);
      column++;
    }
    for (i=d->x_ineq_idx[k];i<d->x_ineq_idx[k+1];++i) {
      int j = d->x_ineq[i]-p->CD[k].offset_c;
      if (j>=p->nx[k]) {
        j -= p->nx[k];
      } else {
        j += p->nu[k];
      }
      blasfeo_pack_tran_dmat(1, 1, &one, 1, res, j, column);
      blasfeo_pack_tran_dmat(1, 1, &zero, 1, res, p->nx[k]+p->nu[k], column);
      column++;
    }
 
    // Second part
    blasfeo_dvec v, r;
    blasfeo_allocate_dvec(p->nx[k]+p->nu[k]+1, &v);
    blasfeo_allocate_dvec(ng_ineq, &r);
    // Fill v with [u;x;1]
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(inputs_k), 1, &v, 0);
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(states_k), 1, &v, p->nu[k]);
    blasfeo_pack_dvec(1, &zero, 1, &v, p->nu[k]+p->nx[k]);
 
    blasfeo_dgemv_t(p->nx[k]+p->nu[k]+1, ng_ineq, 1.0, res, 0, 0,
      &v, 0,
      0.0, &r, 0,
      &r, 0);
    std::vector<double> mem(ng_ineq);
    blasfeo_unpack_dvec(ng_ineq, &r, 0, get_ptr(mem), 1);
 
    blasfeo_pack_dmat(1, ng_ineq, get_ptr(mem), 1, res, p->nx[k]+p->nu[k], 0);
 
    blasfeo_free_dvec(&v);
    blasfeo_free_dvec(&r);
 
    return 0;
  }

References get_ptr().

Referenced by eval_gineq(), eval_RSQrqt(), and casadi::FatropConicInterface::solve().

eval_gineq()

fatrop_int casadi::eval_gineq	(	const double *	states_k,
		const double *	inputs_k,
		const double *	stage_params_k,
		const double *	global_params,
		double *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 836 of file fatrop_conic_interface.cpp.

                                           {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    auto d = &m->d;
    auto p = d->prob;
 
    int n_a_ineq = d->a_ineq_idx[k+1]-d->a_ineq_idx[k];
    int n_x_ineq = d->x_ineq_idx[k+1]-d->x_ineq_idx[k];
    int ng_ineq = n_a_ineq+n_x_ineq;
 
 
    blasfeo_dmat Ggtk;
    blasfeo_allocate_dmat(p->nx[k]+p->nu[k]+1, ng_ineq, &Ggtk);
    eval_Ggt_ineq(states_k, inputs_k, stage_params_k, global_params, &Ggtk, k, user_data);
    blasfeo_unpack_dmat(1, ng_ineq, &Ggtk, p->nx[k]+p->nu[k], 0, res, 1);
    blasfeo_free_dmat(&Ggtk);
 
    return 0;
  }

References eval_Ggt_ineq().

Referenced by casadi::FatropConicInterface::solve().

eval_L()

fatrop_int casadi::eval_L	(	const double *	objective_scale,
		const double *	inputs_k,
		const double *	states_k,
		const double *	stage_params_k,
		const double *	global_params,
		double *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 915 of file fatrop_conic_interface.cpp.

                                           {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    *res = 0.0;
    casadi_assert_dev(*objective_scale==1);
    auto d = &m->d;
    auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
    blasfeo_dmat RSQrqtk;
 
    int n = p->nx[k]+p->nu[k];
 
    blasfeo_dvec v, r;
    blasfeo_allocate_dmat(n, n, &RSQrqtk);
    blasfeo_allocate_dvec(n, &v);
    blasfeo_allocate_dvec(n, &r);
    blasfeo_pack_dmat(p->nx[k], p->nx[k], d->RSQ+p->RSQ_offsets[k],
      n, &RSQrqtk, p->nu[k], p->nu[k]);
    blasfeo_pack_dmat(p->nu[k], p->nu[k], d->RSQ+p->RSQ_offsets[k]+p->nx[k]*n+p->nx[k],
      n, &RSQrqtk, 0, 0);
    blasfeo_pack_dmat(p->nu[k], p->nx[k], d->RSQ+p->RSQ_offsets[k]+p->nx[k],
      n, &RSQrqtk, 0, p->nu[k]);
    blasfeo_pack_dmat(p->nx[k], p->nu[k], d->RSQ+p->RSQ_offsets[k]+p->nx[k]*n,
      n, &RSQrqtk, p->nu[k], 0);
 
    // Fill v with [u;x]
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(inputs_k), 1, &v, 0);
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(states_k), 1, &v, p->nu[k]);
 
    blasfeo_dgemv_n(n, n, 1.0, &RSQrqtk, 0, 0,
      &v, 0,
      0.0, &r, 0,
      &r, 0);
 
    double obj = 0.5*blasfeo_ddot(n, &v, 0, &r, 0);
 
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r),
      1, &r, p->nu[k]);
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r+p->nx[k]),
      1, &r, 0);
 
    obj += blasfeo_ddot(n, &v, 0, &r, 0);
 
    blasfeo_free_dmat(&RSQrqtk);
    blasfeo_free_dvec(&v);
    blasfeo_free_dvec(&r);
    *res = obj;
 
    return 0;
 
  }

References blasfeo_ddot(), and casadi_qp_data< T1 >::g.

Referenced by casadi::FatropConicInterface::solve().

eval_rq()

fatrop_int casadi::eval_rq	(	const double *	objective_scale,
		const double *	inputs_k,
		const double *	states_k,
		const double *	stage_params_k,
		const double *	global_params,
		double *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 862 of file fatrop_conic_interface.cpp.

                                           {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    *res = 0.0;
    casadi_assert_dev(*objective_scale==1);
    auto d = &m->d;
    auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
    blasfeo_dmat RSQrqtk;
 
    int n = p->nx[k]+p->nu[k];
 
    blasfeo_dvec v, r;
    blasfeo_allocate_dmat(n, n, &RSQrqtk);
    blasfeo_allocate_dvec(n, &v);
    blasfeo_allocate_dvec(n, &r);
    blasfeo_pack_dmat(p->nx[k], p->nx[k], d->RSQ+p->RSQ_offsets[k],
      n, &RSQrqtk, p->nu[k], p->nu[k]);
    blasfeo_pack_dmat(p->nu[k], p->nu[k], d->RSQ+p->RSQ_offsets[k]+p->nx[k]*n+p->nx[k],
      n, &RSQrqtk, 0, 0);
    blasfeo_pack_dmat(p->nu[k], p->nx[k], d->RSQ+p->RSQ_offsets[k]+p->nx[k],
      n, &RSQrqtk, 0, p->nu[k]);
    blasfeo_pack_dmat(p->nx[k], p->nu[k], d->RSQ+p->RSQ_offsets[k]+p->nx[k]*n,
      n, &RSQrqtk, p->nu[k], 0);
 
    // Fill v with [u;x]
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(inputs_k), 1, &v, 0);
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(states_k), 1, &v, p->nu[k]);
 
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r), 1, &r, p->nu[k]);
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r+p->nx[k]), 1, &r, 0);
 
    blasfeo_dgemv_n(n, n, 1.0, &RSQrqtk, 0, 0,
      &v, 0,
      1.0, &r, 0,
      &r, 0);
 
    blasfeo_unpack_dvec(n, &r, 0, res, 1);
 
    blasfeo_free_dmat(&RSQrqtk);
    blasfeo_free_dvec(&v);
    blasfeo_free_dvec(&r);
 
    return 0;
  }

References casadi_qp_data< T1 >::g.

Referenced by casadi::FatropConicInterface::solve().

eval_RSQrqt()

fatrop_int casadi::eval_RSQrqt	(	const double *	objective_scale,
		const double *	inputs_k,
		const double *	states_k,
		const double *	lam_dyn_k,
		const double *	lam_eq_k,
		const double *	lam_eq_ineq_k,
		const double *	stage_params_k,
		const double *	global_params,
		MAT *	res,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 669 of file fatrop_conic_interface.cpp.

                                           {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    const auto& solver = *data->solver;
    casadi_assert_dev(*objective_scale==1);
 
    auto d = &m->d;
    auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
    int n = p->nx[k]+p->nu[k];
    blasfeo_pack_dmat(p->nx[k], p->nx[k],
      d->RSQ+p->RSQ_offsets[k], n, res, p->nu[k], p->nu[k]);
    blasfeo_pack_dmat(p->nu[k], p->nu[k],
      d->RSQ+p->RSQ_offsets[k]+p->nx[k]*n+p->nx[k], n, res, 0, 0);
    blasfeo_pack_dmat(p->nu[k], p->nx[k],
      d->RSQ+p->RSQ_offsets[k]+p->nx[k], n, res, 0, p->nu[k]);
    blasfeo_pack_dmat(p->nx[k], p->nu[k],
      d->RSQ+p->RSQ_offsets[k]+p->nx[k]*n, n, res, p->nu[k], 0);
 
    blasfeo_pack_dmat(1, p->nx[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r),
      1, res, p->nu[k]+p->nx[k], p->nu[k]);
    blasfeo_pack_dmat(1, p->nu[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r+p->nx[k]),
      1, res, p->nu[k]+p->nx[k], 0);
 
    blasfeo_dvec r, v;
    blasfeo_allocate_dvec(n, &v);
    blasfeo_allocate_dvec(p->nx[k]+p->nu[k], &r);
    // Fill v with [u;x]
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(inputs_k), 1, &v, 0);
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(states_k), 1, &v, p->nu[k]);
 
    blasfeo_pack_dvec(p->nx[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r),
      1, &r, p->nu[k]);
    blasfeo_pack_dvec(p->nu[k], const_cast<double*>(d_qp->g+p->RSQ[k].offset_r+p->nx[k]),
      1, &r, 0);
 
    blasfeo_dgemv_n(n, n, 1.0, res, 0, 0,
      &v, 0,
      1.0, &r, 0,
      &r, 0);
 
    int n_a_eq = d->a_eq_idx[k+1]-d->a_eq_idx[k];
    int n_x_eq = d->x_eq_idx[k+1]-d->x_eq_idx[k];
    int ng_eq = n_a_eq+n_x_eq;
    int n_a_ineq = d->a_ineq_idx[k+1]-d->a_ineq_idx[k];
    int n_x_ineq = d->x_ineq_idx[k+1]-d->x_ineq_idx[k];
    int ng_ineq = n_a_ineq+n_x_ineq;
 
    bool last_k = k==solver.N_;
 
    blasfeo_dvec lam_dyn, lam_g, lam_g_ineq;
    blasfeo_dmat BAbtk, Ggtk, Ggt_ineqk;
    if (!last_k)
      blasfeo_allocate_dvec(p->nx[k+1], &lam_dyn);
    blasfeo_allocate_dvec(ng_eq, &lam_g);
    blasfeo_allocate_dvec(ng_ineq, &lam_g_ineq);
    if (!last_k)
      blasfeo_allocate_dmat(p->nx[k]+p->nu[k]+1, p->nx[k+1], &BAbtk);
    blasfeo_allocate_dmat(p->nx[k]+p->nu[k]+1, ng_eq, &Ggtk);
    blasfeo_allocate_dmat(p->nx[k]+p->nu[k]+1, ng_ineq, &Ggt_ineqk);
 
    if (!last_k)
      eval_BAbt(0, inputs_k, states_k, stage_params_k, global_params, &BAbtk, k, user_data);
    eval_Ggt(inputs_k, states_k, stage_params_k, global_params, &Ggtk, k, user_data);
    eval_Ggt_ineq(inputs_k, states_k, stage_params_k, global_params, &Ggt_ineqk, k, user_data);
 
    if (!last_k)
      blasfeo_pack_dvec(p->nx[k+1], const_cast<double*>(lam_dyn_k), 1, &lam_dyn, 0);
    blasfeo_pack_dvec(ng_eq, const_cast<double*>(lam_eq_k), 1, &lam_g, 0);
    blasfeo_pack_dvec(ng_ineq, const_cast<double*>(lam_eq_ineq_k), 1, &lam_g_ineq, 0);
 
    if (!last_k)
      blasfeo_dgemv_n(p->nx[k]+p->nu[k], p->nx[k+1], 1.0, &BAbtk, 0, 0,
        &lam_dyn, 0,
        1.0, &r, 0,
        &r, 0);
 
    blasfeo_dgemv_n(p->nx[k]+p->nu[k], ng_eq, 1.0, &Ggtk, 0, 0,
      &lam_g, 0,
      1.0, &r, 0,
      &r, 0);
 
    blasfeo_dgemv_n(p->nx[k]+p->nu[k], ng_ineq, 1.0, &Ggt_ineqk, 0, 0,
      &lam_g_ineq, 0,
      1.0, &r, 0,
      &r, 0);
 
    std::vector<double> mem(p->nx[k]+p->nu[k]);
    blasfeo_unpack_dvec(p->nx[k]+p->nu[k], &r, 0, get_ptr(mem), 1);
 
    blasfeo_pack_dmat(1, p->nx[k]+p->nu[k], const_cast<double*>(get_ptr(mem)),
      1, res, p->nu[k]+p->nx[k], 0);
 
 
    if (!last_k)
      blasfeo_free_dmat(&BAbtk);
    blasfeo_free_dmat(&Ggtk);
    blasfeo_free_dmat(&Ggt_ineqk);
    blasfeo_free_dvec(&r);
    if (!last_k)
      blasfeo_free_dvec(&lam_dyn);
    blasfeo_free_dvec(&lam_g);
    blasfeo_free_dvec(&lam_g_ineq);
    blasfeo_free_dvec(&v);
 
    return 0;
  }

References eval_BAbt(), eval_Ggt(), eval_Ggt_ineq(), casadi_qp_data< T1 >::g, and get_ptr().

Referenced by casadi::FatropConicInterface::solve().

external() [1/3]

CASADI_EXPORT Function casadi::external	(	const std::string &	name,
		const Dict &	opts = Dict()
	)

Parameters

name	Name as in the label assigned to a CasADi Function object: Function(name,...,...) Will be used to look up symbols/functions named eg. <name>_eval Use nm (linux/osx) or depends.exe (win) to check which symbols are present in your shared library

File name is assumed to be ./<name>.so

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

Definition at line 50 of file external.cpp.

                                                           {
  return external(name, "./" + name + SHARED_LIBRARY_SUFFIX, opts);
}

References external().

external() [2/3]

CASADI_EXPORT Function casadi::external	(	const std::string &	name,
		const Importer &	li,
		const Dict &	opts = Dict()
	)

File name given

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

Definition at line 42 of file external.cpp.

                                    {
  std::vector<std::string> config_args;
  Dict opts_filtered = extract_from_dict(opts, "config_args", config_args);
  config_args.insert(config_args.begin(), li.library());
  return Function::create(new GenericExternal(name, li, config_args), opts_filtered);
}

References casadi::Function::create(), extract_from_dict(), and casadi::Importer::library().

Referenced by casadi::DaeBuilder::add_fun(), external(), casadi::External::factory(), casadi::External::get_forward(), casadi::External::get_jacobian(), casadi::External::get_reverse(), casadi::Scpgen::init(), casadi::OracleFunction::jit_dependencies(), and nlpsol().

external() [3/3]

CASADI_EXPORT Function casadi::external	(	const std::string &	name,
		const std::string &	bin_name,
		const Dict &	opts = Dict()
	)

Parameters

name	Name as in the label assigned to a CasADi Function object: Function(name,...,...) Will be used to look up symbols/functions named eg. <name>_eval Use nm (linux/osx) or depends.exe (win) to check which symbols are present in your shared library
bin_name	File name of the shared library

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

Definition at line 54 of file external.cpp.

                                    {
  return external(name, Importer(bin_name, "dll"), opts);
}

References external().

external_transform()

CASADI_EXPORT Function casadi::external_transform	(	const std::string &	name,
		const std::string &	op,
		const Function &	f,
		const Dict &	opts = Dict()
	)

Parameters

name	Name of the shared library
op	Name of the operation
f	Function to transform
opts	Options Extra doc: https://github.com/casadi/casadi/wiki/L_27i

Definition at line 44 of file tools.cpp.

                                      {
    std::string signature = "f";
    Importer li(name + CasadiMeta::shared_library_suffix(), "dll");
    std::string op_full = op + "__" + signature;
    external_transform_t t = (external_transform_t) li.get_function(op_full);
    if (!t) {
        casadi_error("Transformation '" + op + "' not defined in library '" + name +
                     "' for the following signature: " + signature);
    }
 
    StringSerializer ss;
    ss.pack(f);
    ss.pack(opts);
 
    char api_version = 0;
    std::string casadi_version = CasadiMeta::version();
 
    std::string s = ss.encode();
    const char* out = t(api_version, casadi_version.c_str(), s.c_str(),
        callback_stdout, callback_stderr);
    if (!out) {
        casadi_error("Transformation '" + op + "' defined in library '" + name +
                     "' failed.");
    }
 
    StringDeserializer sd(out);
    Function r = sd.unpack_function();
 
    return r;
}

References callback_stderr(), callback_stdout(), casadi::StringSerializer::encode(), casadi::Importer::get_function(), casadi::SerializerBase::pack(), casadi::CasadiMeta::shared_library_suffix(), casadi::DeserializerBase::unpack_function(), and casadi::CasadiMeta::version().

Referenced by casadi::Function::construct(), and casadi::Function::transform().

extract_from_dict()

template<class T >

Dict casadi::extract_from_dict	(	const Dict &	d,
		const std::string &	key,
		T &	value
	)

Definition at line 277 of file generic_type.hpp.

                                                                        {
    Dict ret = d;
    auto it = ret.find(key);
    if (it!=ret.end()) {
        value = it->second;
        ret.erase(it);
    }
    return ret;
  }

Referenced by casadi::Function::bspline(), casadi::Interpolant::construct(), external(), casadi::MX::forward(), casadi::Matrix< double >::has_duplicates(), casadi::Matrix< double >::has_output(), casadi::MX::jacobian(), and casadi::MX::reverse().

extract_from_dict_inplace()

template<class T >

void casadi::extract_from_dict_inplace	(	Dict &	d,
		const std::string &	key,
		T &	value
	)

Definition at line 288 of file generic_type.hpp.

                                                                          {
    auto it = d.find(key);
    if (it!=d.end()) {
        value = it->second;
        d.erase(it);
    }
  }

Referenced by casadi::XFunction< DerivedType, MatType, NodeType >::factory(), and qpsol_nlp().

extract_zip_from_path()

bool casadi::extract_zip_from_path	(	const std::string &	zip_path,
		const std::string &	output_dir
	)

Definition at line 57 of file libzip.cpp.

                                                                                       {
        int err;
        zip_t* za = zip_open(zip_path.c_str(), ZIP_RDONLY, &err);
        if (!za) {
            casadi_error("Cannot open ZIP file: " + zip_path);
            return false;
        }
        return extract_zip_internal(za, output_dir);
    }

References extract_zip_internal().

Referenced by casadi_register_archiver_libzip().

extract_zip_from_stringstream()

bool casadi::extract_zip_from_stringstream	(	std::stringstream &	src,
		const std::string &	output_dir
	)

Definition at line 34 of file libzip.cpp.

                                                                                          {
        src.clear();
        src.seekg(0, std::ios::beg);
        const std::string& s = src.str();
        // Open zip archive from memory buffer
        zip_error_t errorp;
        zip_source_t* zip_src = zip_source_buffer_create(s.data(), s.size(), 0, &errorp);
 
        if (!zip_src) {
            casadi_error("Failed to create zip source: " +
                std::string(zip_error_strerror(&errorp)) + "\n");
            return false;
        }
 
        zip_t* archive = zip_open_from_source(zip_src, 0, &errorp);
        if (!archive) {
            zip_source_free(zip_src);
            casadi_error("Failed to open zip from source: " +
                std::string(zip_error_strerror(&errorp)) + "\n");
        }
        return extract_zip_internal(archive, output_dir);
    }

References extract_zip_internal().

Referenced by casadi_register_archiver_libzip().

extract_zip_internal()

bool casadi::extract_zip_internal	(	zip_t *	za,
		const std::string &	output_dir
	)

Definition at line 67 of file libzip.cpp.

                                                                      {
        Filesystem::assert_enabled();
        auto filesystem = Filesystem::getPlugin("ghc");
 
        zip_int64_t num_entries = zip_get_num_entries(za, 0);
        if (num_entries < 0) {
            zip_close(za);
            casadi_error("Cannot read ZIP contents.");
            return false;
        }
 
 
        for (zip_uint64_t i = 0; i < static_cast<zip_uint64_t>(num_entries); ++i) {
            const char* name = zip_get_name(za, i, 0);
            if (!name) {
                uerr() << "Error: Cannot get file name for entry " << i << std::endl;
                continue;
            }
 
            std::string full_path = output_dir + "/" + name;
            if (full_path.back() == '/') {  // Directory entry
                filesystem.exposed.create_directories(full_path);
            } else {  // File entry
                std::string dir_path = full_path.substr(0, full_path.find_last_of('/'));
                filesystem.exposed.create_directories(dir_path);
 
                zip_file_t* zf = zip_fopen_index(za, i, 0);
                if (!zf) {
                    uerr() << "Error: Cannot open file in ZIP: " << name << std::endl;
                    continue;
                }
 
                auto out_file_ptr = Filesystem::ofstream_ptr(full_path, std::ios::binary);
                std::ostream& out_file = *out_file_ptr;
                if (!out_file) {
                    uerr() << "Error: Cannot write file: " << full_path << std::endl;
                    zip_fclose(zf);
                    continue;
                }
 
                char buffer[8192];
                zip_int64_t bytes_read;
                while ((bytes_read = zip_fread(zf, buffer, sizeof(buffer))) > 0) {
                    out_file.write(buffer, bytes_read);
                }
 
                if (bytes_read < 0) {
                    uerr() << "Error: Read failed for file in ZIP: " << name << std::endl;
                }
 
                out_file_ptr.reset();
                zip_fclose(zf);
            }
        }
 
        zip_close(za);
        return true;
    }

References casadi::Filesystem::assert_enabled(), casadi::PluginInterface< Filesystem >::getPlugin(), casadi::Filesystem::ofstream_ptr(), and uerr().

Referenced by extract_zip_from_path(), and extract_zip_from_stringstream().

fatrop_blocks_pack()

std::vector< casadi_int > casadi::fatrop_blocks_pack

(

const std::vector< casadi_ocp_block > &

blocks

)

Definition at line 311 of file fatrop_conic_interface.cpp.

                                                                                      {
    size_t N = blocks.size();
    std::vector<casadi_int> ret(4*N);
    casadi_int* r = get_ptr(ret);
    for (casadi_int i=0;i<N;++i) {
      *r++ = blocks[i].offset_r;
      *r++ = blocks[i].offset_c;
      *r++ = blocks[i].rows;
      *r++ = blocks[i].cols;
    }
    return ret;
  }

References get_ptr().

Referenced by codegen_unpack_block(), and casadi::FatropInterface::serialize_body().

fd_offset()

CASADI_EXPORT casadi_int casadi::fd_offset

(

FdMode

v

)

Definition at line 52 of file finite_differences.cpp.

                               {
  switch (v) {
    case FdMode::FORWARD: return 0;
    case FdMode::BACKWARD:
    case FdMode::CENTRAL: return 1;
    case FdMode::SMOOTHING: return 2;
    default: break;
  }
  return -1;
}

References BACKWARD, CENTRAL, FORWARD, and SMOOTHING.

Referenced by casadi::FmuInternal::eval_fd().

filename()

std::string casadi::filename

(

const std::string &

path

)

Definition at line 55 of file ghc.cpp.

                                              {
        return ghc::filesystem::path(path).filename().string();
    }

References path().

Referenced by casadi_register_filesystem_ghc(), conic_debug(), casadi::XmlFile::dump(), casadi::TinyXmlInterface::dump(), casadi::Dump::eval(), casadi::GraphBuilderInternal::export_onnx(), casadi::GraphBuilder::export_onnx(), casadi::Sparsity::file_format(), casadi::Sparsity::from_file(), casadi::NlpBuilder::import_nl(), casadi::Function::load(), casadi::DaeBuilder::load_fmi_description(), casadi::DaeBuilderInternal::load_fmi_description(), casadi::NlImporter::NlImporter(), casadi::XmlFile::parse(), casadi::TinyXmlInterface::parse(), casadi::ModelicaParser::parse(), casadi::LaceModelica::parse(), casadi::DaeBuilder::parse_fmi(), and casadi::Sparsity::to_file().

filesep()

CASADI_EXPORT std::string casadi::filesep

(

)

Definition at line 71 of file casadi_os.cpp.

                    {
    #ifdef _WIN32
        return "\\";
    #else
        return "/";
    #endif
}

Referenced by casadi::Dump::eval(), and casadi::ClangCompiler::init().

find()

template<typename T >

std::vector< casadi_int > casadi::find

(

const std::vector< T > &

v

)

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

Definition at line 643 of file casadi_misc.hpp.

                                                    {
    std::vector<casadi_int> ret;
    for (casadi_int i=0;i<v.size();++i) {
      if (v[i]) ret.push_back(i);
    }
    return ret;
  }

Referenced by casadi::Find::eval_mx(), casadi::MXNode::get_find(), casadi::PluginInterface< Derived >::has_plugin(), casadi::PluginInterface< Derived >::load_plugin(), casadi::Opti::to_function(), and casadi::DaeBuilderInternal::variable().

finite_diff()

template<typename T1 >

CASADI_EXPORT void casadi::finite_diff	(	FdMode	v,
		const T1 **	yk,
		T1 *	J,
		T1	h,
		casadi_int	n_y,
		T1	smoothing
	)

Definition at line 49 of file finite_differences.hpp.

                  {
  switch (v) {
    case FdMode::FORWARD:
    case FdMode::BACKWARD:
      return casadi_forward_diff(yk, J, h, n_y);
    case FdMode::CENTRAL:
      return casadi_central_diff(yk, J, h, n_y);
    case FdMode::SMOOTHING:
      return casadi_smoothing_diff(yk, J, h, n_y, eps);
    default:
      casadi_error("FD mode " + to_string(v) + " not implemented");
  }
}

References BACKWARD, CENTRAL, eps, FORWARD, SMOOTHING, and to_string().

Referenced by casadi::FmuInternal::eval_fd().

flatten_nested_vector() [1/2]

template<class T , class S >

void casadi::flatten_nested_vector	(	const std::vector< std::vector< T > > &	nested,
		std::vector< S > &	flat
	)

Contents of nested[i] ends up in flat[indices[i]]..flat[indices[i+1]-1]

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

Definition at line 706 of file casadi_misc.hpp.

                                                 {
    // Count total elements in nested
    casadi_int N = 0;
    for (const auto& e : nested) {
      N += e.size();
    }
 
    // Populate flat, one nested section at a time
    flat.clear();
    flat.reserve(N);
    for (const auto& e : nested) {
      flat.insert(flat.end(), e.begin(), e.end());
    }
  }

Referenced by flatten_nested_vector(), casadi::CplexInterface::init(), casadi::GurobiInterface::init(), and casadi::XpressInterface::init().

flatten_nested_vector() [2/2]

template<class T , class S , class I >

void casadi::flatten_nested_vector	(	const std::vector< std::vector< T > > &	nested,
		std::vector< S > &	flat,
		std::vector< I > &	indices
	)

Contents of nested[i] ends up in flat[indices[i]]..flat[indices[i+1]-1]

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

Definition at line 723 of file casadi_misc.hpp.

                                                    {
    // Delegate
    flatten_nested_vector(nested, flat);
 
    // Build up indices
    casadi_int N = nested.size();
    indices.resize(1, 0);
    indices.reserve(N+1);
    casadi_int offset = 0;
    for (const auto& e : nested) {
      offset += e.size();
      indices.push_back(offset);
    }
  }

References flatten_nested_vector().

flatten_opts()

void casadi::flatten_opts	(	Dict &	ret,
		const Dict &	opts,
		const std::string &	prefix
	)

Definition at line 96 of file ccopt_interface.cpp.

                                                                        {
  for (const auto& kv : opts) {
    switch (kv.second.getType()) {
     case OT_DICT:
       flatten_opts(ret, kv.second, prefix + kv.first + ".");
       break;
     default:
       ret[prefix + kv.first] = kv.second;
    }
  }
}

References OT_DICT.

Referenced by casadi::MadmpecInterface::init(), and casadi::MadnlpInterface::init().

fmtstr()

std::string casadi::fmtstr ( const std::string &  fmt, const std::vector< std::string > &  args  )

inline

Definition at line 236 of file casadi_common.hpp.

                                                                                  {
    std::string s = fmt;
    for (auto&& e : args) {
      std::string::size_type n = s.find("%s");
      if (n==std::string::npos) return "** Ill-formatted string ** " + fmt;
      s.replace(n, 2, e);
    }
    return s;
  }

format_from_path()

static std::string casadi::format_from_path ( const std::string &  path )

static

Definition at line 53 of file graph_builder.cpp.

                                                           {
    auto dot = path.find_last_of('.');
    std::string suffix = dot == std::string::npos ? "" : path.substr(dot + 1);
    if (suffix == "onnx") return "onnx";
    casadi_error("GraphBuilder: cannot infer format from '" + path + "'");
  }

References dot(), and path().

Referenced by casadi::GraphBuilder::GraphBuilder().

from_fmi2()

CASADI_EXPORT Type casadi::from_fmi2

(

TypeFmi2

v

)

Version mappings

Definition at line 63 of file dae_builder_internal.cpp.

                           {
  switch (v) {
  case TypeFmi2::REAL: return Type::FLOAT64;
  case TypeFmi2::INTEGER: return Type::INT32;
  case TypeFmi2::BOOLEAN: return Type::BOOLEAN;
  case TypeFmi2::STRING: return Type::STRING;
  case TypeFmi2::ENUM: return Type::ENUMERATION;
  default: break;
  }
  return Type::NUMEL;
}

References BOOLEAN, ENUM, ENUMERATION, FLOAT64, INT32, INTEGER, NUMEL, REAL, and STRING.

Referenced by casadi::DaeBuilder::set_type().

full_eval_constr_jac()

fatrop_int casadi::full_eval_constr_jac	(	const double *	primal_data,
		const double *	stageparams_p,
		const double *	globalparams_p,
		MAT *	BAbt_p,
		MAT *	Ggt_p,
		MAT *	Ggt_ineq_p,
		const FatropOcpCDims *	s,
		void *	user_data
	)

Definition at line 1033 of file fatrop_conic_interface.cpp.

                                                                                          {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

full_eval_contr_viol()

fatrop_int casadi::full_eval_contr_viol	(	const double *	primal_data,
		const double *	stageparams_p,
		const double *	globalparams_p,
		double *	cv_p,
		const FatropOcpCDims *	s,
		void *	user_data
	)

Definition at line 1039 of file fatrop_conic_interface.cpp.

                                                              {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

full_eval_lag_hess()

fatrop_int casadi::full_eval_lag_hess	(	double	objective_scale,
		const double *	primal_data,
		const double *	lam_data,
		const double *	stageparams_p,
		const double *	globalparams_p,
		MAT *	RSQrqt_p,
		const FatropOcpCDims *	s,
		void *	user_data
	)

Definition at line 1026 of file fatrop_conic_interface.cpp.

                                                                      {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

full_eval_obj()

fatrop_int casadi::full_eval_obj	(	double	objective_scale,
		const double *	primal_data,
		const double *	stageparams_p,
		const double *	globalparams_p,
		double *	res,
		const FatropOcpCDims *	s,
		void *	user_data
	)

Definition at line 1051 of file fatrop_conic_interface.cpp.

                                                                   {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

full_eval_obj_grad()

fatrop_int casadi::full_eval_obj_grad	(	double	objective_scale,
		const double *	primal_data,
		const double *	stageparams_p,
		const double *	globalparams_p,
		double *	grad_p,
		const FatropOcpCDims *	s,
		void *	user_data
	)

Definition at line 1045 of file fatrop_conic_interface.cpp.

                                                                      {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

get_boor()

void casadi::get_boor	(	const MX &	x,
		const MX &	knots,
		casadi_int	degree,
		casadi_int	lookup_mode,
		MX &	start,
		MX &	boor
	)

Definition at line 177 of file bspline.cpp.

                           {
    MX knots_clipped = knots(range(degree, knots.size1()-degree));
 
    Dict low_opts;
    low_opts["lookup_mode"] = Low::lookup_mode_from_enum(lookup_mode);
    MX L = low(knots_clipped, x, low_opts);
    start = fmin(L, knots.size1()-2*degree-2);
 
    DM boor_init = DM::zeros(x.size2(), 2*degree+1);
    boor_init(Slice(), degree) = 1;
    std::vector<MX> boor_full = horzsplit(MX(boor_init));
    casadi_int n_knots = 2*degree+2;
 
    MX kn;
    MX(knots).get_nz(kn, false, start, MX(range(n_knots)));
 
    std::vector<MX> knv = horzsplit(kn);
 
    MX xt = x.T();
 
    for (casadi_int d=1;d<degree+1;++d) {
      for (casadi_int i=0;i<n_knots-d-1;++i) {
        MX bottom = knv[i+d]-knv[i];
        MX b = if_else_zero(bottom, (xt-knv[i])*boor_full[i]/(bottom+1e-100));
        bottom = knv[i+d+1]-knv[i + 1];
        b += if_else_zero(bottom, (knv[i+d+1]-xt)*boor_full[i+1]/(bottom+1e-100));
        boor_full[i] = b;
      }
    }
 
    boor = horzcat(std::vector<MX>(boor_full.begin(), boor_full.begin()+degree+1));
  }

References casadi::MX::get_nz(), if_else_zero(), casadi::Low::lookup_mode_from_enum(), range(), casadi::GenericMatrix< MatType >::size1(), casadi::GenericMatrix< MatType >::size2(), casadi::MX::T(), and casadi::GenericMatrix< MatType >::zeros().

Referenced by do_inline().

get_bounds()

fatrop_int casadi::get_bounds	(	double *	lower,
		double *	upper,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 974 of file fatrop_conic_interface.cpp.

                                                                                           {
      FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    auto d = &m->d;
    //auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
    int i=0;
    int column = 0;
    for (i=d->a_ineq_idx[k];i<d->a_ineq_idx[k+1];++i) {
      lower[column] = d_qp->lba[d->a_ineq[i]];
      upper[column] = d_qp->uba[d->a_ineq[i]];
      column++;
    }
    //int offset = d->a_ineq_idx[k+1]-d->a_ineq_idx[k];
    for (i=d->x_ineq_idx[k];i<d->x_ineq_idx[k+1];++i) {
      lower[column] = d_qp->lbx[d->x_ineq[i]];
      upper[column] = d_qp->ubx[d->x_ineq[i]];
      column++;
    }
 
    //fatrop_int n_a_ineq = d->a_ineq_idx[k+1]-d->a_ineq_idx[k];
    //fatrop_int n_x_ineq = d->x_ineq_idx[k+1]-d->x_ineq_idx[k];
    //fatrop_int ng_ineq = n_a_ineq+n_x_ineq;
 
    return 0;
  }

References casadi_qp_data< T1 >::lba, casadi_qp_data< T1 >::lbx, casadi_qp_data< T1 >::uba, and casadi_qp_data< T1 >::ubx.

Referenced by casadi::FatropConicInterface::solve().

get_bvec_t() [1/4]

CASADI_EXPORT const bvec_t * casadi::get_bvec_t

(

const std::vector< double > &

v

)

Definition at line 200 of file casadi_misc.cpp.

                                                       {
    if (v.empty()) {
      return nullptr;
    } else {
      return reinterpret_cast<const bvec_t*>(&v.front());
    }
  }

get_bvec_t() [2/4]

template<typename T >

const bvec_t * casadi::get_bvec_t

(

const std::vector< T > &

v

)

Definition at line 1021 of file casadi_misc.hpp.

                                                  {
    casadi_assert(0, "get_bvec_t only supported for double");
  }

get_bvec_t() [3/4]

CASADI_EXPORT bvec_t * casadi::get_bvec_t

(

std::vector< double > &

v

)

Get an pointer of sets of booleans from a double vector

Definition at line 191 of file casadi_misc.cpp.

                                           {
    if (v.empty()) {
      return nullptr;
    } else {
      return reinterpret_cast<bvec_t*>(&v.front());
    }
  }

get_bvec_t() [4/4]

template<typename T >

bvec_t * casadi::get_bvec_t

(

std::vector< T > &

v

)

Definition at line 1016 of file casadi_misc.hpp.

                                      {
    casadi_assert(0, "get_bvec_t only supported for double");
  }

get_const()

MX casadi::get_const	(	const Sparsity &	sp,
		const double *	v,
		std::unordered_multimap< std::size_t, std::pair< MX, DM > > &	cache
	)

Definition at line 2360 of file mx.cpp.

                                                                  {
    // Compute hash from sparsity and double values
    std::size_t h = sp.hash();
    hash_combine(h, v, sp.nnz());
 
    // Loop over tentative matches
    auto r = cache.equal_range(h);
    for (auto it = r.first; it != r.second; ++it) {
      const DM& d = it->second.second;
      if (d.sparsity()==sp && std::equal(d.ptr(), d.ptr()+sp.nnz(), v)) {
        // Found match
        return it->second.first;
      }
    }
 
    // fallthrough: failed to find a match
 
    // Create a <MX,DM> pair and store in cache
    std::vector<double> vec(v, v+sp.nnz());
    DM m(sp, vec);
    MX ret = m;
    cache.emplace(h, std::make_pair(ret, m));
 
    // Return the MX
    return ret;
  }

References casadi::Sparsity::hash(), hash_combine(), casadi::Sparsity::nnz(), casadi::Matrix< Scalar >::ptr(), and casadi::Matrix< Scalar >::sparsity().

Referenced by casadi::MX::simplify_const_folding().

get_default_global_params()

fatrop_int casadi::get_default_global_params	(	double *	global_params,
		void *	user_data
	)

Definition at line 465 of file fatrop_conic_interface.cpp.

                                                                               {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

get_default_stage_params()

fatrop_int casadi::get_default_stage_params	(	double *	stage_params,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 461 of file fatrop_conic_interface.cpp.

                                                                                                 {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

get_float_attribute()

double casadi::get_float_attribute	(	const onnx::NodeProto &	node,
		const std::string &	name,
		double	default_value
	)

Definition at line 48 of file onnx_utilities.cpp.

                                                   {
    for (int a = 0; a < node.attribute_size(); ++a) {
      if (node.attribute(a).name() == name) return node.attribute(a).f();
    }
    return default_value;
  }

get_from_dict() [1/2]

template<class T >

T casadi::get_from_dict	(	const Dict &	d,
		const std::string &	key,
		const T &	default_value
	)

Definition at line 270 of file generic_type.hpp.

                                                                               {
    auto it = d.find(key);
    if (it==d.end()) return default_value;
    return it->second;
  }

References T.

get_from_dict() [2/2]

template<class T >

T casadi::get_from_dict	(	const std::map< std::string, T > &	d,
		const std::string &	key,
		const T &	default_value
	)

Definition at line 262 of file generic_type.hpp.

                                                    {
    auto it = d.find(key);
    if (it==d.end()) return default_value;
    return it->second;
  }

References T.

Referenced by construct_nlpsol(), casadi::FunctionInternal::get_jit_directory(), init_gen(), map_semi_expl(), qpsol_nlp(), reduce_index_gen(), and casadi::OptiNode::stats().

get_graph_attribute()

const onnx::GraphProto * casadi::get_graph_attribute	(	const onnx::NodeProto &	node,
		const std::string &	name
	)

Definition at line 63 of file onnx_utilities.cpp.

                                                                     {
    for (int a = 0; a < node.attribute_size(); ++a) {
      if (node.attribute(a).name() == name) return &node.attribute(a).g();
    }
    return nullptr;
  }

get_horizon_length()

fatrop_int casadi::get_horizon_length

(

void *

user_data

)

Definition at line 477 of file fatrop_conic_interface.cpp.

                                                 {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    return data->solver->N_+1;
  }

Referenced by casadi::FatropConicInterface::solve().

get_initial_uk()

fatrop_int casadi::get_initial_uk	(	double *	uk,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 1012 of file fatrop_conic_interface.cpp.

                                                                             {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    auto d = &m->d;
    auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
    casadi_copy(d_qp->x0+p->CD[k].offset_c+p->nx[k], p->nu[k], uk);
    return 0;
  }

References casadi_copy(), and casadi_qp_data< T1 >::x0.

Referenced by casadi::FatropConicInterface::solve().

get_initial_xk()

fatrop_int casadi::get_initial_xk	(	double *	xk,
		const fatrop_int	k,
		void *	user_data
	)

Definition at line 1001 of file fatrop_conic_interface.cpp.

                                                                             {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto m = data->mem;
    auto d = &m->d;
    auto p = d->prob;
    casadi_qp_data<double>* d_qp = d->qp;
    casadi_copy(d_qp->x0+p->CD[k].offset_c, p->nx[k], xk);
 
    return 0;
  }

References casadi_copy(), and casadi_qp_data< T1 >::x0.

Referenced by casadi::FatropConicInterface::solve().

get_int_attribute()

casadi_int casadi::get_int_attribute	(	const onnx::NodeProto &	node,
		const std::string &	name,
		casadi_int	default_value
	)

Definition at line 40 of file onnx_utilities.cpp.

                                                         {
    for (int a = 0; a < node.attribute_size(); ++a) {
      if (node.attribute(a).name() == name) return node.attribute(a).i();
    }
    return default_value;
  }

get_inverse()

std::vector<casadi_int> casadi::get_inverse

(

const std::vector< casadi_int > &

map

)

Definition at line 785 of file integration_tools.cpp.

                                                                    {
  std::vector<casadi_int> ret(map.size(), -1);
  for (casadi_int i=0;i<ret.size();++i) {
    if (map[i]>=0) ret[map[i]] = i;
  }
  return ret;
}

Referenced by reduce_index_gen().

get_n_global_params()

fatrop_int casadi::get_n_global_params

(

void *

user_data

)

Definition at line 457 of file fatrop_conic_interface.cpp.

                                                  {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

get_n_stage_params()

fatrop_int casadi::get_n_stage_params	(	const fatrop_int	k,
		void *	user_data
	)

Definition at line 453 of file fatrop_conic_interface.cpp.

                                                                     {
    return 0;
  }

Referenced by casadi::FatropConicInterface::solve().

get_ng()

fatrop_int casadi::get_ng	(	const fatrop_int	k,
		void *	user_data
	)

Definition at line 442 of file fatrop_conic_interface.cpp.

                                                         {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto d = &data->mem->d;
    int ret;
    fatrop_int n_a_eq = d->a_eq_idx[k+1]-d->a_eq_idx[k];
    fatrop_int n_x_eq = d->x_eq_idx[k+1]-d->x_eq_idx[k];
 
    ret = n_a_eq+n_x_eq;
    return ret;
  }

Referenced by casadi::FatropConicInterface::solve().

get_ng_ineq()

fatrop_int casadi::get_ng_ineq	(	const fatrop_int	k,
		void *	user_data
	)

Definition at line 469 of file fatrop_conic_interface.cpp.

                                                              {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    auto d = &data->mem->d;
    fatrop_int n_a_ineq = d->a_ineq_idx[k+1]-d->a_ineq_idx[k];
    fatrop_int n_x_ineq = d->x_ineq_idx[k+1]-d->x_ineq_idx[k];
    return n_a_ineq+n_x_ineq;
  }

Referenced by casadi::FatropConicInterface::solve().

get_nu()

fatrop_int casadi::get_nu	(	const fatrop_int	k,
		void *	user_data
	)

Definition at line 436 of file fatrop_conic_interface.cpp.

                                                         {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    const auto& solver = *data->solver;
    return solver.nus_[k];
  }

Referenced by casadi::FatropConicInterface::solve().

get_nx()

fatrop_int casadi::get_nx	(	const fatrop_int	k,
		void *	user_data
	)

Definition at line 429 of file fatrop_conic_interface.cpp.

                                                         {
    FatropUserData* data = static_cast<FatropUserData*>(user_data);
    const auto& solver = *data->solver;
    if (k==solver.nxs_.size()) return solver.nxs_[k-1];
    return solver.nxs_[k];
  }

Referenced by casadi::FatropConicInterface::solve().

get_op_mapping()

const OpMapping * casadi::get_op_mapping

(

casadi_int

op

)

Returns nullptr if not a simple mapped operation.

Definition at line 75 of file onnx_operations.cpp.

                                                 {
    for (const auto& entry : op_map) {
      if (entry.casadi_op == op) return &entry;
    }
    return nullptr;
  }

References op_map.

get_op_mapping_by_name()

const OpMapping * casadi::get_op_mapping_by_name

(

const std::string &

onnx_name

)

Returns nullptr if not a simple mapped operation.

Definition at line 83 of file onnx_operations.cpp.

                                                                      {
    for (const auto& entry : op_map) {
      if (entry.onnx_name == onnx_name) return &entry;
    }
    return nullptr;
  }

References op_map.

get_orders()

std::vector<casadi_int> casadi::get_orders

(

const std::vector< casadi_int > &

map

)

Definition at line 777 of file integration_tools.cpp.

                                                                   {
  std::vector<casadi_int> ret(map.size(), 0);
  for (casadi_int i=0;i<ret.size();++i) {
    if (map[i]>=0) ret[map[i]] = ret[i]+1;
  }
  return ret;
}

Referenced by reduce_index_gen().

get_ptr() [1/2]

template<typename T >

const T * casadi::get_ptr

(

const std::vector< T > &

v

)

Definition at line 890 of file casadi_misc.hpp.

                                          {
    if (v.empty())
      return nullptr;
    else
      return &v.front();
  }

References T.

get_ptr() [2/2]

template<typename T >

T * casadi::get_ptr

(

std::vector< T > &

v

)

Definition at line 882 of file casadi_misc.hpp.

                              {
    if (v.empty())
      return nullptr;
    else
      return &v.front();
  }

References T.

Referenced by casadi::FunctionBuffer::_eval(), _which_depends(), casadi::Function::activity(), casadi::SparsityInternal::amd(), casadi::HpmpcInterface::blockptr(), casadi::HpipmInterface::blockptr(), casadi::FatropConicInterface::blockptr(), casadi::Function::buf_in(), casadi::Function::buf_out(), casadi::Blocksqp::calcSR1(), casadi::FunctionInternal::call_gen(), casadi::Function::call_gen(), casadi::ConstantFile::ConstantFile(), casadi::MX::depends_on(), casadi::Convexify::deserialize(), casadi::LinsolQr::det(), casadi::BSpline::dual(), casadi::Matrix< Scalar >::einstein(), einstein_eval(), casadi::Sparsity::etree(), casadi::BSpline::eval(), casadi::BSplineParametric::eval(), casadi::LinearInterpolant::eval(), casadi::LinearInterpolantJac::eval(), casadi::FmuInternal::eval(), casadi::FmuInternal::eval_ad(), casadi::FmuInternal::eval_adj(), eval_BAbt(), casadi::FmuInternal::eval_fd(), eval_Ggt(), eval_Ggt_ineq(), casadi::SXFunction::eval_mx(), eval_RSQrqt(), casadi::CallSX::eval_sx(), casadi::MXFunction::eval_sx(), casadi::Switch::eval_sx(), casadi::Blocksqp::evaluate(), fatrop_blocks_pack(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FmuInternal::finalize(), casadi::FmuFunction::FmuFunction(), casadi::FmuInternal::get_all(), casadi::Fmu2::get_aux_impl(), casadi::Fmu3::get_aux_impl(), casadi::Matrix< double >::get_input(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::Fmu2::get_real(), casadi::FmuFunction::get_stats(), hash_combine(), hash_sparsity(), hpipm_blocks_pack(), casadi::FmuFunction::init(), casadi::SXFunction::init(), casadi::MadmpecInterface::init(), casadi::External::init_external(), casadi::CsparseInterface::init_mem(), casadi::HpmpcInterface::init_mem(), casadi::OsqpInterface::init_mem(), casadi::SuperscsInterface::init_mem(), casadi::SparsityInternal::is_equal(), casadi::BSplineCommon::jac(), casadi::Blocksqp::kktErrorReduction(), casadi::Sparsity::kron(), casadi::Sparsity::ldl(), casadi::Ma27Interface::nfact(), casadi::LapackLu::nfact(), casadi::LapackQr::nfact(), casadi::MumpsInterface::nfact(), casadi::LinsolLdl::nfact(), casadi::LinsolQr::nfact(), casadi::Lsqr::nfact(), casadi::SymbolicQr::nfact(), casadi::Sparsity::norm_0_mul(), casadi::SXFunction::print_arg(), casadi::SXFunction::print_res(), casadi::QpoasesInterface::qpoases_nfact(), casadi::QpoasesInterface::qpoases_sfact(), casadi::QpoasesInterface::qpoases_solve(), qr_block_det(), casadi::Sparsity::qr_sparse(), casadi::Function::rev(), casadi::Blocksqp::secondOrderCorrection(), casadi::FmuInternal::set_all(), casadi::ClarabelInterface::set_clarabel_prob(), casadi::DaqpInterface::set_daqp_prob(), casadi::FatropConicInterface::set_fatrop_conic_prob(), casadi::FatropInterface::set_fatrop_prob(), casadi::HighsInterface::set_highs_prob(), casadi::HpipmInterface::set_hpipm_prob(), casadi::MosekInterface::set_mosek_prob(), casadi::Fmu2::set_values(), casadi::Fmu3::set_values(), casadi::FastNewton::set_work(), casadi::XpressInterface::set_xpress_prob(), casadi::Convexify::setup(), casadi::MX::simplify_const_folding(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::CplexInterface::solve(), casadi::FatropConicInterface::solve(), casadi::GurobiInterface::solve(), casadi::HpmpcInterface::solve(), casadi::OoqpInterface::solve(), casadi::PiqpInterface::solve(), casadi::ProxqpInterface::solve(), casadi::QpoasesInterface::solve(), casadi::SuperscsInterface::solve(), casadi::KnitroInterface::solve(), casadi::SnoptInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Ma27Interface::solve(), casadi::LapackLu::solve(), casadi::LinsolLdl::solve(), casadi::LinsolQr::solve(), casadi::Lsqr::solve(), casadi::SymbolicQr::solve(), casadi::LapackQr::solve_batch(), casadi::Blocksqp::solveQP(), and unpack_block().

get_search_paths()

CASADI_EXPORT std::vector< std::string > casadi::get_search_paths

(

)

Definition at line 79 of file casadi_os.cpp.

                                        {
 
    // Build up search paths;
    std::vector<std::string> search_paths;
 
    // Search path: CASADI_PLUGIN_SEARCH_PATH env variable
    // (highest priority; takes precedence over the bundled install dir
    //  that the Python wrapper writes into GlobalOptions::casadipath)
    char* pPLUGIN = getenv("CASADI_PLUGIN_SEARCH_PATH");
    if (pPLUGIN!=nullptr) {
        std::stringstream pluginpaths(pPLUGIN);
        std::string pluginpath;
        while (std::getline(pluginpaths, pluginpath, pathsep())) {
            search_paths.push_back(pluginpath);
        }
    }
 
    // Search path: global casadipath option
    std::stringstream casadipaths(GlobalOptions::getCasadiPath());
    std::string casadipath;
    while (std::getline(casadipaths, casadipath, pathsep())) {
        search_paths.push_back(casadipath);
    }
 
    // Search path: CASADIPATH env variable
    char* pLIBDIR;
    pLIBDIR = getenv("CASADIPATH");
 
    if (pLIBDIR!=nullptr) {
        std::stringstream casadipaths(pLIBDIR);
        std::string casadipath;
        while (std::getline(casadipaths, casadipath, pathsep())) {
        search_paths.push_back(casadipath);
        }
    }
 
    // Search path: bare
    search_paths.push_back("");
 
    // Search path : PLUGIN_EXTRA_SEARCH_PATH
    #ifdef PLUGIN_EXTRA_SEARCH_PATH
    search_paths.push_back(
        std::string("") + PLUGIN_EXTRA_SEARCH_PATH);
    #endif // PLUGIN_EXTRA_SEARCH_PATH
 
    // Search path : current directory
    search_paths.push_back(".");
 
    return search_paths;
}

References casadi::GlobalOptions::getCasadiPath(), and pathsep().

Referenced by casadi::ShellCompiler::init(), casadi::DllLibrary::init_handle(), and casadi::PluginInterface< Derived >::load_library().

get_string_attribute()

std::string casadi::get_string_attribute	(	const onnx::NodeProto &	node,
		const std::string &	name
	)

Definition at line 56 of file onnx_utilities.cpp.

                                                                                   {
    for (int a = 0; a < node.attribute_size(); ++a) {
      if (node.attribute(a).name() == name) return node.attribute(a).s();
    }
    return "";
  }

getcopy()

template<class A >

A casadi::getcopy	(	const A &	a,
		std::map< typename A::base_type *, typename A::internal_base_type > &	already_copied
	)

Definition at line 128 of file generic_shared_internal.hpp.

                                                             {
    A ret;
    if (!a.is_null()) {
      auto it =
          already_copied.find(const_cast<typename A::base_type*>(a.get()));
      if (it!=already_copied.end()) {
        ret.own(it->second.get());
      }
    }
    return ret;
  }

gurobi_callback_function()

static int casadi::gurobi_callback_function ( GRBmodel *  model, void *  cbdata, int  where, void *  usrdata  )

static

Definition at line 92 of file gurobi_interface.cpp.

                                                                                               {
    try {
      if (where == GRB_CB_MIPSOL && usrdata) {
        GurobiMemory* mem = static_cast<GurobiMemory*>(usrdata);
        mem->interface->handle_lazy_constraints_callback(mem, model, cbdata, where);
      }
    } catch (const std::exception& e) {
      // Don't let exceptions escape to C code
      casadi_warning("Exception in Gurobi callback: " + std::string(e.what()));
    }
    return 0; // Continue optimization
  }

References casadi::GurobiInterface::handle_lazy_constraints_callback(), and casadi::GurobiMemory::interface.

Referenced by casadi::GurobiInterface::solve().

handle_pedantic()

static void casadi::handle_pedantic ( const std::string &  mode, const std::string &  opt_name, const std::string &  msg  )

static

Definition at line 38 of file blazing_spline.cpp.

                                                    {
    if (mode == "ignore") return;
    std::string full = msg + "\n(Controlled by option '" + opt_name +
      "'; set to 'ignore' to silence, 'warn' to demote, 'error' to escalate.)";
    if (mode == "warn") {
      casadi_warning(full);
    } else if (mode == "error") {
      casadi_error(full);
    } else {
      casadi_error("Option '" + opt_name + "' must be one of "
                   "'ignore', 'warn', 'error'; got '" + mode + "'.");
    }
  }

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

has_archiver()

CASADI_EXPORT bool casadi::has_archiver

(

const std::string &

name

)

Definition at line 38 of file archiver.cpp.

                                           {
    return Archiver::has_plugin(name);
  }

References casadi::PluginInterface< Archiver >::has_plugin().

has_blas()

CASADI_EXPORT bool casadi::has_blas

(

const std::string &

name

)

Definition at line 250 of file blas.cpp.

                                     {
  if (name == "reference") return true;
  return Blas::has_plugin(name);
}

References casadi::PluginInterface< Blas >::has_plugin().

has_empty()

bool casadi::has_empty	(	const std::vector< MX > &	x,
		bool	both = false
	)

Definition at line 1104 of file mx.cpp.

                                                          {
    for (auto&& i : x) {
      if (i.is_empty(both)) return true;
    }
    return false;
  }

Referenced by casadi::MX::diagcat(), casadi::MX::horzcat(), and casadi::MX::vertcat().

has_enum()

template<typename T >

bool casadi::has_enum

(

const std::string &

s

)

Definition at line 47 of file casadi_enum.hpp.

                                  {
  // Look for a match
  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i) {
    if (s == to_string(static_cast<T>(i))) return true;
  }
  // Not found
  return false;
}

References T, and to_string().

has_filesystem()

CASADI_EXPORT bool casadi::has_filesystem

(

const std::string &

name

)

Definition at line 92 of file filesystem.cpp.

                                           {
  return Filesystem::has_plugin(name);
}

References casadi::PluginInterface< Filesystem >::has_plugin().

has_graphmodel()

CASADI_EXPORT bool casadi::has_graphmodel

(

const std::string &

name

)

Definition at line 77 of file graph_model.cpp.

{ return GraphModel::has_plugin(name); }

References casadi::GraphModel::has_plugin().

has_linsol()

CASADI_EXPORT bool casadi::has_linsol

(

const std::string &

name

)

Definition at line 229 of file linsol.cpp.

                                         {
    return Linsol::has_plugin(name);
  }

References casadi::Linsol::has_plugin().

has_modelicaparser()

CASADI_EXPORT bool casadi::has_modelicaparser

(

const std::string &

name

)

Definition at line 60 of file modelica_parser.cpp.

                                               {
  return ModelicaParserInternal::has_plugin(name);
}

References casadi::PluginInterface< ModelicaParserInternal >::has_plugin().

has_negative()

template<typename T >

bool casadi::has_negative

(

const std::vector< T > &

v

)

Definition at line 801 of file casadi_misc.hpp.

                                           {
    for (std::size_t i=0; i<v.size(); ++i) {
      if (v[i]<0) return true;
    }
    return false;
  }

Referenced by casadi::SparsityInternal::_enlargeColumns(), casadi::SparsityInternal::_enlargeRows(), casadi::SparsityInternal::_erase(), casadi::GetNonzerosVector::generate(), casadi::SetNonzerosVector< Add >::generate(), lookupvector(), and casadi::SparsityInternal::sub().

has_parent_path()

bool casadi::has_parent_path

(

const std::string &

path

)

Definition at line 67 of file ghc.cpp.

                                                {
        return ghc::filesystem::path(path).has_parent_path();
    }

References path().

Referenced by casadi_register_filesystem_ghc().

has_prefix()

CASADI_EXPORT bool casadi::has_prefix

(

const std::string &

s

)

Definition at line 1492 of file fmu_function.cpp.

                                    {
  return s.find('_') < s.size();
}

Referenced by casadi::Factory< MatType >::get_output(), casadi::InputStruct::parse(), casadi::OutputStruct::parse(), casadi::Factory< MatType >::request_input(), and casadi::Factory< MatType >::request_output().

hash_combine() [1/3]

template<typename T >

void casadi::hash_combine ( std::size_t &  seed, const std::vector< T > &  v  )

inline

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

Definition at line 1056 of file casadi_misc.hpp.

                                                                   {
    hash_combine(seed, get_ptr(v), v.size());
  }

References get_ptr(), and hash_combine().

hash_combine() [2/3]

template<typename T >

void casadi::hash_combine ( std::size_t &  seed, const T *  v, std::size_t  sz  )

inline

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

Definition at line 1048 of file casadi_misc.hpp.

                                                                      {
    for (casadi_int i=0; i<sz; ++i) hash_combine(seed, v[i]);
  }

References hash_combine().

hash_combine() [3/3]

template<typename T >

void casadi::hash_combine ( std::size_t &  seed, T  v  )

inline

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

Definition at line 1040 of file casadi_misc.hpp.

                                                 {
    seed ^= hash_value(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
  }

References hash_value().

Referenced by get_const(), casadi::CodeGenerator::hash(), hash_combine(), hash_sparsity(), and hash_value().

hash_sparsity() [1/2]

CASADI_EXPORT std::size_t casadi::hash_sparsity	(	casadi_int	nrow,
		casadi_int	ncol,
		const casadi_int *	colind,
		const casadi_int *	row
	)

Definition at line 1017 of file sparsity.cpp.

                                                       {
    // Condense the sparsity pattern to a single, deterministric number
    std::size_t ret=0;
    hash_combine(ret, nrow);
    hash_combine(ret, ncol);
    hash_combine(ret, colind, ncol+1);
    hash_combine(ret, row, colind[ncol]);
    return ret;
  }

References hash_combine().

hash_sparsity() [2/2]

CASADI_EXPORT std::size_t casadi::hash_sparsity	(	casadi_int	nrow,
		casadi_int	ncol,
		const std::vector< casadi_int > &	colind,
		const std::vector< casadi_int > &	row
	)

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

Definition at line 1012 of file sparsity.cpp.

                                                              {
    return hash_sparsity(nrow, ncol, get_ptr(colind), get_ptr(row));
  }

References get_ptr().

Referenced by casadi::SparsityInternal::hash().

hash_value() [1/3]

template<>

size_t casadi::hash_value ( double  v )

inline

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

Definition at line 1071 of file casadi_misc.hpp.

                                     {
    std::uint64_t u;
    std::memcpy(&u, &v, sizeof(double));
 
    if (sizeof(size_t) == 8) {
      // 64-bit: keep all bits
      return static_cast<size_t>(u);
    } else {
      // 32-bit: fold with hash_combine
      size_t seed = 0;
      hash_combine(seed, static_cast<std::uint32_t>(u));
      hash_combine(seed, static_cast<std::uint32_t>(u >> 32));
      return seed;
    }
  }

References hash_combine().

hash_value() [2/3]

template<>

size_t casadi::hash_value ( std::string  v )

inline

Definition at line 1061 of file casadi_misc.hpp.

                                        {
    size_t seed = 0;
    hash_combine(seed, v.c_str(), v.size());
    return seed;
  }

References hash_combine().

hash_value() [3/3]

template<typename T >

size_t casadi::hash_value ( T  v )

inline

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

Definition at line 1034 of file casadi_misc.hpp.

{ return size_t(v);}

Referenced by hash_combine().

hpipm_blocks_pack()

std::vector<casadi_int> casadi::hpipm_blocks_pack

(

const std::vector< casadi_hpipm_block > &

blocks

)

Definition at line 476 of file hpipm_interface.cpp.

                                                                                       {
    size_t N = blocks.size();
    std::vector<casadi_int> ret(4*N);
    casadi_int* r = get_ptr(ret);
    for (casadi_int i=0;i<N;++i) {
      *r++ = blocks[i].offset_r;
      *r++ = blocks[i].offset_c;
      *r++ = blocks[i].rows;
      *r++ = blocks[i].cols;
    }
    return ret;
  }

References get_ptr().

Referenced by codegen_unpack_block().

if_else()

double casadi::if_else ( double  x, double  y, double  z  )

inline

CasADi additions

Definition at line 296 of file calculus.hpp.

{ return x==0 ? z : y;}

Referenced by casadi::Call::ad_reverse(), casadi::Switch::codegen_body(), casadi::Switch::eval_sx(), casadi::Nlpsol::get_forward(), casadi::Nlpsol::get_reverse(), and casadi::DaeBuilderInternal::read_expr().

if_else_zero()

double casadi::if_else_zero ( double  x, double  y  )

inline

Definition at line 295 of file calculus.hpp.

{ return x==0 ? 0 : y;}

Referenced by casadi::BinaryMX< ScX, ScY >::ad_forward(), casadi::SXFunction::ad_forward(), casadi::BinaryMX< ScX, ScY >::ad_reverse(), casadi::SXFunction::ad_reverse(), compute_knots_cache(), casadi::BinaryOperation< OP_IF_ELSE_ZERO >::fcn(), casadi::MXNode::get_binary(), and get_boor().

ifstream_compat()

CASADI_EXPORT std::unique_ptr< std::istream > casadi::ifstream_compat	(	const std::string &	utf8_path,
		std::ios::openmode	mode
	)

Definition at line 497 of file casadi_os.cpp.

                                                         {
#ifdef _WIN32
    std::wstring utf16_path = utf8_to_utf16(utf8_path);
    DWORD access = 0;
    access |= GENERIC_READ;
    if (mode & std::ios::out) access |= GENERIC_WRITE;
 
    HANDLE h = CreateFileW(utf16_path.c_str(), access,
                             FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
                           OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
    if (h == INVALID_HANDLE_VALUE) return {};
 
    int flags = (mode & std::ios::out) ? _O_RDWR : _O_RDONLY;
    if (mode & std::ios::binary) flags |= _O_BINARY;
 
    int fd = _open_osfhandle(reinterpret_cast<intptr_t>(h), flags);
    if (fd == -1) {
        CloseHandle(h);
        return {};
    }
    auto owned = std::make_shared<OwnedIStream>(fd);
    return std::unique_ptr<StreamWithOwnedBuffer>(new StreamWithOwnedBuffer(std::move(owned)));
#else
    auto ifs = std::unique_ptr<std::ifstream>(new std::ifstream(utf8_path, mode));
    if (!*ifs) return {};
    return std::unique_ptr<std::istream>(std::move(ifs));
#endif
}

Referenced by casadi::Filesystem::exists(), and casadi::Filesystem::ifstream_ptr().

in_range() [1/2]

template<typename T >

bool casadi::in_range	(	const std::vector< T > &	v,
		casadi_int	lower,
		casadi_int	upper
	)

Definition at line 697 of file casadi_misc.hpp.

                                                                           {
    if (v.empty()) return true;
    casadi_int max = *std::max_element(v.begin(), v.end());
    if (max >= upper) return false;
    casadi_int min = *std::min_element(v.begin(), v.end());
    return (min >= lower);
  }

in_range() [2/2]

template<typename T >

bool casadi::in_range	(	const std::vector< T > &	v,
		casadi_int	upper
	)

Definition at line 692 of file casadi_misc.hpp.

                                                         {
    return in_range(v, 0, upper);
  }

Referenced by check_sos(), complement(), lookupvector(), and casadi::Function::mapaccum().

index_interp1d()

double CASADI_EXPORT casadi::index_interp1d	(	const std::vector< double > &	x,
		double	xq,
		bool	equidistant
	)

Definition at line 30 of file generic_matrix.cpp.

                                                                                 {
 
    if (equidistant) {
      double delta = x[1]-x[0];
      double i = (xq-x[0])/delta;
      double imax = static_cast<double>(x.size()-1);
      return std::max(std::min(i, imax), 0.0);
 
    } else {
      std::vector<double>::const_iterator it = std::lower_bound(x.begin(), x.end(), xq);
 
      // End of x
      if (it==x.end()) return static_cast<double>(x.size()-1);
 
      // Start of x
      if (it==x.begin()) return 0.0;
 
      casadi_int i = std::distance(x.begin(), it);
 
      // Exactly on an entry
      if (*it == xq) return static_cast<double>(i);
 
      double b = *it;
      double a = *(it-1);
 
      return static_cast<double>(i)+(xq-b)/(b-a);
    }
  }

Referenced by casadi::GenericMatrix< MatType >::interp1d().

init_gen()

template<class X >

Function casadi::init_gen	(	const std::map< std::string, X > &	dae,
		const std::map< std::string, X > &	dae_red,
		const std::string &	init_solver,
		const DMDict &	init_strength,
		const Dict &	init_solver_options
	)

Definition at line 1112 of file integration_tools.cpp.

                                                                                              {
 
  X x_impl  = get_from_dict(dae, "x_impl",  X(0, 1));
  X dx_impl = get_from_dict(dae, "dx_impl", X(0, 1));
  X z       = get_from_dict(dae, "z", X(0, 1));
  X p_orig       = get_from_dict(dae, "p", X(0, 1));
 
  Sparsity var_map_sp = jacobian(
    vertcat(dae_red.at("x"), dae_red.at("x_impl"), dae_red.at("dx_impl"), dae_red.at("z")),
    vertcat(x_impl, dx_impl, z)).sparsity();
  DM var_map(var_map_sp, 1.0);
 
  // NLP to obtain consistent initial guesses
  std::map<std::string, X> nlp;
 
  MX pmx = MX::sym("pmx", p_orig.sparsity());
  MX tmx = MX::sym("t");
 
  X init_x_impl_orig  = X::sym("x_impl_init",  x_impl.sparsity());
  X init_dx_impl_orig = X::sym("dx_impl_init", dx_impl.sparsity());
  X init_z_orig       = X::sym("z_init",       z.sparsity());
 
  MX init_x_impl_orig_mx  = MX::sym("x_impl_init",  x_impl.sparsity());
  MX init_dx_impl_orig_mx = MX::sym("dx_impl_init", dx_impl.sparsity());
  MX init_z_orig_mx       = MX::sym("z_init",       z.sparsity());
 
  X init_orig = vertcat(init_x_impl_orig, init_dx_impl_orig, init_z_orig);
  MX init_orig_mx = vertcat(init_x_impl_orig_mx, init_dx_impl_orig_mx, init_z_orig_mx);
 
  X init_sym_red = mtimes(X(var_map), init_orig);
  nlp["p"] = vertcat(init_orig, dae_red.at("p"), dae_red.at("t"));
  MX p = vertcat(init_orig_mx, pmx, tmx);
 
  // Dae input sanitization
 
  for (const auto& e : init_strength) {
    casadi_assert(e.second.is_column() && e.second.is_dense(),
      "Dense column vector expected for key '" + e.first + "' of init_strength. "
      "Got " + e.second.dim(true) + " instead.");
  }
 
  DM init_strength_x_impl = get_from_dict(init_strength, "x_impl", DM::zeros(x_impl.numel(), 1));
  casadi_assert(x_impl.numel()==init_strength_x_impl.numel(),
    "init_strength 'x_impl' entry should have length " + str(x_impl.numel()) + ". "
    "Got length " + str(init_strength_x_impl.numel()) + " instead.");
 
  DM init_strength_dx_impl = get_from_dict(init_strength, "dx_impl",
    DM::zeros(dx_impl.numel(), 1));
  casadi_assert(dx_impl.numel()==init_strength_dx_impl.numel(),
    "init_strength 'dx_impl' entry should have length " + str(dx_impl.numel()) + ". "
    "Got length " + str(init_strength_dx_impl.numel()) + " instead.");
 
  DM init_strength_z = get_from_dict(init_strength, "z", DM::zeros(z.numel(), 1));
  casadi_assert(z.numel()==init_strength_z.numel(),
    "init_strength 'z' entry should have length " + str(z.numel()) + ". "
    "Got length " + str(init_strength_z.numel()) + " instead.");
 
  DM init_strength_cat = vertcat(init_strength_x_impl, init_strength_dx_impl, init_strength_z);
 
  DM weights = mtimes(var_map, init_strength_cat);
  // Should be written more cleanly
  std::vector<casadi_int> ind = sparsify(weights>0).sparsity().T().get_col();
 
  std::vector<X> x_parts = {dae_red.at("x"), dae_red.at("x_impl"),
                      dae_red.at("dx_impl"), dae_red.at("z")};
 
  nlp["x"] = vertcat(x_parts);
  nlp["g"] = vertcat(dae_red.at("I"), dae_red.at("alg"));
  nlp["f"] = sumsqr((nlp["x"](ind)-init_sym_red(ind))*X(weights(ind)));
 
 
  MX x0 = mtimes(var_map, init_orig_mx);
  MX lbx = -MX::inf(nlp.at("x").numel());
  MX ubx = MX::inf(lbx.size());
 
  // Should be written more cleanly
  ind = sparsify(mtimes(var_map, init_strength_cat)==-1).sparsity().T().get_col();
  lbx(ind) = ubx(ind) = x0(ind);
 
  Function solver = nlpsol("init_solver", init_solver, nlp, init_solver_options);
  MXDict res = solver(MXDict{{"x0", x0}, {"lbg", 0}, {"ubg", 0},
    {"lbx", lbx}, {"ubx", ubx}, {"p", p}});
 
  std::vector<casadi_int> x_parts_offsets = {0};
  for (casadi_int i=0;i<x_parts.size();i+=2) {
    x_parts_offsets.push_back(x_parts_offsets.back() + x_parts[i].numel() + x_parts[i+1].numel());
  }
 
  std::vector<MX> parts = vertsplit(res["x"], x_parts_offsets);
 
  return Function("init_gen",
    {init_x_impl_orig_mx, init_dx_impl_orig_mx, init_z_orig_mx, pmx, tmx},
    parts,
    {"x_impl", "dx_impl", "z", "p", "t"},
    {"x0", "z0"});
}

References get_from_dict(), casadi::MX::inf(), nlpsol(), casadi::GenericMatrix< MatType >::numel(), casadi::GenericMatrix< MatType >::size(), str(), casadi::GenericMatrix< MX >::sym(), X, and casadi::GenericMatrix< MatType >::zeros().

Referenced by dae_init_gen().

init_vector()

template<class S , class D >

void casadi::init_vector	(	std::vector< S > &	d,
		const std::vector< D > &	s
	)

Definition at line 685 of file casadi_misc.hpp.

                                                           {
    d.resize(s.size());
    std::copy(s.begin(), s.end(), d.begin());
  }

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

input_categories()

CASADI_EXPORT std::vector< Category > casadi::input_categories

(

)

Definition at line 292 of file dae_builder_internal.cpp.

                                       {
  std::vector<Category> ret;
  for (casadi_int i = 0; i != enum_traits<Category>::n_enum; ++i) {
    auto cat = static_cast<Category>(i);
    if (is_input_category(cat)) ret.push_back(cat);
  }
  return ret;
}

References is_input_category().

Referenced by casadi::DaeBuilderInternal::oracle(), and casadi::DaeBuilderInternal::prune().

input_category()

CASADI_EXPORT Category casadi::input_category

(

Category

cat

)

Definition at line 2225 of file dae_builder_internal.cpp.

                                      {
  switch (cat) {
    case Category::ODE: return Category::X;
    case Category::QUAD: return Category::Q;
    case Category::DDEF: return Category::D;
    case Category::WDEF: return Category::W;
    default: break;
  }
  casadi_error("No input category for " + to_string(cat));
}

References D, DDEF, ODE, Q, QUAD, to_string(), W, WDEF, and X.

Referenced by casadi::DaeBuilderInternal::outputs().

insert_casadi_options()

static void casadi::insert_casadi_options ( void *  solver, Dict  opts  )

static

Definition at line 172 of file uno_interface.cpp.

                                                             {
    Dict casadi_options = Options::sanitize(opts);
    // Apply the preset first: it overwrites some options (e.g. it would reset
    // the Hessian model to exact, clobbering an explicit hessian_model=LBFGS).
    for (auto&& op : casadi_options) {
      if (op.first == "preset") {
        uno_set_solver_preset(solver, op.second.to_string().c_str());
        break;
      }
    }
    for (auto&& op : casadi_options) {
      if (op.first != "preset") set_uno_option(solver, op.first, op.second);
    }
  }

References casadi::Options::sanitize(), and set_uno_option().

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

interpn_G()

MX casadi::interpn_G	(	casadi_int	i,
		const MX &	v,
		const std::vector< MX > &	xis,
		const std::vector< MX > &	L,
		const std::vector< MX > &	Lp,
		const std::vector< casadi_int > &	strides,
		const Slice &	I,
		const MX &	offset = 0
	)

Definition at line 3115 of file mx.cpp.

                  {
    if (i==0) {
      MX ret;
      v.get_nz(ret, false, offset, I);
      return ret;
    } else {
      casadi_int j = xis.size()-i;
      MX offsetL, offsetR;
      if (strides[j]==1) {
        offsetL = offset+L[j];
        offsetR = offset+Lp[j];
      } else {
        offsetL = offset+L[j]*strides[j];
        offsetR = offsetL+strides[j];
      }
      MX vl = interpn_G(i-1, v, xis, L, Lp, strides, I, offsetL);
      MX vu = interpn_G(i-1, v, xis, L, Lp, strides, I, offsetR);
 
      // Perform interpolation between vl and vu
      return vl + xis[j]*(vu-vl);
    }
  }

References casadi::MX::get_nz(), and casadi::GenericMatrix< MatType >::size().

Referenced by casadi::MX::interpn_linear().

invert_lookup()

std::vector<casadi_int> casadi::invert_lookup

(

const std::vector< casadi_int > &

lookup

)

Definition at line 398 of file integration_tools.cpp.

                                                                         {
  std::vector<casadi_int> ret(lookup.size(), -1);
  for (casadi_int i=0;i<lookup.size();++i) {
    casadi_int e = lookup[i];
    if (e>=0) {
      ret[e] = i;
    }
  }
  return ret;
}

invert_permutation()

std::vector< casadi_int > casadi::invert_permutation

(

const std::vector< casadi_int > &

a

)

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

Definition at line 182 of file casadi_misc.cpp.

                                                                           {
    casadi_assert(is_permutation(a), "Not a permutation");
    std::vector<casadi_int> ret(a.size());
    for (casadi_int i=0;i<a.size();++i) {
      ret[a[i]] = i;
    }
    return ret;
  }

References is_permutation().

Referenced by casadi::Sparsity::permutation(), casadi::Sparsity::permutation_vector(), casadi::SparsityInternal::pmult(), and casadi::Sparsity::pmult().

io_node()

static Node casadi::io_node ( const onnx::ValueInfoProto &  vi, const std::string &  io  )

static

Definition at line 87 of file onnx_model.cpp.

                                                                         {
    Node n;
    n.name = vi.name();
    n.io = io;
    const onnx::TypeProto::Tensor& tt = vi.type().tensor_type();
    n.dtype = onnx_dtype_name(tt.elem_type());
    const onnx::TensorShapeProto& sh = tt.shape();
    for (int k = 0; k < sh.dim_size(); ++k) {
      const auto& d = sh.dim(k);
      if (d.has_dim_value()) {
        n.dimension.push_back(static_cast<casadi_int>(d.dim_value()));
        n.dim_params.push_back("");
      } else {  // symbolic or unspecified -> dynamic
        n.dimension.push_back(-1);
        n.dim_params.push_back(d.has_dim_param() ? d.dim_param() : "");
      }
    }
    return n;
  }

References casadi::Node::dim_params, casadi::Node::dimension, casadi::Node::dtype, casadi::Node::io, casadi::Node::name, and onnx_dtype_name().

Referenced by casadi::Onnx::fill_metadata().

is_acyclic()

CASADI_EXPORT bool casadi::is_acyclic

(

Category

cat

)

Definition at line 268 of file dae_builder_internal.cpp.

                              {
  switch (cat) {
    case Category::C:  // Fall-through
    case Category::D:  // Fall-through
    case Category::W:
      // Acyclic category
      return true;
    default:
      return false;
  }
}

References C, D, and W.

Referenced by casadi::DaeBuilderInternal::categorize(), casadi::DaeBuilderInternal::eliminate(), and casadi::DaeBuilderInternal::sort().

is_decreasing()

template<typename T >

bool casadi::is_decreasing

(

const std::vector< T > &

v

)

Definition at line 758 of file casadi_misc.hpp.

                                            {
    if (v.empty()) return true;
    T el = v[0];
    for (casadi_int i=1;i<v.size();++i) {
      if (!(v[i] < el)) return false;
      el = v[i];
    }
    return el==el; // nan -> false
  }

References T.

Referenced by is_strictly_monotone().

is_directory()

bool casadi::is_directory

(

const std::string &

path

)

Definition at line 31 of file ghc.cpp.

                                             {
      return ghc::filesystem::is_directory(path);
    }

References path().

Referenced by casadi_register_filesystem_ghc().

is_equal()

bool casadi::is_equal ( double  x, double  y, casadi_int  depth = 0  )

inline

CasADi additions

Definition at line 287 of file calculus.hpp.

{ return x==y;}

Referenced by common_simp_binary(), casadi::DaeBuilderInternal::find(), casadi::XFunction< DerivedType, MatType, NodeType >::isInput(), casadi::Sparsity::operator!=(), casadi::Sparsity::operator==(), and casadi::MXFunction::symbolic_output().

is_equally_spaced()

CASADI_EXPORT bool casadi::is_equally_spaced

(

const std::vector< double > &

v

)

Definition at line 122 of file casadi_misc.cpp.

                                                     {
    // Quick return if 2 or less entries
    if (v.size()<=2) return true;
    // Permitted error margin
    // NOTE(@jaeandersson) 1e-14 good idea?
    double margin = (v.back()-v.front())*1e-14;
    // Make sure spacing is consistent throughout
    double spacing = v[1]-v[0];
    for (size_t i=2; i<v.size(); ++i) {
      if (fabs(v[i]-v[i-1]-spacing)>margin) return false;
    }
    // Equal if reached this point
    return true;
  }

Referenced by casadi::Interpolant::interpret_lookup_mode().

is_increasing()

template<typename T >

bool casadi::is_increasing

(

const std::vector< T > &

v

)

Definition at line 747 of file casadi_misc.hpp.

                                            {
    if (v.empty()) return true;
    T el = v[0];
    for (casadi_int i=1;i<v.size();++i) {
      if (!(v[i] > el)) return false;
      el = v[i];
    }
    return el==el; // nan -> false
  }

References T.

Referenced by casadi::Interpolant::check_grid(), casadi::GenericMatrix< MatType >::interp1d(), casadi::Interpolant::interpret_lookup_mode(), and is_strictly_monotone().

is_input_category()

CASADI_EXPORT bool casadi::is_input_category

(

Category

cat

)

Definition at line 234 of file dae_builder_internal.cpp.

                                     {
  switch (cat) {
    case Category::T:  // Fall-through
    case Category::P:  // Fall-through
    case Category::U:  // Fall-through
    case Category::X:  // Fall-through
    case Category::Z:  // Fall-through
    case Category::Q:  // Fall-through
    case Category::C:  // Fall-through
    case Category::D:  // Fall-through
    case Category::W:
      // Input category
      return true;
    default: break;
  }
  return false;
}

References C, D, P, Q, T, U, W, X, and Z.

Referenced by input_categories(), casadi::DaeBuilderInternal::inputs(), and casadi::DaeBuilder::set_all().

is_monotone()

template<typename T >

bool casadi::is_monotone

(

const std::vector< T > &

v

)

Definition at line 791 of file casadi_misc.hpp.

                                          {
    return is_nondecreasing(v) || is_nonincreasing(v);
  }

References is_nondecreasing(), and is_nonincreasing().

Referenced by casadi::MX::diagsplit(), casadi::Sparsity::diagsplit(), casadi::MX::horzsplit(), casadi::Sparsity::horzsplit(), and casadi::MX::vertsplit().

is_nondecreasing()

template<typename T >

bool casadi::is_nondecreasing

(

const std::vector< T > &

v

)

Definition at line 780 of file casadi_misc.hpp.

                                               {
    if (v.empty()) return true;
    T el = v[0];
    for (casadi_int i=1;i<v.size();++i) {
      if (!(v[i] >= el)) return false;
      el = v[i];
    }
    return el==el; // nan -> false
  }

References T.

Referenced by casadi::SparsityInternal::_erase(), casadi::BlazingSplineFunction::init(), and is_monotone().

is_nonincreasing()

template<typename T >

bool casadi::is_nonincreasing

(

const std::vector< T > &

v

)

Definition at line 769 of file casadi_misc.hpp.

                                               {
    if (v.empty()) return true;
    T el = v[0];
    for (casadi_int i=1;i<v.size();++i) {
      if (!(v[i] <= el)) return false;
      el = v[i];
    }
    return el==el; // nan -> false
  }

References T.

Referenced by is_monotone().

is_output_category()

CASADI_EXPORT bool casadi::is_output_category

(

Category

cat

)

Definition at line 252 of file dae_builder_internal.cpp.

                                      {
  switch (cat) {
    case Category::ODE:  // Fall-through
    case Category::ALG:  // Fall-through
    case Category::QUAD:  // Fall-through
    case Category::ZERO:  // Fall-through
    case Category::DDEF:  // Fall-through
    case Category::WDEF:  // Fall-through
    case Category::Y:
      // Output category
      return true;
    default: break;
  }
  return false;
}

References ALG, DDEF, ODE, QUAD, WDEF, Y, and ZERO.

Referenced by output_categories(), and casadi::DaeBuilder::set_all().

is_permutation()

bool casadi::is_permutation

(

const std::vector< casadi_int > &

order

)

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

Definition at line 175 of file casadi_misc.cpp.

                                                          {
    std::set<casadi_int> order_set(order.begin(), order.end());
    return (order_set.size()==order.size()) &&
           (*order_set.begin()==0) &&
           (*order_set.rbegin()==order.size()-1);
  }

Referenced by invert_permutation(), casadi::Sparsity::permutation(), and permute().

is_pow2_ge8()

static bool casadi::is_pow2_ge8 ( casadi_int  n )

static

Definition at line 54 of file blazing_spline.cpp.

                                        {
    return n >= 8 && (n & (n - 1)) == 0;
  }

Referenced by casadi::BlazingSplineFunction::init(), and scan_prefix_pow2().

is_range()

CASADI_EXPORT bool casadi::is_range	(	const std::vector< casadi_int > &	v,
		casadi_int	start,
		casadi_int	stop,
		casadi_int	step = 1
	)

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

Definition at line 95 of file casadi_misc.cpp.

                                                        {
    casadi_int nret = (stop-start)/step + ((stop-start)%step!=0);
    if (v.size()!=nret) return false;
    casadi_int ind = start;
    for (casadi_int e : v) {
      if (e!=ind) return false;
      ind += step;
    }
    return true;
  }

Referenced by casadi::MXNode::get_nzref().

is_regular() [1/2]

template<typename T >

bool casadi::is_regular

(

const std::vector< T > &

v

)

Definition at line 428 of file casadi_misc.hpp.

                                         {
    for (auto&& vk : v) {
      if (vk!=vk || vk==std::numeric_limits<T>::infinity() ||
          vk==-std::numeric_limits<T>::infinity()) return false;
    }
    return true;
  }

Referenced by casadi::Interpolant::check_grid(), is_regular(), and casadi::OptiNode::solve_prepare().

is_regular() [2/2]

bool casadi::is_regular ( N_Vector  v )

inline

Definition at line 239 of file sundials_interface.hpp.

                                     {
    std::vector<double> tmp(NV_DATA_S(v), NV_DATA_S(v)+NV_LENGTH_S(v));
    return is_regular(tmp);
  }

References is_regular().

is_slice() [1/2]

bool CASADI_EXPORT casadi::is_slice	(	const IM &	x,
		bool	ind1 = false
	)

Definition at line 30 of file im_instantiator.cpp.

                                                      {
    return x.is_scalar() || (x.is_column() && x.is_dense() && is_slice(x.nonzeros(), ind1));
  }

References casadi::GenericMatrix< MatType >::is_column(), casadi::GenericMatrix< MatType >::is_dense(), casadi::GenericMatrix< MatType >::is_scalar(), and casadi::Matrix< Scalar >::nonzeros().

Referenced by casadi::SetNonzeros< Add >::create(), casadi::GetNonzeros::create(), is_slice2(), to_slice(), and to_slice2().

is_slice() [2/2]

bool CASADI_EXPORT casadi::is_slice	(	const std::vector< casadi_int > &	v,
		bool	ind1
	)

Definition at line 170 of file slice.cpp.

                                                                         {
    // Always false if negative numbers or non-increasing
    casadi_int last_v = -1;
    for (casadi_int i=0; i<v.size(); ++i) {
      casadi_assert(!(ind1 && v[i]<=0),
        "Matlab is 1-based, but requested index " + str(v[i]) + ". "
        "Note that negative slices are disabled in the Matlab interface. "
        "Possibly you may want to use 'end'.");
      if (v[i]-ind1<=last_v) return false;
      last_v = v[i]-ind1;
    }
 
    // Always true if less than 2 elements
    if (v.size()<2) return true;
 
    // If two elements, true if they are different
    if (v.size()==2) return v[0]!=v[1];
 
    // We can now get the beginning, end and step
    casadi_int start = v[0]-ind1;
    casadi_int step = v[1]-v[0];
    //casadi_int stop = start + step*v.size();
 
    // Consistency check
    for (casadi_int i=2; i<v.size(); ++i) {
      if (v[i]-ind1!=start+i*step) return false;
    }
 
    // True if reached this point
    return true;
  }

References str().

is_slice2()

bool CASADI_EXPORT casadi::is_slice2

(

const std::vector< casadi_int > &

v

)

Definition at line 202 of file slice.cpp.

                                                               {
    // Always true if 1D slice
    if (is_slice(v)) return true;
 
    // Always false if negative numbers or non-increasing
    casadi_int last_v = -1;
    for (casadi_int i=0; i<v.size(); ++i) {
      if (v[i]<=last_v) return false;
      last_v = v[i];
    }
 
    // Get the slices
    casadi_int start_outer = 0;
    casadi_int step_outer = -1;
    casadi_int start_inner = v.front();
    casadi_int step_inner = v[1]-v[0];
    casadi_int stop_inner = -1;
    for (casadi_int i=2; i<v.size(); ++i) {
      casadi_int predicted_v = start_inner+i*step_inner;
      if (v[i]!=predicted_v) {
        stop_inner = predicted_v;
        step_outer = v[i] - start_inner;
        break;
      }
    }
    casadi_assert_dev(stop_inner>=0);
 
    // Get the end of the outer slice
    // Calculate based on actual number of groups in the data
    casadi_int inner_size = (stop_inner - start_inner) / step_inner;
    casadi_int num_groups = v.size() / inner_size;
    casadi_int stop_outer = start_outer + num_groups * step_outer;
 
    // Check consistency
    std::vector<casadi_int>::const_iterator it=v.begin();
    for (casadi_int i=start_outer; i!=stop_outer; i+=step_outer) {
      for (casadi_int j=i+start_inner; j!=i+stop_inner; j+=step_inner) {
        // False if we've reached the end
        if (it==v.end()) return false;
 
        // Check if value matches
        if (*it++ != j) return false;
      }
    }
 
    // False if there are still elements not accounted for
    if (it!=v.end()) return false; // NOLINT
 
    // True if reached this point
    return true;
  }

References is_slice().

Referenced by casadi::SetNonzeros< Add >::create(), casadi::GetNonzeros::create(), and to_slice2().

is_strictly_monotone()

template<typename T >

bool casadi::is_strictly_monotone

(

const std::vector< T > &

v

)

Definition at line 796 of file casadi_misc.hpp.

                                                   {
    return is_decreasing(v) || is_increasing(v);
  }

References is_decreasing(), and is_increasing().

is_zero()

template<class T >

bool casadi::is_zero ( const T &  x )

inline

Definition at line 96 of file casadi_limits.hpp.

                                  {
    return casadi_limits<T>::is_zero(x);
  }

References casadi::casadi_limits< T >::is_zero().

Referenced by casadi::MXFunction::ad_forward(), casadi::MXFunction::ad_reverse(), casadi::Solve< Tr >::eval_mx(), casadi::Constant< Value >::get_project(), casadi::Constant< Value >::get_unary(), and casadi::Constant< Value >::is_value().

isUnique()

template<typename T >

bool casadi::isUnique

(

const std::vector< T > &

v

)

Definition at line 741 of file casadi_misc.hpp.

                                       {
    std::set<T> s(v.begin(), v.end());
    return v.size()==s.size();
  }

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

iterate_directory_names()

std::vector<std::string> casadi::iterate_directory_names

(

const std::string &

path

)

Definition at line 39 of file ghc.cpp.

                                                                        {
        std::vector<std::string> ret;
        for (const auto& entry : ghc::filesystem::directory_iterator(path)) {
            ret.push_back(entry.path().string());
        }
        return ret;
    }

References path().

Referenced by casadi_register_filesystem_ghc().

join() [1/3]

CASADI_EXPORT std::string casadi::join	(	const std::vector< std::string > &	l,
		const std::string &	delim
	)

Definition at line 208 of file casadi_misc.cpp.

                                                                        {
    std::stringstream ss;
    for (casadi_int i=0;i<l.size();++i) {
      if (i>0) ss << delim;
      ss << l[i];
    }
    return ss.str();
  }

Referenced by casadi::CodeGenerator::copy_check(), casadi::Function::expand(), casadi::OracleFunction::finalize(), casadi::FunctionInternal::generate_options(), casadi::MapSum::get_forward(), casadi::Map::get_function(), casadi::MapSum::get_function(), casadi::OracleFunction::get_function(), casadi::XFunction< DerivedType, MatType, NodeType >::get_jacobian(), casadi::MapSum::get_reverse(), casadi::Factory< MatType >::imap(), casadi::MXFunction::init(), casadi::SXFunction::init(), casadi::OracleFunction::monitored(), casadi::Factory< MatType >::omap(), reduce_index_gen(), casadi::Factory< MatType >::request_input(), casadi::Factory< MatType >::request_output(), and casadi::FunctionInternal::signature_unrolled().

join() [2/3]

template<typename T >

std::vector< T > casadi::join	(	const std::vector< T > &	a,
		const std::vector< T > &	b
	)

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

Definition at line 621 of file casadi_misc.hpp.

                                                                  {
    std::vector<T> ret = a;
    ret.insert(ret.end(), b.begin(), b.end());
    return ret;
  }

join() [3/3]

template<typename T >

std::vector< T > casadi::join	(	const std::vector< T > &	a,
		const std::vector< T > &	b,
		const std::vector< T > &	c
	)

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

Definition at line 628 of file casadi_misc.hpp.

                                                                                         {
    std::vector<T> ret = a;
    ret.insert(ret.end(), b.begin(), b.end());
    ret.insert(ret.end(), c.begin(), c.end());
    return ret;
  }

kkt_solver_from_string()

piqp::KKTSolver casadi::kkt_solver_from_string ( const std::string &  s )

inline

Definition at line 51 of file piqp_interface.cpp.

                                                                  {
    if (s == "dense_cholesky") return piqp::KKTSolver::dense_cholesky;
    if (s == "sparse_ldlt") return piqp::KKTSolver::sparse_ldlt;
    if (s == "sparse_ldlt_eq_cond") return piqp::KKTSolver::sparse_ldlt_eq_cond;
    if (s == "sparse_ldlt_ineq_cond") return piqp::KKTSolver::sparse_ldlt_ineq_cond;
    if (s == "sparse_ldlt_cond") return piqp::KKTSolver::sparse_ldlt_cond;
    if (s == "sparse_multistage") return piqp::KKTSolver::sparse_multistage;
    casadi_error("Unknown kkt_solver '" + s + "'. Choose one of: dense_cholesky, "
      "sparse_ldlt, sparse_ldlt_eq_cond, sparse_ldlt_ineq_cond, sparse_ldlt_cond, "
      "sparse_multistage.");
    return piqp::KKTSolver::sparse_ldlt;
  }

References kkt_solver_from_string().

Referenced by casadi::PiqpInterface::init(), kkt_solver_from_string(), and casadi::PiqpInterface::PiqpInterface().

knot_offsets()

static std::vector<casadi_int> casadi::knot_offsets ( const std::vector< casadi_int > &  knot_dims )

static

Definition at line 74 of file blazing_spline.cpp.

                                                                                    {
    std::vector<casadi_int> offsets(knot_dims.size() + 1);
    offsets[0] = 0;
    for (size_t i = 0; i < knot_dims.size(); ++i)
      offsets[i + 1] = offsets[i] + knot_dims[i];
    return offsets;
  }

Referenced by blazing_spline().

knot_size() [1/2]

static casadi_int casadi::knot_size ( const MX &  k )

static

Definition at line 213 of file bspline.cpp.

{ return k.size1(); }

References casadi::GenericMatrix< MatType >::size1().

knot_size() [2/2]

static casadi_int casadi::knot_size ( const std::vector< double > &  k )

static

Definition at line 212 of file bspline.cpp.

{ return k.size(); }

Referenced by do_inline().

kron_contract()

MX casadi::kron_contract ( const MX &  m, const MX &  x, bool  inner  )

inline

inner = true: Y[i, j] = sum over (r, s) of M[i*mB+r, j*nB+s] * X[r, s] inner = false: Y[r, s] = sum over (i, j) of X[i, j] * M[i*mB+r, j*nB+s]

Closes the AD algebra of kron under arbitrary-order differentiation.

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

Definition at line 1121 of file mx.hpp.

                                                                {
    return MX::kron_contract(m, x, inner);
  }

References casadi::MX::kron_contract().

Referenced by casadi::KronContract::ad_forward(), casadi::Kron::ad_reverse(), casadi::KronContract::ad_reverse(), and casadi::KronContract::eval_mx().

kron_sp_gen()

template<bool Fwd>

static int casadi::kron_sp_gen ( const Sparsity &  sp_a, const Sparsity &  sp_b, typename KronSpTraits< Fwd >::arg_t  arg, typename KronSpTraits< Fwd >::res_t  res  )

static

Definition at line 61 of file kron.cpp.

                                                              {
    const casadi_int* a_colind = sp_a.colind();
    const casadi_int* b_colind = sp_b.colind();
    const casadi_int a_ncol = sp_a.size2();
    const casadi_int b_ncol = sp_b.size2();
    casadi_int k = 0;
    for (casadi_int a_cc=0; a_cc<a_ncol; ++a_cc) {
      for (casadi_int b_cc=0; b_cc<b_ncol; ++b_cc) {
        for (casadi_int a_el=a_colind[a_cc]; a_el<a_colind[a_cc+1]; ++a_el) {
          for (casadi_int b_el=b_colind[b_cc]; b_el<b_colind[b_cc+1]; ++b_el) {
            KronSpTraits<Fwd>::step(arg, res, a_el, b_el, k);
            ++k;
          }
        }
      }
    }
    return 0;
  }

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

linspace()

template<typename T , typename F , typename L >

void casadi::linspace	(	std::vector< T > &	v,
		const F &	first,
		const L &	last
	)

Definition at line 868 of file casadi_misc.hpp.

                                                                {
    if (v.size()<2)
        throw CasadiException("std::linspace: vector must contain at least two elements");
 
    // Increment
    T increment = (last-first)/T(v.size()-1);
 
    v[0] = first;
    for (unsigned i=1; i<v.size()-1; ++i)
      v[i] = v[i-1] + increment;
    v[v.size()-1] = last;
  }

References T.

load_archiver()

CASADI_EXPORT void casadi::load_archiver

(

const std::string &

name

)

Definition at line 42 of file archiver.cpp.

                                            {
    Archiver::load_plugin(name);
  }

References casadi::PluginInterface< Archiver >::load_plugin().

load_blas()

CASADI_EXPORT void casadi::load_blas

(

const std::string &

name

)

Definition at line 255 of file blas.cpp.

                                      {
  if (name == "reference") return;
  Blas::load_plugin(name);
}

References casadi::PluginInterface< Blas >::load_plugin().

load_filesystem()

CASADI_EXPORT void casadi::load_filesystem

(

const std::string &

name

)

Definition at line 96 of file filesystem.cpp.

                                            {
  Filesystem::load_plugin(name);
}

References casadi::PluginInterface< Filesystem >::load_plugin().

load_graphmodel()

CASADI_EXPORT void casadi::load_graphmodel

(

const std::string &

name

)

Definition at line 78 of file graph_model.cpp.

{ GraphModel::load_plugin(name); }

References casadi::GraphModel::load_plugin().

load_linsol()

CASADI_EXPORT void casadi::load_linsol

(

const std::string &

name

)

Definition at line 233 of file linsol.cpp.

                                          {
    Linsol::load_plugin(name);
  }

References casadi::Linsol::load_plugin().

load_modelicaparser()

CASADI_EXPORT void casadi::load_modelicaparser

(

const std::string &

name

)

Definition at line 64 of file modelica_parser.cpp.

                                                {
  ModelicaParser::load_plugin(name);
}

References casadi::ModelicaParser::load_plugin().

load_raw()

template<typename T >

static bool casadi::load_raw ( DM &  dm, casadi_int  n, const onnx::TensorProto &  tensor, const char *  type_name  )

static

Definition at line 100 of file onnx_utilities.cpp.

                                              {
    if (!(tensor.has_raw_data() && tensor.raw_data().size() > 0)) return false;
    const std::string& raw = tensor.raw_data();
    casadi_assert(raw.size() == static_cast<size_t>(n) * sizeof(T),
                  std::string("Raw data size mismatch for ") + type_name);
    const T* p = reinterpret_cast<const T*>(raw.data());
    for (casadi_int i = 0; i < n; ++i) dm(i) = static_cast<double>(p[i]);
    return true;
  }

References T.

log_level_name()

std::string casadi::log_level_name

(

SLEQP_LOG_LEVEL

level

)

Definition at line 39 of file sleqp_interface.cpp.

  {
    switch (level) {
      case SLEQP_LOG_DEBUG:
        return "  debug";
      case SLEQP_LOG_INFO:
        return "   info";
      default:
        return "unknown";
    }
  }

Referenced by casadi_log_output().

lookupvector() [1/2]

CASADI_EXPORT std::vector< casadi_int > casadi::lookupvector

(

const std::vector< casadi_int > &

v

)

Definition at line 170 of file casadi_misc.cpp.

                                                                     {
    casadi_assert_dev(!has_negative(v));
    return lookupvector(v, (*std::max_element(v.begin(), v.end()))+1);
  }

References has_negative(), and lookupvector().

lookupvector() [2/2]

CASADI_EXPORT std::vector< casadi_int > casadi::lookupvector	(	const std::vector< casadi_int > &	v,
		casadi_int	size
	)

lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v contains i

Duplicates are treated by looking up last occurrence

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

Definition at line 159 of file casadi_misc.cpp.

                                                                                      {
    casadi_assert(in_range(v, size),
                          "lookupvector: out of bounds. Some elements in v fall out of [0, size[");
    std::vector<casadi_int> lookup(size, -1);
 
    for (casadi_int i=0;i<v.size();i++) {
      lookup[v[i]] = i;
    }
    return lookup;
  }

References in_range().

Referenced by detect_simple_bounds_gen(), einstein_process(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::SuperscsInterface::init(), lookupvector(), casadi::Function::mapaccum(), casadi::Convexify::setup(), casadi::SuperscsInterface::solve(), and casadi::SparsityInternal::sub().

map_semi_expl()

template<class X >

std::map<std::string, X> casadi::map_semi_expl	(	const std::map< std::string, X > &	dae,
		const std::map< std::string, X > &	dae_red,
		Function &	state_to_orig,
		Function &	phi
	)

Definition at line 1076 of file integration_tools.cpp.

                                          {
 
  std::map<std::string, X> dae_se;
  dae_se["x"] = vertcat(dae_red.at("x"), dae_red.at("x_impl"));
  dae_se["z"] = vertcat(dae_red.at("dx_impl"), dae_red.at("z"));
  dae_se["ode"] = vertcat(dae_red.at("ode"), dae_red.at("dx_impl"));
  dae_se["alg"] = dae_red.at("alg");
  dae_se["t"] = dae_red.at("t");
  dae_se["p"] = dae_red.at("p");
 
  X x_impl  = get_from_dict(dae, "x_impl",  X(0, 1));
  X dx_impl = get_from_dict(dae, "dx_impl", X(0, 1));
  X z       = get_from_dict(dae, "z", X(0, 1));
 
  Sparsity var_map_sp = jacobian(vertcat(dae_red.at("x"), dae_red.at("x_impl"),
    dae_red.at("dx_impl"), dae_red.at("z")), vertcat(x_impl, dx_impl, z)).sparsity();
  DM var_map(var_map_sp, 1.0);
 
  state_to_orig = Function("state_to_orig",
    {dae_se["x"], dae_se["z"]},
    {x_impl, dx_impl, z},
    {"xf", "zf"},
    {"x_impl", "dx_impl", "z"});
 
  phi = Function("phi",
    {dae_se["x"], dae_se["z"], dae_se["p"], dae_se["t"]},
    {dae_red.at("I")},
    {"x", "z", "p", "t"},
    {"I"});
 
  return dae_se;
}

References get_from_dict(), and X.

Referenced by dae_map_semi_expl().

map_status()

UnifiedReturnStatus casadi::map_status

(

SLEQP_STATUS

status

)

Definition at line 479 of file sleqp_interface.cpp.

  {
    switch (status) {
    case SLEQP_STATUS_OPTIMAL:
      return SOLVER_RET_SUCCESS;
    case SLEQP_STATUS_INFEASIBLE:
      return SOLVER_RET_INFEASIBLE;
 
    case SLEQP_STATUS_ABORT_ITER:
    case SLEQP_STATUS_ABORT_MANUAL:
    case SLEQP_STATUS_ABORT_TIME:
      return SOLVER_RET_LIMITED;
    default:
      // case SLEQP_STATUS_UNKNOWN:
      // case SLEQP_STATUS_RUNNING:
      // case SLEQP_STATUS_UNBOUNDED:
      // case SLEQP_STATUS_ABORT_DEADPOINT:
      return SOLVER_RET_UNKNOWN;
    }
  }

References SOLVER_RET_INFEASIBLE, SOLVER_RET_LIMITED, SOLVER_RET_SUCCESS, and SOLVER_RET_UNKNOWN.

Referenced by casadi::SLEQPInterface::solve().

matrixName()

template<typename Scalar >

std::string casadi::matrixName ( )

inline

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

Definition at line 63 of file matrix_decl.hpp.

  { return std::string("Matrix<") + typeid(Scalar).name() + std::string(">");}

matrixName< casadi_int >()

template<>

std::string casadi::matrixName< casadi_int > ( )

inline

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

Definition at line 66 of file matrix_decl.hpp.

{ return "IM"; }

matrixName< double >()

template<>

std::string casadi::matrixName< double > ( )

inline

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

Definition at line 65 of file matrix_decl.hpp.

{ return "DM"; }

matrixName< SXElem >()

template<>

std::string casadi::matrixName< SXElem > ( )

inline

Definition at line 33 of file sx.hpp.

{ return "SX"; }

message_prefix()

std::ostream& casadi::message_prefix ( std::ostream &  stream )

inline

Definition at line 119 of file exception.hpp.

                                                      {
  // CasADi prefix
  stream << "CasADi - ";
  // Get current time
  auto now = std::chrono::system_clock::now();
  std::time_t tt = std::chrono::system_clock::to_time_t(now);
  auto local_tm = *std::localtime(&tt);  // NOLINT(runtime/threadsafe_fn)
  // Convert to YYYY-MM-DD HH:MM:SS format
  stream << local_tm.tm_year + 1900 << '-';  // YYYY-
  stream << std::setfill('0') << std::setw(2) << local_tm.tm_mon + 1 << '-';  // MM-
  stream << std::setfill('0') << std::setw(2) << local_tm.tm_mday << ' ';  // DD
  stream << std::setfill('0') << std::setw(2) << local_tm.tm_hour << ':';  // hh:
  stream << std::setfill('0') << std::setw(2) << local_tm.tm_min << ':';  // mm:
  stream << std::setfill('0') << std::setw(2) << local_tm.tm_sec;  // ss
  return stream;
}

mosek_stream_cb()

static void casadi::mosek_stream_cb ( void *  , const char *  s  )

static

Definition at line 295 of file mosek_interface.cpp.

{ std::fputs(s, stderr); }

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

mtaylor_recursive()

SX casadi::mtaylor_recursive	(	const SX &	ex,
		const SX &	x,
		const SX &	a,
		casadi_int	order,
		const std::vector< casadi_int > &	order_contributions,
		const SXElem &	current_dx = casadi_limits<SXElem>::one,
		double	current_denom = 1,
		casadi_int	current_order = 1
	)

Definition at line 1265 of file sx_instantiator.cpp.

                                                                           {
    SX result = substitute(ex, x, a)*current_dx/current_denom;
    for (casadi_int i=0;i<x.nnz();i++) {
      if (order_contributions[i]<=order) {
        result += mtaylor_recursive(SX::jacobian(ex, x->at(i)),
                                    x, a,
                                    order-order_contributions[i],
                                    order_contributions,
                                    current_dx*(x->at(i)-a->at(i)),
                                    current_denom*static_cast<double>(current_order),
                                    current_order+1);
      }
    }
    return result;
  }

References mtaylor_recursive(), and casadi::GenericMatrix< MatType >::nnz().

Referenced by mtaylor_recursive().

mtimes_dense_dispatch< double >()

template<>

void CASADI_EXPORT casadi::mtimes_dense_dispatch< double >	(	const std::string &	blas,
		const double *	A,
		casadi_int	m,
		casadi_int	k,
		const double *	B,
		casadi_int	n,
		double *	C
	)

Definition at line 401 of file dm_instantiator.cpp.

                                                {
    Blas::mtimes(Blas::shorthand_for(blas), A, m, k, B, n, C);
  }

References C.

mul_bvec_fwd()

template<bool COMBINE_AND>

static void casadi::mul_bvec_fwd ( const bvec_t *  x, const Sparsity &  x_sp, const bvec_t *  y, const Sparsity &  y_sp, bvec_t *  z, const Sparsity &  z_sp, bvec_t *  w  )

static

Definition at line 1824 of file sparsity.cpp.

                                                                       {
    // Assert dimensions
    casadi_assert(z_sp.size1()==x_sp.size1() && x_sp.size2()==y_sp.size1()
                          && y_sp.size2()==z_sp.size2(),
                          "Dimension error. Got x=" + x_sp.dim() + ", y=" + y_sp.dim()
                          + " and z=" + z_sp.dim() + ".");
 
    // Direct access to the arrays
    const casadi_int* y_colind = y_sp.colind();
    const casadi_int* y_row = y_sp.row();
    const casadi_int* x_colind = x_sp.colind();
    const casadi_int* x_row = x_sp.row();
    const casadi_int* z_colind = z_sp.colind();
    const casadi_int* z_row = z_sp.row();
 
    // Loop over the columns of y and z
    casadi_int ncol = z_sp.size2();
    for (casadi_int cc=0; cc<ncol; ++cc) {
      // Get the dense column of z
      for (casadi_int kk=z_colind[cc]; kk<z_colind[cc+1]; ++kk) {
        w[z_row[kk]] = z[kk];
      }
 
      // Loop over the nonzeros of y
      for (casadi_int kk=y_colind[cc]; kk<y_colind[cc+1]; ++kk) {
        casadi_int rr = y_row[kk];
 
        // Loop over corresponding columns of x
        bvec_t yy = y[kk];
        for (casadi_int kk1=x_colind[rr]; kk1<x_colind[rr+1]; ++kk1) {
          w[x_row[kk1]] |= COMBINE_AND ? (x[kk1] & yy) : (x[kk1] | yy);
        }
      }
 
      // Get the sparse column of z
      for (casadi_int kk=z_colind[cc]; kk<z_colind[cc+1]; ++kk) {
        z[kk] = w[z_row[kk]];
      }
    }
  }

References casadi::Sparsity::colind(), casadi::Sparsity::dim(), casadi::Sparsity::row(), casadi::Sparsity::size1(), and casadi::Sparsity::size2().

mul_overflows()

template<typename T >

bool casadi::mul_overflows	(	const T &	a,
		const T &	b
	)

Definition at line 553 of file casadi_misc.hpp.

                                             {
    if (a==0 || b==0) return false;
    return std::abs(std::numeric_limits<T>::max()/a) < std::abs(b);
  }

Referenced by casadi::SparsityInternal::find().

n_fd_points()

CASADI_EXPORT casadi_int casadi::n_fd_points

(

FdMode

v

)

Definition at line 41 of file finite_differences.cpp.

                                 {
  switch (v) {
    case FdMode::FORWARD:
    case FdMode::BACKWARD: return 2;
    case FdMode::CENTRAL: return 3;
    case FdMode::SMOOTHING: return 5;
    default: break;
  }
  return -1;
}

References BACKWARD, CENTRAL, FORWARD, and SMOOTHING.

Referenced by casadi::FmuInternal::eval_fd().

name_has_g()

bool casadi::name_has_g

(

const std::string &

name

)

Definition at line 47 of file nlpsol.cpp.

                                         {
    size_t pos = name.find("g");
 
    // 'g' does not occur
    if (pos == std::string::npos) return false;
 
    // Check if 'g' has a word boundary on the left
    bool left = pos==0 || !isalnum(name[pos-1]);
 
    // Check if 'g' has a word boundary on the right
    bool right = pos+1 == name.size() || !isalnum(name[pos+1]);
 
    return left && right;
  }

Referenced by construct_nlpsol().

new_ifstream_compat()

CASADI_EXPORT std::ifstream* casadi::new_ifstream_compat	(	const std::string &	utf8_path,
		std::ios::openmode	mode = std::ios::in
	)

next_quoted_token()

static std::string casadi::next_quoted_token ( const std::string &  line, size_t &  pos  )

static

Definition at line 2638 of file code_generator.cpp.

                                                                         {
    size_t n1 = line.find('"', pos);
    casadi_assert(n1 != std::string::npos, "Missing quoted token in: " + line);
    std::string r;
    size_t i = n1 + 1;
    for (; i < line.size(); ++i) {
      if (line[i] == '\\' && i + 1 < line.size()) {
        r += line[++i];
      } else if (line[i] == '"') {
        break;
      } else {
        r += line[i];
      }
    }
    casadi_assert(i < line.size(), "Unterminated quoted token in: " + line);
    pos = i + 1;
    return r;
  }

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

norm_1()

template<typename T >

T casadi::norm_1

(

const std::vector< T > &

x

)

Definition at line 998 of file casadi_misc.hpp.

                                  {
    T ret = 0;
    for (casadi_int k=0; k<x.size(); ++k) {
      ret += fabs(x[k]);
    }
    return ret;
  }

References T.

Referenced by casadi::BSplineInterpolant::construct_graph().

norm_2()

template<typename T >

T casadi::norm_2

(

const std::vector< T > &

x

)

Definition at line 1007 of file casadi_misc.hpp.

                                  {
    T ret = 0;
    for (casadi_int k=0; k<x.size(); ++k) {
      ret += x[k]*x[k];
    }
    return sqrt(ret);
  }

References T.

norm_inf()

template<typename T >

T casadi::norm_inf

(

const std::vector< T > &

x

)

Definition at line 989 of file casadi_misc.hpp.

                                    {
    T ret = 0;
    for (casadi_int k=0; k<x.size(); ++k) {
      ret = fmax(ret, fabs(x[k]));
    }
    return ret;
  }

References T.

normalized_in()

int casadi::normalized_in ( std::istream &  stream, double &  ret  )

inline

Definition at line 469 of file casadi_misc.hpp.

                                                            {
    std::streampos start = stream.tellg();
    stream >> ret;
    // Failed to interpret as double?
    if (stream.fail()) {
      // Clear error flag
      stream.clear();
      // Reset stream position
      // Need to parse e.g "-inf"
      stream.seekg(start);
      // Might be a inf/nan
      std::string non_reg;
      stream >> non_reg;
      // Break on trailing whitespace
      if (stream.fail()) {
        if (stream.eof()) {
          ret = std::numeric_limits<double>::quiet_NaN();
          return -1; // End of stream
        } else {
          ret = std::numeric_limits<double>::quiet_NaN();
          return 1; // Failed to parse to string
        }
      }
      if (non_reg=="inf") {
        ret = std::numeric_limits<double>::infinity();
      } else if (non_reg=="-inf") {
        ret = -std::numeric_limits<double>::infinity();
      } else if (non_reg=="nan" || non_reg=="-nan") {
        ret = std::numeric_limits<double>::quiet_NaN();
      } else {
        ret = std::numeric_limits<double>::quiet_NaN();
        return 2; // Failed to interpret as number
      }
    }
    return 0;
  }

normalized_out()

void casadi::normalized_out ( std::ostream &  stream, double  val  )

inline

Definition at line 458 of file casadi_misc.hpp.

                                                             {
    if (val==std::numeric_limits<double>::infinity()) {
      stream << "inf";
    } else if (val==-std::numeric_limits<double>::infinity()) {
      stream << "-inf";
    } else if (val!=val) {
      stream << "nan";
    } else {
      stream << val;
    }
  }

Referenced by casadi::FunctionInternal::generate_in(), casadi::Function::generate_in(), casadi::Function::generate_out(), casadi::FunctionInternal::generate_out(), and casadi::FunctionInternal::print_canonical().

normalized_setup() [1/2]

CASADI_EXPORT void casadi::normalized_setup

(

std::istream &

stream

)

Definition at line 420 of file casadi_misc.cpp.

                                            {
    stream.imbue(std::locale("C"));
  }

Referenced by casadi::FunctionInternal::generate_in(), casadi::Function::generate_in(), casadi::Function::generate_out(), casadi::FunctionInternal::generate_out(), and casadi::FunctionInternal::print_canonical().

normalized_setup() [2/2]

CASADI_EXPORT void casadi::normalized_setup

(

std::ostream &

stream

)

Definition at line 424 of file casadi_misc.cpp.

                                            {
    stream.imbue(std::locale("C"));
    stream << std::scientific;
    stream << std::setprecision(std::numeric_limits<double>::digits10 + 1);
  }

ofstream_compat()

CASADI_EXPORT std::unique_ptr< std::ostream > casadi::ofstream_compat	(	const std::string &	utf8_path,
		std::ios::openmode	mode
	)

Definition at line 527 of file casadi_os.cpp.

                                                                   {
#ifdef _WIN32
    std::wstring utf16_path = utf8_to_utf16(utf8_path);
 
    DWORD access = 0;
    access |= GENERIC_WRITE;
    if (mode & std::ios::in)   access |= GENERIC_READ;
 
    DWORD creation = (mode & std::ios::app) ? OPEN_ALWAYS : CREATE_ALWAYS;
 
    HANDLE h = CreateFileW(utf16_path.c_str(), access,
                            FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
                           creation, FILE_ATTRIBUTE_NORMAL, nullptr);
    if (h == INVALID_HANDLE_VALUE) return {};
 
    int flags = (mode & std::ios::in) ? _O_RDWR : _O_WRONLY;
    if (mode & std::ios::app) flags |= _O_APPEND;
    if (mode & std::ios::binary) {
        flags |= _O_BINARY;
    } else {
        flags |= _O_TEXT;
    }
 
    int fd = _open_osfhandle(reinterpret_cast<intptr_t>(h), flags);
    if (fd == -1) {
        CloseHandle(h);
        return {};
    }
 
    auto owned = std::make_shared<OwnedOStream>(fd);
    return std::unique_ptr<StreamWithOwnedOBuffer>(new StreamWithOwnedOBuffer(std::move(owned)));
#else
    auto ofs = std::unique_ptr<std::ofstream>(new std::ofstream(utf8_path, mode));
    if (!*ofs) return {};
    return std::unique_ptr<std::ostream>(std::move(ofs));
#endif
}

Referenced by casadi::Filesystem::ofstream_ptr().

onnx_dtype_enum()

CASADI_EXPORT casadi_int casadi::onnx_dtype_enum

(

const std::string &

name

)

Definition at line 87 of file onnx_function.cpp.

                                                    {
    static const std::map<std::string, casadi_int> m = {
      {"FLOAT", 1},  {"UINT8", 2},  {"INT8", 3},   {"UINT16", 4},   {"INT16", 5},
      {"INT32", 6},  {"INT64", 7},  {"STRING", 8}, {"BOOL", 9},     {"FLOAT16", 10},
      {"DOUBLE", 11}, {"UINT32", 12}, {"UINT64", 13}, {"BFLOAT16", 16}};
    auto it = m.find(name);
    return it != m.end() ? it->second : 0;
  }

Referenced by casadi::OnnxFunction::OnnxFunction().

onnx_dtype_name()

std::string casadi::onnx_dtype_name

(

casadi_int

t

)

Definition at line 76 of file onnx_function.cpp.

                                          {
    switch (t) {
      case 1: return "FLOAT";       case 2: return "UINT8";    case 3: return "INT8";
      case 4: return "UINT16";      case 5: return "INT16";    case 6: return "INT32";
      case 7: return "INT64";       case 8: return "STRING";   case 9: return "BOOL";
      case 10: return "FLOAT16";    case 11: return "DOUBLE";  case 12: return "UINT32";
      case 13: return "UINT64";     case 16: return "BFLOAT16";
      default: return "TYPE" + str(t);
    }
  }

References str().

Referenced by io_node().

onnx_input_name()

std::string casadi::onnx_input_name	(	const Function &	f,
		casadi_int	i
	)

Definition at line 34 of file onnx_export.cpp.

                                                             {
    std::string n = f.name_in(i);
    return n.empty() ? "input_" + std::to_string(i) : n;
  }

References casadi::Function::name_in().

Referenced by casadi::Onnx::load().

onnx_output_name()

std::string casadi::onnx_output_name	(	const Function &	f,
		casadi_int	i
	)

Definition at line 39 of file onnx_export.cpp.

                                                              {
    std::string n = f.name_out(i);
    return n.empty() ? "output_" + std::to_string(i) : n;
  }

References casadi::Function::name_out().

Referenced by casadi::Onnx::load().

open_resource()

static Resource casadi::open_resource ( const std::string &  path )

static

Definition at line 642 of file dae_builder_internal.cpp.

                                                     {
  // Check for .bmo extension (Lace Modelica binary model)
  if (path.size() >= 4 && path.substr(path.size() - 4) == ".bmo") {
    // Create temporary directory resource
    std::string bmo_file = Filesystem::filename(path);
    TemporaryDirResource* res = new TemporaryDirResource(bmo_file, "temp");
 
    // Use Lace Modelica plugin to process BMO and populate the directory
    ModelicaParser parser("lacemodelica");
    parser.parse(path, res->path());
 
    return Resource::create(res);
  }
 
  // Default: treat as FMU (zip file or directory)
  return Resource(path);
}

References casadi::Resource::create(), casadi::Filesystem::filename(), casadi::ModelicaParser::parse(), casadi::TemporaryDirResource::path(), and path().

operation_checker()

template<template< casadi_int > class F>

bool casadi::operation_checker

(

casadi_int

op

)

Definition at line 1129 of file calculus.hpp.

                                        {
    return operation_getter<F, bool>(op);
  }

operation_getter()

template<template< casadi_int > class F, typename T >

T casadi::operation_getter

(

casadi_int

op

)

Definition at line 1021 of file calculus.hpp.

                                    {
    switch (static_cast<Operation>(op)) {
    case OP_ASSIGN:        return F<OP_ASSIGN>::check;
    case OP_ADD:           return F<OP_ADD>::check;
    case OP_SUB:           return F<OP_SUB>::check;
    case OP_MUL:           return F<OP_MUL>::check;
    case OP_DIV:           return F<OP_DIV>::check;
    case OP_NEG:           return F<OP_NEG>::check;
    case OP_EXP:           return F<OP_EXP>::check;
    case OP_LOG:           return F<OP_LOG>::check;
    case OP_POW:           return F<OP_POW>::check;
    case OP_CONSTPOW:      return F<OP_CONSTPOW>::check;
    case OP_SQRT:          return F<OP_SQRT>::check;
    case OP_SQ:            return F<OP_SQ>::check;
    case OP_TWICE:         return F<OP_TWICE>::check;
    case OP_SIN:           return F<OP_SIN>::check;
    case OP_COS:           return F<OP_COS>::check;
    case OP_TAN:           return F<OP_TAN>::check;
    case OP_ASIN:          return F<OP_ASIN>::check;
    case OP_ACOS:          return F<OP_ACOS>::check;
    case OP_ATAN:          return F<OP_ATAN>::check;
    case OP_LT:            return F<OP_LT>::check;
    case OP_LE:            return F<OP_LE>::check;
    case OP_EQ:            return F<OP_EQ>::check;
    case OP_NE:            return F<OP_NE>::check;
    case OP_NOT:           return F<OP_NOT>::check;
    case OP_AND:           return F<OP_AND>::check;
    case OP_OR:            return F<OP_OR>::check;
    case OP_FLOOR:         return F<OP_FLOOR>::check;
    case OP_CEIL:          return F<OP_CEIL>::check;
    case OP_FMOD:          return F<OP_FMOD>::check;
    case OP_REMAINDER:     return F<OP_REMAINDER>::check;
    case OP_FABS:          return F<OP_FABS>::check;
    case OP_SIGN:          return F<OP_SIGN>::check;
    case OP_COPYSIGN:      return F<OP_COPYSIGN>::check;
    case OP_IF_ELSE_ZERO:  return F<OP_IF_ELSE_ZERO>::check;
    case OP_ERF:           return F<OP_ERF>::check;
    case OP_FMIN:          return F<OP_FMIN>::check;
    case OP_FMAX:          return F<OP_FMAX>::check;
    case OP_INV:           return F<OP_INV>::check;
    case OP_SINH:          return F<OP_SINH>::check;
    case OP_COSH:          return F<OP_COSH>::check;
    case OP_TANH:          return F<OP_TANH>::check;
    case OP_ASINH:         return F<OP_ASINH>::check;
    case OP_ACOSH:         return F<OP_ACOSH>::check;
    case OP_ATANH:         return F<OP_ATANH>::check;
    case OP_ATAN2:         return F<OP_ATAN2>::check;
    case OP_CONST:         return F<OP_CONST>::check;
    case OP_INPUT:         return F<OP_INPUT>::check;
    case OP_OUTPUT:        return F<OP_OUTPUT>::check;
    case OP_PARAMETER:     return F<OP_PARAMETER>::check;
    case OP_CALL:          return F<OP_CALL>::check;
    case OP_FIND:          return F<OP_FIND>::check;
    case OP_LOW:           return F<OP_LOW>::check;
    case OP_MAP:           return F<OP_MAP>::check;
    case OP_MTIMES:        return F<OP_MTIMES>::check;
    case OP_SOLVE:         return F<OP_SOLVE>::check;
    case OP_TRANSPOSE:     return F<OP_TRANSPOSE>::check;
    case OP_DETERMINANT:   return F<OP_DETERMINANT>::check;
    case OP_INVERSE:       return F<OP_INVERSE>::check;
    case OP_DOT:           return F<OP_DOT>::check;
    case OP_BILIN:         return F<OP_BILIN>::check;
    case OP_RANK1:         return F<OP_RANK1>::check;
    case OP_HORZCAT:       return F<OP_HORZCAT>::check;
    case OP_VERTCAT:       return F<OP_VERTCAT>::check;
    case OP_DIAGCAT:       return F<OP_DIAGCAT>::check;
    case OP_HORZSPLIT:     return F<OP_HORZSPLIT>::check;
    case OP_VERTSPLIT:     return F<OP_VERTSPLIT>::check;
    case OP_DIAGSPLIT:     return F<OP_DIAGSPLIT>::check;
    case OP_RESHAPE:       return F<OP_RESHAPE>::check;
    case OP_SPARSITY_CAST: return F<OP_SPARSITY_CAST>::check;
    case OP_SUBREF:        return F<OP_SUBREF>::check;
    case OP_SUBASSIGN:     return F<OP_SUBASSIGN>::check;
    case OP_GETNONZEROS:   return F<OP_GETNONZEROS>::check;
    case OP_GETNONZEROS_PARAM:   return F<OP_GETNONZEROS_PARAM>::check;
    case OP_ADDNONZEROS:   return F<OP_ADDNONZEROS>::check;
    case OP_ADDNONZEROS_PARAM:   return F<OP_ADDNONZEROS>::check;
    case OP_SETNONZEROS:   return F<OP_SETNONZEROS>::check;
    case OP_SETNONZEROS_PARAM:   return F<OP_SETNONZEROS>::check;
    case OP_PROJECT:       return F<OP_PROJECT>::check;
    case OP_ASSERTION:     return F<OP_ASSERTION>::check;
    case OP_MONITOR:       return F<OP_MONITOR>::check;
    case OP_DUMP:          return F<OP_DUMP>::check;
    case OP_NORM2:         return F<OP_NORM2>::check;
    case OP_NORM1:         return F<OP_NORM1>::check;
    case OP_NORMINF:       return F<OP_NORMINF>::check;
    case OP_NORMF:         return F<OP_NORMF>::check;
    case OP_MMIN:          return F<OP_MMIN>::check;
    case OP_MMAX:          return F<OP_MMAX>::check;
    case OP_HORZREPMAT:    return F<OP_HORZREPMAT>::check;
    case OP_HORZREPSUM:    return F<OP_HORZREPSUM>::check;
    case OP_ERFINV:        return F<OP_ERFINV>::check;
    case OP_PRINTME:       return F<OP_PRINTME>::check;
    case OP_LIFT:          return F<OP_LIFT>::check;
    case OP_EINSTEIN:      return F<OP_EINSTEIN>::check;
    case OP_BSPLINE:       return F<OP_BSPLINE>::check;
    case OP_CONVEXIFY:     return F<OP_CONVEXIFY>::check;
    case OP_LOG1P:         return F<OP_LOG1P>::check;
    case OP_EXPM1:         return F<OP_EXPM1>::check;
    case OP_HYPOT:         return F<OP_HYPOT>::check;
    case OP_LOGSUMEXP:     return F<OP_LOGSUMEXP>::check;
    case OP_KRON:          return F<OP_KRON>::check;
    case OP_KRON_CONTRACT: return F<OP_KRON_CONTRACT>::check;
    }
    return T();
  }

References OP_ACOS, OP_ACOSH, OP_ADD, OP_ADDNONZEROS, OP_ADDNONZEROS_PARAM, OP_AND, OP_ASIN, OP_ASINH, OP_ASSERTION, OP_ASSIGN, OP_ATAN, OP_ATAN2, OP_ATANH, OP_BILIN, OP_BSPLINE, OP_CALL, OP_CEIL, OP_CONST, OP_CONSTPOW, OP_CONVEXIFY, OP_COPYSIGN, OP_COS, OP_COSH, OP_DETERMINANT, OP_DIAGCAT, OP_DIAGSPLIT, OP_DIV, OP_DOT, OP_DUMP, OP_EINSTEIN, OP_EQ, OP_ERF, OP_ERFINV, OP_EXP, OP_EXPM1, OP_FABS, OP_FIND, OP_FLOOR, OP_FMAX, OP_FMIN, OP_FMOD, OP_GETNONZEROS, OP_GETNONZEROS_PARAM, OP_HORZCAT, OP_HORZREPMAT, OP_HORZREPSUM, OP_HORZSPLIT, OP_HYPOT, OP_IF_ELSE_ZERO, OP_INPUT, OP_INV, OP_INVERSE, OP_KRON, OP_KRON_CONTRACT, OP_LE, OP_LIFT, OP_LOG, OP_LOG1P, OP_LOGSUMEXP, OP_LOW, OP_LT, OP_MAP, OP_MMAX, OP_MMIN, OP_MONITOR, OP_MTIMES, OP_MUL, OP_NE, OP_NEG, OP_NORM1, OP_NORM2, OP_NORMF, OP_NORMINF, OP_NOT, OP_OR, OP_OUTPUT, OP_PARAMETER, OP_POW, OP_PRINTME, OP_PROJECT, OP_RANK1, OP_REMAINDER, OP_RESHAPE, OP_SETNONZEROS, OP_SETNONZEROS_PARAM, OP_SIGN, OP_SIN, OP_SINH, OP_SOLVE, OP_SPARSITY_CAST, OP_SQ, OP_SQRT, OP_SUB, OP_SUBASSIGN, OP_SUBREF, OP_TAN, OP_TANH, OP_TRANSPOSE, OP_TWICE, OP_VERTCAT, OP_VERTSPLIT, and T.

operator<<() [1/7]

template<typename T , size_t N>

std::ostream& casadi::operator<<	(	std::ostream &	stream,
		const std::array< T, N > &	v
	)

Definition at line 522 of file casadi_misc.hpp.

                                                                      {
    stream << casadi::str(v);
    return stream;
  }

References str().

operator<<() [2/7]

template<typename T2 >

std::ostream& casadi::operator<<	(	std::ostream &	stream,
		const std::map< std::string, T2 > &	p
	)

Definition at line 547 of file casadi_misc.hpp.

                                                                             {
    stream << casadi::str(p);
    return stream;
  }

References str().

operator<<() [3/7]

template<typename T1 , typename T2 >

std::ostream& casadi::operator<<	(	std::ostream &	stream,
		const std::map< T1, T2 > &	p
	)

Definition at line 541 of file casadi_misc.hpp.

                                                                      {
    stream << casadi::str(p);
    return stream;
  }

References str().

operator<<() [4/7]

template<typename T1 , typename T2 >

std::ostream& casadi::operator<<	(	std::ostream &	stream,
		const std::pair< T1, T2 > &	p
	)

Definition at line 535 of file casadi_misc.hpp.

                                                                       {
    stream << casadi::str(p);
    return stream;
  }

References str().

operator<<() [5/7]

template<typename T >

std::ostream& casadi::operator<<	(	std::ostream &	stream,
		const std::set< T > &	v
	)

Definition at line 529 of file casadi_misc.hpp.

                                                                 {
    stream << casadi::str(v);
    return stream;
  }

References str().

operator<<() [6/7]

template<typename T >

std::ostream& casadi::operator<<	(	std::ostream &	stream,
		const std::vector< T > &	v
	)

Definition at line 515 of file casadi_misc.hpp.

                                                                    {
    stream << casadi::str(v);
    return stream;
  }

References str().

operator<<() [7/7]

std::ostream& casadi::operator<<	(	std::ostream &	stream,
		const XmlNode &	node
	)

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

Definition at line 79 of file xml_node.cpp.

                                                                {
  node.dump(stream);
  return stream;
}

Orring()

static bvec_t casadi::Orring ( bvec_t  x, bvec_t  y  )

static

Definition at line 65 of file repmat.cpp.

{ return x | y; }

Referenced by casadi::HorzRepsum::sp_forward(), casadi::HorzRepmat::sp_reverse(), and casadi::HorzRepsum::sp_reverse().

output_categories()

CASADI_EXPORT std::vector< Category > casadi::output_categories

(

)

Definition at line 301 of file dae_builder_internal.cpp.

                                        {
  std::vector<Category> ret;
  for (casadi_int i = 0; i != enum_traits<Category>::n_enum; ++i) {
    auto cat = static_cast<Category>(i);
    if (is_output_category(cat)) ret.push_back(cat);
  }
  return ret;
}

References is_output_category().

Referenced by casadi::DaeBuilderInternal::gather_eq(), casadi::DaeBuilderInternal::oracle(), and casadi::DaeBuilderInternal::prune().

override_num()

bool casadi::override_num	(	const std::map< casadi_int, MX > &	temp,
		std::vector< DM > &	num,
		casadi_int	i
	)

Definition at line 1391 of file optistack_internal.cpp.

                                                                                         {
  // Override when values are supplied
  auto it = temp.find(i);
  if (it==temp.end()) {
    return true;
  } else {
    Slice all;
    DM t = static_cast<DM>(it->second);
    num.back().set(t, false, all, all);
  }
  return false;
}

References all(), and casadi::Matrix< Scalar >::set().

Referenced by casadi::OptiNode::value().

pack_tensors()

static void casadi::pack_tensors ( SerializingStream &  s, const std::string &  d, const std::vector< OnnxTensorInfo > &  v  )

static

Definition at line 143 of file onnx_function.cpp.

                                                               {
    std::vector<std::string> names;
    std::vector<std::vector<casadi_int>> shapes;
    std::vector<casadi_int> elem_types, numels;
    for (const OnnxTensorInfo& t : v) {
      names.push_back(t.name);
      shapes.push_back(t.shape);
      elem_types.push_back(t.elem_type);
      numels.push_back(t.numel);
    }
    s.pack(d + "::names", names);
    s.pack(d + "::shapes", shapes);
    s.pack(d + "::elem_types", elem_types);
    s.pack(d + "::numels", numels);
  }

References casadi::SerializingStream::pack().

Referenced by casadi::OnnxFunction::serialize_body().

param_by_name()

int casadi::param_by_name	(	CPXENVptr	env,
		const std::string &	name
	)

Definition at line 191 of file cplex_interface.cpp.

                                                          {
    int whichparam;
    if (CPXXgetparamnum(env, name.c_str(), &whichparam)) {
      casadi_error("No such CPLEX parameter: " + name);
    }
    return whichparam;
  }

Referenced by casadi::CplexInterface::init_mem(), and casadi::CplexInterface::solve().

parent_path()

std::string casadi::parent_path

(

const std::string &

path

)

Definition at line 63 of file ghc.cpp.

                                                 {
        return ghc::filesystem::path(path).parent_path().string();
    }

References path().

Referenced by casadi_register_filesystem_ghc().

path()

std::vector<casadi_int> casadi::path	(	const std::vector< casadi_int > &	map,
		casadi_int	i_start
	)

Definition at line 793 of file integration_tools.cpp.

                                                                                 {
  std::vector<casadi_int> ret;
  casadi_int i = i_start;
  while (true) {
    casadi_int i_next = map[i];
    if (i_next==-1) break;
    i = i_next;
    ret.push_back(i);
  }
  return ret;
}

Referenced by casadi::Filesystem::absolute(), absolute(), casadi::Filesystem::create_directories(), create_directories(), casadi::DaeBuilder::DaeBuilder(), casadi::Filesystem::ensure_trailing_slash(), casadi::Filesystem::exists(), casadi::Filesystem::filename(), filename(), format_from_path(), casadi::ClangCompiler::getIncludes(), casadi::Filesystem::has_parent_path(), has_parent_path(), casadi::Filesystem::ifstream_ptr(), casadi::ClangCompiler::init(), casadi::DllLibrary::init_handle(), casadi::Filesystem::is_absolute(), casadi::Filesystem::is_directory(), is_directory(), casadi::Filesystem::iterate_directory_names(), iterate_directory_names(), casadi::Filesystem::ofstream_ptr(), open_resource(), casadi::DaeBuilderInternal::pack_fmu(), casadi::FmuInternal::pack_fmu(), casadi::Filesystem::parent_path(), parent_path(), reduce_index_gen(), casadi::Filesystem::remove(), remove(), casadi::Filesystem::remove_all(), remove_all(), casadi::GlobalOptions::setCasadiIncludePath(), and casadi::GlobalOptions::setCasadiPath().

pathsep()

CASADI_EXPORT char casadi::pathsep

(

)

Definition at line 64 of file casadi_os.cpp.

               {
    #ifdef _WIN32
        return ';';
    #else
        return ':';
    #endif
}

Referenced by get_search_paths(), and casadi::ClangCompiler::init().

permutation_sign() [1/2]

static double casadi::permutation_sign ( const std::vector< casadi_int > &  p )

static

Definition at line 87 of file linsol_qr.cpp.

                                                                 {
    std::vector<bool> seen(p.size(), false);
    casadi_int ncycle = 0;
    for (casadi_int i=0; i<static_cast<casadi_int>(p.size()); ++i) {
      if (!seen[i]) {
        ncycle++;
        for (casadi_int j=i; !seen[j]; j=p[j]) seen[j] = true;
      }
    }
    return (static_cast<casadi_int>(p.size())-ncycle) % 2 ? -1 : 1;
  }

Referenced by casadi::SymbolicQr::det(), casadi::LinsolQr::finalize(), and qr_block_det().

permutation_sign() [2/2]

static double casadi::permutation_sign ( const std::vector< casadi_int > &  p )

static

Definition at line 48 of file symbolic_qr.cpp.

                                                                 {
    std::vector<bool> seen(p.size(), false);
    casadi_int ncycle = 0;
    for (casadi_int i=0; i<static_cast<casadi_int>(p.size()); ++i) {
      if (!seen[i]) {
        ncycle++;
        for (casadi_int j=i; !seen[j]; j=p[j]) seen[j] = true;
      }
    }
    return (static_cast<casadi_int>(p.size())-ncycle) % 2 ? -1.0 : 1.0;
  }

permute()

template<typename T >

std::vector< T > casadi::permute	(	const std::vector< T > &	a,
		const std::vector< casadi_int > &	order
	)

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

Definition at line 636 of file casadi_misc.hpp.

                                                                                  {
    casadi_assert_dev(order.size()==a.size());
    casadi_assert_dev(is_permutation(order));
    return vector_slice(a, order);
  }

References is_permutation(), and vector_slice().

pop_prefix()

CASADI_EXPORT std::string casadi::pop_prefix	(	const std::string &	s,
		std::string *	rem
	)

Definition at line 1496 of file fmu_function.cpp.

                                                         {
  // Get prefix
  casadi_assert_dev(!s.empty());
  size_t pos = s.find('_');
  casadi_assert(pos < s.size(), "Cannot process \"" + s + "\"");
  // Get prefix
  std::string r = s.substr(0, pos);
  // Remainder, if requested (note that rem == &s is possible)
  if (rem) *rem = s.substr(pos+1, std::string::npos);
  // Return prefix
  return r;
}

Referenced by casadi::InputStruct::parse(), and casadi::OutputStruct::parse().

prefix_graph_names()

static void casadi::prefix_graph_names ( onnx::GraphProto *  g, const std::string &  prefix  )

static

Definition at line 413 of file onnx_export.cpp.

                                                                             {
    std::set<std::string> defined;
    for (int i = 0; i < g->input_size(); ++i) defined.insert(g->input(i).name());
    for (int i = 0; i < g->initializer_size(); ++i) defined.insert(g->initializer(i).name());
    for (int n = 0; n < g->node_size(); ++n) {
      for (int j = 0; j < g->node(n).output_size(); ++j) defined.insert(g->node(n).output(j));
    }
    for (int n = 0; n < g->node_size(); ++n) {
      onnx::NodeProto* nd = g->mutable_node(n);
      for (int i = 0; i < nd->input_size(); ++i) {
        if (defined.count(nd->input(i))) nd->set_input(i, prefix + nd->input(i));
      }
      for (int i = 0; i < nd->output_size(); ++i) nd->set_output(i, prefix + nd->output(i));
    }
    for (int i = 0; i < g->input_size(); ++i) {
      g->mutable_input(i)->set_name(prefix + g->input(i).name());
    }
    for (int i = 0; i < g->output_size(); ++i) {
      g->mutable_output(i)->set_name(prefix + g->output(i).name());
    }
  }

print_vec()

void casadi::print_vec	(	const std::string &	str,
		const double *	v,
		casadi_int	n
	)

Definition at line 48 of file ipqp.cpp.

                                                                      {
    uout() << str << " =";
    for (casadi_int k = 0; k < n; ++k) uout() << " " << v[k];
    uout() << "\n";
  }

References str(), and uout().

printme()

double casadi::printme ( double  x, double  y  )

inline

CasADi additions

Examples

misc/printme.py.

Definition at line 279 of file calculus.hpp.

                                            {
    std::ios::fmtflags f(uout().flags());
    uout() << "|> " << y << " : ";
    uout() << std::setprecision(std::numeric_limits<double>::digits10 + 1) << std::scientific;
    uout() << x << std::endl;
    uout().flags(f);
    return x;
  }

References uout().

Referenced by casadi::BinaryOperation< OP_PRINTME >::fcn().

product()

template<typename T >

T casadi::product

(

const std::vector< T > &

values

)

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

Definition at line 934 of file casadi_misc.hpp.

                                        {
    T r = 1;
    for (casadi_int i=0;i<values.size();++i) r*=values[i];
    return r;
  }

References T.

Referenced by casadi_func_hess_prod(), casadi::Matrix< Scalar >::einstein(), casadi::MX::einstein(), einstein_process(), casadi::MX::interpn_linear(), and interpolant().

qpsol_nlp()

template<typename M >

Function casadi::qpsol_nlp	(	const std::string &	name,
		const std::string &	solver,
		const std::map< std::string, M > &	qp,
		const Dict &	opts
	)

Definition at line 111 of file conic.cpp.

                                                                       {
    // We have: minimize    f(x) = 1/2 * x' H x + c'x
    //          subject to  lbx <= x <= ubx
    //                      lbg <= g(x) = A x + b <= ubg
    //                      h(x) >=0 (psd)
 
    // Extract 'expand' option
    bool expand = false;
    Dict opt = opts;
    extract_from_dict_inplace(opt, "expand", expand);
    bool postpone_expand = false;
    extract_from_dict_inplace(opt, "postpone_expand", postpone_expand);
    bool error_on_fail = get_from_dict(opts, "error_on_fail", true);
 
    if (expand && !postpone_expand && M::type_name()=="MX") {
      Function f = Function("f", qp, {"x", "p"}, {"f", "g", "h"});
      std::vector<SX> arg = f.sx_in();
      std::vector<SX> res = f(arg);
      SXDict qp_mod;
      for (casadi_int i=0;i<f.n_in();++i) qp_mod[f.name_in(i)] = arg[i];
      for (casadi_int i=0;i<f.n_out();++i) qp_mod[f.name_out(i)] = res[i];
      return qpsol_nlp(name, solver, qp_mod, opt);
    }
 
    M x, p, f, g, h;
    for (auto&& i : qp) {
      if (i.first=="x") {
        x = i.second;
      } else if (i.first=="p") {
        p = i.second;
      } else if (i.first=="f") {
        f = i.second;
      } else if (i.first=="g") {
        g = i.second;
      } else if (i.first=="h") {
        h = i.second;
      } else {
        casadi_error("No such field: " + i.first);
      }
    }
 
    if (f.is_empty()) f = 0;
    if (g.is_empty()) g = M(0, 1);
 
    // Dimension checks
    casadi_assert(g.is_dense() && g.is_vector(),
      "Expected a dense vector 'g', but got " + g.dim() + ".");
 
    casadi_assert(f.is_dense() && f.is_scalar(),
      "Expected a dense scalar 'f', but got " + f.dim() + ".");
 
    casadi_assert(x.is_dense() && x.is_vector(),
      "Expected a dense vector 'x', but got " + x.dim() + ".");
 
    casadi_assert(h.is_square(),
      "Expected a symmetric matrix 'h', but got " + h.dim() + ".");
 
    if (g.is_empty(true)) g = M(0, 1); // workaround
 
    // Gradient of the objective: gf == Hx + g
    M gf = M::gradient(f, x);
 
    // Identify the linear term in the objective
    M c = substitute(gf, x, M::zeros(x.sparsity()));
 
    // Identify the quadratic term in the objective
    M H = M::jacobian(gf, x, {{"symmetric", true}});
 
    // Identify constant term in the objective
    Function r("constant_qp", {x, p}, {substitute(f, x, M::zeros(x.sparsity()))});
 
    // Identify the constant term in the constraints
    M b = substitute(g, x, M::zeros(x.sparsity()));
 
    // Identify the linear term in the constraints
    M A = M::jacobian(g, x);
 
    // Identify the constant term in the psd constraints
    M P = substitute(h, x, M::zeros(x.sparsity()));
 
    // Identify the linear term in the psd constraints
    M Q = M::jacobian(h, x);
 
    // Create a function for calculating the required matrices vectors
    Function prob(name + "_qp", {x, p}, {H, c, A, b, Q, P},
      {"x", "p"}, {"H", "c", "A", "b", "Q", "P"});
    if (expand && postpone_expand) prob = prob.expand();
 
    // Make sure that the problem is sound
    casadi_assert(!prob.has_free(), "Cannot create '" + prob.name() + "' "
                          "since " + str(prob.get_free()) + " are free.");
 
    // Create the QP solver
    Function conic_f = conic(name + "_qpsol", solver,
                             {{"h", H.sparsity()}, {"a", A.sparsity()},
                              {"p", P.sparsity()}, {"q", Q.sparsity()}}, opt);
 
    // Create an MXFunction with the right signature
    std::vector<MX> ret_in(NLPSOL_NUM_IN);
    ret_in[NLPSOL_X0] = MX::sym("x0", x.sparsity());
    ret_in[NLPSOL_P] = MX::sym("p", p.sparsity());
    ret_in[NLPSOL_LBX] = MX::sym("lbx", x.sparsity());
    ret_in[NLPSOL_UBX] = MX::sym("ubx", x.sparsity());
    ret_in[NLPSOL_LBG] = MX::sym("lbg", g.sparsity());
    ret_in[NLPSOL_UBG] = MX::sym("ubg", g.sparsity());
    ret_in[NLPSOL_LAM_X0] = MX::sym("lam_x0", x.sparsity());
    ret_in[NLPSOL_LAM_G0] = MX::sym("lam_g0", g.sparsity());
    std::vector<MX> ret_out(NLPSOL_NUM_OUT);
 
 
    std::vector<MX> v(NL_NUM_IN);
    v[NL_X] = ret_in[NLPSOL_X0];
    v[NL_P] = ret_in[NLPSOL_P];
    // Evaluate constant part of objective
    MX rv = r(v)[0];
    // Get expressions for the QP matrices and vectors
    v = prob(v);
 
    // Call the QP solver
    std::vector<MX> w(CONIC_NUM_IN);
    w[CONIC_H] = v.at(0);
    w[CONIC_G] = v.at(1);
    w[CONIC_A] = v.at(2);
    w[CONIC_Q] = v.at(4);
    w[CONIC_P] = v.at(5);
    w[CONIC_LBX] = ret_in[NLPSOL_LBX];
    w[CONIC_UBX] = ret_in[NLPSOL_UBX];
    w[CONIC_LBA] = ret_in[NLPSOL_LBG] - v.at(3);
    w[CONIC_UBA] = ret_in[NLPSOL_UBG] - v.at(3);
    w[CONIC_X0] = ret_in[NLPSOL_X0];
    w[CONIC_LAM_X0] = ret_in[NLPSOL_LAM_X0];
    w[CONIC_LAM_A0] = ret_in[NLPSOL_LAM_G0];
    w = conic_f(w);
 
    // Get expressions for the solution
    ret_out[NLPSOL_X] = reshape(w[CONIC_X], x.size());
    ret_out[NLPSOL_F] = rv + w[CONIC_COST];
    ret_out[NLPSOL_G] = reshape(mtimes(v.at(2), w[CONIC_X]), g.size()) + v.at(3);
    ret_out[NLPSOL_LAM_X] = reshape(w[CONIC_LAM_X], x.size());
    ret_out[NLPSOL_LAM_G] = reshape(w[CONIC_LAM_A], g.size());
    ret_out[NLPSOL_LAM_P] = MX::nan(p.sparsity());
 
    Dict fun_opts;
    fun_opts["default_in"] = nlpsol_default_in();
    fun_opts["error_on_fail"] = error_on_fail;
 
    return Function(name, ret_in, ret_out, nlpsol_in(), nlpsol_out(), fun_opts);
  }

References conic(), CONIC_A, CONIC_COST, CONIC_G, CONIC_H, CONIC_LAM_A, CONIC_LAM_A0, CONIC_LAM_X, CONIC_LAM_X0, CONIC_LBA, CONIC_LBX, CONIC_NUM_IN, CONIC_P, CONIC_Q, CONIC_UBA, CONIC_UBX, CONIC_X, CONIC_X0, casadi::Function::expand(), extract_from_dict_inplace(), get_from_dict(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::name_in(), casadi::Function::name_out(), casadi::MX::nan(), NL_NUM_IN, NL_P, NL_X, nlpsol_default_in(), NLPSOL_F, NLPSOL_G, nlpsol_in(), NLPSOL_LAM_G, NLPSOL_LAM_G0, NLPSOL_LAM_P, NLPSOL_LAM_X, NLPSOL_LAM_X0, NLPSOL_LBG, NLPSOL_LBX, NLPSOL_NUM_IN, NLPSOL_NUM_OUT, nlpsol_out(), NLPSOL_P, NLPSOL_UBG, NLPSOL_UBX, NLPSOL_X, NLPSOL_X0, P, Q, str(), casadi::Function::sx_in(), and casadi::GenericMatrix< MX >::sym().

Referenced by qpsol().

qr_block_det()

static SX casadi::qr_block_det ( const SX &  B, bool  amd  )

static

Definition at line 62 of file symbolic_qr.cpp.

                                                {
    if (B.is_scalar()) return B;
    SX V, R, beta;
    std::vector<casadi_int> prinv, pc;
    SX::qr_sparse(B, V, R, beta, prinv, pc, amd);
    SXElem d = casadi_det(V.sparsity(), get_ptr(V.nonzeros()),
                          R.sparsity(), get_ptr(R.nonzeros()), get_ptr(beta.nonzeros()));
    return permutation_sign(prinv) * permutation_sign(pc) * d;
  }

References get_ptr(), casadi::GenericMatrix< MatType >::is_scalar(), casadi::Matrix< Scalar >::nonzeros(), permutation_sign(), casadi::Matrix< Scalar >::qr_sparse(), and casadi::Matrix< Scalar >::sparsity().

Referenced by casadi::SymbolicQr::det().

range() [1/2]

CASADI_EXPORT std::vector< casadi_int > casadi::range	(	casadi_int	start,
		casadi_int	stop,
		casadi_int	step = 1,
		casadi_int	len = std::numeric_limits< casadi_int >::max()
	)

Parameters

start
stop
step
len	Consider a infinitely long list [start, start+step, start+2*step, ...] Elements larger than or equal to stop are chopped off.

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

Examples

misc/range.cc.

Definition at line 108 of file casadi_misc.cpp.

                                       {
    start = std::min(start, len);
    stop = std::min(stop, len);
    casadi_int nret = (stop-start)/step + ((stop-start)%step!=0);
    std::vector<casadi_int> ret(nret);
    casadi_int ind = start;
    for (std::vector<casadi_int>::iterator it=ret.begin(); it!=ret.end(); ++it) {
      *it = ind;
      ind += step;
    }
    return ret;
  }

Referenced by casadi::SparsityInternal::_erase(), casadi::Slice::all(), casadi::HpmpcInterface::blocksparsity(), casadi::HpipmInterface::blocksparsity(), casadi::FatropConicInterface::blocksparsity(), casadi::SparsityInterface< MatType >::blocksplit(), casadi::BSplineCommon::derivative_coeff(), derivative_coeff_mx(), casadi::SymbolicQr::det(), detect_simple_bounds_gen(), casadi::Sparsity::diag(), casadi::SparsityInterface< MatType >::diagsplit(), do_inline(), casadi::MX::enlarge(), casadi::MXFunction::export_code_body(), casadi::SparsityInternal::find(), casadi::Function::fold(), get_boor(), casadi::External::get_forward(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::External::get_reverse(), casadi::SparsityInterface< MatType >::horzsplit(), casadi::FmuFunction::init(), casadi::SnoptInterface::init(), casadi::SuperscsInterface::init(), casadi::LinsolLdl::init(), casadi::Sqpmethod::init(), casadi::Sparsity::ldl(), casadi::Function::map(), casadi::Function::mapaccum(), casadi::FunctionInternal::mapsum_mx(), casadi::MX::MX(), casadi::Sparsity::permutation(), casadi::Sparsity::qr_sparse(), range(), casadi::Conic::sdp_to_socp_init(), casadi::Convexify::setup(), casadi::SuperscsInterface::solve(), casadi::SparsityInternal::star_coloring(), and casadi::SparsityInterface< MatType >::vertsplit().

range() [2/2]

CASADI_EXPORT std::vector< casadi_int > casadi::range

(

casadi_int

stop

)

Parameters

stop

Returns

list [0, 1, 2...stop-1]

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

Definition at line 137 of file casadi_misc.cpp.

                                               {
    return range(0, stop);
  }

References range().

read_list()

template<typename T >

std::vector<T> casadi::read_list

(

const XmlNode &

n

)

Definition at line 3811 of file dae_builder_internal.cpp.

                                         {
  // Number of elements
  size_t sz = n.size();
  // Read the elements
  std::vector<T> r;
  r.reserve(sz);
  for (size_t i = 0; i < sz; ++i) {
    r.push_back(T(n[i]));
  }
  return r;
}

References casadi::XmlNode::size(), and T.

read_matlab() [1/2]

template<typename T >

void casadi::read_matlab	(	std::ifstream &	file,
		std::vector< std::vector< T > > &	v
	)

Definition at line 842 of file casadi_misc.hpp.

                                                                   {
    v.clear();
    std::string line;
    while (!getline(file, line, '\n').eof()) {
      std::istringstream reader(line);
      std::vector<T> lineData;
 
      while (!reader.eof()) {
        T val;
        reader >> val;
        if (reader.fail()) {
          reader.clear();
          std::string s;
          reader >> s;
          if (s=="inf")
            val = std::numeric_limits<T>::infinity();
          else
            break;
        }
        lineData.push_back(val);
      }
      v.push_back(lineData);
    }
  }

References T.

read_matlab() [2/2]

template<typename T >

void casadi::read_matlab	(	std::istream &	stream,
		std::vector< T > &	v
	)

Definition at line 822 of file casadi_misc.hpp.

                                                        {
    v.clear();
 
    while (!stream.eof()) {
      T val;
      stream >> val;
      if (stream.fail()) {
        stream.clear();
        std::string s;
        stream >> s;
        if (s=="inf")
          val = std::numeric_limits<T>::infinity();
        else
          break;
      }
      v.push_back(val);
    }
  }

References T.

reduce_index_gen()

template<class X >

const std::map<std::string, X> casadi::reduce_index_gen	(	const std::map< std::string, X > &	dae,
		Dict &	stats,
		const Dict &	opts
	)

Definition at line 807 of file integration_tools.cpp.

                                                                                 {
  double baumgarte_pole_ = 0;
  std::string algorithm = "pantelides";
  casadi_int max_iter = 500;
  // Option parsing
  for (auto&& op : opts) {
    if (op.first=="baumgarte_pole") {
      baumgarte_pole_ = op.second;
    } else if (op.first=="algorithm") {
      algorithm = op.second.to_string();
    } else if (op.first=="max_iter") {
      max_iter = op.second;
    } else {
      casadi_error("Unknown option '" + op.first + "'.");
    }
  }
 
  // Dae input sanitization
 
  for (const auto& e : dae) {
    casadi_assert(e.second.is_column() && e.second.is_dense(),
      "Dense column vector expected for key '" + e.first + "'. "
      "Got " + e.second.dim(true) + " instead.");
  }
 
  X x   = get_from_dict(dae, "x",   X(0, 1));
  X ode = get_from_dict(dae, "ode", X(0, 1));
  casadi_assert(x.numel()==ode.numel(),
    "Size of explicit differential state vector (x: " + str(x.numel()) + ") must "
    "match size of ode right-hand-side (ode: " + str(ode.numel()) + ").");
  casadi_assert(x.size1()==0, "Explicit differential states not supported yet.");
 
  X x_impl  = get_from_dict(dae, "x_impl",  X(0, 1));
  X dx_impl = get_from_dict(dae, "dx_impl", X(0, 1));
  casadi_assert(x_impl.numel()==dx_impl.numel(),
    "Size of implicit differential state vector (x_impl: " + str(x_impl.numel()) + ") must "
    "match size of implicit differential state derivative vector (dx_impl: "
    + str(dx_impl.numel()) + ").");
 
  X z   = get_from_dict(dae, "z",   X(0, 1));
  X alg = get_from_dict(dae, "alg", X(0, 1));
  casadi_assert(z.numel()+x_impl.numel()==alg.numel(),
    "Size of algebraic state vector (z: " + str(z.numel()) + ") + "
    "size of implicit states (x_impl: " + str(x_impl.numel()) + ") must "
    "match size of algebraic equations (alg: " + str(alg.numel()) + ").");
 
  X t = get_from_dict(dae, "t", X::sym("t"));
  casadi_assert(t.is_scalar(), "Time must be scalar. Got " + t.dim() + " instead.");
 
  X p = get_from_dict(dae, "p", X(0, 1));
 
  // Check that dx_impl are classified correctly
  std::vector<bool> dep = X::which_depends(alg, dx_impl);
 
  if (!all(dep)) {
    std::vector<X> dx_impl_split = vertsplit(dx_impl);
    std::vector<std::string> prob;
    for (casadi_int i=0;i<dep.size();++i) {
      if (!dep[i]) prob.push_back(dx_impl_split[i].name());
    }
    casadi_error("Found dx_impl variables that do not appear in alg: " + join(prob, ",") +
      ". They should be classified as z instead.");
  }
 
 
  bool normal_order = true;
 
  // Determine graph structure of problem for structural index reduction
  X V;
  if (normal_order) {
    V = vertcat(x_impl, dx_impl, z);
  } else {
    V = vertcat(x_impl, z, dx_impl);
  }
 
  Function temp("temp", {V, p, t}, {alg});
  Sparsity G = temp.jac_sparsity(0, 0);
 
  // Populate var_map: a list that associates variables with their derivatives
  int nx_impl = x_impl.numel();
  int nz = z.numel();
  std::vector<casadi_int> var_map(V.numel(), -1);
  for (casadi_int i=0;i<nx_impl;++i) {
    var_map[i] = i+nx_impl+(normal_order? 0: nz);
  }
 
  // Allocate space for eq_map: a list that associates equations with their derivatives
  std::vector<casadi_int> eq_map;
 
  // Modifies var_map and eq_map
  dae_struct_detect(algorithm, G, var_map, eq_map, max_iter);
 
  // Variables should not be removed
  casadi_assert_dev(var_map.size()>=2*nx_impl+nz);
 
  // List of scalarized variables
  std::vector<X> var_ext = vertsplit(V);
  // Allocate extra space for extension due to index reduction
  var_ext.resize(var_map.size());
 
  // Populate extra space
  for (casadi_int i=0;i<var_map.size();++i) {
    casadi_int i_der = var_map[i];
    // Derivate index is in the extra space?
    if (i_der>=V.numel())
      // Consstruct a new symbol with derived name
      var_ext[i_der] = X::sym("d"+var_ext[i].name());
  }
 
  // Prepare arguments for jtimes
  // In essence, this is like to the novel x_impl and dx_impl,
  // but a subset may be promoted to x (explicit diff. state)
  std::vector<X> xs; xs.reserve(var_map.size());
  std::vector<X> dxs; dxs.reserve(var_map.size());
 
  for (casadi_int i=0;i<var_map.size();++i) {
    casadi_int i_der = var_map[i];
    if (i_der>=0) {
      xs.push_back(var_ext[i]);
      dxs.push_back(var_ext[i_der]);
    }
  }
 
  // Stack to be used as jtimes arguments
  X x_cat = vertcat(xs);
  X dx_cat = vertcat(dxs);
 
  // Don't forget to differentiate time itself
  X j1 = vertcat(x_cat, t);
  X j2 = vertcat(dx_cat, 1);
 
  // List of scalarized equations
  std::vector<X> eq_ext = vertsplit(alg);
  // Allocate extra space for extension due to index reduction
  eq_ext.resize(eq_map.size());
 
  // For each equation, figure out how many times it was differentiated (=order)
  std::vector<casadi_int> order = get_orders(eq_map);
  casadi_int max_order = *std::max_element(order.begin(), order.end());
 
  // We lump together all relevant equations before doing differentiation in a target group,
  // in order to make use of shared subexpressions.
  // order -> all equations that give rise to an equation of this order
  std::map<casadi_int, std::vector<casadi_int> > targets;
  for (casadi_int i=0;i<eq_map.size();++i) {
    if (eq_map[i]>=0) {
      targets[order[eq_map[i]]].push_back(i);
    }
  }
 
  // Non-active equations will be dropped from the final set
  std::vector<bool> active(eq_map.size(), true);
 
  // Equations that get dropped, but should still hold for initial guess
  std::vector<X> dropped_constraints;
 
  // Loop over equation elements in increasing order
  for (casadi_int ord=1;ord<=max_order;++ord) {
    const std::vector<casadi_int> & target = targets[ord];
 
    // Remember to-be-dropped equations
    for (casadi_int i : target) dropped_constraints.push_back(eq_ext[i]);
 
    // Gather target's equations
    X block = vertcat(vector_slice(eq_ext, target));
    // Perform differentiation
    std::vector<X> dblocks = vertsplit(jtimes(block, j1, j2, false));
    // Scatter computed derivatives into target resultant equation slots
    for (casadi_int i=0;i<target.size();++i) {
      casadi_int t = target[i];
      eq_ext[eq_map[t]] = dblocks[i];
      active[t] = false;
    }
  }
 
  std::vector<casadi_int> eq_map_inverse = get_inverse(eq_map);
 
  // Construct the new list of algebraic equations
  // In theory, just collect all active members of eq_ext
  // In practice, we add some Baumgarte stabilization to avoid constraint drifting
  std::vector<X> alg_new;
  for (casadi_int i=0;i<eq_map.size();++i) {
    if (active[i]) {
 
      // Start from the pure equation
      X new_eq = eq_ext[i];
 
      // Construct coefficients of the polynomial (x-gamma)^order
      Polynomial p(1);
      for (casadi_int k=0;k<order[i];++k) {
        p *= Polynomial(1, -baumgarte_pole_);
      }
 
      const std::vector<double>& coeff = p.coeff();
 
      // Find indices of originating equations of equation i
      // e.g. if eq_i = der(eq_j), eq_j = der(eq_k), obtain [j,k]
      std::vector<casadi_int> gen_i = path(eq_map_inverse, i);
 
      // Add inner product of coefficients with originating equations of new_eq
      for (casadi_int k=0;k<gen_i.size();++k) {
        new_eq += coeff[k+1]*eq_ext[gen_i[k]];
      }
 
      // Ready to add
      alg_new.push_back(new_eq);
    }
  }
 
  std::vector<casadi_int> var_order = get_orders(var_map);
  std::vector<casadi_int> var_map_inverse = get_inverse(var_map);
 
 
  // Which implicit states become explicit pure integrators?
  std::vector<casadi_int> impl_to_expl;
  for (casadi_int i=0;i<var_map.size();++i) {
    if (var_order[i]>=2) {
      // Find indices of originating variables of variable i
      // e.g. if var_i = der(var_j), var_j = der(var_k), obtain [j,k]
      std::vector<casadi_int> gen_i = path(var_map_inverse, i);
 
      // Anything too deep should become explicit integrator
      if (gen_i.size()>1)
        impl_to_expl.insert(impl_to_expl.end(), gen_i.begin()+1, gen_i.end());
 
    }
  }
 
  // Take complement
  std::vector<casadi_int> impl_to_expl_compl = complement(impl_to_expl, xs.size());
  std::map<std::string, X> dae_result;
 
  dae_result["x"] = vertcat(vector_slice(xs, impl_to_expl));
  dae_result["ode"] = vertcat(vector_slice(dxs, impl_to_expl));
 
  dae_result["x_impl"] = vertcat(vector_slice(xs, impl_to_expl_compl));
  dae_result["dx_impl"] = vertcat(vector_slice(dxs, impl_to_expl_compl));
 
  dae_result["t"] = t;
  dae_result["p"] = p;
 
  // Which algebraic variables were not promoted to differential states?
  std::vector<X> z_orig = vertsplit(z);
  std::vector<X> z_new;
  for (casadi_int i=0;i<var_map.size();++i) {
    // Algebraic
    if (var_order[i]==0 && var_map[i]==-1) {
      z_new.push_back(z_orig.at(i-(normal_order?2:1)*nx_impl));
    }
  }
  dae_result["z"] = vertcat(z_new);
  dae_result["alg"] = vertcat(alg_new);
 
  dae_result["I"] = vertcat(dropped_constraints);
 
  stats["index"] = max_order+1;
 
  return dae_result;
}

References all(), casadi::Polynomial::coeff(), complement(), casadi::IndexReduction::dae_struct_detect(), get_from_dict(), get_inverse(), get_orders(), join(), casadi::Sparsity::numel(), path(), str(), vector_slice(), and X.

Referenced by dae_reduce_index().

register_symbol() [1/2]

MX casadi::register_symbol	(	const MX &	node,
		std::map< MXNode *, MX > &	symbol_map,
		std::vector< MX > &	symbol_v,
		std::vector< MX > &	parametric_v,
		bool	extract_trivial,
		casadi_int	v_offset,
		const std::string &	v_prefix,
		const std::string &	v_suffix
	)

Definition at line 2780 of file mx.cpp.

                                                                        {
    // Check if a symbol is already registered
    auto it = symbol_map.find(node.get());
 
    // Ignore trivial expressions if applicable
    bool is_trivial = node.is_symbolic();
    if (is_trivial && !extract_trivial) {
      return node;
    }
 
    if (it==symbol_map.end()) {
      // Create a symbol and register
      MX sym = MX::sym(v_prefix + str(symbol_map.size()+v_offset) + v_suffix, node.sparsity());
      symbol_map[node.get()] = sym;
 
      // Make the (symbol,parametric expression) pair available
      symbol_v.push_back(sym);
      parametric_v.push_back(node);
 
      // Use the new symbol
      return sym;
    } else {
      // Just use the registered symbol
      return it->second;
    }
  }

References casadi::MX::find(), casadi::MX::get(), casadi::MX::is_symbolic(), casadi::MX::sparsity(), str(), and casadi::GenericMatrix< MX >::sym().

Referenced by casadi::MX::extract_parametric().

register_symbol() [2/2]

SXElem casadi::register_symbol	(	const SXElem &	node,
		std::map< SXNode *, SXElem > &	symbol_map,
		std::vector< SXElem > &	symbol_v,
		std::vector< SXElem > &	parametric_v,
		bool	extract_trivial,
		casadi_int	v_offset,
		const std::string &	v_prefix,
		const std::string &	v_suffix
	)

Definition at line 630 of file sx_instantiator.cpp.

                                                                        {
 
    // Check if a symbol is already registered
    auto it = symbol_map.find(node.get());
 
    // Ignore trivial expressions if applicable
    bool is_trivial = node.is_symbolic();
    if (is_trivial && !extract_trivial) {
      return node;
    }
 
    if (it==symbol_map.end()) {
      // Create a symbol and register
      SXElem sym = SXElem::sym(v_prefix + str(symbol_map.size()+v_offset) + v_suffix);
      symbol_map[node.get()] = sym;
 
      // Make the (symbol,parametric expression) pair available
      symbol_v.push_back(sym);
      parametric_v.push_back(node);
 
      // Overwrite the argument
      return sym;
    } else {
      // Just use the registered symbol
      return it->second;
    }
  }

References casadi::MX::find(), casadi::SXElem::get(), casadi::SXElem::is_symbolic(), str(), and casadi::SXElem::sym().

remove()

bool casadi::remove

(

const std::string &

path

)

Definition at line 47 of file ghc.cpp.

                                       {
        return ghc::filesystem::remove(path);
    }

References path().

Referenced by casadi_register_filesystem_ghc(), casadi::AmplInterface::solve(), casadi::FunctionInternal::~FunctionInternal(), and casadi::ShellCompiler::~ShellCompiler().

remove_all()

casadi_int casadi::remove_all

(

const std::string &

path

)

Definition at line 51 of file ghc.cpp.

                                                 {
        return ghc::filesystem::remove_all(path);
    }

References path().

Referenced by casadi_register_filesystem_ghc().

replace()

CASADI_EXPORT std::string casadi::replace	(	const std::string &	s,
		const std::string &	p,
		const std::string &	r
	)

Definition at line 225 of file casadi_misc.cpp.

                                              {
    std::string ret = s;
    std::string::size_type n = 0;
    while ((n = ret.find(p, n)) != std::string::npos) {
      ret.replace(n, p.size(), r);
      n += r.size();
    }
    return ret;
  }

Referenced by casadi::CodeGenerator::constant(), casadi::MX::extract(), casadi::External::factory(), casadi::CodeGenerator::fmu_helpers(), casadi::Factory< MatType >::request_output(), and casadi::CodeGenerator::sanitize_source().

replace_mat()

template<typename M >

M casadi::replace_mat	(	const M &	arg,
		const Sparsity &	inp,
		casadi_int	npar
	)

Definition at line 1821 of file function_internal.hpp.

                                                                    {
    if (arg.size()==inp.size()) {
      // Matching dimensions already
      return arg;
    } else if (arg.is_scalar()) {
      // Scalar assign means set all
      return M(inp, arg);
    } else if (arg.is_vector() && inp.size()==std::make_pair(arg.size2(), arg.size1())) {
      // Transpose vector
      return arg.T();
    } else if (arg.size1()==inp.size1() && arg.size2()>0 && inp.size2()>0
               && inp.size2()%arg.size2()==0) {
      // Horizontal repmat
      return repmat(arg, 1, inp.size2()/arg.size2());
    } else if (npar!=-1 && arg.size1()==inp.size1() && arg.size2()>0 && inp.size2()>0
               && (npar*inp.size2())%arg.size2()==0) {
      // Multiple evaluation: grow argument horizontally to npar*inp columns
      return repmat(arg, 1, (npar*inp.size2())/arg.size2());
    } else {
      // Empty matrix means set zero (kept last so a 0-by-N argument is first given the
      // chance to be recognised as a parallel/repmat call above)
      casadi_assert_dev(arg.is_empty());
      return M(inp.size());
    }
  }

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

Referenced by casadi::FunctionInternal::mapsum_mx(), casadi::FunctionInternal::replace_arg(), and casadi::FunctionInternal::replace_res().

report_issue()

void casadi::report_issue	(	casadi_int	i,
		const std::string &	msg
	)

Definition at line 92 of file fatrop_interface.cpp.

                                                        {
    casadi_int idx = i+GlobalOptions::start_index;
    casadi_warning("Structure detection error on row " + str(idx) + ". " + msg);
  }

References casadi::GlobalOptions::start_index, and str().

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

return_code()

std::string casadi::return_code

(

casadi_int

status

)

Definition at line 233 of file fast_newton.cpp.

                                           {
    switch (status) {
      case 0:
        return "max_iteration_reached";
      case 1:
         return "converged_abstol";
       case 2:
         return "converged_abstol_step";
      default:
        return "unknown";
    }
  }

Referenced by casadi::FastNewton::get_stats().

return_secondary_status_string()

std::string casadi::return_secondary_status_string ( int  status )

inline

Definition at line 141 of file cbc_interface.cpp.

                                                              {
    switch (status) {
    case -1:
      return "unset";
    case 0:
      return "search completed with solution";
    case 1:
      return "linear relaxation not feasible (or worse than cutoff)";
    case 2:
      return "stopped on gap";
    case 3:
      return "stopped on nodes";
    case 4:
      return "stopped on time";
    case 5:
      return "stopped on user event";
    case 6:
      return "stopped on solutions";
    case CbcEventHandler::CbcEvent::node:
      return "node";
    case CbcEventHandler::CbcEvent::treeStatus:
      return "treeStatus";
    case CbcEventHandler::CbcEvent::solution:
      return "solution";
    case CbcEventHandler::CbcEvent::heuristicSolution:
      return "heuristicSolution";
    case CbcEventHandler::CbcEvent::beforeSolution1:
      return "beforeSolution1";
    case CbcEventHandler::CbcEvent::beforeSolution2:
      return "beforeSolution2";
    case CbcEventHandler::CbcEvent::afterHeuristic:
      return "afterHeuristic";
    case CbcEventHandler::CbcEvent::smallBranchAndBound:
      return "smallBranchAndBound";
    case CbcEventHandler::CbcEvent::heuristicPass:
      return "heuristicPass";
    case CbcEventHandler::CbcEvent::convertToCuts:
      return "convertToCuts";
    case CbcEventHandler::CbcEvent::endSearch:
      return "endSearch";
    default:
      return "unknown";
    }
  }

Referenced by casadi::CbcInterface::get_stats(), casadi::ClpInterface::get_stats(), casadi::CbcInterface::solve(), and casadi::ClpInterface::solve().

return_status_string() [1/4]

const char* casadi::return_status_string ( Bonmin::TMINLP::SolverReturn  status )

inline

Definition at line 325 of file bonmin_interface.cpp.

                                                                           {
    switch (status) {
    case Bonmin::TMINLP::MINLP_ERROR:
      return "MINLP_ERROR";
    case Bonmin::TMINLP::SUCCESS:
      return "SUCCESS";
    case Bonmin::TMINLP::INFEASIBLE:
      return "INFEASIBLE";
    case Bonmin::TMINLP::CONTINUOUS_UNBOUNDED:
      return "CONTINUOUS_UNBOUNDED";
    case Bonmin::TMINLP::LIMIT_EXCEEDED:
      return "LIMIT_EXCEEDED";
    case Bonmin::TMINLP::USER_INTERRUPT:
      return "USER_INTERRUPT";
    }
    return "Unknown";
  }

Referenced by casadi::BonminInterface::finalize_solution(), casadi::CbcInterface::get_stats(), casadi::ClpInterface::get_stats(), casadi::GurobiInterface::get_stats(), casadi::CbcInterface::solve(), casadi::ClpInterface::solve(), casadi::GurobiInterface::solve(), casadi::IpoptInterface::solve(), and casadi::UnoInterface::solve().

return_status_string() [2/4]

const char * casadi::return_status_string ( casadi_int  status )

inline

Definition at line 330 of file gurobi_interface.cpp.

                                                             {
    switch (status) {
    case GRB_LOADED:
      return "LOADED";
    case GRB_OPTIMAL:
      return "OPTIMAL";
    case GRB_INFEASIBLE:
      return "INFEASIBLE";
    case GRB_INF_OR_UNBD:
      return "INF_OR_UNBD";
    case GRB_UNBOUNDED:
      return "UNBOUNDED";
    case GRB_CUTOFF:
      return "CUTOFF";
    case GRB_ITERATION_LIMIT:
      return "ITERATION_LIMIT";
    case GRB_NODE_LIMIT:
      return "NODE_LIMIT";
    case GRB_TIME_LIMIT:
      return "TIME_LIMIT";
    case GRB_SOLUTION_LIMIT:
      return "SOLUTION_LIMIT";
    case GRB_INTERRUPTED:
      return "INTERRUPTED";
    case GRB_NUMERIC:
      return "NUMERIC";
    case GRB_SUBOPTIMAL:
      return "SUBOPTIMAL";
    case GRB_INPROGRESS:
      return "INPROGRESS";
    }
    return "Unknown";
  }

return_status_string() [3/4]

const char * casadi::return_status_string ( int  status )

inline

Definition at line 82 of file cbc_interface.cpp.

                                                    {
    switch (status) {
    case -1:
      return "before branchAndBound";
    case 0:
      return "finished";
    case 1:
      return "stopped - on maxnodes, maxsols, maxtime";
    case 2:
      return "difficulties so run was abandoned";
    case 5:
      return "stopped by event handler";
    default:
      return "unknown";
    }
  }

return_status_string() [4/4]

const char* casadi::return_status_string ( Ipopt::ApplicationReturnStatus  status )

inline

Definition at line 385 of file ipopt_interface.cpp.

                                                                               {
    switch (status) {
    case Solve_Succeeded:
      return "Solve_Succeeded";
    case Solved_To_Acceptable_Level:
      return "Solved_To_Acceptable_Level";
    case Infeasible_Problem_Detected:
      return "Infeasible_Problem_Detected";
    case Search_Direction_Becomes_Too_Small:
      return "Search_Direction_Becomes_Too_Small";
    case Diverging_Iterates:
      return "Diverging_Iterates";
    case User_Requested_Stop:
      return "User_Requested_Stop";
    case Maximum_Iterations_Exceeded:
      return "Maximum_Iterations_Exceeded";
    case Restoration_Failed:
      return "Restoration_Failed";
    case Error_In_Step_Computation:
      return "Error_In_Step_Computation";
    case Not_Enough_Degrees_Of_Freedom:
      return "Not_Enough_Degrees_Of_Freedom";
    case Invalid_Problem_Definition:
      return "Invalid_Problem_Definition";
    case Invalid_Option:
      return "Invalid_Option";
    case Invalid_Number_Detected:
      return "Invalid_Number_Detected";
    case Unrecoverable_Exception:
      return "Unrecoverable_Exception";
    case NonIpopt_Exception_Thrown:
      return "NonIpopt_Exception_Thrown";
    case Insufficient_Memory:
      return "Insufficient_Memory";
    case Internal_Error:
      return "Internal_Error";
    case Maximum_CpuTime_Exceeded:
      return "Maximum_CpuTime_Exceeded";
    case Feasible_Point_Found:
      return "Feasible_Point_Found";
#if (IPOPT_VERSION_MAJOR > 3) || (IPOPT_VERSION_MAJOR == 3 && IPOPT_VERSION_MINOR >= 14)
    case Maximum_WallTime_Exceeded:
      return "Maximum_WallTime_Exceeded";
#endif
    }
    return "Unknown";
  }

reverse()

template<typename T >

std::vector< T > casadi::reverse

(

const std::vector< T > &

v

)

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

Definition at line 614 of file casadi_misc.hpp.

                                              {
    std::vector<T> ret(v.size());
    std::reverse_copy(v.begin(), v.end(), ret.begin());
    return ret;
  }

Referenced by casadi::Factory< MatType >::calculate_adj(), and casadi::External::get_reverse().

scan_prefix_pow2()

static void casadi::scan_prefix_pow2 ( std::vector< std::string > &  offenders, const std::vector< casadi_int > &  ext, const std::string &  tag  )

static

Definition at line 61 of file blazing_spline.cpp.

                                                     {
    casadi_int p = 1;
    for (size_t i = 0; i < ext.size(); ++i) {
      p *= ext[i];
      if (i >= 1 && is_pow2_ge8(p)) {
        offenders.push_back("prefix product over dims 0.." + str(i)
                            + " = " + str(p) + tag);
      }
    }
  }

References is_pow2_ge8(), and str().

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

select_tensors()

static std::vector<OnnxTensorInfo> casadi::select_tensors ( const std::vector< OnnxTensorInfo > &  all, const std::vector< std::string > &  req  )

static

Definition at line 97 of file onnx_function.cpp.

                                                                                     {
    if (req.empty()) return all;
    std::vector<OnnxTensorInfo> sel;
    for (const std::string& name : req) {
      bool found = false;
      for (const OnnxTensorInfo& t : all)
        if (t.name == name) { sel.push_back(t); found = true; break; }
      casadi_assert(found, "ONNX tensor '" + name + "' not found in model");
    }
    return sel;
  }

References all().

Referenced by casadi::OnnxFunction::OnnxFunction().

sense_to_gurobi()

char casadi::sense_to_gurobi

(

const std::string &

sense

)

Definition at line 43 of file gurobi_interface.cpp.

                                               {
    if (sense == "<=") return GRB_LESS_EQUAL;
    if (sense == ">=") return GRB_GREATER_EQUAL;
    if (sense == "=") return GRB_EQUAL;
    return GRB_LESS_EQUAL; // default
  }

Referenced by casadi::GurobiInterface::handle_lazy_constraints_callback().

set_uno_option()

static void casadi::set_uno_option ( void *  solver, const std::string &  name, const GenericType &  value  )

static

Definition at line 158 of file uno_interface.cpp.

                                                                                            {
    if (value.is_bool()) {
      uno_set_solver_bool_option(solver, name.c_str(), value.to_bool());
    } else if (value.is_int()) {
      uno_set_solver_integer_option(solver, name.c_str(), static_cast<uno_int>(value.to_int()));
    } else if (value.is_double()) {
      uno_set_solver_double_option(solver, name.c_str(), value.to_double());
    } else if (value.is_string()) {
      uno_set_solver_string_option(solver, name.c_str(), value.to_string().c_str());
    } else {
      casadi_assert(false, "Unsupported UNO option type for " + name);
    }
  }

References casadi::GenericType::is_bool(), casadi::GenericType::is_double(), casadi::GenericType::is_int(), casadi::GenericType::is_string(), casadi::GenericType::to_bool(), casadi::GenericType::to_double(), casadi::GenericType::to_int(), and casadi::GenericType::to_string().

Referenced by insert_casadi_options().

shared_cast() [1/2]

template<class B , class S >

const B casadi::shared_cast

(

const S &

A

)

cf. dynamic_cast (const)

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

Definition at line 230 of file generic_shared.hpp.

                                  {
    S A_copy = A;
    return shared_cast<B, S>(A_copy);
  }

shared_cast() [2/2]

template<class B , class S >

B casadi::shared_cast

(

S &

A

)

cf. dynamic_cast

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

Get a pointer to the node

Create a return object

Quick return if not allowed

Assign node of B and return

Definition at line 208 of file generic_shared.hpp.

                      {
 
    typename S::internal_base_type* ptr = A.get();
 
    B ret;
 
    if (!B::test_cast(ptr)) return ret;
 
    ret.own(ptr);
    return ret;
  }

sign()

double casadi::sign ( double  x )

inline

Definition at line 270 of file calculus.hpp.

{ return x<0 ? -1 : x>0 ? 1 : x;}

Referenced by casadi::Norm1::ad_forward(), casadi::NormInf::ad_forward(), casadi::Norm1::ad_reverse(), casadi::NormInf::ad_reverse(), casadi::UnaryOperation< OP_FABS >::der(), casadi::FmuInternal::eval_fd(), casadi::UnaryOperation< OP_SIGN >::fcn(), casadi::Smoothing::pert(), and casadi::OoqpInterface::printBounds().

simpleIntegrator()

CASADI_EXPORT Function casadi::simpleIntegrator	(	Function	f,
		const std::string &	integrator = "cvodes",
		const Dict &	integrator_options = Dict()
	)

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

Definition at line 356 of file integration_tools.cpp.

                                                      {
  // Consistency check
  casadi_assert(f.n_in()==2, "Function must have two inputs: x and p");
  casadi_assert(f.n_out()==1, "Function must have one outputs: dot(x)");
 
  // Sparsities
  Sparsity x_sp = f.sparsity_in(0);
  Sparsity p_sp = f.sparsity_in(1);
 
  // Wrapper function inputs
  MX x = MX::sym("x", x_sp);
  MX u = MX::sym("u", vertcat(Sparsity::scalar(), vec(p_sp))); // augment p with t
 
  // Normalized xdot
  casadi_int u_offset[] = {0, 1, 1+p_sp.size1()};
  std::vector<MX> pp = vertsplit(u, std::vector<casadi_int>(u_offset, u_offset+3));
  MX h = pp[0];
  MX p = reshape(pp[1], p_sp.size());
  MX f_in[] = {x, p};
  MX xdot = f(std::vector<MX>(f_in, f_in+2)).at(0);
  xdot *= h;
 
  // Form DAE function
  MXDict dae = {{"x", x}, {"p", u}, {"ode", xdot}};
 
  // Create integrator function with normalized time from 0 to 1
  Function ifcn = integrator("integrator", plugin, dae, plugin_options);
 
  // Inputs of constructed function
  MX x0 = MX::sym("x0", x_sp);
  p = MX::sym("p", p_sp);
  h = MX::sym("h");
 
  // State at end
  MX xf = ifcn(MXDict{{"x0", x0}, {"p", vertcat(h, vec(p))}}).at("xf");
 
  // Form discrete-time dynamics
  return Function("F", {x0, p, h}, {xf}, {"x0", "p", "h"}, {"xf"});
}

References integrator(), casadi::Function::n_in(), casadi::Function::n_out(), casadi::Sparsity::scalar(), casadi::Sparsity::size(), casadi::Sparsity::size1(), casadi::Function::sparsity_in(), and casadi::GenericMatrix< MX >::sym().

simpleIRK()

CASADI_EXPORT Function casadi::simpleIRK	(	Function	f,
		casadi_int	N = 10,
		casadi_int	order = 4,
		const std::string &	scheme = "radau",
		const std::string &	solver = "newton",
		const Dict &	solver_options = Dict()
	)

The constructed function has three inputs, corresponding to initial state (x0), parameter (p) and integration time (h) and one output, corresponding to final state (xf).

Parameters

f	ODE function with two inputs (x and p) and one output (xdot)
N	Number of integrator steps
order	Order of interpolating polynomials
scheme	Collocation scheme, as excepted by collocationPoints function.
solver	Solver plugin
solver_options	Options to be passed to the solver plugin

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

Definition at line 289 of file integration_tools.cpp.

                                                  {
  // Consistency check
  casadi_assert(N>=1,
    "Parameter N (number of steps) must be at least 1, but got " + str(N) + ".");
  casadi_assert(f.n_in()==2, "Function must have two inputs: x and p");
  casadi_assert(f.n_out()==1, "Function must have one outputs: dot(x)");
 
  // Obtain collocation points
  std::vector<double> tau_root = collocation_points(order, scheme);
 
  // Retrieve collocation interpolating matrices
  std::vector < std::vector <double> > C;
  std::vector < double > D;
  collocation_interpolators(tau_root, C, D);
 
  // Inputs of constructed function
  MX x0 = MX::sym("x0", f.sparsity_in(0));
  MX p = MX::sym("p", f.sparsity_in(1));
  MX h = MX::sym("h");
 
  // Time step
  MX dt = h/N;
 
  // Implicitly defined variables
  MX v = MX::sym("v", repmat(x0.sparsity(), order));
  std::vector<MX> x = vertsplit(v, x0.size1());
  x.insert(x.begin(), x0);
 
  // Collect the equations that implicitly define v
  std::vector<MX> V_eq, f_in(2), f_out;
  for (casadi_int j=1; j<order+1; ++j) {
    // Expression for the state derivative at the collocation point
    MX xp_j = 0;
    for (casadi_int r=0; r<=order; ++r) xp_j+= C[j][r]*x[r];
 
    // Collocation equations
    f_in[0] = x[j];
    f_in[1] = p;
    f_out = f(f_in);
    V_eq.push_back(dt*f_out.at(0)-xp_j);
  }
 
  // Root-finding function
  Function rfp("rfp", {v, x0, p, h}, {vertcat(V_eq)});
 
  // Create a implicit function instance to solve the system of equations
  Function ifcn = rootfinder("ifcn", solver, rfp, solver_options);
 
  // Get state at end time
  MX xf = x0;
  for (casadi_int k=0; k<N; ++k) {
    std::vector<MX> ifcn_out = ifcn({repmat(xf, order), xf, p, h});
    x = vertsplit(ifcn_out[0], xf.size1());
 
    // State at end of step
    xf = D[0]*xf;
    for (casadi_int i=1; i<=order; ++i) {
      xf += D[i]*x[i-1];
    }
  }
 
  // Form discrete-time dynamics
  return Function("F", {x0, p, h}, {xf}, {"x0", "p", "h"}, {"xf"});
}

References C, collocation_interpolators(), collocation_points(), D, casadi::Function::n_in(), casadi::Function::n_out(), rootfinder(), casadi::GenericMatrix< MatType >::size1(), casadi::MX::sparsity(), casadi::Function::sparsity_in(), str(), and casadi::GenericMatrix< MX >::sym().

simpleRK()

CASADI_EXPORT Function casadi::simpleRK	(	Function	f,
		casadi_int	N = 10,
		casadi_int	order = 4
	)

The constructed function has three inputs, corresponding to initial state (x0), parameter (p) and integration time (h) and one output, corresponding to final state (xf).

Parameters

f	ODE function with two inputs (x and p) and one output (xdot)
N	Number of integrator steps
order	Order of interpolating polynomials

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

Definition at line 128 of file integration_tools.cpp.

                                                              {
  // Consistency check
  casadi_assert(N>=1,
    "Parameter N (number of steps) must be at least 1, but got " + str(N) + ".");
  casadi_assert(order==4, "Only RK order 4 is supported now.");
  casadi_assert(f.n_in()==2, "Function must have two inputs: x and p");
  casadi_assert(f.n_out()==1, "Function must have one outputs: dot(x)");
 
  MX x0 = MX::sym("x0", f.sparsity_in(0));
  MX p = MX::sym("p", f.sparsity_in(1));
  MX h = MX::sym("h");
 
  std::vector<double> b(order);
  b[0]=1.0/6;
  b[1]=1.0/3;
  b[2]=1.0/3;
  b[3]=1.0/6;
 
  std::vector<double> c(order);
  c[0]=0;
  c[1]=1.0/2;
  c[2]=1.0/2;
  c[3]=1;
 
  std::vector< std::vector<double> > A(order-1);
  A[0].resize(1);
  A[0][0]=1.0/2;
  A[1].resize(2);
  A[1][0]=0;A[1][1]=1.0/2;
  A[2].resize(3);
  A[2][0]=0;
  A[2][1]=0;A[2][2]=1;
 
  // Time step
  MX dt = h/N;
 
  std::vector<MX> k(order);
  std::vector<MX> f_arg(2);
 
  // Integrate
  MX xf = x0;
  for (casadi_int i=0; i<N; ++i) {
    for (casadi_int j=0; j<order; ++j) {
      MX xL = 0;
      for (casadi_int jj=0; jj<j; ++jj) {
        xL += k.at(jj)*A.at(j-1).at(jj);
      }
      f_arg[0] = xf+xL;
      f_arg[1] = p;
      k[j] = dt*f(f_arg).at(0);
    }
 
    for (casadi_int j=0; j<order; ++j) {
      xf += b.at(j)*k.at(j);
    }
  }
 
  // Form discrete-time dynamics
  return Function("F", {x0, p, h}, {xf}, {"x0", "p", "h"}, {"xf"});
}

References casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::sparsity_in(), str(), and casadi::GenericMatrix< MX >::sym().

simplify()

double casadi::simplify ( double  x )

inline

CasADi additions

Definition at line 277 of file calculus.hpp.

{ return x;}

Referenced by casadi::FixedStepIntegrator::create_advanced().

simplify_const_folding_order()

bool casadi::simplify_const_folding_order	(	std::vector< MX > &	arg,
		std::vector< MX > &	res,
		const Dict &	opts
	)

Definition at line 2261 of file mx.cpp.

                                                {
    Dict temp_opts = {{"live_variables", false},
                      {"max_io", 0},
                      {"cse", false},
                      {"allow_free", true}};
    Function f("temp", arg, res, temp_opts);
    MXFunction *ff = f.get<MXFunction>();
    const std::vector<casadi_int>& workloc_ = ff->workloc_;
    const auto& algorithm_ = ff->algorithm_;
 
    // Is the work vector entry numeric?
    std::vector<bool> is_numeric(workloc_.size()-1);
    // Symbolic work, non-differentiated
    std::vector<MX> swork(workloc_.size()-1);
 
    // Split up inputs analogous to symbolic primitives
    std::vector<std::vector<MX> > arg_split(arg.size());
    for (casadi_int i=0; i<arg.size(); ++i) arg_split[i] = arg[i].split_primitives(arg[i]);
 
    // Allocate storage for split outputs
    std::vector<std::vector<MX> > res_split(res.size());
    for (casadi_int i=0; i<res.size(); ++i) res_split[i].resize(res[i].n_primitives());
 
    std::vector<MX> arg1, res1;
 
    std::unordered_map<const MXNode*, bool> numeric_node;
    // Loop over computational nodes in forward order
    for (auto it=algorithm_.begin(); it!=algorithm_.end(); ++it) {
      if (it->op == OP_INPUT) {
        swork[it->res.front()] = project(arg_split.at(it->data->ind()).at(it->data->segment()),
                                          it->data.sparsity(), true);
        is_numeric[it->res.front()] = false;
      } else if (it->op==OP_OUTPUT) {
        // Collect the results
        res_split.at(it->data->ind()).at(it->data->segment()) = swork[it->arg.front()];
      } else if (it->op==OP_PARAMETER) {
        // Fetch parameter
        swork[it->res.front()] = it->data;
        is_numeric[it->res.front()] = false;
      } else {
        // Arguments of the operation
        arg1.resize(it->arg.size());
 
 
        bool numeric = true;
 
        for (casadi_int i=0; i<arg1.size(); ++i) {
          casadi_int el = it->arg[i];
          if (el<0) {
            arg1[i] = MX(it->data->dep(i).size());
          } else {
            arg1[i] = swork[el];
            numeric = numeric && is_numeric[el];
          }
        }
 
        numeric_node[it->data.get()] = numeric;
 
        // Perform the operation
        res1.resize(it->res.size());
 
        bool matched = false;
        // Rules to promote constant folding
        // A*(B*X)
        if (it->op == OP_MUL && is_numeric[it->arg[0]] &&
            !is_numeric[it->arg[1]] && arg1[1].is_op(OP_MUL)) {
          if (numeric_node[arg1[1].dep(0).get()]) {
            matched = true;
            res1[0] = (arg1[0]*arg1[1].dep(0))*arg1[1].dep(1);
          }
        }
 
        if (!matched) it->data->eval_mx(arg1, res1);
 
        for (casadi_int i=0; i<res1.size(); ++i) {
          casadi_int el = it->res[i]; // index of the output
          if (el>=0) {
            is_numeric[el] = numeric;
          }
        }
 
        // Get the result
        for (casadi_int i=0; i<res1.size(); ++i) {
          casadi_int el = it->res[i]; // index of the output
          if (el>=0) {
            swork[el] = res1[i];
          }
        }
      }
    }
 
    // Join split outputs
    for (casadi_int i=0; i<res.size(); ++i) res[i] = res[i].join_primitives(res_split[i]);
 
    return true;
  }

References casadi::MXFunction::algorithm_, casadi::Function::get(), OP_INPUT, OP_MUL, OP_OUTPUT, OP_PARAMETER, and casadi::MXFunction::workloc_.

Referenced by casadi::MX::simplify_const_folding().

slicot_mb03vd()

int casadi::slicot_mb03vd	(	int	n,
		int	p,
		int	ilo,
		int	ihi,
		double *	a,
		int	lda1,
		int	lda2,
		double *	tau,
		int	ldtau,
		double *	dwork
	)

Definition at line 51 of file slicot_layer.cpp.

                                                {
     f_int n_ = n;
     f_int p_ = p;
     f_int ilo_ = ilo;
     f_int ihi_ = ihi;
     f_int lda1_ = lda1;
     f_int lda2_ = lda2;
     f_int ldtau_ = ldtau;
     f_int ret_ = 0;
 
     mb03vd_(&n_, &p_, &ilo_, &ihi_, a, &lda1_, &lda2_, tau, &ldtau_, dwork, &ret_);
     return ret_;
  }

Referenced by slicot_periodic_schur().

slicot_mb03vy()

int casadi::slicot_mb03vy	(	int	n,
		int	p,
		int	ilo,
		int	ihi,
		double *	a,
		int	lda1,
		int	lda2,
		const double *	tau,
		int	ldtau,
		double *	dwork,
		int	ldwork
	)

Definition at line 66 of file slicot_layer.cpp.

                                                                                {
     f_int n_ = n;
     f_int p_ = p;
     f_int ilo_ = ilo;
     f_int ihi_ = ihi;
     f_int lda1_ = lda1;
     f_int lda2_ = lda2;
     f_int ldtau_ = ldtau;
     f_int ldwork_ = ldwork;
     f_int ret_=0;
     mb03vy_(&n_, &p_, &ilo_, &ihi_, a, &lda1_, &lda2_, tau, &ldtau_, dwork, &ldwork_, &ret_);
 
     return ret_;
 
  }

Referenced by slicot_periodic_schur().

slicot_mb03wd()

int casadi::slicot_mb03wd	(	char	job,
		char	compz,
		int	n,
		int	p,
		int	ilo,
		int	ihi,
		int	iloz,
		int	ihiz,
		double *	h,
		int	ldh1,
		int	ldh2,
		double *	z,
		int	ldz1,
		int	ldz2,
		double *	wr,
		double *	wi,
		double *	dwork,
		int	ldwork
	)

Definition at line 83 of file slicot_layer.cpp.

                                                             {
     f_int n_ = n;
     f_int p_ = p;
     f_int ilo_ = ilo;
     f_int ihi_ = ihi;
     f_int iloz_ = ilo;
     f_int ihiz_ = ihi;
     f_int ldh1_ = ldh1;
     f_int ldh2_ = ldh2;
     f_int ldz1_ = ldz1;
     f_int ldz2_ = ldz2;
     f_int ldwork_ = ldwork;
     f_int ret_ = 0;
     mb03wd_(&job, &compz, &n_, &p_, &ilo_, &ihi_, &iloz_, &ihiz_, h, &ldh1_, &ldh2_,
             z, &ldz1_, &ldz2_, wr, wi, dwork, &ldwork_, &ret_);
 
     return ret_;
  }

Referenced by slicot_periodic_schur().

slicot_mb05nd()

int casadi::slicot_mb05nd	(	int	n,
		double	delta,
		const double *	a,
		int	lda,
		double *	ex,
		int	ldex,
		double *	exint,
		int	ldexin,
		double	tol,
		int *	iwork,
		double *	dwork,
		int	ldwork
	)

Definition at line 105 of file slicot_layer.cpp.

                                                                         {
    f_int n_ = n;
    f_int lda_ = lda;
    f_int ldex_ = ldex;
    f_int ldexin_ = ldexin;
    f_int* iwork_ = reinterpret_cast<f_int*>(iwork);
    f_int ldwork_ = ldwork;
    f_int ret_ = 0;
    mb05nd_(&n_, &delta, a, &lda_, ex, &ldex_, exint, &ldexin_,
      &tol, iwork_, dwork, &ldwork_, &ret_);
 
    return ret_;
  }

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

slicot_periodic_schur()

void casadi::slicot_periodic_schur	(	casadi_int	n,
		casadi_int	K,
		const double *	a,
		double *	t,
		double *	z,
		double *	dwork,
		double *	eig_real,
		double *	eig_imag,
		double	num_zero
	)

Definition at line 409 of file slicot_dple.cpp.

                                                                {
    casadi_int mem_base = std::max(n+K-2, 4*n);
    casadi_int mem_needed = mem_base+(n-1)*K;
 
    // a is immutable, we need a mutable pointer, so we use available buffer
    std::copy(a, a+n*n*K, z);
 
    casadi_int ret;
 
    ret = slicot_mb03vd(n, K, 1, n, z, n, n, dwork+mem_base, n-1, dwork);
    casadi_assert(ret==0, "mb03vd return code " + str(ret));
    std::copy(z, z+n*n*K, t);
 
    ret = slicot_mb03vy(n, K, 1, n, z, n, n, dwork+mem_base, n-1, dwork, mem_needed);
    casadi_assert(ret==0, "mb03vy return code " + str(ret));
    // Set numerical zeros to zero
    if (num_zero>0) {
      for (casadi_int k = 0;k<n*n*K;++k) {
        double &r = t[k];
        if (fabs(r)<num_zero) r = 0.0;
      }
    }
 
    ret = slicot_mb03wd('S', 'V', n, K, 1, n, 1, n, t, n, n, z, n, n,
                  eig_real, eig_imag, dwork, mem_needed);
    casadi_assert(ret==0, "mb03wd return code " + str(ret));
  }

References slicot_mb03vd(), slicot_mb03vy(), slicot_mb03wd(), and str().

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

sort()

template<typename T >

void casadi::sort	(	const std::vector< T > &	values,
		std::vector< T > &	sorted_values,
		std::vector< casadi_int > &	indices,
		bool	invert_indices = false
	)

Parameters

[in]	values	the vector that needs sorting
[out]	sorted_values	the sorted vector
[out]	indices	The indices such that 'sorted_values= values[indices]'
[in]	invert_indices	Output indices such that 'sorted_values[indices=values'

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

Definition at line 906 of file casadi_misc.hpp.

                                                                 {
    // Call recursively if indices need to be inverted
    if (invert_indices) {
      std::vector<casadi_int> inverted;
      sort(values, sorted_values, inverted, false);
      indices.resize(inverted.size());
      for (size_t i=0; i<inverted.size(); ++i) {
        indices[inverted[i]] = i;
      }
      return;
    }
 
    // Create list of indices
    indices.resize(values.size());
    for (size_t i=0; i<indices.size(); ++i) indices[i] = i;
 
    // Sort this list by the values
    std::sort(indices.begin(), indices.end(), sortCompare<T>(values));
 
    // Sort the values accordingly
    sorted_values.resize(values.size());
    for (size_t i=0; i<values.size(); ++i) {
      sorted_values[i] = values[indices[i]];
    }
  }

Referenced by casadi::MX::extract(), casadi::SparsityInternal::get_nz(), and casadi::SparsityInternal::sub().

sq()

template<typename T >

T casadi::sq

(

const T &

x

)

Definition at line 337 of file calculus.hpp.

                   {
    return x*x;
  }

References T.

Referenced by common_simp_binary(), common_simp_unary(), casadi::UnaryOperation< OP_TAN >::der(), casadi::UnaryOperation< OP_SQ >::fcn(), and casadi::OoqpInterface::solve().

startswith()

CASADI_EXPORT bool casadi::startswith	(	const std::string &	s,
		const std::string &	p
	)

Definition at line 217 of file casadi_misc.cpp.

                                                          {
    if (p.size()>s.size()) return false;
    for (casadi_int i=0;i<p.size();++i) {
      if (s[i]!=p[i]) return false;
    }
    return true;
  }

Referenced by casadi::IpoptInterface::codegen_body(), and casadi::IpoptInterface::init_mem().

status_string()

static std::string casadi::status_string ( SLEQP_STATUS  status )

static

Definition at line 248 of file sleqp_interface.cpp.

  {
    switch (status) {
    case SLEQP_STATUS_RUNNING:
      return "running";
    case SLEQP_STATUS_OPTIMAL:
      return "optimal";
    case SLEQP_STATUS_INFEASIBLE:
      return "infeasible";
    case SLEQP_STATUS_UNBOUNDED:
      return "unbounded";
    case SLEQP_STATUS_ABORT_DEADPOINT:
      return "deadpoint";
    case SLEQP_STATUS_ABORT_ITER:
      return "iteration limit";
    case SLEQP_STATUS_ABORT_MANUAL:
      return "manual abort";
    case SLEQP_STATUS_ABORT_TIME:
      return "time limit";
    default:
      return "unknown";
    }
  }

Referenced by casadi::CplexInterface::get_stats(), casadi::SLEQPInterface::get_stats(), and casadi::CplexInterface::solve().

str() [1/8]

template<typename T , size_t N>

std::string casadi::str	(	const std::array< T, N > &	p,
		bool	more = false
	)

Definition at line 318 of file casadi_common.hpp.

                                                    {
    std::stringstream ss;
    ss << "[";
    for (casadi_int i=0; i<N; ++i) {
      if (i!=0) ss << ", ";
      ss << str(v[i]);
    }
    ss << "]";
    return ss.str();
  }

References str().

str() [2/8]

template<typename T2 >

std::string casadi::str	(	const std::map< std::string, T2 > &	p,
		bool	more = false
	)

Definition at line 305 of file casadi_common.hpp.

                                                           {
    std::stringstream ss;
    ss << "{";
    casadi_int count = 0;
    for (auto& e : p) {
      ss << "\"" << e.first << "\": " << str(e.second);
      if (++count < p.size()) ss << ", ";
    }
    ss << "}";
    return ss.str();
  }

References str().

str() [3/8]

template<typename T1 , typename T2 >

std::string casadi::str	(	const std::map< T1, T2 > &	p,
		bool	more = false
	)

Definition at line 292 of file casadi_common.hpp.

                                                    {
    std::stringstream ss;
    ss << "{";
    casadi_int count = 0;
    for (auto& e : p) {
      ss << str(e.first) << ": " << str(e.second);
      if (++count < p.size()) ss << ", ";
    }
    ss << "}";
    return ss.str();
  }

References str().

str() [4/8]

template<typename T1 , typename T2 >

std::string casadi::str	(	const std::pair< T1, T2 > &	p,
		bool	more = false
	)

Definition at line 285 of file casadi_common.hpp.

                                                     {
    std::stringstream ss;
    ss << "[" << str(p.first) << "," << str(p.second) << "]";
    return ss.str();
  }

References str().

str() [5/8]

template<typename T >

std::string casadi::str	(	const std::set< T > &	v,
		bool	more = false
	)

Definition at line 272 of file casadi_common.hpp.

                                               {
    std::stringstream ss;
    ss << "{";
    casadi_int cnt = 0;
    for (const auto& e : v) {
      if (cnt++!=0) ss << ", ";
      ss << str(e);
    }
    ss << "}";
    return ss.str();
  }

References str().

str() [6/8]

template<typename T >

std::string casadi::str	(	const std::vector< T > &	v,
		bool	more = false
	)

Definition at line 260 of file casadi_common.hpp.

                                                  {
    std::stringstream ss;
    ss << "[";
    for (casadi_int i=0; i<v.size(); ++i) {
      if (i!=0) ss << ", ";
      ss << str(v[i]);
    }
    ss << "]";
    return ss.str();
  }

References str().

str() [7/8]

template<typename T >

std::string casadi::str

(

const T &

v

)

Definition at line 248 of file casadi_common.hpp.

                            {
    std::stringstream ss;
    ss << v;
    return ss.str();
  }

Referenced by casadi::SparsityInternal::_appendColumns(), casadi::SparsityInternal::_appendVector(), casadi::SparsityInternal::_reshape(), _which_depends(), casadi::Function::activity(), casadi::MXFunction::ad_forward(), casadi::MXFunction::ad_reverse(), casadi::CodeGenerator::add_dependency(), casadi::Integrator::advance(), casadi::Slice::apply(), casadi::CodeGenerator::arg(), casadi::Function::assert_size_in(), casadi::Function::assert_size_out(), casadi::Function::assert_sparsity_out(), casadi::Integrator::augmented_dae(), casadi::CodeGenerator::axpy(), casadi::CodeGenerator::bound_consistency(), casadi::Function::bspline(), casadi::OnnxFunction::build_io_map(), casadi::CodeGenerator::cache_check(), casadi::Factory< MatType >::calculate(), casadi::Call::Call(), casadi_KN_puts(), casadi::FunctionInternal::check_arg(), casadi::Conic::check_inputs(), casadi::Nlpsol::check_inputs(), casadi::FunctionInternal::check_res(), check_sos(), casadi::CodeGenerator::clip_max(), casadi::CodeGenerator::clip_min(), casadi::BlazingSplineFunction::codegen_body(), casadi::FiniteDiff::codegen_body(), casadi::OmpMap::codegen_body(), casadi::ThreadMap::codegen_body(), casadi::MapSum::codegen_body(), casadi::MXFunction::codegen_body(), casadi::Switch::codegen_body(), casadi::SXFunction::codegen_body(), casadi::FatropInterface::codegen_body(), casadi::OsqpInterface::codegen_body(), casadi::XpressInterface::codegen_body(), casadi::FastNewton::codegen_body(), casadi::Feasiblesqpmethod::codegen_body(), casadi::Qrqp::codegen_body(), casadi::Sqpmethod::codegen_body(), casadi::Sqpmethod::codegen_calc_gamma_1(), casadi::MXFunction::codegen_declarations(), casadi::SXFunction::codegen_declarations(), casadi::Feasiblesqpmethod::codegen_feasibility_iterations(), casadi::MadmpecInterface::codegen_init_mem(), casadi::MadnlpInterface::codegen_init_mem(), casadi::OsqpInterface::codegen_init_mem(), casadi::FunctionInternal::codegen_meta(), casadi::FunctionInternal::codegen_name(), casadi::MadmpecInterface::codegen_options(), casadi::Nlpsol::codegen_post_solve(), casadi::Nlpsol::codegen_setup_per_call(), casadi::Sqpmethod::codegen_solve_elastic_mode(), casadi::Feasiblesqpmethod::codegen_tr_update(), codegen_unpack_block(), casadi::CodeGenerator::CodeGenerator(), casadi::Sparsity::colind(), collocation_pointsGen(), casadi::SparsityInternal::combineGen(), casadi::Conic::Conic(), casadi::CodeGenerator::constant(), casadi::CodeGenerator::constant_copy(), casadi::ConstantFile::ConstantFile(), casadi::BSplineInterpolant::construct_graph(), casadi::FunctionInternal::convert_arg(), casadi::FunctionInternal::convert_res(), casadi::CallSX::create(), casadi::BSplineParametric::create(), casadi::BSpline::create(), casadi::MapSum::create(), casadi::Map::create(), casadi::OracleFunction::create_function(), casadi::GenericSharedInternal< Shared, Internal >::debug_repr(), casadi::StringDeserializer::decode(), casadi::CodeGenerator::define_pool_double(), casadi::CodeGenerator::define_rom_double(), casadi::CodeGenerator::define_rom_integer(), casadi::OptiNode::describe(), casadi::MXNode::deserialize(), casadi::SXNode::deserialize(), casadi::Sparsity::diagsplit(), casadi::SparsityInternal::dim(), casadi::OutputNode::disp(), casadi::Dple::Dple(), dplesol(), casadi::CodeGenerator::dump(), casadi::StringSerializer::encode(), casadi::Fmu2::enter_initialization_mode(), casadi::Fmu3::enter_initialization_mode(), casadi::DaeBuilderInternal::eq(), casadi::FunctionInternal::eval(), casadi::Integrator::eval(), casadi::MXFunction::eval(), casadi::SXFunction::eval(), casadi::SlicotDple::eval(), casadi::SlicotExpm::eval(), casadi::FmuInternal::eval_fd(), casadi::FunctionInternal::eval_gen(), casadi::FunctionInternal::eval_mx(), casadi::MXFunction::export_code_body(), casadi::Function::factory(), casadi::External::factory(), casadi::Sparsity::file_format(), casadi::CodeGenerator::file_slurp(), casadi::SnoptInterface::formatSecondaryStatus(), casadi::SnoptInterface::formatStatus(), casadi::FunctionInternal::forward_name(), casadi::CodeGenerator::from_mex(), casadi::GenericType::from_type(), casadi::KinsolInterface::func(), casadi::FunctionInternal::fwd_seed(), casadi::OptiNode::g_describe(), casadi::Input::generate(), casadi::Output::generate(), casadi::HorzRepmat::generate(), casadi::Split::generate(), casadi::CodeGenerator::generate(), casadi::CodeGenerator::generate_dump(), casadi::LinsolQr::generate_factorize(), casadi::Function::generate_in(), casadi::Function::generate_out(), casadi::CodeGenerator::generate_print(), casadi::Matrix< Scalar >::get(), casadi::MX::get(), casadi::Fmu2::get_aux_impl(), casadi::Fmu3::get_aux_impl(), casadi::MXNode::get_dot(), casadi::Integrator::get_forward(), casadi::MapSum::get_forward(), casadi::Integrator::get_forward_dae(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm(), casadi::MXNode::get_mac(), casadi::FunctionInternal::get_name_in(), casadi::FunctionInternal::get_name_out(), casadi::SparsityInternal::get_nz(), casadi::MX::get_nz(), casadi::FunctionInternal::get_partition(), casadi::Integrator::get_reverse(), casadi::MapSum::get_reverse(), casadi::MX::graph_substitute(), casadi::Matrix< Scalar >::has_duplicates(), casadi::External::has_forward(), casadi::External::has_reverse(), casadi::MX::horzcat(), casadi::Sparsity::horzsplit(), casadi::SparsityInterface< MatType >::horzsplit_n(), casadi::DaeBuilderInternal::import_binding_equations(), casadi::DaeBuilderInternal::import_dynamic_equations(), casadi::DaeBuilderInternal::import_initial_equations(), casadi::FunctionInternal::index_in(), casadi::FunctionInternal::index_out(), casadi::BlazingSplineFunction::init(), casadi::Conic::init(), casadi::FiniteDiff::init(), casadi::FmuFunction::init(), casadi::FunctionInternal::init(), casadi::Integrator::init(), casadi::MXFunction::init(), casadi::Nlpsol::init(), casadi::Rootfinder::init(), casadi::SXFunction::init(), casadi::XFunction< DerivedType, MatType, NodeType >::init(), casadi::AmplInterface::init(), casadi::Blocksqp::init(), casadi::MadmpecInterface::init(), casadi::FatropConicInterface::init(), casadi::FatropInterface::init(), casadi::HpipmInterface::init(), casadi::HpmpcInterface::init(), casadi::IpoptInterface::init(), casadi::ProxqpInterface::init(), casadi::SLEQPInterface::init(), casadi::IdasInterface::init(), casadi::WorhpInterface::init(), init_gen(), casadi::CplexInterface::init_mem(), casadi::GurobiInterface::init_mem(), casadi::UnoInterface::init_mem(), casadi::WorhpInterface::init_mem(), casadi::XpressInterface::init_mem(), integrator(), casadi::GenericMatrix< MatType >::interp1d(), casadi::MX::interpn_linear(), interpolant(), is_slice(), casadi::XFunction< DerivedType, MatType, NodeType >::jac(), casadi::FunctionInternal::jacobian(), casadi::CodeGenerator::ldl_solve(), casadi::Low::Low(), casadi::CodeGenerator::low(), casadi::CodeGenerator::lsqr_solve(), casadi::FunctionInternal::map(), casadi::Function::map(), casadi::Integrator::map2oracle(), casadi::Function::mapaccum(), casadi::CodeGenerator::masked_norm_inf(), casadi::CodeGenerator::max_viol(), casadi::CodeGenerator::mmax(), casadi::CodeGenerator::mmin(), casadi::CodeGenerator::mtimes(), casadi::CodeGenerator::mtimes_dense_sparse(), casadi::CodeGenerator::mv(), casadi::CsparseInterface::nfact(), casadi::Ma27Interface::nfact(), casadi::LapackLu::nfact(), casadi::LapackQr::nfact(), casadi::NlImporter::NlImporter(), nlpsol(), casadi::CodeGenerator::norm_1(), casadi::CodeGenerator::norm_2(), casadi::CodeGenerator::norm_inf(), casadi::FunctionInternal::nz_in(), casadi::FunctionInternal::nz_out(), onnx_dtype_name(), operator<<(), casadi::DaeBuilderInternal::outputs(), casadi::OptiNode::parameter(), casadi::CodeGenerator::pool_double(), casadi::Sparsity::postfix_dim(), casadi::Integrator::predict_events(), casadi::MXFunction::print(), casadi::OutputSX::print(), casadi::MXFunction::print_arg(), casadi::SXFunction::print_arg(), casadi::MXNode::print_compact(), casadi::MXFunction::print_res(), casadi::SXFunction::print_res(), print_vec(), casadi::Matrix< double >::print_vector(), casadi::CodeGenerator::printf(), casadi::Function::proceed_to(), casadi::Call::projectArg(), qpsol_nlp(), casadi::CodeGenerator::qr_solve(), casadi::XmlNode::read(), casadi::DaeBuilderInternal::read_expr(), reduce_index_gen(), register_symbol(), casadi::PluginInterface< Derived >::registerPlugin(), casadi::Scpgen::regularize(), casadi::DaeBuilderInternal::reorder(), report_issue(), casadi::CodeGenerator::res(), casadi::CodeGenerator::reserve_work(), casadi::FunctionInternal::reverse_name(), casadi::CodeGenerator::rom_double(), casadi::CodeGenerator::rom_integer(), rootfinder(), casadi::Sparsity::row(), casadi::CodeGenerator::sanitize_source(), casadi::CodeGenerator::scal(), scan_prefix_pow2(), casadi::Matrix< Scalar >::set(), casadi::MX::set(), casadi::FunctionBuffer::set_arg(), casadi::DaeBuilderInternal::set_attribute(), casadi::Matrix< Scalar >::set_nz(), casadi::MX::set_nz(), casadi::FunctionBuffer::set_res(), casadi::Fmu2::set_values(), casadi::Fmu3::set_values(), casadi::MosekInterface::set_work(), casadi::XpressInterface::set_work(), casadi::DeserializingStream::setup(), casadi::Convexify::setup(), casadi::FunctionInternal::signature_unrolled(), simpleIRK(), simpleRK(), casadi::Slice::Slice(), slicot_periodic_schur(), casadi::CbcInterface::solve(), casadi::GurobiInterface::solve(), casadi::OoqpInterface::solve(), casadi::AlpaqaInterface::solve(), casadi::KnitroInterface::solve(), casadi::WorhpInterface::solve(), casadi::Newton::solve(), casadi::LapackQr::solve_batch(), casadi::Sqpmethod::solve_elastic_mode(), casadi::CodeGenerator::sparsity(), casadi::MX::sparsity_cast(), casadi::SparsityInternal::star_coloring_new(), casadi::MX::stop_diff(), str(), strvec(), casadi::SparsityInternal::sub(), casadi::MX::substitute_inplace(), casadi::CodeGenerator::sum_viol(), casadi::CodeGenerator::sx_work(), casadi::DaeBuilderInternal::tearing_variables(), casadi::OptiNode::to_function(), transform_stats(), transform_token_str(), casadi::DaeBuilderInternal::transition(), casadi::Integrator::trigger_event(), casadi::CodeGenerator::trilsolve(), casadi::Sparsity::triplet(), casadi::CodeGenerator::triusolve(), casadi::SerializerBase::type_to_string(), casadi::DaeBuilderInternal::unique_name(), casadi::SnoptInterface::userfun(), casadi::OptiNode::variable(), casadi::CodeGenerator::vector_fmax(), casadi::CodeGenerator::vector_fmin(), vector_slice(), casadi::DeserializingStream::version(), casadi::MX::vertcat(), casadi::SparsityInterface< MatType >::vertsplit_n(), casadi::CodeGenerator::vfmax(), casadi::CodeGenerator::vfmin(), casadi::DaeBuilderInternal::when(), casadi::CodeGenerator::wrapper(), and casadi::OptiNode::x_describe().

str() [8/8]

template<typename T >

std::string casadi::str	(	const T &	v,
		bool	more
	)

Definition at line 255 of file casadi_common.hpp.

                                       {
    return v.get_str(more);
  }

str_bvec()

CASADI_EXPORT std::string casadi::str_bvec

(

bvec_t

v

)

Definition at line 444 of file casadi_misc.cpp.

                               {
    std::stringstream ss;
    for (casadi_int i=0;i<sizeof(bvec_t)*8;++i) {
      bool bit = v & (bvec_t(1) << i);
      ss << (bit ? "1" : "0");
    }
    return ss.str();
  }

strategy_to_string()

std::string casadi::strategy_to_string

(

casadi_convexify_strategy_t

s

)

Definition at line 30 of file convexify.cpp.

                                                              {
    switch (s) {
      case CVX_REGULARIZE: return "regularize";
      case CVX_EIGEN_REFLECT: return "eigen-reflect";
      case CVX_EIGEN_CLIP: return "eigen-clip";
    }
    return "unknown";
  }

Referenced by casadi::Convexify::eval_mx().

strvec() [1/7]

std::vector<std::string> casadi::strvec ( )

inline

Definition at line 192 of file casadi_common.hpp.

                                       {
    return {};
  }

strvec() [2/7]

template<typename T1 >

std::vector<std::string> casadi::strvec ( const T1 &  t1 )

inline

Definition at line 198 of file casadi_common.hpp.

                                                   {
    return {str(t1)};
  }

References str().

strvec() [3/7]

template<typename T1 , typename T2 >

std::vector<std::string> casadi::strvec ( const T1 &  t1, const T2 &  t2  )

inline

Definition at line 204 of file casadi_common.hpp.

                                                                 {
    return {str(t1), str(t2)};
  }

References str().

strvec() [4/7]

template<typename T1 , typename T2 , typename T3 >

std::vector<std::string> casadi::strvec ( const T1 &  t1, const T2 &  t2, const T3 &  t3  )

inline

Definition at line 210 of file casadi_common.hpp.

                                                                               {
    return {str(t1), str(t2), str(t3)};
  }

References str().

strvec() [5/7]

template<typename T1 , typename T2 , typename T3 , typename T4 >

std::vector<std::string> casadi::strvec ( const T1 &  t1, const T2 &  t2, const T3 &  t3, const T4 &  t4  )

inline

Definition at line 216 of file casadi_common.hpp.

                                                       {
    return {str(t1), str(t2), str(t3), str(t4)};
  }

References str().

strvec() [6/7]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

std::vector<std::string> casadi::strvec ( const T1 &  t1, const T2 &  t2, const T3 &  t3, const T4 &  t4, const T5 &  t5  )

inline

Definition at line 223 of file casadi_common.hpp.

                                                                     {
    return {str(t1), str(t2), str(t3), str(t4), str(t5)};
  }

References str().

strvec() [7/7]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >

std::vector<std::string> casadi::strvec ( const T1 &  t1, const T2 &  t2, const T3 &  t3, const T4 &  t4, const T5 &  t5, const T6 &  t6  )

inline

Definition at line 230 of file casadi_common.hpp.

                                                                                   {
    return {str(t1), str(t2), str(t3), str(t4), str(t5), str(t6)};
  }

References str().

sum()

template<typename T >

T casadi::sum

(

const std::vector< T > &

values

)

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

Definition at line 941 of file casadi_misc.hpp.

                                    {
    T r = 0;
    for (casadi_int i=0;i<values.size();++i) r+=values[i];
    return r;
  }

References T.

Referenced by casadi::FatropInterface::init(), and casadi::GenericMatrix< MatType >::repsum().

temporary_file()

CASADI_EXPORT std::string casadi::temporary_file	(	const std::string &	prefix,
		const std::string &	suffix,
		const std::string &	directory
	)

Definition at line 354 of file casadi_misc.cpp.

                                  {
 
    std::string temp_dir = Filesystem::ensure_trailing_slash(directory);
    if (temp_dir.empty()) temp_dir = GlobalOptions::getTempWorkDir();
 
    if (Filesystem::is_enabled()) {
      casadi_assert(Filesystem::ensure_directory_exists(temp_dir),
        "Unable to create the required directory for '" + temp_dir + "'.");
    }
 
    #ifdef HAVE_MKSTEMPS
    // Preferred solution
    std::string ret = temp_dir + prefix + "XXXXXX" + suffix;
    if (mkstemps(&ret[0], static_cast<int>(suffix.size())) == -1) {
      casadi_error("Failed to create temporary file: '" + ret + "'. "
      + (Filesystem::is_enabled() ? "" : "Does the directory exits? "
      "Note that CasADi needs to be compiled with WITH_GHC_FILESYSTEM=ON "
      "for directories to be automatically created."));
    }
    return ret;
    #else // HAVE_MKSTEMPS
    #ifdef HAVE_SIMPLE_MKSTEMPS
    return simple_mkstemps(temp_dir + prefix, suffix);
    #else // HAVE_SIMPLE_MKSTEMPS
    casadi_assert(temp_dir=="./", "tmpnam fallback not compatible with custom temporary directory");
    // Fallback, may result in deprecation warnings
    return std::string(tmpnam(nullptr)) + suffix;
    #endif // HAVE_SIMPLE_MKSTEMPS
    #endif // HAVE_MKSTEMPS
  }

References casadi::Filesystem::ensure_directory_exists(), casadi::Filesystem::ensure_trailing_slash(), casadi::GlobalOptions::getTempWorkDir(), and casadi::Filesystem::is_enabled().

Referenced by casadi::FunctionInternal::finalize(), casadi::Scpgen::init(), casadi::ShellCompiler::init(), casadi::TemporaryDirResource::setup_temp_dir(), and casadi::AmplInterface::solve().

text2set()

template<typename T >

std::set<T> casadi::text2set

(

const std::string &

text

)

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

Definition at line 62 of file importer.hpp.

                                              {
      std::vector<T> v = text2vector<T>(text);
      std::set<T> ret;
      for (auto&& i : v) ret.insert(i);
      return ret;
    }

text2type()

template<typename T >

T casadi::text2type

(

const std::string &

text

)

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

Definition at line 39 of file importer.hpp.

                                       {
      std::istringstream ss(text);
      T ret;
      ss >> ret;
      return ret;
    }

References T.

text2vector()

template<typename T >

std::vector<T> casadi::text2vector

(

const std::string &

text

)

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

Definition at line 50 of file importer.hpp.

                                                    {
      std::istringstream ss(text);
      T tmp;
      std::vector<T> ret;
      while (ss >> tmp) ret.push_back(tmp);
      return ret;
    }

References T.

ThreadsWork()

void casadi::ThreadsWork	(	const Function &	f,
		casadi_int	i,
		const double **	arg,
		double **	res,
		casadi_int *	iw,
		double *	w,
		casadi_int	ind,
		int &	ret
	)

Definition at line 450 of file map.cpp.

                                {
 
    // Function dimensions
    casadi_int n_in = f.n_in();
    casadi_int n_out = f.n_out();
 
    // Function work sizes
    size_t sz_arg, sz_res, sz_iw, sz_w;
    f.sz_work(sz_arg, sz_res, sz_iw, sz_w);
 
    // Input buffers
    const double** arg1 = arg + n_in + i*sz_arg;
    for (casadi_int j=0; j<n_in; ++j) {
      arg1[j] = arg[j] ? arg[j] + i*f.nnz_in(j) : nullptr;
    }
 
    // Output buffers
    double** res1 = res + n_out + i*sz_res;
    for (casadi_int j=0; j<n_out; ++j) {
      res1[j] = res[j] ? res[j] + i*f.nnz_out(j) : nullptr;
    }
 
    try {
      ret = f(arg1, res1, iw + i*sz_iw, w + i*sz_w, ind);
    } catch (std::exception& e) {
      ret = 1;
      casadi_warning("Exception raised: " + std::string(e.what()));
    } catch (...) {
      ret = 1;
      casadi_warning("Uncaught exception.");
    }
  }

References casadi::Function::n_in(), casadi::Function::n_out(), casadi::Function::nnz_in(), casadi::Function::nnz_out(), and casadi::Function::sz_work().

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

to_enum()

template<typename T >

T casadi::to_enum	(	const std::string &	s,
		const std::string &	s_def = ""
	)

Definition at line 58 of file casadi_enum.hpp.

                                                           {
  // Default value, if empty string
  if (s.empty() && !s_def.empty()) return to_enum<T>(s_def);
  // Linear search over permitted values
  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i) {
    if (s == to_string(static_cast<T>(i))) return static_cast<T>(i);
  }
  // Informative error message
  std::stringstream ss;
  ss << "No such enum: '" << s << "'. Permitted values: ";
  for (size_t i = 0; i < enum_traits<T>::n_enum; ++i) {
    // Separate strings
    if (i > 0) ss << ", ";
    // Print enum name
    ss << "'" << to_string(static_cast<T>(i)) << "'";
  }
  casadi_error(ss.str());
  return static_cast<T>(enum_traits<T>::n_enum);  // never reached
}

References T, and to_string().

to_fmi2()

CASADI_EXPORT TypeFmi2 casadi::to_fmi2

(

Type

v

)

Version mappings

Definition at line 75 of file dae_builder_internal.cpp.

                         {
  switch (v) {
  case Type::FLOAT64: return TypeFmi2::REAL;
  case Type::INT32: return TypeFmi2::INTEGER;
  case Type::BOOLEAN: return TypeFmi2::BOOLEAN;
  case Type::STRING: return TypeFmi2::STRING;
  case Type::ENUMERATION: return TypeFmi2::ENUM;
  case Type::FLOAT32:  // fall-through
  case Type::INT8:  // fall-through
  case Type::UINT8:  // fall-through
  case Type::INT16:  // fall-through
  case Type::UINT16:  // fall-through
  case Type::UINT32:  // fall-through
  case Type::INT64:  // fall-through
  case Type::UINT64:  // fall-through
  case Type::BINARY:  // fall-through
  case Type::CLOCK:  // fall-through
    casadi_error(to_string(v) + " cannot be converted to FMI 2");
  default: break;
  }
  return TypeFmi2::NUMEL;
}

References BINARY, BOOLEAN, CLOCK, ENUM, ENUMERATION, FLOAT32, FLOAT64, INT16, INT32, INT64, INT8, INTEGER, NUMEL, REAL, STRING, to_string(), UINT16, UINT32, UINT64, and UINT8.

Referenced by casadi::Fmu2::init(), casadi::Fmu3::init(), and casadi::DaeBuilder::type().

to_int() [1/3]

CASADI_EXPORT int casadi::to_int

(

casadi_int

rhs

)

Definition at line 60 of file casadi_misc.cpp.

                             {
    casadi_assert(rhs<=std::numeric_limits<int>::max(), "Integer overflow detected.");
    casadi_assert(rhs>=std::numeric_limits<int>::min(), "Integer overflow detected.");
    return rhs;
  }

Referenced by casadi::BonminInterface::init(), casadi::CbcInterface::init(), casadi::GurobiInterface::init(), casadi::GenericType::operator casadi_int(), casadi::GenericType::operator int(), casadi::GenericType::operator std::vector< int >(), casadi::ClpInterface::solve(), to_int(), and casadi::GenericType::to_int_type_vector().

to_int() [2/3]

CASADI_EXPORT std::vector< int > casadi::to_int

(

const std::vector< casadi_int > &

rhs

)

Definition at line 66 of file casadi_misc.cpp.

                                                          {
    std::vector<int> ret;
    ret.reserve(rhs.size());
    for (casadi_int e : rhs) ret.push_back(to_int(e));
    return ret;
  }

References to_int().

to_int() [3/3]

CASADI_EXPORT std::vector< std::vector< int > > casadi::to_int

(

const std::vector< std::vector< casadi_int > > &

rhs

)

Definition at line 73 of file casadi_misc.cpp.

                                                     {
    std::vector< std::vector<int> > ret;
    ret.reserve(rhs.size());
    for (const std::vector<casadi_int>& e : rhs) ret.push_back(to_int(e));
    return ret;
  }

References to_int().

to_slice() [1/2]

Slice CASADI_EXPORT casadi::to_slice	(	const IM &	x,
		bool	ind1 = false
	)

Definition at line 34 of file im_instantiator.cpp.

                                                       {
    return x.is_scalar() ? Slice(x.scalar(), ind1) : to_slice(x.nonzeros(), ind1);
  }

References casadi::GenericMatrix< MatType >::is_scalar(), casadi::Matrix< Scalar >::nonzeros(), and casadi::Matrix< Scalar >::scalar().

Referenced by casadi::Matrix< double >::__nonzero__(), casadi::SetNonzeros< Add >::create(), casadi::GetNonzeros::create(), casadi::Matrix< double >::cumsum(), casadi::Matrix< Scalar >::get(), casadi::Matrix< Scalar >::set(), casadi::Matrix< Scalar >::set_nz(), and to_slice2().

to_slice() [2/2]

Slice CASADI_EXPORT casadi::to_slice	(	const std::vector< casadi_int > &	v,
		bool	ind1
	)

Definition at line 152 of file slice.cpp.

                                                                          {
    Slice r;
    casadi_assert(is_slice(v, ind1), "Cannot be represented as a Slice");
    if (v.empty()) {
      r.start=r.stop=0;
      r.step = 1;
    } else if (v.size()==1) {
      r.start = v.front()-ind1;
      r.stop = r.start + 1;
      r.step = 1;
    } else {
      r.start = v[0]-ind1;
      r.step = v[1]-v[0];
      r.stop = r.start + r.step*v.size();
    }
    return r;
  }

References is_slice(), casadi::Slice::start, casadi::Slice::step, and casadi::Slice::stop.

to_slice2()

std::pair< Slice, Slice > CASADI_EXPORT casadi::to_slice2

(

const std::vector< casadi_int > &

v

)

Definition at line 254 of file slice.cpp.

                                                                                {
    casadi_assert(is_slice2(v), "Cannot be represented as a nested Slice");
    Slice inner, outer;
 
    // If simple slice
    if (is_slice(v)) {
      inner = to_slice(v);
      outer.start = 0;
      outer.step = outer.stop = inner.stop;
      return std::make_pair(inner, outer);
    }
 
    // Get the slices
    outer.start = 0;
    outer.step = -1;
    inner.start = v.front();
    inner.step = v[1]-v[0];
    inner.stop = -1;
    for (casadi_int i=2; i<v.size(); ++i) {
      casadi_int predicted_v = inner.start+i*inner.step;
      if (v[i]!=predicted_v) {
        inner.stop = predicted_v;
        outer.step = v[i] - inner.start;
        break;
      }
    }
 
    // Get the end of the outer slice
    // Calculate based on actual number of groups in the data
    casadi_int inner_size = (inner.stop - inner.start) / inner.step;
    casadi_int num_groups = v.size() / inner_size;
    outer.stop = outer.start + num_groups * outer.step;
    return std::make_pair(inner, outer);
  }

References is_slice(), is_slice2(), casadi::Slice::start, casadi::Slice::step, casadi::Slice::stop, and to_slice().

Referenced by casadi::SetNonzeros< Add >::create(), and casadi::GetNonzeros::create().

to_str() [1/2]

std::string casadi::to_str ( const CoinError &  e )

inline

Definition at line 343 of file bonmin_interface.cpp.

                                              {
    std::stringstream ss;
    if (e.lineNumber()<0) {
      ss << e.message()<< " in "<< e.className()<< "::" << e.methodName();
    } else {
      ss << e.fileName() << ":" << e.lineNumber() << " method " << e.methodName()
         << " : assertion \'" << e.message() <<"\' failed.";
      if (!e.className().empty())
        ss <<"Possible reason: "<< e.className();
    }
    return ss.str();
  }

Referenced by casadi::BonminInterface::solve().

to_str() [2/2]

std::string casadi::to_str ( TNLPSolver::UnsolvedError &  e )

inline

Definition at line 356 of file bonmin_interface.cpp.

                                                      {
    std::stringstream ss;
    e.printError(ss);
    return ss.str();
  }

to_string() [1/15]

CASADI_EXPORT std::string casadi::to_string

(

Attribute

v

)

Convert to string

Definition at line 168 of file dae_builder_internal.cpp.

                                               {
  switch (v) {
  case Attribute::MIN: return "min";
  case Attribute::MAX: return "max";
  case Attribute::NOMINAL: return "nominal";
  case Attribute::START: return "start";
  case Attribute::VALUE: return "value";
  case Attribute::STRINGVALUE: return "stringvalue";
  default: break;
  }
  return "";
}

References MAX, MIN, NOMINAL, START, STRINGVALUE, and VALUE.

to_string() [2/15]

CASADI_EXPORT std::string casadi::to_string

(

Category

v

)

Convert to string

Definition at line 193 of file dae_builder_internal.cpp.

                                {
  switch (v) {
  case Category::T: return "t";
  case Category::P: return "p";
  case Category::U: return "u";
  case Category::X: return "x";
  case Category::Z: return "z";
  case Category::Q: return "q";
  case Category::C: return "c";
  case Category::D: return "d";
  case Category::W: return "w";
  case Category::CALCULATED: return "calculated";
  case Category::ODE: return "ode";
  case Category::ALG: return "alg";
  case Category::QUAD: return "quad";
  case Category::ZERO: return "zero";
  case Category::DDEF: return "ddef";
  case Category::WDEF: return "wdef";
  case Category::Y: return "y";
  default: break;
  }
  return "";
}

References ALG, C, CALCULATED, D, DDEF, ODE, P, Q, QUAD, T, U, W, WDEF, X, Y, Z, and ZERO.

to_string() [3/15]

CASADI_EXPORT std::string casadi::to_string

(

Causality

v

)

Convert to string

Definition at line 132 of file dae_builder_internal.cpp.

                                 {
  switch (v) {
  case Causality::PARAMETER: return "parameter";
  case Causality::CALCULATED_PARAMETER: return "calculatedParameter";
  case Causality::INPUT: return "input";
  case Causality::OUTPUT: return "output";
  case Causality::LOCAL: return "local";
  case Causality::INDEPENDENT: return "independent";
  default: break;
  }
  return "";
}

References CALCULATED_PARAMETER, INDEPENDENT, INPUT, LOCAL, OUTPUT, and PARAMETER.

to_string() [4/15]

CASADI_EXPORT std::string casadi::to_string

(

DependenciesKind

v

)

Convert to string

Definition at line 181 of file dae_builder_internal.cpp.

                                                      {
  switch (v) {
  case DependenciesKind::DEPENDENT: return "dependent";
  case DependenciesKind::CONSTANT: return "constant";
  case DependenciesKind::FIXED: return "fixed";
  case DependenciesKind::TUNABLE: return "tunable";
  case DependenciesKind::DISCRETE: return "discrete";
  default: break;
  }
  return "";
}

References CONSTANT, DEPENDENT, DISCRETE, FIXED, and TUNABLE.

to_string() [5/15]

CASADI_EXPORT std::string casadi::to_string

(

DynIn

v

)

Convert to string

Definition at line 31 of file integrator.cpp.

                             {
  switch (v) {
  case DYN_T: return "t";
  case DYN_X: return "x";
  case DYN_Z: return "z";
  case DYN_P: return "p";
  case DYN_U: return "u";
  default: break;
  }
  return "";
}

References DYN_P, DYN_T, DYN_U, DYN_X, and DYN_Z.

to_string() [6/15]

CASADI_EXPORT std::string casadi::to_string

(

DynOut

v

)

Convert to string

Definition at line 43 of file integrator.cpp.

                              {
  switch (v) {
  case DYN_ODE: return "ode";
  case DYN_ALG: return "alg";
  case DYN_QUAD: return "quad";
  case DYN_ZERO: return "zero";
  default: break;
  }
  return "";
}

References DYN_ALG, DYN_ODE, DYN_QUAD, and DYN_ZERO.

to_string() [7/15]

CASADI_EXPORT std::string casadi::to_string

(

EventIn

v

)

Convert to string

Definition at line 54 of file integrator.cpp.

                               {
  switch (v) {
  case EVENT_INDEX: return "index";
  case EVENT_T: return "t";
  case EVENT_X: return "x";
  case EVENT_Z: return "z";
  case EVENT_P: return "p";
  case EVENT_U: return "u";
  default: break;
  }
  return "";
}

References EVENT_INDEX, EVENT_P, EVENT_T, EVENT_U, EVENT_X, and EVENT_Z.

to_string() [8/15]

CASADI_EXPORT std::string casadi::to_string

(

EventOut

v

)

Convert to string

Definition at line 67 of file integrator.cpp.

                                {
  switch (v) {
  case EVENT_POST_X: return "post_x";
  case EVENT_POST_Z: return "post_z";
  default: break;
  }
  return "";
}

References EVENT_POST_X, and EVENT_POST_Z.

to_string() [9/15]

CASADI_EXPORT std::string casadi::to_string

(

FdMode

v

)

Definition at line 30 of file finite_differences.cpp.

                              {
  switch (v) {
  case FdMode::FORWARD: return "forward";
  case FdMode::BACKWARD: return "backward";
  case FdMode::CENTRAL: return "central";
  case FdMode::SMOOTHING: return "smoothing";
  default: break;
  }
  return "";
}

References BACKWARD, CENTRAL, FORWARD, and SMOOTHING.

to_string() [10/15]

CASADI_EXPORT std::string casadi::to_string

(

FmuApi

v

)

Definition at line 656 of file fmu.cpp.

                              {
  switch (v) {
  case FmuApi::FMI2: return "fmi2";
  case FmuApi::FMI3: return "fmi3";
  default: break;
  }
  return "";
}

References FMI2, and FMI3.

to_string() [11/15]

CASADI_EXPORT std::string casadi::to_string

(

Initial

v

)

Convert to string

Definition at line 157 of file dae_builder_internal.cpp.

                               {
  switch (v) {
  case Initial::EXACT: return "exact";
  case Initial::APPROX: return "approx";
  case Initial::CALCULATED: return "calculated";
  case Initial::NA: return "na";
  default: break;
  }
  return "";
}

References APPROX, CALCULATED, EXACT, and NA.

to_string() [12/15]

CASADI_EXPORT std::string casadi::to_string

(

Parallelization

v

)

Definition at line 1482 of file fmu_function.cpp.

                                       {
  switch (v) {
  case Parallelization::SERIAL: return "serial";
  case Parallelization::OPENMP: return "openmp";
  case Parallelization::THREAD: return "thread";
  default: break;
  }
  return "";
}

References OPENMP, SERIAL, and THREAD.

to_string() [13/15]

CASADI_EXPORT std::string casadi::to_string

(

Type

v

)

Convert to string

Definition at line 110 of file dae_builder_internal.cpp.

                            {
  switch (v) {
  case Type::FLOAT32: return "Float32";
  case Type::FLOAT64: return "Float64";
  case Type::INT8: return "Int8";
  case Type::UINT8: return "UInt8";
  case Type::INT16: return "Int16";
  case Type::UINT16: return "UInt16";
  case Type::INT32: return "Int32";
  case Type::UINT32: return "UInt32";
  case Type::INT64: return "Int64";
  case Type::UINT64: return "UInt64";
  case Type::BOOLEAN: return "Boolean";
  case Type::STRING: return "String";
  case Type::BINARY: return "Binary";
  case Type::ENUMERATION: return "Enumeration";
  case Type::CLOCK: return "Clock";
  default: break;
  }
  return "";
}

References BINARY, BOOLEAN, CLOCK, ENUMERATION, FLOAT32, FLOAT64, INT16, INT32, INT64, INT8, STRING, UINT16, UINT32, UINT64, and UINT8.

to_string() [14/15]

CASADI_EXPORT std::string casadi::to_string

(

TypeFmi2

v

)

Convert to string

Definition at line 98 of file dae_builder_internal.cpp.

                                {
  switch (v) {
  case TypeFmi2::REAL: return "real";
  case TypeFmi2::INTEGER: return "integer";
  case TypeFmi2::BOOLEAN: return "boolean";
  case TypeFmi2::STRING: return "string";
  case TypeFmi2::ENUM: return "enum";
  default: break;
  }
  return "";
}

References BOOLEAN, ENUM, INTEGER, REAL, and STRING.

Referenced by casadi::DaeBuilderInternal::add(), casadi::Variable::categories(), casadi::DaeBuilder::categories(), casadi::DaeBuilder::category(), casadi::DaeBuilder::causality(), dependent_definition(), casadi::DaeBuilderInternal::disp(), dyn_in(), dyn_out(), casadi::DaeBuilderInternal::eliminate(), enum_names(), casadi::FmuFunction::eval_all(), casadi::FmuInternal::eval_fd(), casadi::Variable::export_xml(), casadi::FmuFunction::factory(), finite_diff(), casadi::Fmu::Fmu(), casadi::DaeBuilderInternal::gather_eq(), casadi::Variable::get_attribute(), casadi::FmuFunction::get_forward(), casadi::FmuFunction::get_jacobian(), casadi::FmuFunction::get_reverse(), has_enum(), casadi::DaeBuilderInternal::import_model_variables(), casadi::Fmu2::init(), casadi::Fmu3::init(), casadi::FmuFunction::init(), casadi::DaeBuilder::initial(), input_category(), casadi::DaeBuilderInternal::inputs(), casadi::GenericType::operator std::string(), casadi::DaeBuilderInternal::oracle(), casadi::DaeBuilderInternal::prune(), casadi::DaeBuilderInternal::read_identifier(), casadi::DaeBuilderInternal::reorder(), casadi::DaeBuilderInternal::set_attribute(), casadi::Variable::set_attribute(), casadi::DaeBuilderInternal::set_category(), casadi::DaeBuilderInternal::set_causality(), casadi::DaeBuilderInternal::set_variability(), casadi::DaeBuilderInternal::sort(), to_enum(), to_fmi2(), casadi::DaeBuilder::type(), casadi::DaeBuilderInternal::update_dependencies(), and casadi::DaeBuilder::variability().

to_string() [15/15]

CASADI_EXPORT std::string casadi::to_string

(

Variability

v

)

Convert to string

Definition at line 145 of file dae_builder_internal.cpp.

                                   {
  switch (v) {
  case Variability::CONSTANT: return "constant";
  case Variability::FIXED: return "fixed";
  case Variability::TUNABLE: return "tunable";
  case Variability::DISCRETE: return "discrete";
  case Variability::CONTINUOUS: return "continuous";
  default: break;
  }
  return "";
}

References CONSTANT, CONTINUOUS, DISCRETE, FIXED, and TUNABLE.

transform_passes_str()

std::string casadi::transform_passes_str

(

const std::vector< std::vector< GenericType > > &

ps

)

Definition at line 338 of file function.cpp.

                                                                               {
    std::string s = "[";
    for (size_t i=0; i<ps.size(); ++i) {
      if (i) s += ", ";
      s += "[";
      for (size_t j=0; j<ps[i].size(); ++j) {
        if (j) s += ", ";
        s += transform_token_str(ps[i][j]);
      }
      s += "]";
    }
    return s + "]";
  }

References transform_token_str().

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

transform_stats()

std::string casadi::transform_stats

(

const Function &

f

)

Definition at line 352 of file function.cpp.

                                               {
    std::string s;
    try { s += "n_nodes=" + str(f.n_nodes()); } catch (...) { s += "n_nodes=?"; }
    try { s += ", n_instructions=" + str(f.n_instructions()); } catch (...) {}
    return s;
  }

References casadi::Function::n_instructions(), casadi::Function::n_nodes(), and str().

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

transform_token_str()

std::string casadi::transform_token_str

(

const GenericType &

g

)

Definition at line 331 of file function.cpp.

                                                      {
    if (g.is_int()) return str(g.to_int());
    if (g.is_string()) return "\"" + g.to_string() + "\"";
    if (g.is_dict()) return str(g.to_dict());
    return "?";
  }

References casadi::GenericType::is_dict(), casadi::GenericType::is_int(), casadi::GenericType::is_string(), str(), casadi::GenericType::to_dict(), casadi::GenericType::to_int(), and casadi::GenericType::to_string().

Referenced by transform_passes_str().

trim_empty()

std::vector<MX> casadi::trim_empty	(	const std::vector< MX > &	x,
		bool	both = false
	)

Definition at line 1111 of file mx.cpp.

                                                                    {
    std::vector<MX> ret;
    for (auto&& i : x) {
      if (!i.is_empty(both)) ret.push_back(i);
    }
    return ret;
  }

Referenced by casadi::MX::diagcat(), casadi::MX::horzcat(), and casadi::MX::vertcat().

trim_path()

std::string casadi::trim_path ( const std::string &  full_path )

inline

Definition at line 107 of file exception.hpp.

                                                       {
  size_t found = full_path.rfind("/casadi/");
  if (found == std::string::npos) {
    return full_path;
  } else {
    std::string ret = full_path;
    ret.replace(0, found, "...");
    return ret;
  }
}

twice()

template<typename T >

T casadi::twice

(

const T &

x

)

Definition at line 332 of file calculus.hpp.

                      {
    return x+x;
  }

References T.

Referenced by casadi::UnaryOperation< OP_SQRT >::der(), and casadi::UnaryOperation< OP_SQ >::der().

uerr()

CASADI_EXPORT std::ostream & casadi::uerr

(

)

Definition at line 70 of file casadi_logger.cpp.

                     {
    // Thread-local stream: each thread gets its own instance
    // ThreadLocalStorage avoids MinGW thread_local destructor ordering bug
    static thread_local ThreadLocalStorage<Logger::Stream<true>> instance;
    return instance.get();
  }

References casadi::ThreadLocalStorage< T >::get().

Referenced by add_file_to_zip(), casadi::KinsolInterface::bjac_wrapper(), calc_function(), casadi::KnitroInterface::callback(), callback_stderr(), casadi_func_cons_jac(), casadi_func_cons_val(), casadi_func_hess_prod(), casadi_func_obj_grad(), casadi_func_obj_val(), casadi::KinsolInterface::djac_wrapper(), casadi::IdasInterface::ehfun(), casadi::KinsolInterface::ehfun(), casadi::CvodesInterface::ehfun(), extract_zip_internal(), casadi::BonminInterface::finalize_solution(), casadi::IpoptInterface::finalize_solution(), casadi::KinsolInterface::func_wrapper(), casadi::BonminInterface::get_bounds_info(), casadi::IpoptInterface::get_bounds_info(), casadi::BonminInterface::get_list_of_nonlinear_variables(), casadi::IpoptInterface::get_list_of_nonlinear_variables(), casadi::BonminInterface::get_nlp_info(), casadi::IpoptInterface::get_nlp_info(), casadi::BonminInterface::get_number_of_nonlinear_variables(), casadi::IpoptInterface::get_number_of_nonlinear_variables(), casadi::BonminInterface::get_starting_point(), casadi::IpoptInterface::get_starting_point(), casadi::ClangCompiler::init(), casadi::BonminInterface::intermediate_callback(), casadi::IpoptInterface::intermediate_callback(), casadi::KinsolInterface::jtimes_wrapper(), casadi::IdasInterface::jtimesB(), casadi::CvodesInterface::jtimesB(), casadi::IdasInterface::jtimesF(), casadi::CvodesInterface::jtimesF(), casadi::PluginInterface< Derived >::load_plugin(), casadi::KinsolInterface::lsetup(), casadi::CvodesInterface::lsetupB(), casadi::IdasInterface::lsetupB(), casadi::CvodesInterface::lsetupF(), casadi::KinsolInterface::lsolve(), casadi::CvodesInterface::lsolveB(), casadi::IdasInterface::lsolveB(), casadi::CvodesInterface::lsolveF(), casadi::IdasInterface::lsolveF(), casadi::Function::operator()(), casadi::KinsolInterface::psetup_wrapper(), casadi::CvodesInterface::psetupB(), casadi::IdasInterface::psetupB(), casadi::CvodesInterface::psetupF(), casadi::IdasInterface::psetupF(), casadi::KinsolInterface::psolve_wrapper(), casadi::CvodesInterface::psolveB(), casadi::IdasInterface::psolveB(), casadi::CvodesInterface::psolveF(), casadi::IdasInterface::psolveF(), casadi::IdasInterface::resB(), casadi::IdasInterface::resF(), casadi::CvodesInterface::rhsB(), casadi::CvodesInterface::rhsF(), casadi::CvodesInterface::rhsQB(), casadi::IdasInterface::rhsQB(), casadi::CvodesInterface::rhsQF(), casadi::IdasInterface::rhsQF(), casadi::SnoptInterface::userfun(), worhp_disp(), zip_entries_to_path(), zip_to_path(), zip_to_path2(), zip_to_stream(), and casadi::CplexMemory::~CplexMemory().

unpack_block()

void casadi::unpack_block	(	const std::vector< casadi_int > &	p,
		std::vector< casadi_ocp_block > &	blocks
	)

Definition at line 824 of file fatrop_interface.cpp.

                                                                                         {
    const casadi_int* packed = get_ptr(p);
    casadi_int N = *packed++;
    blocks.resize(N);
    for (casadi_int i=0;i<N;++i) {
        blocks[i].offset_r = *packed++;
        blocks[i].offset_c = *packed++;
        blocks[i].rows = *packed++;
        blocks[i].cols = *packed++;
    }
  }

References get_ptr().

Referenced by casadi::FatropInterface::FatropInterface().

unpack_tensors()

static void casadi::unpack_tensors ( DeserializingStream &  s, const std::string &  d, std::vector< OnnxTensorInfo > &  v  )

static

Definition at line 159 of file onnx_function.cpp.

                                                           {
    std::vector<std::string> names;
    std::vector<std::vector<casadi_int>> shapes;
    std::vector<casadi_int> elem_types, numels;
    s.unpack(d + "::names", names);
    s.unpack(d + "::shapes", shapes);
    s.unpack(d + "::elem_types", elem_types);
    s.unpack(d + "::numels", numels);
    v.clear();
    for (size_t k = 0; k < names.size(); ++k)
      v.push_back(OnnxTensorInfo{names[k], shapes[k], elem_types[k], numels[k]});
  }

References casadi::DeserializingStream::unpack().

Referenced by casadi::OnnxFunction::OnnxFunction().

uout()

CASADI_EXPORT std::ostream & casadi::uout

(

)

Definition at line 61 of file casadi_logger.cpp.

                     {
    // Thread-local stream: each thread gets its own instance
    // This prevents data races on stream state (width, fill, flags, etc.)
    // while WriteFunThreadSafe still protects actual I/O with mutex
    // ThreadLocalStorage avoids MinGW thread_local destructor ordering bug
    static thread_local ThreadLocalStorage<Logger::Stream<false>> instance;
    return instance.get();
  }

References casadi::ThreadLocalStorage< T >::get().

Referenced by casadi::OptiCallback::call(), callback_stdout(), casadi_KN_puts(), casadi_log_output(), casadi::Dump::eval(), casadi::Monitor::eval(), casadi::Conic::eval(), casadi::MXFunction::eval(), casadi::SXFunction::eval(), casadi::FunctionInternal::eval_gen(), casadi::Feasiblesqpmethod::feasibility_iterations(), casadi::KinsolInterface::func(), casadi::SqicInterface::generateNativeCode(), casadi::KinsolInterface::ihfun(), casadi::DaeBuilderInternal::import_binding_equations(), casadi::DaeBuilderInternal::import_dynamic_equations(), casadi::DaeBuilderInternal::import_initial_equations(), casadi::DaeBuilderInternal::import_model_variables(), casadi::FatropConicInterface::init(), casadi::Feasiblesqpmethod::init(), casadi::Scpgen::init(), casadi::IpoptInterface::init_mem(), casadi::Onnx::load(), casadi::PluginInterface< Derived >::load_plugin(), casadi::Fmu3::log_message_callback(), casadi::Fmu2::logger(), casadi::CsparseInterface::nfact(), casadi::LapackLu::nfact(), casadi::ProtoFunction::print(), print_vec(), printme(), casadi::SundialsInterface::printvar(), casadi::QpoasesInterface::qpoases_printf(), casadi::Onnx::set_dimension(), casadi::OptiNode::show_infeasibilities(), casadi::FatropConicInterface::solve(), casadi::GurobiInterface::solve(), casadi::HpipmInterface::solve(), casadi::HpmpcInterface::solve(), casadi::Ipqp::solve(), casadi::Qrqp::solve(), casadi::AlpaqaInterface::solve(), casadi::AmplInterface::solve(), casadi::BonminInterface::solve(), casadi::Feasiblesqpmethod::solve(), casadi::Newton::solve(), casadi::Scpgen::solve(), casadi::Feasiblesqpmethod::step_update(), casadi::Function::transform(), and worhp_disp().

update_dict() [1/2]

CASADI_EXPORT void casadi::update_dict	(	Dict &	target,
		const Dict &	source,
		bool	recurse = false
	)

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

Definition at line 835 of file generic_type.cpp.

                                                                   {
    for (auto&& e : source) {
      if (recurse) {
        auto it = target.find(e.first);
        if (it!=target.end() && it->second.is_dict()) {
          Dict local = it->second;
          casadi_assert(e.second.is_dict(),
            "update_dict error: Key '" + it->first + "' exists in target, "
            "but source value is not a dict");
          update_dict(local, e.second, recurse);
          it->second = local;
          continue;
        }
      }
      target[e.first] = e.second;
    }
  }

Referenced by combine(), casadi::FixedStepIntegrator::create_advanced(), casadi::Function::expand(), casadi::XFunction< DerivedType, MatType, NodeType >::factory(), casadi::Options::sanitize(), and update_dict().

update_dict() [2/2]

CASADI_EXPORT void casadi::update_dict	(	Dict &	target,
		const std::string &	key,
		const GenericType &	value,
		bool	recurse
	)

Definition at line 854 of file generic_type.cpp.

                                              {
    auto it = target.find(key);
    if (it==target.end()) {
      target[key] = value;
    } else {
      // value.is_dict()
      casadi_assert(it->second.is_dict() && value.is_dict(),
        "update_dict error: Key '" + key + "' exists in target, but values are not dicts");
      Dict orig = it->second;
      update_dict(orig, value, recurse);
      target[key] = orig;
    }
  }

References casadi::GenericType::is_dict(), and update_dict().

vector_init()

template<typename T >

std::vector< T > casadi::vector_init

(

const std::vector< T > &

v

)

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

Definition at line 607 of file casadi_misc.hpp.

                                                  {
    std::vector<T> ret;
    ret.insert(ret.begin(), v.begin(), v.begin()+v.size()-1);
    return ret;
  }

Referenced by casadi::BlazingSplineFunction::merge().

vector_select()

template<typename T >

std::vector< T > casadi::vector_select	(	const std::vector< T > &	v,
		const std::vector< bool > &	s,
		bool	invert = false
	)

Parameters

v	Vector to slice
s	Select?

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

Definition at line 584 of file casadi_misc.hpp.

                                                                                           {
    std::vector<T> ret;
    casadi_assert(v.size()==s.size(), "Dimension mismatch.");
    if (invert) {
      for (casadi_int k=0;k<s.size();++k) {
        if (!s[k]) ret.push_back(v[k]);
      }
    } else {
      for (casadi_int k=0;k<s.size();++k) {
        if (s[k]) ret.push_back(v[k]);
      }
    }
    return ret;
  }

Referenced by construct_nlpsol(), and casadi::XFunction< DerivedType, MatType, NodeType >::get_jacobian().

vector_slice()

template<typename T >

std::vector< T > casadi::vector_slice	(	const std::vector< T > &	v,
		const std::vector< casadi_int > &	i
	)

Parameters

v	Vector to slice
i	List of indices

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

Definition at line 567 of file casadi_misc.hpp.

                                                                                   {
    std::vector<T> ret;
    ret.reserve(i.size());
    for (casadi_int k=0;k<i.size();++k) {
       casadi_int j = i[k];
       casadi_assert(j>=0,
         "vector_slice: Indices should be larger than zero."
         "You have " + str(j) + " at location " + str(k) + ".");
       casadi_assert(j<v.size(),
         "vector_slice: Indices should be larger than zero."
         "You have " + str(j) + " at location " + str(k) + ".");
       ret.push_back(v[j]);
    }
    return ret;
  }

References str().

Referenced by permute(), and reduce_index_gen().

vector_static_cast()

template<typename T , typename S >

std::vector< T > casadi::vector_static_cast

(

const std::vector< S > &

rhs

)

Definition at line 559 of file casadi_misc.hpp.

                                                           {
    std::vector<T> ret;
    ret.reserve(rhs.size());
    for (auto e : rhs) ret.push_back(static_cast<T>(e));
    return ret;
  }

References T.

vector_tail()

template<typename T >

std::vector< T > casadi::vector_tail

(

const std::vector< T > &

v

)

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

Definition at line 600 of file casadi_misc.hpp.

                                                  {
    std::vector<T> ret;
    ret.insert(ret.begin(), v.begin()+1, v.end());
    return ret;
  }

Referenced by casadi::XFunction< DerivedType, MatType, NodeType >::jac(), and casadi::External::serialize_body().

version_ge()

CASADI_EXPORT bool casadi::version_ge	(	const std::string &	version_left,
		const std::string &	version_right
	)

Definition at line 263 of file casadi_misc.cpp.

                                                                                 {
    std::vector<casadi_int> left_parts, right_parts;
 
    // Parse left version
    std::stringstream left_stream(version_left);
    std::string part;
    while (std::getline(left_stream, part, '.')) {
      left_parts.push_back(std::stoi(part));
    }
 
    // Parse right version
    std::stringstream right_stream(version_right);
    while (std::getline(right_stream, part, '.')) {
      right_parts.push_back(std::stoi(part));
    }
 
    // Compare component by component
    casadi_int min_size = std::min(left_parts.size(), right_parts.size());
    for (casadi_int i = 0; i < min_size; ++i) {
      if (left_parts[i] > right_parts[i]) return true;
      if (left_parts[i] < right_parts[i]) return false;
    }
 
    // If all components are equal, the longer version is greater or equal
    return left_parts.size() >= right_parts.size();
  }

Referenced by casadi::OsqpInterface::deps_version_check(), and version_le().

version_gt()

CASADI_EXPORT bool casadi::version_gt	(	const std::string &	version_left,
		const std::string &	version_right
	)

Definition at line 236 of file casadi_misc.cpp.

                                                                                 {
    std::vector<casadi_int> left_parts, right_parts;
 
    // Parse left version
    std::stringstream left_stream(version_left);
    std::string part;
    while (std::getline(left_stream, part, '.')) {
      left_parts.push_back(std::stoi(part));
    }
 
    // Parse right version
    std::stringstream right_stream(version_right);
    while (std::getline(right_stream, part, '.')) {
      right_parts.push_back(std::stoi(part));
    }
 
    // Compare component by component
    casadi_int min_size = std::min(left_parts.size(), right_parts.size());
    for (casadi_int i = 0; i < min_size; ++i) {
      if (left_parts[i] > right_parts[i]) return true;
      if (left_parts[i] < right_parts[i]) return false;
    }
 
    // If all components are equal, the longer version is greater
    return left_parts.size() > right_parts.size();
  }

Referenced by version_lt().

version_le()

CASADI_EXPORT bool casadi::version_le	(	const std::string &	version_left,
		const std::string &	version_right
	)

Definition at line 294 of file casadi_misc.cpp.

                                                                                 {
    return version_ge(version_right, version_left);
  }

References version_ge().

version_lt()

CASADI_EXPORT bool casadi::version_lt	(	const std::string &	version_left,
		const std::string &	version_right
	)

Definition at line 290 of file casadi_misc.cpp.

                                                                                 {
    return version_gt(version_right, version_left);
  }

References version_gt().

worhp_disp()

void casadi::worhp_disp	(	int	mode,
		const char	message[]
	)

Definition at line 138 of file worhp_interface.cpp.

                                                  {
    if (mode & WORHP_PRINT_MESSAGE) {
      uout() << message << std::endl;
    }
    if (mode & WORHP_PRINT_WARNING) {
      uerr() << message << std::endl;
    }
    if (mode & WORHP_PRINT_ERROR) {
      uerr() << message << std::endl;
    }
  }

References uerr(), and uout().

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

write_matlab() [1/2]

template<typename T >

void casadi::write_matlab	(	std::ostream &	stream,
		const std::vector< std::vector< T > > &	v
	)

Definition at line 814 of file casadi_misc.hpp.

                                                                           {
    for (casadi_uint i=0; i<v.size(); ++i) {
      std::copy(v[i].begin(), v[i].end(), std::ostream_iterator<T>(stream, " "));
      stream << std::endl;
    }
  }

write_matlab() [2/2]

template<typename T >

void casadi::write_matlab	(	std::ostream &	stream,
		const std::vector< T > &	v
	)

Definition at line 809 of file casadi_misc.hpp.

                                                               {
    std::copy(v.begin(), v.end(), std::ostream_iterator<T>(stream, " "));
  }

xpress_global_init()

static void casadi::xpress_global_init ( )

static

Definition at line 40 of file xpress_interface.cpp.

                                   {
    s_xpress_init_rc = XPRSinit(nullptr);
  }

References s_xpress_init_rc.

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

zip()

template<typename T >

std::vector<std::pair<std::string, T> > casadi::zip	(	const std::vector< std::string > &	id,
		const std::vector< T > &	mat
	)

Definition at line 55 of file function_internal.hpp.

                                                                      {
    casadi_assert_dev(id.size()==mat.size());
    std::vector<std::pair<std::string, T>> r(id.size());
    for (casadi_uint i=0; i<r.size(); ++i) r[i] = std::make_pair(id[i], mat[i]);
    return r;
  }

zip_entries_to_path()

bool casadi::zip_entries_to_path	(	const std::vector< std::pair< std::string, std::string > > &	entries,
		const std::string &	zip_path
	)

Definition at line 339 of file libzip.cpp.

                                   {
        int errorp;
        zip_t* archive = zip_open(zip_path.c_str(), ZIP_CREATE | ZIP_TRUNCATE, &errorp);
        if (!archive) {
            zip_error_t ziperror;
            zip_error_init_with_code(&ziperror, errorp);
            uerr() << "Error: Cannot open zip archive " << zip_path << ": "
                   << zip_error_strerror(&ziperror) << std::endl;
            zip_error_fini(&ziperror);
            return false;
        }
        // Add each file at its archive-relative name (libzip creates parent entries implicitly)
        for (const auto& e : entries) {
            if (!add_file_to_zip(archive, e.first, e.second)) {
                zip_discard(archive);
                return false;
            }
        }
        if (zip_close(archive) < 0) {
            uerr() << "Error: Cannot finalize zip archive: " << zip_strerror(archive) << std::endl;
            zip_discard(archive);
            return false;
        }
        return true;
    }

References add_file_to_zip(), and uerr().

Referenced by casadi_register_archiver_libzip().

zip_to_path()

bool casadi::zip_to_path	(	const std::string &	dir_path,
		const std::string &	zip_path
	)

Definition at line 299 of file libzip.cpp.

                                                                           {
        auto ofs_ptr = Filesystem::ofstream_ptr(zip_path, std::ios::binary);
        std::ostream& ofs = *ofs_ptr;
        if (!ofs) {
            uerr() << "Failed to open output file: " << zip_path << std::endl;
            return false;
        }
 
        return zip_to_stream(dir_path, ofs);
    }

References casadi::Filesystem::ofstream_ptr(), uerr(), and zip_to_stream().

Referenced by casadi_register_archiver_libzip().

zip_to_path2()

bool casadi::zip_to_path2	(	const std::string &	dir_path,
		const std::string &	zip_path
	)

Definition at line 310 of file libzip.cpp.

                                                                            {
        int errorp;
        zip_t* archive = zip_open(zip_path.c_str(), ZIP_CREATE | ZIP_TRUNCATE, &errorp);
        if (!archive) {
            zip_error_t ziperror;
            zip_error_init_with_code(&ziperror, errorp);
            uerr() << "Error: Cannot open zip archive " << zip_path << ": "
                   << zip_error_strerror(&ziperror) << std::endl;
            zip_error_fini(&ziperror);
            return false;
        }
 
        try {
            add_directory_recursive(archive, dir_path, dir_path, "");
        } catch (const std::exception& e) {
            uerr() << "Exception while zipping directory: " << e.what() << std::endl;
            zip_discard(archive);
            return false;
        }
 
        if (zip_close(archive) < 0) {
            uerr() << "Error: Cannot finalize zip archive: " << zip_strerror(archive) << std::endl;
            zip_discard(archive);
            return false;
        }
 
        return true;
    }

References add_directory_recursive(), and uerr().

zip_to_stream()

bool casadi::zip_to_stream	(	const std::string &	dir,
		std::ostream &	output
	)

Definition at line 188 of file libzip.cpp.

                                                                 {
        zip_error_t error;
        zip_error_init(&error);
 
        zip_source_t* src = zip_source_buffer_create(nullptr, 0, 0, &error);
        if (!src) {
            uerr() << "Failed to create zip source buffer: "
                   << zip_error_strerror(&error) << std::endl;
            zip_error_fini(&error);
            return false;
        }
 
        // Prevent zip_close from destroying the source
        zip_source_keep(src);
 
        zip_t* archive = zip_open_from_source(src, ZIP_TRUNCATE, &error);
        if (!archive) {
            uerr() << "Failed to open zip archive from source: "
                   << zip_error_strerror(&error) << std::endl;
            zip_source_free(src);
            zip_error_fini(&error);
            return false;
        }
 
        try {
            add_directory_recursive(archive, dir, dir, "");
        } catch (const std::exception& e) {
            uerr() << "Exception while zipping directory: " << e.what() << std::endl;
            zip_discard(archive);  // also frees src
            zip_error_fini(&error);
            return false;
        }
 
        if (zip_close(archive) != 0) {
            uerr() << "Failed to finalize zip archive: "
                   << zip_error_strerror(&error) << std::endl;
            zip_source_free(src);
            zip_error_fini(&error);
            return false;
        }
 
        // At this point, src contains the archive in memory.
        if (zip_source_open(src) < 0) {
            uerr() << "Failed to open zip source for reading." << std::endl;
            zip_source_free(src);
            zip_error_fini(&error);
            return false;
        }
 
        // Seek to end to get size
        if (zip_source_seek(src, 0, SEEK_END) < 0) {
            uerr() << "Failed to seek to end of zip source." << std::endl;
            zip_source_close(src);
            zip_source_free(src);
            zip_error_fini(&error);
            return false;
        }
 
        zip_int64_t size = zip_source_tell(src);
        if (size < 0) {
            uerr() << "Failed to get size of zip source." << std::endl;
            zip_source_close(src);
            zip_source_free(src);
            zip_error_fini(&error);
            return false;
        }
 
        if (zip_source_seek(src, 0, SEEK_SET) < 0) {
            uerr() << "Failed to rewind zip source." << std::endl;
            zip_source_close(src);
            zip_source_free(src);
            zip_error_fini(&error);
            return false;
        }
 
        if (zip_source_seek(src, 0, SEEK_SET) < 0) {
            uerr() << "Failed to rewind zip source." << std::endl;
            zip_source_close(src);
            zip_source_free(src);
            zip_error_fini(&error);
            return false;
        }
 
        // Efficient streaming read/write
        char buf[8192];
        zip_int64_t bytes_read;
 
        while ((bytes_read = zip_source_read(src, buf, sizeof(buf))) > 0) {
            output.write(buf, bytes_read);
            if (!output) {
                uerr() << "Write error while streaming zip data to output." << std::endl;
                zip_source_close(src);
                zip_source_free(src);
                zip_error_fini(&error);
                return false;
            }
        }
 
        zip_source_close(src);
        zip_source_free(src);
        zip_error_fini(&error);
 
        if (bytes_read < 0) {
            uerr() << "Error reading from zip source." << std::endl;
            return false;
        }
 
        return true;
    }

References add_directory_recursive(), and uerr().

Referenced by casadi_register_archiver_libzip(), and zip_to_path().

Variable Documentation

BLASFEO_DAXPY_DECL

const char* casadi::BLASFEO_DAXPY_DECL

static

Initial value:

=
  "extern void blasfeo_blas_daxpy(int* n, double* alpha,\n"
  "                               double* x, int* incx,\n"
  "                               double* y, int* incy);"

Definition at line 88 of file blas_blasfeo.cpp.

Referenced by blasfeo_codegen_axpy_aux().

BLASFEO_DDOT_DECL

const char* casadi::BLASFEO_DDOT_DECL

static

Initial value:

=
  "extern double blasfeo_blas_ddot(int* n,\n"
  "                                double* x, int* incx,\n"
  "                                double* y, int* incy);"

Definition at line 93 of file blas_blasfeo.cpp.

Referenced by blasfeo_codegen_dot_aux().

BLASFEO_DECL

const char* casadi::BLASFEO_DECL

static

Initial value:

=
  "/* BLAS \"blasfeo\" plugin: namespaced Fortran ABI, link with -lblasfeo */\n"
  "extern void blasfeo_blas_dgemm(char* transa, char* transb,\n"
  "                               int* m, int* n, int* k,\n"
  "                               double* alpha,\n"
  "                               double* A, int* lda,\n"
  "                               double* B, int* ldb,\n"
  "                               double* beta,\n"
  "                               double* C, int* ldc);"

Definition at line 78 of file blas_blasfeo.cpp.

Referenced by blasfeo_codegen_mtimes().

bvec_size

const int casadi::bvec_size = CHAR_BIT*sizeof(bvec_t)

Definition at line 130 of file casadi_common.hpp.

Referenced by casadi::FunctionInternal::get_jac_sparsity(), casadi::FunctionInternal::get_jac_sparsity_gen(), casadi::FunctionInternal::get_jac_sparsity_hierarchical(), and casadi::FunctionInternal::get_jac_sparsity_hierarchical_symm().

casadi_limits< double >

template class CASADI_EXPORT casadi::casadi_limits< double >

Definition at line 409 of file dm_instantiator.cpp.

CLASSIC_DASUM_DECL

const char* casadi::CLASSIC_DASUM_DECL

static

Initial value:

=
  "#ifndef CASADI_BLAS_DASUM\n"
  "#define CASADI_BLAS_DASUM dasum_\n"
  "#endif\n"
  "extern double CASADI_BLAS_DASUM(const int* n, const double* x, const int* incx);"

Definition at line 144 of file blas_classic.cpp.

Referenced by classic_codegen_asum_aux().

CLASSIC_DAXPY_DECL

const char* casadi::CLASSIC_DAXPY_DECL

static

Initial value:

=
  "#ifndef CASADI_BLAS_DAXPY\n"
  "#define CASADI_BLAS_DAXPY daxpy_\n"
  "#endif\n"
  "extern void CASADI_BLAS_DAXPY(const int* n, const double* alpha,\n"
  "                              const double* x, const int* incx,\n"
  "                              double* y, const int* incy);"

Definition at line 115 of file blas_classic.cpp.

Referenced by classic_codegen_axpy_aux().

CLASSIC_DDOT_DECL

const char* casadi::CLASSIC_DDOT_DECL

static

Initial value:

=
  "#ifndef CASADI_BLAS_DDOT\n"
  "#define CASADI_BLAS_DDOT ddot_\n"
  "#endif\n"
  "extern double CASADI_BLAS_DDOT(const int* n,\n"
  "                               const double* x, const int* incx,\n"
  "                               const double* y, const int* incy);"

Definition at line 123 of file blas_classic.cpp.

Referenced by classic_codegen_dot_aux().

CLASSIC_DECL

const char* casadi::CLASSIC_DECL

static

Initial value:

=
  "/* BLAS \"classic\" plugin: Fortran ABI dgemm_, link with -lblas/-lopenblas/-lmkl. */\n"
  "/* Override the symbol at compile time with -DCASADI_BLAS_DGEMM=my_dgemm. */\n"
  "#ifndef CASADI_BLAS_DGEMM\n"
  "#define CASADI_BLAS_DGEMM dgemm_\n"
  "#endif\n"
  "extern void CASADI_BLAS_DGEMM(const char* transa, const char* transb,\n"
  "                              const int* m, const int* n, const int* k,\n"
  "                              const double* alpha,\n"
  "                              const double* A, const int* lda,\n"
  "                              const double* B, const int* ldb,\n"
  "                              const double* beta,\n"
  "                              double* C, const int* ldc);"

Definition at line 101 of file blas_classic.cpp.

Referenced by classic_codegen_mtimes().

CLASSIC_DNRM2_DECL

const char* casadi::CLASSIC_DNRM2_DECL

static

Initial value:

=
  "#ifndef CASADI_BLAS_DNRM2\n"
  "#define CASADI_BLAS_DNRM2 dnrm2_\n"
  "#endif\n"
  "extern double CASADI_BLAS_DNRM2(const int* n, const double* x, const int* incx);"

Definition at line 138 of file blas_classic.cpp.

Referenced by classic_codegen_nrm2_aux().

CLASSIC_DSCAL_DECL

const char* casadi::CLASSIC_DSCAL_DECL

static

Initial value:

=
  "#ifndef CASADI_BLAS_DSCAL\n"
  "#define CASADI_BLAS_DSCAL dscal_\n"
  "#endif\n"
  "extern void CASADI_BLAS_DSCAL(const int* n, const double* alpha,\n"
  "                              double* x, const int* incx);"

Definition at line 131 of file blas_classic.cpp.

Referenced by classic_codegen_scal_aux().

empty_mutex_set_

const std::set<std::string> casadi::empty_mutex_set_

static

Definition at line 930 of file code_generator.cpp.

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

eps

const double casadi::eps = std::numeric_limits<double>::epsilon()

Definition at line 56 of file calculus.hpp.

Referenced by casadi::FmuInternal::eval_fd(), finite_diff(), casadi::FunctionInternal::get_abstol(), casadi::FunctionInternal::get_reltol(), and casadi::FiniteDiff::init().

GenericShared< SharedObject, SharedObjectInternal >

template class CASADI_EXPORT casadi::GenericShared< SharedObject, SharedObjectInternal >

Definition at line 59 of file shared_object.cpp.

GenericShared< SharedSXElem, OutputSX >

template class CASADI_EXPORT casadi::GenericShared< SharedSXElem, OutputSX >

Definition at line 34 of file output_sx.cpp.

GenericWeakRef< SharedObject, SharedObjectInternal >

template class CASADI_EXPORT casadi::GenericWeakRef< SharedObject, SharedObjectInternal >

Definition at line 60 of file shared_object.cpp.

GenericWeakRef< SharedSXElem, OutputSX >

template class CASADI_EXPORT casadi::GenericWeakRef< SharedSXElem, OutputSX >

Definition at line 35 of file output_sx.cpp.

inf

const double casadi::inf = std::numeric_limits<double>::infinity()

Definition at line 50 of file calculus.hpp.

Referenced by casadi::DaeBuilderInternal::add(), casadi::OptiNode::canon_expr(), casadi::Conic::check_inputs(), casadi::Nlpsol::check_inputs(), casadi::Sqpmethod::codegen_solve_elastic_mode(), casadi::BSplineInterpolant::construct_graph(), erfinv(), casadi::Variable::export_xml(), casadi::Blocksqp::feasibilityRestorationPhase(), casadi::FunctionInternal::get_max_in(), casadi::FunctionInternal::get_min_in(), casadi::DaeBuilderInternal::import_model_variables(), casadi::FiniteDiff::init(), casadi::Blocksqp::init(), casadi::Blocksqp::initIterate(), casadi::Integrator::Integrator(), casadi::NlImporter::NlImporter(), casadi::Blocksqp::reduceSOCStepsize(), casadi::CplexInterface::solve(), casadi::WorhpInterface::solve(), casadi::Sqpmethod::solve(), casadi::Sqpmethod::solve_elastic_mode(), casadi::Options::suggestions(), and casadi::Blocksqp::updateStepBounds().

legendre_points

const long double* casadi::legendre_points[]

Initial value:

=
  { nullptr, legendre_points1, legendre_points2, legendre_points3, legendre_points4,
    legendre_points5, legendre_points6, legendre_points7, legendre_points8, legendre_points9}

Definition at line 63 of file integration_tools.cpp.

Referenced by collocation_pointsGen().

legendre_points1

const long double casadi::legendre_points1[] = { 0.50000000000000000000 }

Definition at line 34 of file integration_tools.cpp.

legendre_points2

const long double casadi::legendre_points2[]

Initial value:

=
    { 0.21132486540518713447, 0.78867513459481286553 }

Definition at line 35 of file integration_tools.cpp.

legendre_points3

const long double casadi::legendre_points3[]

Initial value:

=
  { 0.11270166537925824235, 0.50000000000000000000,
    0.88729833462074170214 }

Definition at line 37 of file integration_tools.cpp.

legendre_points4

const long double casadi::legendre_points4[]

Initial value:

=
  { 0.06943184420297354720, 0.33000947820757187134,
    0.66999052179242823968, 0.93056815579702623076 }

Definition at line 40 of file integration_tools.cpp.

legendre_points5

const long double casadi::legendre_points5[]

Initial value:

=
  { 0.04691007703066807366, 0.23076534494715861268,
    0.49999999999999994449, 0.76923465505284149835, 0.95308992296933192634 }

Definition at line 43 of file integration_tools.cpp.

legendre_points6

const long double casadi::legendre_points6[]

Initial value:

=
  { 0.03376524289842347537, 0.16939530676686742616,
    0.38069040695840172805, 0.61930959304159849399, 0.83060469323313235179,
    0.96623475710157580298 }

Definition at line 46 of file integration_tools.cpp.

legendre_points7

const long double casadi::legendre_points7[]

Initial value:

=
  { 0.02544604382862047931, 0.12923440720030288098,
    0.29707742431130129690, 0.50000000000000000000, 0.70292257568869853657,
    0.87076559279969734106, 0.97455395617137896558 }

Definition at line 50 of file integration_tools.cpp.

legendre_points8

const long double casadi::legendre_points8[]

Initial value:

=
  { 0.01985507175123157886, 0.10166676129318691357,
    0.23723379504183561561, 0.40828267875217505445, 0.59171732124782483453,
    0.76276620495816449541, 0.89833323870681347501, 0.98014492824876797705 }

Definition at line 54 of file integration_tools.cpp.

legendre_points9

const long double casadi::legendre_points9[]

Initial value:

=
  { 0.01591988024618706810, 0.08198444633668211523,
    0.19331428364970504319, 0.33787328829809543107, 0.49999999999999988898,
    0.66212671170190451342, 0.80668571635029517886, 0.91801555366331766272,
    0.98408011975381259884 }

Definition at line 58 of file integration_tools.cpp.

LOOKUP_BINARY

constexpr casadi_int casadi::LOOKUP_BINARY = 2

constexpr

Definition at line 157 of file casadi_common.hpp.

Referenced by casadi::Low::interpret_lookup_mode(), and casadi::Low::lookup_mode_from_enum().

LOOKUP_EXACT

constexpr casadi_int casadi::LOOKUP_EXACT = 1

constexpr

Definition at line 156 of file casadi_common.hpp.

Referenced by casadi::Low::interpret_lookup_mode(), casadi::Interpolant::interpret_lookup_mode(), and casadi::Low::lookup_mode_from_enum().

LOOKUP_LINEAR

constexpr casadi_int casadi::LOOKUP_LINEAR = 0

constexpr

Definition at line 155 of file casadi_common.hpp.

Referenced by casadi::Low::interpret_lookup_mode(), and casadi::Low::lookup_mode_from_enum().

Matrix< casadi_int >

template class CASADI_EXPORT casadi::Matrix< casadi_int >

Definition at line 56 of file im_instantiator.cpp.

Referenced by casadi::GetNonzeros::mapping(), and casadi::SetNonzeros< Add >::mapping().

Matrix< double >

template class CASADI_EXPORT casadi::Matrix< double >

Definition at line 414 of file dm_instantiator.cpp.

Referenced by casadi::Constant< Value >::get_DM().

Matrix< SXElem >

template class CASADI_EXPORT casadi::Matrix< SXElem >

Definition at line 1802 of file sx_instantiator.cpp.

nan

const double casadi::nan = std::numeric_limits<double>::quiet_NaN()

Definition at line 53 of file calculus.hpp.

Referenced by casadi::Qrqp::codegen_body(), casadi::DaeBuilderInternal::DaeBuilderInternal(), erfinv(), casadi::GetNonzerosParamVector::eval(), casadi::GetNonzerosSliceParam::eval(), casadi::GetNonzerosParamSlice::eval(), casadi::GetNonzerosParamParam::eval(), casadi::Nlpsol::eval(), casadi::FmuFunction::eval(), casadi::FmuInternal::eval_fd(), casadi::FmuFunction::eval_task(), casadi::BonminInterface::finalize_solution(), casadi::FmuInternal::gather_io(), casadi::GetNonzerosParamVector::generate(), casadi::GetNonzerosSliceParam::generate(), casadi::GetNonzerosParamSlice::generate(), casadi::GetNonzerosParamParam::generate(), casadi::IdasMemory::IdasMemory(), casadi::DaeBuilderInternal::import_default_experiment(), casadi::FmuInternal::init_mem(), casadi::DaeBuilderInternal::reset(), casadi::SundialsInterface::reset_stats(), casadi::CplexInterface::solve(), casadi::GurobiInterface::solve(), casadi::Qrqp::solve(), casadi::AmplInterface::solve(), casadi::Sqpmethod::solve(), casadi::DaeBuilder::start_time(), casadi::DaeBuilder::step_size(), casadi::DaeBuilder::stop_time(), and casadi::DaeBuilder::tolerance().

NL_INPUTS

const std::vector<std::string> casadi::NL_INPUTS = {"x", "p"}

Definition at line 178 of file nlpsol.hpp.

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

NL_OUTPUTS

const std::vector<std::string> casadi::NL_OUTPUTS = {"f", "g"}

Definition at line 191 of file nlpsol.hpp.

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

op_map

const OpMapping casadi::op_map[]

static

Definition at line 35 of file onnx_operations.cpp.

Referenced by get_op_mapping(), and get_op_mapping_by_name().

pi

const double casadi::pi = 3.14159265358979323846

Definition at line 46 of file calculus.hpp.

Referenced by casadi::UnaryOperation< OP_ERF >::der(), casadi::UnaryOperation< OP_ERFINV >::der(), erfinv(), casadi::GurobiInterface::solve(), and casadi::ImplicitToNlp::solve().

radau_points

const long double* casadi::radau_points[]

Initial value:

=
  { nullptr, radau_points1, radau_points2, radau_points3, radau_points4, radau_points5,
    radau_points6, radau_points7, radau_points8, radau_points9}

Definition at line 98 of file integration_tools.cpp.

Referenced by collocation_pointsGen().

radau_points1

const long double casadi::radau_points1[]

Initial value:

=
  { 1.00000000000000000000 }

Definition at line 68 of file integration_tools.cpp.

radau_points2

const long double casadi::radau_points2[]

Initial value:

=
  { 0.33333333333333337034, 1.00000000000000000000 }

Definition at line 70 of file integration_tools.cpp.

radau_points3

const long double casadi::radau_points3[]

Initial value:

=
  { 0.15505102572168222297, 0.64494897427831787695,
    1.00000000000000000000 }

Definition at line 72 of file integration_tools.cpp.

radau_points4

const long double casadi::radau_points4[]

Initial value:

=
  { 0.08858795951270420632, 0.40946686444073465694,
    0.78765946176084700170, 1.00000000000000000000 }

Definition at line 75 of file integration_tools.cpp.

radau_points5

const long double casadi::radau_points5[]

Initial value:

=
  { 0.05710419611451822419, 0.27684301363812369168,
    0.58359043236891683382, 0.86024013565621926247, 1.00000000000000000000 }

Definition at line 78 of file integration_tools.cpp.

radau_points6

const long double casadi::radau_points6[]

Initial value:

=
  { 0.03980985705146905529, 0.19801341787360787761,
    0.43797481024738621480, 0.69546427335363603106, 0.90146491420117347282,
    1.00000000000000000000 }

Definition at line 81 of file integration_tools.cpp.

radau_points7

const long double casadi::radau_points7[]

Initial value:

=
  { 0.02931642715978521885, 0.14807859966848435640,
    0.33698469028115418666, 0.55867151877155019069, 0.76923386203005450490,
    0.92694567131974103802, 1.00000000000000000000 }

Definition at line 85 of file integration_tools.cpp.

radau_points8

const long double casadi::radau_points8[]

Initial value:

=
  { 0.02247938643871305597, 0.11467905316090415413,
    0.26578982278458951338, 0.45284637366944457959, 0.64737528288683043876,
    0.81975930826310761113, 0.94373743946307731001, 1.00000000000000000000 }

Definition at line 89 of file integration_tools.cpp.

radau_points9

const long double casadi::radau_points9[]

Initial value:

=
  { 0.01777991514736393386, 0.09132360789979432347,
    0.21430847939563035798, 0.37193216458327238438, 0.54518668480342658000,
    0.71317524285556954666, 0.85563374295785443735, 0.95536604471003006012,
    1.00000000000000000000 }

Definition at line 93 of file integration_tools.cpp.

REFERENCE_DOC

const char* casadi::REFERENCE_DOC

static

Initial value:

=
    "Built-in dense BLAS implementation, no external dependency. "
    "Used by default and as the fallback when other plugins are unavailable."

Definition at line 127 of file blas.cpp.

Referenced by doc_blas().

s_xpress_init_flag

std::once_flag casadi::s_xpress_init_flag

static

Definition at line 38 of file xpress_interface.cpp.

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

s_xpress_init_rc

int casadi::s_xpress_init_rc = 0

static

Definition at line 39 of file xpress_interface.cpp.

Referenced by casadi::XpressInterface::init_mem(), and xpress_global_init().

serialization_check

casadi_int casadi::serialization_check = 123456789012345

static

Definition at line 45 of file serializing_stream.cpp.

Referenced by casadi::SerializingStream::SerializingStream(), and casadi::DeserializingStream::setup().

serialization_protocol_version

casadi_int casadi::serialization_protocol_version = 3

static

Definition at line 44 of file serializing_stream.cpp.

Referenced by casadi::SerializingStream::SerializingStream(), and casadi::DeserializingStream::setup().