codac2 Namespace Reference

Classes
class	OctaSym
	Represents an hyperoctahedral symmetry. More...
class	SlicedTube
	Tube represented over a sliced temporal domain. More...
class	Slice
	Codomain of a sliced tube over one temporal slice. More...
class	CtcDist
	Implements the distance constraint on \(\mathbf{a}\in\mathbb{R}^2\), \(\mathbf{b}\in\mathbb{R}^2\) and \(d\in\mathbb{R}\) such that: More...
class	CtcInter
	Sequential intersection of several contractors: More...
class	CtcInter<>
	Default CtcInter specialization for box contractors. More...
struct	CtcInterType
	Helper meta-function returning the appropriate CtcInter type from a tuple. More...
struct	CtcInterType< std::tuple< T... > >
	CtcInterType specialization for tuples of contracted types. More...
class	GlobalEnclosureError
	Encapsulates runtime error for global enclosure estimation failure. More...
class	LohnerAlgorithm
	Simple first order Lohner algorithm to perform guaranteed integration of a system \(\dot{\mathbf{x}}=\mathbf{f}(\mathbf{x})\). More...
class	CtcLohner
	The Lohner contractor uses Lohner's guaranteed integration algorithm to contract a tube according to a differential equation. More...
class	CtcPolar
	Implements the polar constraint on \(x\in\mathbb{R}\), \(y\in\mathbb{R}\), \(\rho\in\mathbb{R}^+\) and \(\theta\in\mathbb{R}\) such that: More...
class	CtcGaussElim
	Contractor for a linear system of interval equations, based on the classical Gauss elimination procedure. More...
class	CtcGaussSeidel
	Contractor for a linear system of interval equations, using a fixed-point approach based on the Gauss Seidel method. More...
class	CtcLinearPrecond
	Contractor for a linear system of interval equations, using a preconditioning method before calling some provided contractor. More...
class	Ellipsoid
	Ellipsoid representation. More...
class	Interval
	Interval class, for representing closed and connected subsets of \(\mathbb{R}\). More...
class	SliceBase
	Base class for codomain slices attached to a temporal slice. More...
class	SlicedTubeBase
	Base class for tubes defined over a sliced temporal domain. More...
class	TDomain
	Temporal partition associated with sliced tubes. More...
class	TSlice
	Temporal slice shared by sliced tubes. More...
class	TubeBase
	Base class for tubes defined over a temporal domain. More...
class	Parallelepiped
	Class representing a parallelepiped \(\mathbf{z} + \mathbf{A}\cdot[-1,1]^m\). More...
class	Zonotope
	Class representing a zonotope \(\mathbf{z} + \mathbf{A}\cdot[-1,1]^m\). More...
struct	FlatInputBinding
	Binding information associated with one input argument in a flattened input domain. More...
class	FlatInputLayout
	Flattened layout associated with an analytic function input domain. More...
class	ExprID
	A class representing a unique identifier for expressions. More...
class	ExprBase
	Abstract base class for representing an expression. More...
class	OperationExprBase
	A base class for expressions representing operations with multiple operands. More...
class	FunctionArgsList
	A container class to manage a collection of function arguments. More...
class	FunctionBase
	A base class for functions (either analytic functions, or set functions). More...
class	VarBase
	Abstract base class for representing variables in analytic or set functions. More...
class	ConvexPolygon
	Represents a convex polygon defined by vertices enclosed in IntervalVectors. More...
class	Polygon
	Represents a polygon (convex or non-convex) defined by its vertices enclosed in IntervalVectors. More...
class	Segment
	Represents a geometric segment defined by two points enclosed in IntervalVectors. More...
class	IntvFullPivLU
	Full pivot LU decomposition for a matrix of intervals, based on Eigen decomposition. The decomposition is of the form \(\mathbf{M} = \mathbf{P}^{-1} [\mathbf{L}][\mathbf{U}] \mathbf{Q}^{-1}\) where \(\mathbf{P}\) and \(\mathbf{Q}\) are permutation matrices, and \([\mathbf{L}]\) and \([\mathbf{U}]\) are lower and upper interval matrices (i.e. \([\mathbf{L}]\)'s diagonal is 1). More...
struct	VectorCompare
	Comparison functor for codac2::Vector objects. More...
class	ProjBase
	Base class for projection-related operations. More...
class	SepChi
	A separator on the Chi constraint If [x] in Sa, then Sb, else Sc. More...
struct	PEIBOS_CAPD_Key
	Key structure for PEIBOS CAPD results. More...
class	Figure2D_IPE
	IPE output class. More...
class	Figure2D_VIBes
	VIBes output class. More...
class	Figure2D
	Figure2D class, used for 2D display. More...
class	DefaultFigure
	Default view class, used to manage the default figure. More...
class	Figure2DInterface
	Interface for 2D figures. More...
class	Figure3D
	Figure3D class, used for 3D figures. More...
class	OutputFigure2D
	Output figure class, used to manage the output figures. More...
struct	Color
	Color structure, in RGBA or HSVA format. More...
struct	ColorMap
	Represents a set of RGB or HSV values. More...
struct	StyleGradientProperties
	Style properties structure, to specify the style of a shape. More...
struct	StyleProperties
	Style properties structure, to specify the style of a shape. More...
struct	StylePropertiesBase
	Style properties structure, to specify the style of a shape. More...

Typedefs
using	IntervalMatrix = Eigen::Matrix<Interval,-1,-1>
	Alias for a dynamic-size matrix of intervals.
using	IntervalRow = Eigen::Matrix<Interval,1,-1>
	Alias for a dynamic-size row vector of intervals.
using	IntervalVector = Eigen::Matrix<Interval,-1,1>
	Alias for a dynamic-size column vector of intervals.
using	ScalarExprTransform = std::function<ScalarExpr(const ScalarExpr&)>
	Scalar transformation applied to the entries of an analytic function output.
using	Matrix = Eigen::Matrix<double,-1,-1>
	Alias for a dynamic-size matrix of doubles.
using	Row = Eigen::Matrix<double,1,-1>
	Alias for a dynamically-sized row vector of doubles.
using	Vector = Eigen::Matrix<double,-1,1>
	Alias for a dynamically-sized column vector of doubles.

Enumerations
enum class	BoolInterval { }
	Enumeration representing a boolean interval. More...
enum class	TimePropag
	Enumeration specifying the temporal propagation way (forward or backward in time). More...
enum class	OrientationInterval { }
	Enumeration representing feasible orientations. Can be used to assess an oriented angle, or the alignement of three points. More...
enum	Model
	Color model (RGB or HSV). More...

Functions
template<typename C1, typename C2>
CtcInterType< typenameC1::ContractedTypes >::Ctc	operator& (const C1 &c1, const C2 &c2)
	Builds an intersection contractor from two contractors.
template<typename C1, typename C2>
CtcInterType< typenameC1::ContractedTypes >::Ctc	operator& (const std::shared_ptr< C1 > &c1, const std::shared_ptr< C2 > &c2)
	Builds an intersection contractor from two shared contractor pointers.
template<typename C1, typename C2>
CtcInterType< typenameC1::ContractedTypes >::Ctc	operator& (const std::shared_ptr< C1 > &c1, const C2 &c2)
	Builds an intersection contractor from a shared contractor pointer and a contractor.
template<typename C1, typename C2>
CtcInterType< typenameC1::ContractedTypes >::Ctc	operator& (const C1 &c1, const std::shared_ptr< C2 > &c2)
	Builds an intersection contractor from a contractor and a shared contractor pointer.
template<typename C2>
CtcInter< IntervalVector >	operator& (const IntervalVector &c1, const C2 &c2)
	Intersects a box with a contractor by wrapping the box into a CtcWrapper.
template<typename C1>
CtcInter< IntervalVector >	operator& (const C1 &c1, const IntervalVector &c2)
	Intersects a contractor with a box by wrapping the box into a CtcWrapper.
constexpr BoolInterval	operator& (BoolInterval x, BoolInterval y)
	Intersection operator for BoolInterval sets.
constexpr BoolInterval	operator| (BoolInterval x, BoolInterval y)
	Union operator for BoolInterval sets.
constexpr BoolInterval	operator&& (BoolInterval x, BoolInterval y)
	Logical AND operator for BoolInterval sets.
constexpr BoolInterval	operator|| (BoolInterval x, BoolInterval y)
	Logical OR operator for BoolInterval sets.
BoolInterval	operator~ (BoolInterval x)
	Returns the complementary of a BoolInterval.
std::ostream &	operator<< (std::ostream &os, const BoolInterval &x)
	Streams out a BoolInterval.
Ellipsoid	operator+ (const Ellipsoid &e1, const Ellipsoid &e2)
	Compute the Minkowski sum of two ellipsoids.
Ellipsoid	linear_mapping (const Ellipsoid &e, const Matrix &A, const Vector &b)
	Guaranteed linear evaluation A*e+b, considering the rounding errors.
Ellipsoid	unreliable_linear_mapping (const Ellipsoid &e, const Matrix &A, const Vector &b)
	Nonrigorous linear evaluation A*e+b.
Ellipsoid	nonlinear_mapping (const Ellipsoid &e, const AnalyticFunction< VectorType > &f)
	(Rigorous?) non-linear evaluation f(e)
Ellipsoid	nonlinear_mapping (const Ellipsoid &e, const AnalyticFunction< VectorType > &f, const Vector &trig, const Vector &q)
	(Rigorous?) non-linear evaluation f(e), with parameters
Matrix	nonlinear_mapping_base (const Matrix &G, const Matrix &J, const IntervalMatrix &J_box, const Vector &trig, const Vector &q)
	(Rigorous?) non-linear evaluation f(e), from Jacobian information
std::ostream &	operator<< (std::ostream &os, const Ellipsoid &e)
	Streams out an Ellipsoid.
BoolInterval	stability_analysis (const AnalyticFunction< VectorType > &f, unsigned int alpha_max, Ellipsoid &e, Ellipsoid &e_out, bool verbose=false)
	...
Matrix	solve_discrete_lyapunov (const Matrix &A, const Matrix &Q)
	...
std::ostream &	operator<< (std::ostream &os, const Interval &x)
	Streams out this.
Interval	operator""_i (long double x)
	Codac defined literals allowing to produce an interval from a double.
double	prev_float (double x)
	Returns the previous representable double-precision floating-point value before x.
double	next_float (double x)
	Returns the next representable double-precision floating-point value after x.
Interval	operator& (const Interval &x, const Interval &y)
	Returns the intersection of two intervals: \([x]\cap[y]\).
Interval	operator| (const Interval &x, double y)
	Returns the squared-union of an interval and a real: \([x]\sqcup\{y\}\).
Interval	operator| (const Interval &x, const Interval &y)
	Returns the squared-union of two intervals: \([x]\sqcup[y]\).
const Interval &	operator+ (const Interval &x)
	Returns this.
Interval	operator+ (const Interval &x, double y)
	Returns \([x]+y\) with \(y\in\mathbb{R}\).
Interval	operator+ (double x, const Interval &y)
	Returns \(x+[y]\) with \(x\in\mathbb{R}\).
Interval	operator+ (const Interval &x, const Interval &y)
	Returns \([x]+[y]\).
Interval	operator- (const Interval &x, double y)
	Returns \([x]-y\) with \(y\in\mathbb{R}\).
Interval	operator- (double x, const Interval &y)
	Returns \(x-[y]\) with \(x\in\mathbb{R}\).
Interval	operator- (const Interval &x, const Interval &y)
	Returns \([x]-[y]\).
Interval	operator* (const Interval &x, double y)
	Returns \([x]*y\) with \(y\in\mathbb{R}\).
Interval	operator* (double x, const Interval &y)
	Returns \(x*[y]\) with \(x\in\mathbb{R}\).
Interval	operator* (const Interval &x, const Interval &y)
	Returns \([x]*[y]\).
Interval	operator/ (const Interval &x, double y)
	Returns \([x]/y\) with \(y\in\mathbb{R}\).
Interval	operator/ (double x, const Interval &y)
	Returns \(x/[y]\) with \(x\in\mathbb{R}\).
Interval	operator/ (const Interval &x, const Interval &y)
	Returns \([x]/[y]\).
Interval	sqr (const Interval &x)
	Returns \([x]^2\).
Interval	sqrt (const Interval &x)
	Returns \(\sqrt{[x]}\).
Interval	pow (const Interval &x, int n)
	Returns \([x]^n\), \(n\in\mathbb{Z}\).
Interval	pow (const Interval &x, double p)
	Returns \([x]^p\), \(p\in\mathbb{R}\).
Interval	pow (const Interval &x, const Interval &p)
	Returns \([x]^{[p]}\), \(p\in\mathbb{IR}\).
Interval	root (const Interval &x, int p)
	Returns the p-th root: \(\sqrt[p]{[x]}\).
Interval	exp (const Interval &x)
	Returns \(\exp([x])\).
Interval	log (const Interval &x)
	Returns \(\log([x])\).
Interval	cos (const Interval &x)
	Returns \(\cos([x])\).
Interval	sin (const Interval &x)
	Returns \(\sin([x])\).
Interval	tan (const Interval &x)
	Returns \(\tan([x])\).
Interval	acos (const Interval &x)
	Returns \(\acos([x])\).
Interval	asin (const Interval &x)
	Returns \(\asin([x])\).
Interval	atan (const Interval &x)
	Returns \(\atan([x])\).
Interval	atan2 (const Interval &y, const Interval &x)
	Returns \(\mathrm{arctan2}([y],[x])\).
Interval	cosh (const Interval &x)
	Returns \(\cosh([x])\).
Interval	sinh (const Interval &x)
	Returns \(\sinh([x])\).
Interval	tanh (const Interval &x)
	Returns \(\tanh([x])\).
Interval	acosh (const Interval &x)
	Returns \(\acosh([x])\).
Interval	asinh (const Interval &x)
	Returns \(\asinh([x])\).
Interval	atanh (const Interval &x)
	Returns \(\atanh([x])\).
Interval	abs (const Interval &x)
	Returns \(\mid[x]\mid = \left\{\mid x \mid, x\in[x]\right\}\).
Interval	min (const Interval &x, const Interval &y)
	Returns \(\min([x],[y])=\left\{\min(x,y), x\in[x], y\in[y]\right\}\).
Interval	max (const Interval &x, const Interval &y)
	Returns \(\max([x],[y])=\left\{\max(x,y), x\in[x], y\in[y]\right\}\).
Interval	sign (const Interval &x)
	Returns \(\sign([x])=\left[\left\{\sign(x), x\in[x]\right\}\right]\).
Interval	integer (const Interval &x)
	Returns the largest integer interval included in \([x]\).
Interval	floor (const Interval &x)
	Returns floor of \([x]\).
Interval	ceil (const Interval &x)
	Returns ceil of \([x]\).
Interval	chi (const Interval &x, const Interval &y, const Interval &z)
	Return \([y]\) if \(x^+ <= 0\), \([z]\) if \(x^- > 0\), \([y]\sqcup[z]\) else.
std::ostream &	operator<< (std::ostream &os, const IntervalMatrix &x)
	Stream output operator for IntervalMatrix objects.
std::ostream &	operator<< (std::ostream &os, const IntervalRow &x)
	Stream output operator for IntervalRow objects.
std::ostream &	operator<< (std::ostream &os, const IntervalVector &x)
	Stream output operator for IntervalVector objects.
template<typename T>
SlicedTube< T > &	operator|= (SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_member_binary_tube_tube(operator_tube_union< T >)
	Pointwise hull-union assignment of two tubes with the same codomain type.
template<typename T>
SlicedTube< T >	operator| (const SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_binary_tube_tube(operator_tube_union< T >
	Pointwise hull-union of two tubes with the same codomain type.
template<typename T>
SlicedTube< T > &	operator&= (SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_member_binary_tube_tube(operator_tube_intersection< T >)
	Pointwise intersection assignment of two tubes with the same codomain type.
template<typename T>
SlicedTube< T >	operator& (const SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_binary_tube_tube(operator_tube_intersection< T >
	Pointwise intersection of two tubes with the same codomain type.
template<typename T>
const SlicedTube< T > &	operator+ (const SlicedTube< T > &x1)
	Unary plus.
template<typename T>
SlicedTube< T >	operator+ (const SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_binary_tube_tube(operator_tube_add< T >
	Pointwise sum of two tubes with the same codomain type.
template<typename T, typename Q>
SlicedTube< T >	operator+ (const SlicedTube< T > &x1, const Q &x2) macro_binary_tube_real(operator_tube_add< T >)
	Pointwise sum of a tube and a constant object with matching codomain type.
template<typename T, typename Q>
SlicedTube< T >	operator+ (const Q &x1, const SlicedTube< T > &x2) macro_binary_real_tube(operator_tube_add< T >)
	Pointwise sum of a constant object and a tube with matching codomain type.
template<typename T, typename Q>
SlicedTube< T > &	operator+= (SlicedTube< T > &x1, const Q &x2) macro_member_binary_tube_real(operator_tube_add< T >)
	Pointwise addition assignment with a constant object of matching codomain type.
template<typename T>
SlicedTube< T > &	operator+= (SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_member_binary_tube_tube(operator_tube_add< T >)
	Pointwise addition assignment with a tube of the same codomain type.
template<typename T>
SlicedTube< T >	operator- (const SlicedTube< T > &x1)
	Unary minus.
template<typename T>
SlicedTube< T >	operator- (const SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_binary_tube_tube(operator_tube_sub< T >
	Pointwise difference of two tubes with the same codomain type.
template<typename T, typename Q>
SlicedTube< T >	operator- (const SlicedTube< T > &x1, const Q &x2) macro_binary_tube_real(operator_tube_sub< T >)
	Pointwise difference between a tube and a constant object with matching codomain type.
template<typename T, typename Q>
SlicedTube< T >	operator- (const Q &x1, const SlicedTube< T > &x2) macro_binary_real_tube(operator_tube_sub< T >)
	Pointwise difference between a constant object and a tube with matching codomain type.
template<typename T, typename Q>
SlicedTube< T > &	operator-= (SlicedTube< T > &x1, const Q &x2) macro_member_binary_tube_real(operator_tube_sub< T >)
	Pointwise subtraction assignment with a constant object of matching codomain type.
template<typename T>
SlicedTube< T > &	operator-= (SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_member_binary_tube_tube(operator_tube_sub< T >)
	Pointwise subtraction assignment with a tube of the same codomain type.
template<typename T>
SlicedTube< T >	operator* (const Interval &x1, const SlicedTube< T > &x2) macro_binary_real_tube(operator_tube_scal_mul< T >)
	Pointwise multiplication of a scalar interval and a tube.
template<typename T>
SlicedTube< T >	operator* (const SlicedTube< T > &x1, const Interval &x2) macro_binary_tube_real(operator_tube_mul_scal< T >)
	Pointwise multiplication of a tube by a scalar interval.
SlicedTube< Interval >	operator* (const SlicedTube< Interval > &x1, const SlicedTube< Interval > &x2) macro_binary_tube_tube(operator_tube_mul< Interval >
	Pointwise multiplication of two scalar interval tubes.
SlicedTube< IntervalVector >	operator* (const SlicedTube< IntervalVector > &x1, const SlicedTube< IntervalVector > &x2) macro_binary_tube_tube(operator_tube_mul< IntervalVector >
	Pointwise multiplication of two interval-vector tubes.
SlicedTube< IntervalMatrix >	operator* (const SlicedTube< IntervalMatrix > &x1, const SlicedTube< IntervalMatrix > &x2) macro_binary_tube_tube(operator_tube_mul< IntervalMatrix >
	Pointwise multiplication of two interval-matrix tubes.
template<typename T>
SlicedTube< T >	operator* (const SlicedTube< Interval > &x1, const SlicedTube< T > &x2) macro_binary_tube_tube(operator_tube_mul< T >
	Pointwise multiplication of a scalar interval tube and a non-scalar tube.
template<typename T>
SlicedTube< T >	operator* (const SlicedTube< T > &x1, const SlicedTube< Interval > &x2) macro_binary_tube_tube(operator_tube_mul< T >
	Pointwise multiplication of a non-scalar tube and a scalar interval tube.
template<typename T, typename Q>
SlicedTube< T >	operator* (const SlicedTube< T > &x1, const Q &x2) macro_binary_tube_real(operator_tube_mul< T >)
	Pointwise multiplication of a tube and a constant object with matching codomain type.
template<typename T, typename Q>
SlicedTube< T >	operator* (const Q &x1, const SlicedTube< T > &x2) macro_binary_real_tube(operator_tube_mul< T >)
	Pointwise multiplication of a constant object and a tube with matching codomain type.
SlicedTube< IntervalVector >	operator* (const SlicedTube< IntervalMatrix > &x1, const SlicedTube< IntervalVector > &x2) macro_binary_tube_tube(operator_tube_mul_vec
	Pointwise multiplication of an interval-matrix tube by an interval-vector tube.
template<typename T, typename Q>
SlicedTube< T > &	operator*= (SlicedTube< T > &x1, const Q &x2) macro_member_binary_tube_real(operator_tube_mul< T >)
	Pointwise multiplication assignment with a constant object of matching codomain type.
template<typename T>
SlicedTube< T > &	operator*= (SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_member_binary_tube_tube(operator_tube_mul< T >)
	Pointwise multiplication assignment with a tube of the same codomain type.
template<typename T>
SlicedTube< T > &	operator*= (SlicedTube< T > &x1, const SlicedTube< Interval > &x2) macro_member_binary_tube_tube(operator_tube_mul< T >)
	Pointwise multiplication assignment by a scalar interval tube.
template<typename T>
SlicedTube< T >	operator/ (const SlicedTube< T > &x1, const Interval &x2) macro_binary_tube_real(operator_tube_div_scal< T >)
	Pointwise division of a tube by a scalar interval.
SlicedTube< Interval >	operator/ (const SlicedTube< Interval > &x1, const SlicedTube< Interval > &x2) macro_binary_tube_tube(operator_tube_div< Interval >
	Pointwise division of two scalar interval tubes.
template<typename T>
SlicedTube< T >	operator/ (const SlicedTube< T > &x1, const SlicedTube< Interval > &x2) macro_binary_tube_tube(operator_tube_div< T >
	Pointwise division of a non-scalar tube by a scalar interval tube.
template<typename T, typename Q>
SlicedTube< T >	operator/ (const SlicedTube< T > &x1, const Q &x2) macro_binary_tube_real(operator_tube_div< T >)
	Pointwise division of a tube by a constant object with matching codomain type.
template<typename T, typename Q>
SlicedTube< T >	operator/ (const Q &x1, const SlicedTube< T > &x2) macro_binary_real_tube(operator_tube_div< T >)
	Pointwise division of a constant object by a tube with matching codomain type.
template<typename T, typename Q>
SlicedTube< T > &	operator/= (SlicedTube< T > &x1, const Q &x2) macro_member_binary_tube_real(operator_tube_div< T >)
	Pointwise division assignment with a constant object of matching codomain type.
template<typename T>
SlicedTube< T > &	operator/= (SlicedTube< T > &x1, const SlicedTube< T > &x2) macro_member_binary_tube_tube(operator_tube_div< T >)
	Pointwise division assignment with a tube of the same codomain type.
template<typename T>
SlicedTube< T > &	operator/= (SlicedTube< T > &x1, const SlicedTube< Interval > &x2) macro_member_binary_tube_tube(operator_tube_div< T >)
	Pointwise division assignment by a scalar interval tube.
SlicedTube< Interval >	sqr (const SlicedTube< Interval > &x1)
	Pointwise square of a scalar interval tube.
SlicedTube< Interval >	sqrt (const SlicedTube< Interval > &x1)
	Pointwise square root of a scalar interval tube.
SlicedTube< Interval >	pow (const SlicedTube< Interval > &x1, int x2)
	Pointwise power of a scalar interval tube with an integer exponent.
SlicedTube< Interval >	pow (const SlicedTube< Interval > &x1, const Interval &x2)
	Pointwise power of a scalar interval tube with an interval exponent.
SlicedTube< Interval >	exp (const SlicedTube< Interval > &x1)
	Pointwise exponential of a scalar interval tube.
SlicedTube< Interval >	log (const SlicedTube< Interval > &x1)
	Pointwise natural logarithm of a scalar interval tube.
SlicedTube< Interval >	cos (const SlicedTube< Interval > &x1)
	Pointwise cosine of a scalar interval tube.
SlicedTube< Interval >	sin (const SlicedTube< Interval > &x1)
	Pointwise sine of a scalar interval tube.
SlicedTube< Interval >	tan (const SlicedTube< Interval > &x1)
	Pointwise tangent of a scalar interval tube.
SlicedTube< Interval >	acos (const SlicedTube< Interval > &x1)
	Pointwise arc-cosine of a scalar interval tube.
SlicedTube< Interval >	asin (const SlicedTube< Interval > &x1)
	Pointwise arc-sine of a scalar interval tube.
SlicedTube< Interval >	atan (const SlicedTube< Interval > &x1)
	Pointwise arc-tangent of a scalar interval tube.
SlicedTube< Interval >	atan2 (const SlicedTube< Interval > &x1, const SlicedTube< Interval > &x2)
	Pointwise two-argument arc-tangent of two scalar interval tubes.
SlicedTube< Interval >	atan2 (const SlicedTube< Interval > &x1, const Interval &x2)
	Pointwise two-argument arc-tangent of a scalar interval tube and an interval.
SlicedTube< Interval >	atan2 (const Interval &x1, const SlicedTube< Interval > &x2)
	Pointwise two-argument arc-tangent of an interval and a scalar interval tube.
SlicedTube< Interval >	cosh (const SlicedTube< Interval > &x1)
	Pointwise hyperbolic cosine of a scalar interval tube.
SlicedTube< Interval >	sinh (const SlicedTube< Interval > &x1)
	Pointwise hyperbolic sine of a scalar interval tube.
SlicedTube< Interval >	tanh (const SlicedTube< Interval > &x1)
	Pointwise hyperbolic tangent of a scalar interval tube.
SlicedTube< Interval >	acosh (const SlicedTube< Interval > &x1)
	Pointwise inverse hyperbolic cosine of a scalar interval tube.
SlicedTube< Interval >	asinh (const SlicedTube< Interval > &x1)
	Pointwise inverse hyperbolic sine of a scalar interval tube.
SlicedTube< Interval >	atanh (const SlicedTube< Interval > &x1)
	Pointwise inverse hyperbolic tangent of a scalar interval tube.
SlicedTube< Interval >	abs (const SlicedTube< Interval > &x1)
	Pointwise absolute value of a scalar interval tube.
SlicedTube< Interval >	min (const SlicedTube< Interval > &x1, const SlicedTube< Interval > &x2)
	Pointwise minimum of two scalar interval tubes.
SlicedTube< Interval >	min (const SlicedTube< Interval > &x1, const Interval &x2)
	Pointwise minimum of a scalar interval tube and an interval.
SlicedTube< Interval >	min (const Interval &x1, const SlicedTube< Interval > &x2)
	Pointwise minimum of an interval and a scalar interval tube.
SlicedTube< Interval >	max (const SlicedTube< Interval > &x1, const SlicedTube< Interval > &x2)
	Pointwise maximum of two scalar interval tubes.
SlicedTube< Interval >	max (const SlicedTube< Interval > &x1, const Interval &x2)
	Pointwise maximum of a scalar interval tube and an interval.
SlicedTube< Interval >	max (const Interval &x1, const SlicedTube< Interval > &x2)
	Pointwise maximum of an interval and a scalar interval tube.
SlicedTube< Interval >	sign (const SlicedTube< Interval > &x1)
	Pointwise sign of a scalar interval tube.
SlicedTube< Interval >	integer (const SlicedTube< Interval > &x1)
	Pointwise integer-part operator applied to a scalar interval tube.
SlicedTube< Interval >	floor (const SlicedTube< Interval > &x1)
	Pointwise floor of a scalar interval tube.
SlicedTube< Interval >	ceil (const SlicedTube< Interval > &x1)
	Pointwise ceiling of a scalar interval tube.
std::shared_ptr< TDomain >	create_tdomain (const Interval &t0_tf=Interval(-oo, oo))
	Creates a temporal domain made of a single slice.
std::shared_ptr< TDomain >	create_tdomain (const Interval &t0_tf, double dt, bool with_gates=true)
	Creates a sampled temporal domain.
std::ostream &	operator<< (std::ostream &os, const TimePropag &x)
	Streams out a TimePropag.
template<typename... X>
SlicedTube< IntervalVector >	tube_cart_prod (const X &... x)
	Computes the Cartesian product of several sliced tubes.
AnalyticFunction< ScalarType >	map_scalar_entries (const AnalyticFunction< ScalarType > &f, const ScalarExprTransform &transform)
	Applies a scalar transformation to a scalar analytic function.
AnalyticFunction< VectorType >	map_scalar_entries (const AnalyticFunction< VectorType > &f, const ScalarExprTransform &transform)
	Applies a scalar transformation componentwise to a vector analytic function.
AnalyticFunction< MatrixType >	map_scalar_entries (const AnalyticFunction< MatrixType > &f, const ScalarExprTransform &transform)
	Applies a scalar transformation entrywise to a matrix analytic function.
ConvexPolygon	operator& (const ConvexPolygon &p1, const ConvexPolygon &p2)
	Computes the intersection of two convex polygons.
std::ostream &	operator<< (std::ostream &os, const OrientationInterval &x)
	Streams out a OrientationInterval.
OrientationInterval	orientation (const IntervalVector &p1, const IntervalVector &p2, const IntervalVector &p3)
	Computes the orientation of an ordered triplet of 2D points.
BoolInterval	aligned (const IntervalVector &p1, const IntervalVector &p2, const IntervalVector &p3)
	Checks whether three 2D points are aligned (colinear).
std::vector< IntervalVector >	convex_hull (std::vector< IntervalVector > pts)
	Computes the convex hull of a set of 2d points.
IntervalVector	rotate (const IntervalVector &p, const Interval &a, const IntervalVector &c=Vector::zero(2))
	Rotates a 2D interval vector around a point by a given angle.
template<typename T>
T	rotate (const T &x, const Interval &a, const IntervalVector &c=Vector::zero(2))
	Rotates a 2D object (Segment, Polygon, etc) around a point by a given angle.
void	merge_adjacent_points (std::list< IntervalVector > &l)
	Merges overlapping or adjacent IntervalVector points within a list.
std::ostream &	operator<< (std::ostream &str, const Polygon &p)
	Stream output operator for Polygon.
IntervalVector	operator& (const Segment &e1, const Segment &e2)
	Computes the intersection of two segments.
IntervalVector	proj_intersection (const Segment &e1, const Segment &e2)
	Computes the projected intersection of two segments.
BoolInterval	colinear (const Segment &e1, const Segment &e2)
	Checks if two segments are colinear.
std::ostream &	operator<< (std::ostream &str, const Segment &e)
	Stream output operator for Segment.
Matrix	gauss_jordan (const Matrix &A)
	Gauss Jordan band diagonalization preconditioning.
template<LeftOrRightInv O = LEFT_INV, typename OtherDerived, typename OtherDerived_>
IntervalMatrix	inverse_correction (const Eigen::MatrixBase< OtherDerived > &A, const Eigen::MatrixBase< OtherDerived_ > &B)
	Correct the approximation of the inverse \(\mathbf{B}\approx\mathbf{A}^{-1}\) of a square matrix \(\mathbf{A}\) by providing a reliable enclosure \([\mathbf{A}^{-1}]\).
template<typename OtherDerived>
IntervalMatrix	inverse_enclosure (const Eigen::MatrixBase< OtherDerived > &A)
	Enclosure of the inverse of a (non-singular) matrix expression, possibly an interval matrix.
IntervalMatrix	infinite_sum_enclosure (const IntervalMatrix &A, double &mrad)
	Compute an upper bound of \(\left([\mathbf{A}]+[\mathbf{A}]^2+[\mathbf{A}]^3+\dots\right)\), with \([\mathbf{A}]\) a matrix of intervals as an "error term" (uses only bounds on coefficients).
template<typename OtherDerived>
auto	abs (const Eigen::MatrixBase< OtherDerived > &x)
	Compute the element-wise absolute value of a matrix.
template<typename OtherDerived>
auto	floor (const Eigen::MatrixBase< OtherDerived > &x)
	Compute the element-wise floor of a matrix.
template<typename OtherDerived>
auto	ceil (const Eigen::MatrixBase< OtherDerived > &x)
	Compute the element-wise ceiling of a matrix.
template<typename OtherDerived>
auto	round (const Eigen::MatrixBase< OtherDerived > &x)
	Compute the element-wise rounding of a matrix.
Eigen::IOFormat	codac_row_fmt ()
	Provides an Eigen IOFormat for formatting row vectors.
Eigen::IOFormat	codac_vector_fmt ()
	Provides an Eigen IOFormat for formatting column vectors.
Eigen::IOFormat	codac_matrix_fmt ()
	Provides an Eigen IOFormat for formatting matrices.
std::ostream &	operator<< (std::ostream &os, const Matrix &x)
	Stream output operator for Matrix objects.
std::ostream &	operator<< (std::ostream &os, const Row &x)
	Stream output operator for Row objects.
std::ostream &	operator<< (std::ostream &os, const Vector &x)
	Stream output operator for Vector objects.
Parallelepiped	parallelepiped_inclusion (const IntervalVector &Y, const IntervalMatrix &Jf, const Matrix &Jf_tild, const AnalyticFunction< VectorType > &psi_0, const OctaSym &sigma, const IntervalVector &X)
	Used in PEIBOS. Compute a parallelepiped enclosing of \(\mathbf{g}([\mathbf{x}])\) where \(\mathbf{g} = \mathbf{f}\circ \sigma \circ \psi_0\).
std::vector< Parallelepiped >	PEIBOS (const AnalyticFunction< VectorType > &f, const AnalyticFunction< VectorType > &psi_0, const std::vector< OctaSym > &Sigma, double epsilon, bool verbose=false)
	Compute a set of parallelepipeds enclosing \(\mathbf{f}(\sigma(\psi_0([-1,1]^m)))\) for each symmetry \(\sigma\) in the set of symmetries \(\Sigma\). Note that \(\left\{\psi_0,\Sigma\right\}\) form a gnomonic atlas.
std::vector< Parallelepiped >	PEIBOS (const AnalyticFunction< VectorType > &f, const AnalyticFunction< VectorType > &psi_0, const std::vector< OctaSym > &Sigma, double epsilon, const Vector &offset, bool verbose=false)
	Compute a set of parallelepipeds enclosing \(\mathbf{f}(\sigma(\psi_0([-1,1]^m)) + offset) \) for each symmetry \(\sigma\) in the set of symmetries \(\Sigma\). Note that \(\left\{\psi_0,\Sigma\right\}\) form a gnomonic atlas.
double	split (const IntervalVector &X, double eps, std::vector< IntervalVector > &boxes)
	Recursively split a box until the maximum diameter of each box is less than eps. Note that the resulting boxes are stored in place in the vector boxes.
double	error_peibos (const IntervalVector &Y, const Vector &z, const IntervalMatrix &Jf, const Matrix &A, const IntervalVector &X)
	Compute the error term for the parallelepiped inclusion. The error is later used to inflate the flat parallelepiped \(\mathbf{z}+\mathbf{A}\cdot(\left[\mathbf{x}\right]-\bar{\mathbf{x}})\).
Matrix	inflate_flat_parallelepiped (const Matrix &A, const Vector &e_vec, double rho)
	Inflate the flat parallelepiped \(\mathbf{A}\cdot e_{vec}\) by \(\rho\).
template<typename T>
void	serialize (std::ostream &f, const T &x)
	Writes the binary representation of a trivially copyable object to the given output stream.
template<typename T>
void	deserialize (std::istream &f, T &x)
	Reads the binary representation of a trivially copyable object from the given input stream.
void	serialize (std::ostream &f, const Interval &x)
	Writes the binary representation of an Interval object to the given output stream.
void	deserialize (std::istream &f, Interval &x)
	Creates an Interval object from the binary representation given in an input stream.
template<typename T, int R = -1, int C = -1>
void	serialize (std::ostream &f, const Eigen::Matrix< T, R, C > &x)
	Writes the binary representation of an Eigen::Matrix to the given output stream. The structure can be a matrix, a row, a vector, with double or Interval components.
template<typename T, int R = -1, int C = -1>
void	deserialize (std::istream &f, Eigen::Matrix< T, R, C > &x)
	Reads the binary representation of an Eigen::Matrix from the given input stream. The structure can be a matrix, a row, a vector, with double or Interval components.
template<typename T>
void	serialize (std::ostream &f, const SampledTraj< T > &x)
	Writes the binary representation of a SampledTraj object to the given output stream.
template<typename T>
void	deserialize (std::istream &f, SampledTraj< T > &x)
	Reads the binary representation of a SampledTraj object from the given input stream.
template<typename T>
const SampledTraj< T > &	operator+ (const SampledTraj< T > &x1)
	\(x1(\cdot)\)
template<typename T>
SampledTraj< T >	operator+ (const SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_binary_traj_traj(operator_add< T >)
	\(x_1(\cdot)+x_2(\cdot)\)
template<typename T, typename Q>
SampledTraj< T >	operator+ (const SampledTraj< T > &x1, const Q &x2) macro_binary_traj_real(operator_add< T >)
	\(x_1(\cdot)+x_2\)
template<typename T, typename Q>
SampledTraj< T >	operator+ (const Q &x1, const SampledTraj< T > &x2) macro_binary_real_traj(operator_add< T >)
	\(x+x_2(\cdot)\)
template<typename T, typename Q>
SampledTraj< T > &	operator+= (SampledTraj< T > &x1, const Q &x2) macro_member_binary_traj_real(operator_add< T >)
	Operates +=.
template<typename T>
SampledTraj< T > &	operator+= (SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_member_binary_traj_traj(operator_add< T >)
	Operates +=.
template<typename T>
SampledTraj< T >	operator- (const SampledTraj< T > &x1)
	\(-x_1(\cdot)\)
template<typename T>
SampledTraj< T >	operator- (const SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_binary_traj_traj(operator_sub< T >)
	\(x_1(\cdot)-x_2(\cdot)\)
template<typename T, typename Q>
SampledTraj< T >	operator- (const SampledTraj< T > &x1, const Q &x2) macro_binary_traj_real(operator_sub< T >)
	\(x_1(\cdot)-x_2\)
template<typename T, typename Q>
SampledTraj< T >	operator- (const Q &x1, const SampledTraj< T > &x2) macro_binary_real_traj(operator_sub< T >)
	\(x-x_2(\cdot)\)
template<typename T, typename Q>
SampledTraj< T > &	operator-= (SampledTraj< T > &x1, const Q &x2) macro_member_binary_traj_real(operator_sub< T >)
	Operates -=.
template<typename T>
SampledTraj< T > &	operator-= (SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_member_binary_traj_traj(operator_sub< T >)
	Operates -=.
template<typename T>
SampledTraj< T >	operator* (double x1, const SampledTraj< T > &x2) macro_binary_real_traj(operator_mul_scal< T >)
	\(x_1\cdot x_2(\cdot)\)
template<typename T>
SampledTraj< T >	operator* (const SampledTraj< T > &x1, double x2) macro_binary_traj_real(operator_mul_scal< T >)
	\(x_1(\cdot)\cdot x_2\)
template<typename T>
SampledTraj< T >	operator* (const SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_binary_traj_traj(operator_mul< T >)
	\(x_1(\cdot)\cdot x_2(\cdot)\)
template<typename T, typename Q>
SampledTraj< T >	operator* (const SampledTraj< T > &x1, const Q &x2) macro_binary_traj_real(operator_mul< T >)
	\(x_1(\cdot)\cdot x_2\)
template<typename T, typename Q>
SampledTraj< T >	operator* (const Q &x1, const SampledTraj< T > &x2) macro_binary_real_traj(operator_mul< T >)
	\(x\cdot x_2(\cdot)\)
SampledTraj< Vector >	operator* (const SampledTraj< Matrix > &x1, const SampledTraj< Vector > &x2) macro_binary_traj_traj(operator_mul_vec)
	\(x_1(\cdot)\cdot x_2\)
template<typename T, typename Q>
SampledTraj< T > &	operator*= (SampledTraj< T > &x1, const Q &x2) macro_member_binary_traj_real(operator_mul< T >)
	Operates *=.
template<typename T>
SampledTraj< T > &	operator*= (SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_member_binary_traj_traj(operator_mul< T >)
	Operates *=.
template<typename T>
SampledTraj< T >	operator/ (const SampledTraj< T > &x1, double x2) macro_binary_traj_real(operator_div_scal< T >)
	\(x_2(\cdot)/x_1\)
template<typename T>
SampledTraj< T >	operator/ (const SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_binary_traj_traj(operator_div< T >)
	\(x_1(\cdot)/x_2(\cdot)\)
template<typename T, typename Q>
SampledTraj< T >	operator/ (const SampledTraj< T > &x1, const Q &x2) macro_binary_traj_real(operator_div< T >)
	\(x_1(\cdot)/x_2\)
template<typename T, typename Q>
SampledTraj< T >	operator/ (const Q &x1, const SampledTraj< T > &x2) macro_binary_real_traj(operator_div< T >)
	\(x/x_2(\cdot)\)
template<typename T, typename Q>
SampledTraj< T > &	operator/= (SampledTraj< T > &x1, const Q &x2) macro_member_binary_traj_real(operator_div< T >)
	Operates /=.
template<typename T>
SampledTraj< T > &	operator/= (SampledTraj< T > &x1, const SampledTraj< T > &x2) macro_member_binary_traj_traj(operator_div< T >)
	Operates /=.
SampledTraj< double >	sqr (const SampledTraj< double > &x1)
	\(x^2(\cdot)\)
SampledTraj< double >	sqrt (const SampledTraj< double > &x1)
	\(\sqrt{x_1(\cdot)}\)
SampledTraj< double >	pow (const SampledTraj< double > &x1, int x2)
	\(x^x_2(\cdot)\)
SampledTraj< double >	pow (const SampledTraj< double > &x1, double x2)
	\(x^x_2(\cdot)\)
SampledTraj< double >	root (const SampledTraj< double > &x1, int x2)
	\(x^x_2(\cdot)\)
SampledTraj< double >	exp (const SampledTraj< double > &x1)
	\(\exp(x_1(\cdot))\)
SampledTraj< double >	log (const SampledTraj< double > &x1)
	\(\log(x_1(\cdot))\)
SampledTraj< double >	cos (const SampledTraj< double > &x1)
	\(\cos(x_1(\cdot))\)
SampledTraj< double >	sin (const SampledTraj< double > &x1)
	\(\sin(x_1(\cdot))\)
SampledTraj< double >	tan (const SampledTraj< double > &x1)
	\(\tan(x_1(\cdot))\)
SampledTraj< double >	acos (const SampledTraj< double > &x1)
	\(\arccos(x_1(\cdot))\)
SampledTraj< double >	asin (const SampledTraj< double > &x1)
	\(\arcsin(x_1(\cdot))\)
SampledTraj< double >	atan (const SampledTraj< double > &x1)
	\(\arctan(x_1(\cdot))\)
SampledTraj< double >	atan2 (const SampledTraj< double > &x1, const SampledTraj< double > &x2)
	\(\mathrm{arctan2}(x_1(\cdot),x_2(\cdot))\)
SampledTraj< double >	atan2 (const SampledTraj< double > &x1, double x2)
	\(\mathrm{arctan2}(x_1(\cdot),x_2)\)
SampledTraj< double >	atan2 (double x1, const SampledTraj< double > &x2)
	\(\mathrm{arctan2}(x_1, x_2(\cdot))\)
SampledTraj< double >	cosh (const SampledTraj< double > &x1)
	\(\cosh(x_1(\cdot))\)
SampledTraj< double >	sinh (const SampledTraj< double > &x1)
	\(\sinh(x_1(\cdot))\)
SampledTraj< double >	tanh (const SampledTraj< double > &x1)
	\(\tanh(x_1(\cdot))\)
SampledTraj< double >	acosh (const SampledTraj< double > &x1)
	\(\mathrm{arccosh}(x_1(\cdot))\)
SampledTraj< double >	asinh (const SampledTraj< double > &x1)
	\(\mathrm{arcsinh}(x_1(\cdot))\)
SampledTraj< double >	atanh (const SampledTraj< double > &x1)
	\(\mathrm{arctanh}(x_1(\cdot))\)
SampledTraj< double >	abs (const SampledTraj< double > &x1)
	\(\mid x_1(\cdot)\mid\)
SampledTraj< double >	min (const SampledTraj< double > &x1, const SampledTraj< double > &x2)
	\(\min(x_1(\cdot),x_2(\cdot))\)
SampledTraj< double >	min (const SampledTraj< double > &x1, double x2)
	\(\min(x_1(\cdot),x_2)\)
SampledTraj< double >	min (double x1, const SampledTraj< double > &x2)
	\(\min(x_1, x_2(\cdot))\)
SampledTraj< double >	max (const SampledTraj< double > &x1, const SampledTraj< double > &x2)
	\(\max(x_1(\cdot),x_2(\cdot))\)
SampledTraj< double >	max (const SampledTraj< double > &x1, double x2)
	\(\max(x_1(\cdot),x_2)\)
SampledTraj< double >	max (double x1, const SampledTraj< double > &x2)
	\(\max(x_1, x_2(\cdot))\)
capd::Interval	to_capd (const codac2::Interval &x)
	Converts a Codac Interval object into an CAPD Interval object.
codac2::Interval	to_codac (const capd::Interval &x)
	Converts an CAPD Interval object into a Codac Interval object.
capd::IVector	to_capd (const codac2::IntervalVector &x)
	Converts a Codac IntervalVector object into an CAPD IVector object.
codac2::IntervalVector	to_codac (const capd::IVector &x)
	Converts an CAPD IVector object into a Codac IntervalVector object.
capd::IMatrix	to_capd (const codac2::IntervalMatrix &x)
	Converts a Codac IntervalMatrix object into an CAPD IMatrix object.
codac2::IntervalMatrix	to_codac (const capd::IMatrix &x)
	Converts an CAPD IMatrix object into a Codac IntervalMatrix object.
codac2::SlicedTube< codac2::IntervalVector >	to_codac (const codac2::SolutionCurveWrapper &solution_curve, const std::shared_ptr< TDomain > &tdomain)
	Converts a CAPD SolutionCurve into a Codac SlicedTube.
std::map< double, std::vector< T > >	PEIBOS (const capd::IMap &i_map, double tf, double dt, const AnalyticFunction< VectorType > &psi_0, const std::vector< OctaSym > &Sigma, double epsilon, bool verbose=false)
	PEIBOS algorithm using CAPD for guaranteed ODE propagation.
std::map< double, std::vector< T > >	PEIBOS (const capd::IMap &i_map, double tf, double dt, const AnalyticFunction< VectorType > &psi_0, const std::vector< OctaSym > &Sigma, double epsilon, const Vector &offset, bool verbose=false)
	PEIBOS algorithm using CAPD for guaranteed ODE propagation.
std::map< double, std::vector< Parallelepiped > >	reach_set (const std::map< double, std::vector< T > > &peibos_output)
	Compute the reach set parallelepipeds from the PEIBOS CAPD output.
AnalyticFunction< ScalarType >	sympy_simplify (const AnalyticFunction< ScalarType > &f)
	Symbolically simplifies a scalar analytic function.
AnalyticFunction< VectorType >	sympy_simplify (const AnalyticFunction< VectorType > &f)
	Symbolically simplifies a vector analytic function componentwise.
AnalyticFunction< MatrixType >	sympy_simplify (const AnalyticFunction< MatrixType > &f)
	Symbolically simplifies a matrix analytic function componentwise.
AnalyticFunction< ScalarType >	sympy_horner (const AnalyticFunction< ScalarType > &f)
	Rewrites a scalar analytic function in Horner form when possible.
AnalyticFunction< VectorType >	sympy_horner (const AnalyticFunction< VectorType > &f)
	Rewrites a vector analytic function in Horner form componentwise.
AnalyticFunction< MatrixType >	sympy_horner (const AnalyticFunction< MatrixType > &f)
	Rewrites a matrix analytic function in Horner form componentwise.
AnalyticFunction< ScalarType >	sympy_partial_diff (const AnalyticFunction< ScalarType > &f, Index flat_input_index)
	Returns the symbolic partial derivative of a scalar function.
AnalyticFunction< ScalarType >	sympy_partial_diff (const AnalyticFunction< ScalarType > &f, const ScalarVar &x)
	Returns the symbolic partial derivative of a scalar function with respect to a scalar input variable.
AnalyticFunction< ScalarType >	sympy_partial_diff (const AnalyticFunction< ScalarType > &f, const ScalarExpr &x)
	Returns the symbolic partial derivative of a scalar function with respect to a scalar input expression.
AnalyticFunction< ScalarType >	sympy_diff (const AnalyticFunction< ScalarType > &f)
	Returns the symbolic derivative of a scalar univariate function.
AnalyticFunction< ScalarType >	sympy_diff (const AnalyticFunction< ScalarType > &f, const ScalarVar &x)
	Returns the symbolic first derivative of a scalar function with respect to a scalar input variable.
AnalyticFunction< ScalarType >	sympy_diff (const AnalyticFunction< ScalarType > &f, const ScalarExpr &x)
	Returns the symbolic first derivative of a scalar function with respect to a scalar input expression.
AnalyticFunction< ScalarType >	sympy_diff (const AnalyticFunction< ScalarType > &f, Index order)
	Returns the symbolic derivative of given order for a scalar univariate function.
AnalyticFunction< ScalarType >	sympy_diff (const AnalyticFunction< ScalarType > &f, const ScalarVar &x, Index order)
	Returns the symbolic derivative of given order for a scalar function with respect to a scalar input variable.
AnalyticFunction< ScalarType >	sympy_diff (const AnalyticFunction< ScalarType > &f, const ScalarExpr &x, Index order)
	Returns the symbolic derivative of given order for a scalar function with respect to a scalar input expression.
AnalyticFunction< VectorType >	sympy_gradient (const AnalyticFunction< ScalarType > &f)
	Returns the symbolic gradient of a scalar function.
AnalyticFunction< MatrixType >	sympy_hessian (const AnalyticFunction< ScalarType > &f)
	Returns the symbolic Hessian matrix of a scalar function.
AnalyticFunction< MatrixType >	sympy_diff (const AnalyticFunction< VectorType > &f)
	Returns the symbolic Jacobian matrix of a vector function.
AnalyticFunction< ScalarType >	sympy_series (const AnalyticFunction< ScalarType > &f, double center, Index order)
	Returns a truncated Taylor series of a scalar univariate function.
AnalyticFunction< ScalarType >	sympy_series (const AnalyticFunction< ScalarType > &f, const ScalarVar &x, double center, Index order)
	Returns a truncated Taylor series of a scalar function with respect to a scalar input variable.
AnalyticFunction< ScalarType >	sympy_series (const AnalyticFunction< ScalarType > &f, const ScalarExpr &x, double center, Index order)
	Returns a truncated Taylor series of a scalar function with respect to a scalar input expression.
bool	sympy_equal (const AnalyticFunction< ScalarType > &f, const AnalyticFunction< ScalarType > &g)
	Tests symbolic equality of two scalar analytic functions through SymPy.
bool	sympy_equal (const AnalyticFunction< VectorType > &f, const AnalyticFunction< VectorType > &g)
	Tests symbolic equality of two vector analytic functions through SymPy.
bool	sympy_equal (const AnalyticFunction< MatrixType > &f, const AnalyticFunction< MatrixType > &g)
	Tests symbolic equality of two matrix analytic functions through SymPy.
template<typename T = void>
void	draw_while_paving (const IntervalVector &x0, std::shared_ptr< const CtcBase< IntervalVector > > c, double eps, std::shared_ptr< Figure2D > fig=nullptr)
	Deprecated!
template<typename T = void>
void	draw_while_paving (const IntervalVector &x0, const CtcBase< IntervalVector > &c, double eps, std::shared_ptr< Figure2D > fig=nullptr)
	Deprecated!
template<typename T = void>
void	draw_while_paving (const IntervalVector &x0, std::shared_ptr< const SepBase > s, double eps, std::shared_ptr< Figure2D > fig=nullptr)
	Deprecated!
template<typename T = void>
void	draw_while_paving (const IntervalVector &x0, const SepBase &s, double eps, std::shared_ptr< Figure2D > fig=nullptr)
	Deprecated!

Detailed Description

codac2_ibex_impl.h

Date

2024

Author

Gilles Chabert, (Simon Rohou)

Copyright

Copyright 2024 Codac Team

License: GNU Lesser General Public License (LGPL)

Typedef Documentation

IntervalMatrix

using codac2::IntervalMatrix = Eigen::Matrix<Interval,-1,-1>

Alias for a dynamic-size matrix of intervals.

Represents a matrix with a dynamic number of rows and columns, where each element is an Interval object.

This type alias is based on Eigen's matrix template and corresponds to Eigen::Matrix<Interval,-1,-1>.

IntervalRow

using codac2::IntervalRow = Eigen::Matrix<Interval,1,-1>

Alias for a dynamic-size row vector of intervals.

Represents a row vector with a dynamic number of columns, where each element is an Interval object.

This type alias is based on Eigen's matrix template and corresponds to Eigen::Matrix<Interval,1,-1>.

IntervalVector

using codac2::IntervalVector = Eigen::Matrix<Interval,-1,1>

Alias for a dynamic-size column vector of intervals.

Represents a column vector with a dynamic number of rows, where each element is an Interval object.

This type alias is based on Eigen's matrix template and corresponds to Eigen::Matrix<Interval,-1,1>.

ScalarExprTransform

using codac2::ScalarExprTransform = std::function<ScalarExpr(const ScalarExpr&)>

Scalar transformation applied to the entries of an analytic function output.

This callback takes one scalar analytic expression and returns the transformed scalar expression.

Matrix

using codac2::Matrix = Eigen::Matrix<double,-1,-1>

Alias for a dynamic-size matrix of doubles.

Represents a matrix with dynamic number of rows and columns, where each element is a double precision floating point number.

This type alias is based on Eigen's matrix template and corresponds to Eigen::Matrix<double,-1,-1>.

See also

Vector, Row, Eigen::Matrix

Row

using codac2::Row = Eigen::Matrix<double,1,-1>

Alias for a dynamically-sized row vector of doubles.

Defines a convenient shorthand for representing row vectors with dynamic size. This type alias is based on Eigen's matrix template and corresponds to Eigen::Matrix<double,1,-1>.

See also

Eigen::Matrix

Vector

using codac2::Vector = Eigen::Matrix<double,-1,1>

Alias for a dynamically-sized column vector of doubles.

Defines a convenient shorthand for representing column vectors with dynamic size. This type alias is based on Eigen's matrix template and corresponds to Eigen::Matrix<double,-1,1>.

See also

Eigen::Matrix

Enumeration Type Documentation

BoolInterval

enum class codac2::BoolInterval

strong

Enumeration representing a boolean interval.

The logical operators & and | can be used to combine BoolInterval values.

Set operators & (intersection) and | (union) and logical operators && (AND) and || (OR) are overloaded to combine BoolInterval values consistently.

Enumerator
EMPTY	EMPTY is equivalent to the operation TRUE & FALSE.
UNKNOWN	UNKNOWN is equivalent to the operation TRUE | FALSE.

  {
    FALSE = 0x01,
    TRUE = 0x02,
    EMPTY = 0x00,
    UNKNOWN = 0x01 | 0x02
  };

TimePropag

enum class codac2::TimePropag

strong

Enumeration specifying the temporal propagation way (forward or backward in time).

The logical operators & and | can be used to combine TimePropag values.

  {
    FWD = 0x01,
    BWD = 0x02,
    FWD_BWD = 0x01 | 0x02
  };

OrientationInterval

enum class codac2::OrientationInterval

strong

Enumeration representing feasible orientations. Can be used to assess an oriented angle, or the alignement of three points.

The logical operator | can be used to combine OrientationInterval values.

Enumerator
UNKNOWN	UNKNOWN: the orientation can be either clockwise, counter-clockwise, or aligned.

  {
    COLINEAR = 0x01,
    CLOCKWISE = 0x02,
    COUNTERCLOCKWISE = 0x04,
    EMPTY = 0x00,
    UNKNOWN = 0x01 | 0x02 | 0x04
  };

Model

enum codac2::Model

Color model (RGB or HSV).

This enum is used to specify the color model of a color, either RGB or HSV.

{ RGB, HSV };

Function Documentation

operator&() [1/11]

template<typename C1, typename C2>

CtcInterType< typenameC1::ContractedTypes >::Ctc codac2::operator&	(	const C1 &	c1,
		const C2 &	c2 )

Builds an intersection contractor from two contractors.

This overload enables the natural syntax c1 & c2.

Template Parameters

C1	Type of the first contractor.
C2	Type of the second contractor.

Parameters

c1	First contractor.
c2	Second contractor.

Returns

The intersection contractor storing c1 and c2.

  {
    return { c1, c2 };
  }

operator&() [2/11]

template<typename C1, typename C2>

CtcInterType< typenameC1::ContractedTypes >::Ctc codac2::operator&	(	const std::shared_ptr< C1 > &	c1,
		const std::shared_ptr< C2 > &	c2 )

Builds an intersection contractor from two shared contractor pointers.

Template Parameters

C1	Type of the first pointed contractor.
C2	Type of the second pointed contractor.

Parameters

c1	Shared pointer to the first contractor.
c2	Shared pointer to the second contractor.

Returns

The resulting intersection contractor.

  {
    return { c1, c2 };
  }

operator&() [3/11]

template<typename C1, typename C2>

CtcInterType< typenameC1::ContractedTypes >::Ctc codac2::operator&	(	const std::shared_ptr< C1 > &	c1,
		const C2 &	c2 )

Builds an intersection contractor from a shared contractor pointer and a contractor.

Template Parameters

C1	Type of the first pointed contractor.
C2	Type of the second contractor.

Parameters

c1	Shared pointer to the first contractor.
c2	Second contractor.

Returns

The resulting intersection contractor.

  {
    return { c1, c2 };
  }

operator&() [4/11]

template<typename C1, typename C2>

CtcInterType< typenameC1::ContractedTypes >::Ctc codac2::operator&	(	const C1 &	c1,
		const std::shared_ptr< C2 > &	c2 )

Builds an intersection contractor from a contractor and a shared contractor pointer.

Template Parameters

C1	Type of the first contractor.
C2	Type of the second pointed contractor.

Parameters

c1	First contractor.
c2	Shared pointer to the second contractor.

Returns

The resulting intersection contractor.

  {
    return { c1, c2 };
  }

operator&() [5/11]

template<typename C2>

CtcInter< IntervalVector > codac2::operator& ( const IntervalVector & c1, const C2 & c2 )

inline

Intersects a box with a contractor by wrapping the box into a CtcWrapper.

This overload enables expressions such as box & ctc.

Template Parameters

C2	Type of the contractor.

Parameters

c1	Box interpreted as a wrapper contractor.
c2	Contractor.

Returns

The resulting box-contractor intersection.

  {
    assert_release(c1.size() == c2.size());
    return CtcInter<IntervalVector>(CtcWrapper(c1),c2);
  }

operator&() [6/11]

template<typename C1>

CtcInter< IntervalVector > codac2::operator& ( const C1 & c1, const IntervalVector & c2 )

inline

Intersects a contractor with a box by wrapping the box into a CtcWrapper.

This overload enables expressions such as ctc & box.

Template Parameters

C1	Type of the contractor.

Parameters

c1	Contractor.
c2	Box interpreted as a wrapper contractor.

Returns

The resulting box-contractor intersection.

  {
    assert_release(c1.size() == c2.size());
    return CtcInter<IntervalVector>(c1,CtcWrapper(c2));
  }

operator&() [7/11]

BoolInterval codac2::operator& ( BoolInterval x, BoolInterval y )

constexpr

Intersection operator for BoolInterval sets.

Performs a bitwise AND on the integer representations of two BoolInterval values.

Parameters

x	The left-hand BoolInterval operand.
y	The right-hand BoolInterval operand.

Returns

The result of the intersection.

  {
    return static_cast<BoolInterval>(static_cast<int>(x) & static_cast<int>(y));
  }

operator|() [1/4]

BoolInterval codac2::operator| ( BoolInterval x, BoolInterval y )

constexpr

Union operator for BoolInterval sets.

Performs a bitwise OR on the integer representations of two BoolInterval values.

Parameters

x	The left-hand BoolInterval operand.
y	The right-hand BoolInterval operand.

Returns

The result of the union.

  {
    return static_cast<BoolInterval>(static_cast<int>(x) | static_cast<int>(y));
  }

operator&&()

BoolInterval codac2::operator&& ( BoolInterval x, BoolInterval y )

constexpr

Logical AND operator for BoolInterval sets.

Note

Not to be confused with the bitwise AND operator & (which represents an interval intersection rather than a logical conjunction).

Parameters

x	The left-hand BoolInterval operand.
y	The right-hand BoolInterval operand.

Returns

The logical AND result as a BoolInterval.

  {
    if((x == BoolInterval::EMPTY) || (y == BoolInterval::EMPTY))
      return BoolInterval::EMPTY;
    if((x == BoolInterval::FALSE) || (y == BoolInterval::FALSE))
      return BoolInterval::FALSE;
    if((x == BoolInterval::UNKNOWN) || (y == BoolInterval::UNKNOWN))
      return BoolInterval::UNKNOWN;
    return BoolInterval::TRUE;
  }

operator||()

BoolInterval codac2::operator|| ( BoolInterval x, BoolInterval y )

constexpr

Logical OR operator for BoolInterval sets.

Note

Not to be confused with the bitwise OR operator | (which represents an interval union rather than a logical disjunction).

Parameters

x	The left-hand BoolInterval operand.
y	The right-hand BoolInterval operand.

Returns

The logical OR result as a BoolInterval.

  {
    if((x == BoolInterval::EMPTY) || (y == BoolInterval::EMPTY))
      return BoolInterval::EMPTY;
    if((x == BoolInterval::TRUE) || (y == BoolInterval::TRUE))
      return BoolInterval::TRUE;
    if((x == BoolInterval::UNKNOWN) || (y == BoolInterval::UNKNOWN))
      return BoolInterval::UNKNOWN;
    return BoolInterval::FALSE;
  }

operator~()

BoolInterval codac2::operator~ ( BoolInterval x )

inline

Returns the complementary of a BoolInterval.

Parameters

x	the boolean interval

Returns

the complementary

  {
    switch(x)
    {
      case BoolInterval::FALSE:
        return BoolInterval::TRUE;
      case BoolInterval::TRUE:
        return BoolInterval::FALSE;
      default:
        return x;
    }
  }

operator<<() [1/13]

std::ostream & codac2::operator<< ( std::ostream & os, const BoolInterval & x )

inline

Streams out a BoolInterval.

Parameters

os	the stream to be updated
x	the boolean interval to stream out

Returns

a reference to the updated stream

  {
    switch(x)
    {
      case BoolInterval::EMPTY:
        os << "[ empty ]";
        break;
      case BoolInterval::FALSE:
        os << "[ false ]";
        break;
      case BoolInterval::TRUE:
        os << "[ true ]";
        break;
      case BoolInterval::UNKNOWN:
        os << "[ true, false ]";
        break;
    }
    return os;
  }

operator+() [1/13]

Ellipsoid codac2::operator+	(	const Ellipsoid &	e1,
		const Ellipsoid &	e2 )

Compute the Minkowski sum of two ellipsoids.

Parameters

e1	first ellipsoid
e2	second ellipsoid

Returns

the Minkowski sum

linear_mapping()

Ellipsoid codac2::linear_mapping	(	const Ellipsoid &	e,
		const Matrix &	A,
		const Vector &	b )

Guaranteed linear evaluation A*e+b, considering the rounding errors.

Parameters

e	input ellipsoid
A	matrix
b	vector

Returns

a rigorous outer enclosure of the linear mapping

unreliable_linear_mapping()

Ellipsoid codac2::unreliable_linear_mapping	(	const Ellipsoid &	e,
		const Matrix &	A,
		const Vector &	b )

Nonrigorous linear evaluation A*e+b.

Note

This function is used in linear_mapping() and provides a faster output than its guaranteed counterpart.

Parameters

e	input ellipsoid
A	matrix
b	vector

Returns

a nonrigorous approximation of the linear mapping

nonlinear_mapping() [1/2]

Ellipsoid codac2::nonlinear_mapping	(	const Ellipsoid &	e,
		const AnalyticFunction< VectorType > &	f )

(Rigorous?) non-linear evaluation f(e)

Parameters

e	input ellipsoid
f	non-linear analytical function

Returns

a (rigorous?) outer enclosure of the non-linear mapping

nonlinear_mapping() [2/2]

Ellipsoid codac2::nonlinear_mapping	(	const Ellipsoid &	e,
		const AnalyticFunction< VectorType > &	f,
		const Vector &	trig,
		const Vector &	q )

(Rigorous?) non-linear evaluation f(e), with parameters

Parameters

e	input ellipsoid
f	non-linear analytical function
trig	(?)
q	(?)

Returns

a (rigorous?) outer enclosure of the non-linear mapping

nonlinear_mapping_base()

Matrix codac2::nonlinear_mapping_base	(	const Matrix &	G,
		const Matrix &	J,
		const IntervalMatrix &	J_box,
		const Vector &	trig,
		const Vector &	q )

(Rigorous?) non-linear evaluation f(e), from Jacobian information

Parameters

G	(?)
J	approximated Jacobian matrix of f
J_box	reliable enclosure of the Jacobian matrix of f
trig	(?)
q	(?)

Returns

a (rigorous?) outer enclosure of the non-linear mapping

operator<<() [2/13]

std::ostream & codac2::operator<<	(	std::ostream &	os,
		const Ellipsoid &	e )

Streams out an Ellipsoid.

Parameters

os	the stream to be updated
e	the ellipsoid stream out

Returns

a reference to the updated stream

stability_analysis()

BoolInterval codac2::stability_analysis	(	const AnalyticFunction< VectorType > &	f,
		unsigned int	alpha_max,
		Ellipsoid &	e,
		Ellipsoid &	e_out,
		bool	verbose = false )

...

Parameters

f	...
alpha_max	...
e	...
e_out	...
verbose	...

Returns

...

solve_discrete_lyapunov()

Matrix codac2::solve_discrete_lyapunov	(	const Matrix &	A,
		const Matrix &	Q )

...

Parameters

A	...
Q	...

Returns

...

operator<<() [3/13]

std::ostream & codac2::operator<< ( std::ostream & os, const Interval & x )

inline

Streams out this.

Parameters

os	the stream to be updated
x	the interval to stream out

Returns

a reference to the updated stream

  {
    gaol::interval::precision(os.precision());
    gaol::operator<<(os,x);
    return os;
  }

operator""_i()

Interval codac2::operator""_i ( long double x )

inline

Codac defined literals allowing to produce an interval from a double.

Parameters

x	value to convert into an interval object

Returns

the interval \([x]\)

  {
    return Interval(x);
  }

prev_float()

double codac2::prev_float ( double x )

inline

Returns the previous representable double-precision floating-point value before x.

This function computes the largest double value that is strictly less than the input value x, effectively moving one step down in the floating-point representation.

See also

For obtaining the next representable double value greater than x, use next_float().

Parameters

x	The input double value.

Returns

The previous representable double value before x.

  {
    return gaol::previous_float(x);
  }

next_float()

double codac2::next_float ( double x )

inline

Returns the next representable double-precision floating-point value after x.

This function computes the smallest double value that is strictly greater than the input value x, effectively moving one step up in the floating-point representation.

See also

For obtaining the previous representable double value less than x, use prev_float().

Parameters

x	The input double value.

Returns

The next representable double value after x.

  {
    return gaol::next_float(x);
  }

operator&() [8/11]

Interval codac2::operator& ( const Interval & x, const Interval & y )

inline

Returns the intersection of two intervals: \([x]\cap[y]\).

Note

Returns an empty interval if there is no intersection.

Parameters

x	interval value
y	interval value

Returns

intersection result

  {
    if(x.is_empty() || y.is_empty() || x.ub() < y.lb())
      return Interval::empty();
    
    else
      return gaol::operator&(x,y);
  }

operator|() [2/4]

Interval codac2::operator| ( const Interval & x, double y )

inline

Returns the squared-union of an interval and a real: \([x]\sqcup\{y\}\).

Note

The squared-union is defined as: \([x]\sqcup[y]=\left[[x]\cup[y]\right]\)

Parameters

x	interval value
y	real value

Returns

squared-union result

  {
    return gaol::operator|(x,Interval(y));
  }

operator|() [3/4]

Interval codac2::operator| ( const Interval & x, const Interval & y )

inline

Returns the squared-union of two intervals: \([x]\sqcup[y]\).

Note

The squared-union is defined as: \([x]\sqcup[y]=\left[[x]\cup[y]\right]\)

Parameters

x	interval value
y	interval value

Returns

squared-union result

  {
    return gaol::operator|(x,y);
  }

operator+() [2/13]

const Interval & codac2::operator+ ( const Interval & x )

inline

Returns this.

Note

This operator is only provided for consistency purposes.

Parameters

x	interval value

Returns

the same interval

  {
    return x;
  }

operator+() [3/13]

Interval codac2::operator+ ( const Interval & x, double y )

inline

Returns \([x]+y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the addition result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator+(x,y);
  }

operator+() [4/13]

Interval codac2::operator+ ( double x, const Interval & y )

inline

Returns \(x+[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the addition result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator+(x,y);
  }

operator+() [5/13]

Interval codac2::operator+ ( const Interval & x, const Interval & y )

inline

Returns \([x]+[y]\).

Parameters

x	interval value
y	interval value

Returns

the addition result

  {
    return gaol::operator+(x,y);
  }

operator-() [1/11]

Interval codac2::operator- ( const Interval & x, double y )

inline

Returns \([x]-y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the substraction result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator-(x, y);
  }

operator-() [2/11]

Interval codac2::operator- ( double x, const Interval & y )

inline

Returns \(x-[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the substraction result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator-(x, y);
  }

operator-() [3/11]

Interval codac2::operator- ( const Interval & x, const Interval & y )

inline

Returns \([x]-[y]\).

Parameters

x	interval value
y	interval value

Returns

the substraction result

  {
    return gaol::operator-(x, y);
  }

operator*() [1/19]

Interval codac2::operator* ( const Interval & x, double y )

inline

Returns \([x]*y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the multiplication result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator*(x,y);
  }

operator*() [2/19]

Interval codac2::operator* ( double x, const Interval & y )

inline

Returns \(x*[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the multiplication result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator*(x,y);
  }

operator*() [3/19]

Interval codac2::operator* ( const Interval & x, const Interval & y )

inline

Returns \([x]*[y]\).

Parameters

x	interval value
y	interval value

Returns

the multiplication result

  {
    return gaol::operator*(x,y);
  }

operator/() [1/12]

Interval codac2::operator/ ( const Interval & x, double y )

inline

Returns \([x]/y\) with \(y\in\mathbb{R}\).

Parameters

x	interval value
y	real value

Returns

the division result

  {
    if(y == -oo || y == oo)
      return Interval::empty();
 
    else
      return gaol::operator/(x,y);
  }

operator/() [2/12]

Interval codac2::operator/ ( double x, const Interval & y )

inline

Returns \(x/[y]\) with \(x\in\mathbb{R}\).

Parameters

x	real value
y	interval value

Returns

the division result

  {
    if(x == -oo || x == oo)
      return Interval::empty();
 
    else
      return gaol::operator/(x,y);
  }

operator/() [3/12]

Interval codac2::operator/ ( const Interval & x, const Interval & y )

inline

Returns \([x]/[y]\).

Parameters

x	interval value
y	interval value

Returns

the division result

  {
    return gaol::operator/(x,y);
  }

sqr() [1/3]

Interval codac2::sqr ( const Interval & x )

inline

Returns \([x]^2\).

Parameters

x	interval value

Returns

the operation result

  {
    return gaol::sqr(x);
  }

sqrt() [1/3]

Interval codac2::sqrt ( const Interval & x )

inline

Returns \(\sqrt{[x]}\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::sqrt(x);
    gaol::round_upward();
    return y;
  }

pow() [1/7]

Interval codac2::pow ( const Interval & x, int n )

inline

Returns \([x]^n\), \(n\in\mathbb{Z}\).

Parameters

x	interval value
n	integer power value

Returns

the operation result

  {
    Interval y = gaol::pow(x,p);
    //gaol::round_upward(); // not necessary?
    return y;
  }

pow() [2/7]

Interval codac2::pow ( const Interval & x, double p )

inline

Returns \([x]^p\), \(p\in\mathbb{R}\).

Parameters

x	interval value
p	real power value

Returns

the operation result

  {
    if(p == -oo || p == oo)
      return Interval::empty();
 
    else
    {
      Interval y = gaol::pow(x,p);
      gaol::round_upward();
      return y;
    }
  }

pow() [3/7]

Interval codac2::pow ( const Interval & x, const Interval & p )

inline

Returns \([x]^{[p]}\), \(p\in\mathbb{IR}\).

Parameters

x	interval value
p	interval power value

Returns

the operation result

  {
    Interval y = gaol::pow(x,p);
    gaol::round_upward();
    return y;
  }

root() [1/2]

Interval codac2::root ( const Interval & x, int p )

inline

Returns the p-th root: \(\sqrt[p]{[x]}\).

Parameters

x	interval value
p	integer root

Returns

the operation result

  {
    // Get the root of the positive part (gaol does
    // not consider negative values to be in the definition
    // domain of the root function)
 
    gaol::interval y = gaol::nth_root(x, p>=0 ? p : -p);
 
    if(p%2 == 1 && x.lb() < 0)
      y |= -gaol::nth_root(-x, p >= 0 ? p : -p);
 
    if(p < 0)
      y = 1.0/y;
 
    gaol::round_upward();
    return y;
  }

exp() [1/3]

Interval codac2::exp ( const Interval & x )

inline

Returns \(\exp([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::exp(x);
    gaol::round_upward();
    return y;
  }

log() [1/3]

Interval codac2::log ( const Interval & x )

inline

Returns \(\log([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    if(x.ub() <= 0) // gaol returns (-oo,-DBL_MAX) if x.ub()==0, instead of empty set
      return Interval::empty();
 
    else
    {
      Interval y = gaol::log(x);
      gaol::round_upward();
      return y;
    }
  }

cos() [1/3]

Interval codac2::cos ( const Interval & x )

inline

Returns \(\cos([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::cos(x);
    gaol::round_upward();
    return y;
  }

sin() [1/3]

Interval codac2::sin ( const Interval & x )

inline

Returns \(\sin([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::sin(x);
    gaol::round_upward();
    return y;
  }

tan() [1/3]

Interval codac2::tan ( const Interval & x )

inline

Returns \(\tan([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::tan(x);
    gaol::round_upward();
    return y;
  }

acos() [1/3]

Interval codac2::acos ( const Interval & x )

inline

Returns \(\acos([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::acos(x);
    gaol::round_upward();
    return y;
  }

asin() [1/3]

Interval codac2::asin ( const Interval & x )

inline

Returns \(\asin([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::asin(x);
    gaol::round_upward();
    return y;
  }

atan() [1/3]

Interval codac2::atan ( const Interval & x )

inline

Returns \(\atan([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::atan(x);
    gaol::round_upward();
    return y;
  }

atan2() [1/7]

Interval codac2::atan2 ( const Interval & y, const Interval & x )

inline

Returns \(\mathrm{arctan2}([y],[x])\).

Parameters

y	interval value
x	interval value

Returns

the operation result

  {
    if(y.is_empty() || x.is_empty())
      return Interval::empty();
 
    // We handle the special case x=[0,0] separately
    else if(x == Interval::zero())
    {
      if(y.lb() >= 0)
      {
        if(y.ub() == 0)
          return Interval::empty(); // atan2(0,0) is undefined
        else
          return Interval::half_pi();
      }
 
      else if(y.ub() <= 0)
        return -Interval::half_pi();
 
      else
        return Interval(-1,1)*Interval::half_pi();
    }
 
    else if(x.lb() >= 0)
      return atan(y/x); // now, x.ub()>0 -> atan does not give an empty set
 
    else if(x.ub() <= 0)
    {
      if(y.lb() >= 0)
        return atan(y/x) + Interval::pi(); // x.lb()<0
      else if(y.ub() < 0)
        return atan(y/x) - Interval::pi();
      else
        return Interval(-1,1)*Interval::pi();
    }
 
    else
    {
      if(y.lb() >= 0)
        return atan(y/x.ub()) | (atan(y/x.lb()) + Interval::pi());
 
      else if(y.ub() <= 0)
      {
        if(x.lb() != -oo)
        {
          if(x.ub() != oo)
            return (atan(y/x.lb())-Interval::pi()) | atan(y/x.ub());
          else
            return (atan(y/x.lb())-Interval::pi()) | Interval::zero();
        }
 
        else
        {
          if(x.ub() != oo)
            return (-Interval::pi()) | atan(y/x.ub());
          else
            return -Interval::pi() | Interval::zero();
        }
      }
 
      else
        return Interval(-1,1)*Interval::pi();
    }
  }

cosh() [1/3]

Interval codac2::cosh ( const Interval & x )

inline

Returns \(\cosh([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y;
    if(x.is_unbounded()) 
      y = Interval(gaol::cosh(x).left(),oo);
    else
      y = gaol::cosh(x);
    gaol::round_upward();
    return y;
  }

sinh() [1/3]

Interval codac2::sinh ( const Interval & x )

inline

Returns \(\sinh([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::sinh(x);
    gaol::round_upward();
    return y;
  }

tanh() [1/3]

Interval codac2::tanh ( const Interval & x )

inline

Returns \(\tanh([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::tanh(x);
    gaol::round_upward();
    return y;
  }

acosh() [1/3]

Interval codac2::acosh ( const Interval & x )

inline

Returns \(\acosh([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::acosh(x);
    gaol::round_upward();
    return y;
  }

asinh() [1/3]

Interval codac2::asinh ( const Interval & x )

inline

Returns \(\asinh([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    if(x.is_empty())
      return Interval::empty();
 
    else if(x.lb() >= 0)
      return gaol::asinh(x);
 
    else if(x.ub() <= 0)
      return -gaol::asinh(-x);
 
    else
      return {
        -gaol::asinh(gaol::interval(0,-x.lb())).right(),
        gaol::asinh(gaol::interval(0,x.ub())).right()
      };
 
    // no round_upward?
  }

atanh() [1/3]

Interval codac2::atanh ( const Interval & x )

inline

Returns \(\atanh([x])\).

Parameters

x	interval value

Returns

the operation result

  {
    Interval y = gaol::atanh(x);
    gaol::round_upward();
    return y;
  }

abs() [1/4]

Interval codac2::abs ( const Interval & x )

inline

Returns \(\mid[x]\mid = \left\{\mid x \mid, x\in[x]\right\}\).

Parameters

x	interval value

Returns

the operation result

  {
    return gaol::abs(x);
  }

min() [1/7]

Interval codac2::min ( const Interval & x, const Interval & y )

inline

Returns \(\min([x],[y])=\left\{\min(x,y), x\in[x], y\in[y]\right\}\).

Parameters

x	interval value
y	interval value

Returns

the operation result

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

max() [1/7]

Interval codac2::max ( const Interval & x, const Interval & y )

inline

Returns \(\max([x],[y])=\left\{\max(x,y), x\in[x], y\in[y]\right\}\).

Parameters

x	interval value
y	interval value

Returns

the operation result

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

sign() [1/2]

Interval codac2::sign ( const Interval & x )

inline

Returns \(\sign([x])=\left[\left\{\sign(x), x\in[x]\right\}\right]\).

Note

By convention, \( 0\in[x] \Longrightarrow \sign([x])=[-1,1]\).

Parameters

x	interval value

Returns

the operation result

  {
    return x.ub() < 0 ? -1. : x.lb() > 0 ? 1. : Interval(-1.,1.);
  }

integer() [1/2]

Interval codac2::integer ( const Interval & x )

inline

Returns the largest integer interval included in \([x]\).

The result is a subset interval of x.

Parameters

x	interval value

Returns

the operation result

  {
    return gaol::integer(x);
  }

floor() [1/3]

Interval codac2::floor ( const Interval & x )

inline

Returns floor of \([x]\).

Parameters

x	interval value

Returns

the operation result

  {
    return gaol::floor(x);
  }

ceil() [1/3]

Interval codac2::ceil ( const Interval & x )

inline

Returns ceil of \([x]\).

Parameters

x	interval value

Returns

the operation result

  {
    return gaol::ceil(x);
  }

chi()

Interval codac2::chi ( const Interval & x, const Interval & y, const Interval & z )

inline

Return \([y]\) if \(x^+ <= 0\), \([z]\) if \(x^- > 0\), \([y]\sqcup[z]\) else.

Parameters

x	interval value
y	interval value
z	interval value

Returns

the operation result

  {
    if(x.ub() <= 0)
      return y;
    
    else if(x.lb() > 0)
      return z;
 
    else
      return y | z;
  }

operator<<() [4/13]

std::ostream & codac2::operator<< ( std::ostream & os, const IntervalMatrix & x )

inline

Stream output operator for IntervalMatrix objects.

Parameters

os	The output stream to write to.
x	The interval matrix whose contents are to be printed.

Returns

A reference to the modified output stream.

  {
    if(x.is_empty())
      return os << "[ empty " << x.rows() << "x" << x.cols() << " mat ]";
 
    else
    {
      os << x.format(codac_matrix_fmt());
      return os;
    }
  }

operator<<() [5/13]

std::ostream & codac2::operator<< ( std::ostream & os, const IntervalRow & x )

inline

Stream output operator for IntervalRow objects.

Parameters

os	The output stream to write to.
x	The interval row whose contents are to be printed.

Returns

A reference to the modified output stream.

  {
    if(x.is_empty())
      return os << "[ empty row ]";
 
    else
    {
      os << x.format(codac_row_fmt());
      return os;
    }
  }

operator<<() [6/13]

std::ostream & codac2::operator<< ( std::ostream & os, const IntervalVector & x )

inline

Stream output operator for IntervalVector objects.

Parameters

os	The output stream to write to.
x	The interval vector whose contents are to be printed.

Returns

A reference to the modified output stream.

  {
    if(x.is_empty())
      return os << "[ empty " << x.size() << "d box ]";
 
    else
    {
      os << x.format(codac_vector_fmt());
      return os;
    }
  }

operator|=()

template<typename T>

SlicedTube< T > & codac2::operator|= ( SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise hull-union assignment of two tubes with the same codomain type.

According to T, the operation is respectively \([x_1](\cdot)\sqcup[x_2](\cdot)\), \([\mathbf{x}_1](\cdot)\sqcup[\mathbf{x}_2](\cdot)\) or \([\mathbf{A}_1](\cdot)\sqcup[\mathbf{A}_2](\cdot)\).

Parameters

x1	left operand, updated in place.
x2	right operand.

Returns

x1 after the pointwise hull-union.

operator|() [4/4]

template<typename T>

SlicedTube< T > codac2::operator| ( const SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise hull-union of two tubes with the same codomain type.

According to T, the operation is respectively \([x_1](\cdot)\sqcup[x_2](\cdot)\), \([\mathbf{x}_1](\cdot)\sqcup[\mathbf{x}_2](\cdot)\) or \([\mathbf{A}_1](\cdot)\sqcup[\mathbf{A}_2](\cdot)\).

Parameters

x1	left operand.
x2	right operand.

Returns

The pointwise hull-union tube.

operator&=()

template<typename T>

SlicedTube< T > & codac2::operator&= ( SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise intersection assignment of two tubes with the same codomain type.

According to T, the operation is respectively \([x_1](\cdot)\cap[x_2](\cdot)\), \([\mathbf{x}_1](\cdot)\cap[\mathbf{x}_2](\cdot)\) or \([\mathbf{A}_1](\cdot)\cap[\mathbf{A}_2](\cdot)\).

Parameters

x1	left operand, updated in place.
x2	right operand.

Returns

x1 after the pointwise intersection.

operator&() [9/11]

template<typename T>

SlicedTube< T > codac2::operator& ( const SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise intersection of two tubes with the same codomain type.

According to T, the operation is respectively \([x_1](\cdot)\cap[x_2](\cdot)\), \([\mathbf{x}_1](\cdot)\cap[\mathbf{x}_2](\cdot)\) or \([\mathbf{A}_1](\cdot)\cap[\mathbf{A}_2](\cdot)\).

Parameters

x1	left operand.
x2	right operand.

Returns

The pointwise intersection tube.

operator+() [6/13]

template<typename T>

const SlicedTube< T > & codac2::operator+ ( const SlicedTube< T > & x1 )

inline

Unary plus.

According to T, the operand is respectively denoted \([x_1](\cdot)\), \([\mathbf{x}_1](\cdot)\) or \([\mathbf{A}_1](\cdot)\).

Parameters

x1

operand.

Returns

x1 unchanged.

  {
    return x1;
  }

operator+() [7/13]

template<typename T>

SlicedTube< T > codac2::operator+ ( const SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise sum of two tubes with the same codomain type.

According to T, the operation is respectively \([x_1](\cdot)+[x_2](\cdot)\), \([\mathbf{x}_1](\cdot)+[\mathbf{x}_2](\cdot)\) or \([\mathbf{A}_1](\cdot)+[\mathbf{A}_2](\cdot)\).

Parameters

x1	left operand.
x2	right operand.

Returns

The pointwise sum tube.

operator+() [8/13]

template<typename T, typename Q>

SlicedTube< T > codac2::operator+ ( const SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise sum of a tube and a constant object with matching codomain type.

According to T, the operation is respectively \([x_1](\cdot)+x_2\), \([\mathbf{x}_1](\cdot)+\mathbf{x}_2\) or \([\mathbf{A}_1](\cdot)+\mathbf{A}_2\).

Parameters

x1	left tube operand.
x2	right constant operand.

Returns

The resulting tube.

operator+() [9/13]

template<typename T, typename Q>

SlicedTube< T > codac2::operator+ ( const Q & x1, const SlicedTube< T > & x2 )

inline

Pointwise sum of a constant object and a tube with matching codomain type.

According to T, the operation is respectively \(x_1+[x_2](\cdot)\), \(\mathbf{x}_1+[\mathbf{x}_2](\cdot)\) or \(\mathbf{A}_1+[\mathbf{A}_2](\cdot)\).

Parameters

x1	left constant operand.
x2	right tube operand.

Returns

The resulting tube.

operator+=() [1/4]

template<typename T, typename Q>

SlicedTube< T > & codac2::operator+= ( SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise addition assignment with a constant object of matching codomain type.

Parameters

x1	left tube operand, updated in place.
x2	right constant operand.

Returns

x1 after the pointwise addition.

operator+=() [2/4]

template<typename T>

SlicedTube< T > & codac2::operator+= ( SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise addition assignment with a tube of the same codomain type.

Parameters

x1	left tube operand, updated in place.
x2	right tube operand.

Returns

x1 after the pointwise addition.

operator-() [4/11]

template<typename T>

SlicedTube< T > codac2::operator- ( const SlicedTube< T > & x1 )

inline

Unary minus.

According to T, the operand is respectively denoted \([x_1](\cdot)\), \([\mathbf{x}_1](\cdot)\) or \([\mathbf{A}_1](\cdot)\).

Parameters

x1

operand.

Returns

The pointwise opposite tube.

  {
    return -1. * x1;
  }

operator-() [5/11]

template<typename T>

SlicedTube< T > codac2::operator- ( const SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise difference of two tubes with the same codomain type.

According to T, the operation is respectively \([x_1](\cdot)-[x_2](\cdot)\), \([\mathbf{x}_1](\cdot)-[\mathbf{x}_2](\cdot)\) or \([\mathbf{A}_1](\cdot)-[\mathbf{A}_2](\cdot)\).

Parameters

x1	left operand.
x2	right operand.

Returns

The pointwise difference tube.

operator-() [6/11]

template<typename T, typename Q>

SlicedTube< T > codac2::operator- ( const SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise difference between a tube and a constant object with matching codomain type.

According to T, the operation is respectively \([x_1](\cdot)-x_2\), \([\mathbf{x}_1](\cdot)-\mathbf{x}_2\) or \([\mathbf{A}_1](\cdot)-\mathbf{A}_2\).

Parameters

x1	left tube operand.
x2	right constant operand.

Returns

The resulting tube.

operator-() [7/11]

template<typename T, typename Q>

SlicedTube< T > codac2::operator- ( const Q & x1, const SlicedTube< T > & x2 )

inline

Pointwise difference between a constant object and a tube with matching codomain type.

According to T, the operation is respectively \(x_1-[x_2](\cdot)\), \(\mathbf{x}_1-[\mathbf{x}_2](\cdot)\) or \(\mathbf{A}_1-[\mathbf{A}_2](\cdot)\).

Parameters

x1	left constant operand.
x2	right tube operand.

Returns

The resulting tube.

operator-=() [1/4]

template<typename T, typename Q>

SlicedTube< T > & codac2::operator-= ( SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise subtraction assignment with a constant object of matching codomain type.

Parameters

x1	left tube operand, updated in place.
x2	right constant operand.

Returns

x1 after the pointwise subtraction.

operator-=() [2/4]

template<typename T>

SlicedTube< T > & codac2::operator-= ( SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise subtraction assignment with a tube of the same codomain type.

Parameters

x1	left tube operand, updated in place.
x2	right tube operand.

Returns

x1 after the pointwise subtraction.

operator*() [4/19]

template<typename T>

SlicedTube< T > codac2::operator* ( const Interval & x1, const SlicedTube< T > & x2 )

inline

Pointwise multiplication of a scalar interval and a tube.

According to T, the operation is respectively \(x_1\,[x_2](\cdot)\), \(x_1\,[\mathbf{x}_2](\cdot)\) or \(x_1\,[\mathbf{A}_2](\cdot)\).

Parameters

x1	scalar interval.
x2	right tube operand.

Returns

The resulting tube.

operator*() [5/19]

template<typename T>

SlicedTube< T > codac2::operator* ( const SlicedTube< T > & x1, const Interval & x2 )

inline

Pointwise multiplication of a tube by a scalar interval.

According to T, the operation is respectively \([x_1](\cdot)\,x_2\), \([\mathbf{x}_1](\cdot)\,x_2\) or \([\mathbf{A}_1](\cdot)\,x_2\).

Parameters

x1	left tube operand.
x2	scalar interval.

Returns

The resulting tube.

operator*() [6/19]

SlicedTube< Interval > codac2::operator* ( const SlicedTube< Interval > & x1, const SlicedTube< Interval > & x2 )

inline

Pointwise multiplication of two scalar interval tubes.

\([x_1](\cdot)\,[x_2](\cdot)\)

Parameters

x1	left operand.
x2	right operand.

Returns

The resulting scalar interval tube.

operator*() [7/19]

SlicedTube< IntervalVector > codac2::operator* ( const SlicedTube< IntervalVector > & x1, const SlicedTube< IntervalVector > & x2 )

inline

Pointwise multiplication of two interval-vector tubes.

\([\mathbf{x}_1](\cdot)\,[\mathbf{x}_2](\cdot)\)

Parameters

x1	left operand.
x2	right operand.

Returns

The resulting interval-vector tube.

operator*() [8/19]

SlicedTube< IntervalMatrix > codac2::operator* ( const SlicedTube< IntervalMatrix > & x1, const SlicedTube< IntervalMatrix > & x2 )

inline

Pointwise multiplication of two interval-matrix tubes.

\([\mathbf{A}_1](\cdot)\,[\mathbf{A}_2](\cdot)\)

Parameters

x1	left operand.
x2	right operand.

Returns

The resulting interval-matrix tube.

operator*() [9/19]

template<typename T>

SlicedTube< T > codac2::operator* ( const SlicedTube< Interval > & x1, const SlicedTube< T > & x2 )

inline

Pointwise multiplication of a scalar interval tube and a non-scalar tube.

Depending on T, the operation is \([x_1](\cdot)\,[\mathbf{x}_2](\cdot)\) or \([x_1](\cdot)\,[\mathbf{A}_2](\cdot)\).

Parameters

x1	scalar interval tube.
x2	non-scalar tube operand.

Returns

The resulting tube.

operator*() [10/19]

template<typename T>

SlicedTube< T > codac2::operator* ( const SlicedTube< T > & x1, const SlicedTube< Interval > & x2 )

inline

Pointwise multiplication of a non-scalar tube and a scalar interval tube.

Depending on T, the operation is \([\mathbf{x}_1](\cdot)\,[x_2](\cdot)\) or \([\mathbf{A}_1](\cdot)\,[x_2](\cdot)\).

Parameters

x1	non-scalar tube operand.
x2	scalar interval tube.

Returns

The resulting tube.

operator*() [11/19]

template<typename T, typename Q>

SlicedTube< T > codac2::operator* ( const SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise multiplication of a tube and a constant object with matching codomain type.

According to T, the operation is respectively \([x_1](\cdot)\,x_2\), \([\mathbf{x}_1](\cdot)\,\mathbf{x}_2\) or \([\mathbf{A}_1](\cdot)\,\mathbf{A}_2\).

Parameters

x1	left tube operand.
x2	right constant operand.

Returns

The resulting tube.

operator*() [12/19]

template<typename T, typename Q>

SlicedTube< T > codac2::operator* ( const Q & x1, const SlicedTube< T > & x2 )

inline

Pointwise multiplication of a constant object and a tube with matching codomain type.

According to T, the operation is respectively \(x_1\,[x_2](\cdot)\), \(\mathbf{x}_1\,[\mathbf{x}_2](\cdot)\) or \(\mathbf{A}_1\,[\mathbf{A}_2](\cdot)\).

Parameters

x1	left constant operand.
x2	right tube operand.

Returns

The resulting tube.

operator*() [13/19]

SlicedTube< IntervalVector > codac2::operator* ( const SlicedTube< IntervalMatrix > & x1, const SlicedTube< IntervalVector > & x2 )

inline

Pointwise multiplication of an interval-matrix tube by an interval-vector tube.

\([\mathbf{A}_1](\cdot)\,[\mathbf{x}_2](\cdot)\)

Parameters

x1	interval-matrix tube.
x2	interval-vector tube.

Returns

The resulting interval-vector tube.

operator*=() [1/5]

template<typename T, typename Q>

SlicedTube< T > & codac2::operator*= ( SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise multiplication assignment with a constant object of matching codomain type.

Parameters

x1	left tube operand, updated in place.
x2	right constant operand.

Returns

x1 after the pointwise multiplication.

operator*=() [2/5]

template<typename T>

SlicedTube< T > & codac2::operator*= ( SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise multiplication assignment with a tube of the same codomain type.

Parameters

x1	left tube operand, updated in place.
x2	right tube operand.

Returns

x1 after the pointwise multiplication.

operator*=() [3/5]

template<typename T>

SlicedTube< T > & codac2::operator*= ( SlicedTube< T > & x1, const SlicedTube< Interval > & x2 )

inline

Pointwise multiplication assignment by a scalar interval tube.

Depending on T, the operation is \([\mathbf{x}_1](\cdot)\,[x_2](\cdot)\) or \([\mathbf{A}_1](\cdot)\,[x_2](\cdot)\).

Parameters

x1	non-scalar tube operand, updated in place.
x2	scalar interval tube.

Returns

x1 after the pointwise multiplication.

operator/() [4/12]

template<typename T>

SlicedTube< T > codac2::operator/ ( const SlicedTube< T > & x1, const Interval & x2 )

inline

Pointwise division of a tube by a scalar interval.

According to T, the operation is respectively \([x_1](\cdot)/x_2\), \([\mathbf{x}_1](\cdot)/x_2\) or \([\mathbf{A}_1](\cdot)/x_2\).

Parameters

x1	numerator tube.
x2	scalar interval denominator.

Returns

The resulting tube.

operator/() [5/12]

SlicedTube< Interval > codac2::operator/ ( const SlicedTube< Interval > & x1, const SlicedTube< Interval > & x2 )

inline

Pointwise division of two scalar interval tubes.

\([x_1](\cdot)/[x_2](\cdot)\)

Parameters

x1	numerator tube.
x2	denominator tube.

Returns

The resulting scalar interval tube.

operator/() [6/12]

template<typename T>

SlicedTube< T > codac2::operator/ ( const SlicedTube< T > & x1, const SlicedTube< Interval > & x2 )

inline

Pointwise division of a non-scalar tube by a scalar interval tube.

Depending on T, the operation is \([\mathbf{x}_1](\cdot)/[x_2](\cdot)\) or \([\mathbf{A}_1](\cdot)/[x_2](\cdot)\).

Parameters

x1	non-scalar numerator tube.
x2	scalar interval denominator tube.

Returns

The resulting tube.

operator/() [7/12]

template<typename T, typename Q>

SlicedTube< T > codac2::operator/ ( const SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise division of a tube by a constant object with matching codomain type.

According to T, the operation is respectively \([x_1](\cdot)/x_2\), \([\mathbf{x}_1](\cdot)/\mathbf{x}_2\) or \([\mathbf{A}_1](\cdot)/\mathbf{A}_2\).

Parameters

x1	numerator tube.
x2	denominator constant object.

Returns

The resulting tube.

operator/() [8/12]

template<typename T, typename Q>

SlicedTube< T > codac2::operator/ ( const Q & x1, const SlicedTube< T > & x2 )

inline

Pointwise division of a constant object by a tube with matching codomain type.

According to T, the operation is respectively \(x_1/[x_2](\cdot)\), \(\mathbf{x}_1/[\mathbf{x}_2](\cdot)\) or \(\mathbf{A}_1/[\mathbf{A}_2](\cdot)\).

Parameters

x1	numerator constant object.
x2	denominator tube.

Returns

The resulting tube.

operator/=() [1/5]

template<typename T, typename Q>

SlicedTube< T > & codac2::operator/= ( SlicedTube< T > & x1, const Q & x2 )

inline

Pointwise division assignment with a constant object of matching codomain type.

Parameters

x1	numerator tube, updated in place.
x2	denominator constant object.

Returns

x1 after the pointwise division.

operator/=() [2/5]

template<typename T>

SlicedTube< T > & codac2::operator/= ( SlicedTube< T > & x1, const SlicedTube< T > & x2 )

inline

Pointwise division assignment with a tube of the same codomain type.

Parameters

x1	numerator tube, updated in place.
x2	denominator tube.

Returns

x1 after the pointwise division.

operator/=() [3/5]

template<typename T>

SlicedTube< T > & codac2::operator/= ( SlicedTube< T > & x1, const SlicedTube< Interval > & x2 )

inline

Pointwise division assignment by a scalar interval tube.

Depending on T, the operation is \([\mathbf{x}_1](\cdot)/[x_2](\cdot)\) or \([\mathbf{A}_1](\cdot)/[x_2](\cdot)\).

Parameters

x1	non-scalar numerator tube, updated in place.
x2	scalar interval denominator tube.

Returns

x1 after the pointwise division.

sqr() [2/3]

SlicedTube< Interval > codac2::sqr

(

const SlicedTube< Interval > &

x1

)

Pointwise square of a scalar interval tube.

\(\big([x_1](\cdot)\big)^2\)

Parameters

x1	scalar interval tube.

Returns

The squared tube.

sqrt() [2/3]

SlicedTube< Interval > codac2::sqrt

(

const SlicedTube< Interval > &

x1

)

Pointwise square root of a scalar interval tube.

\(\sqrt{[x_1](\cdot)}\)

Parameters

x1	scalar interval tube.

Returns

The square-root tube.

pow() [4/7]

SlicedTube< Interval > codac2::pow	(	const SlicedTube< Interval > &	x1,
		int	x2 )

Pointwise power of a scalar interval tube with an integer exponent.

\(\big([x_1](\cdot)\big)^{x_2}\)

Parameters

x1	scalar interval tube.
x2	integer exponent.

Returns

The resulting tube.

pow() [5/7]

SlicedTube< Interval > codac2::pow	(	const SlicedTube< Interval > &	x1,
		const Interval &	x2 )

Pointwise power of a scalar interval tube with an interval exponent.

\(\big([x_1](\cdot)\big)^{x_2}\)

Parameters

x1	scalar interval tube.
x2	interval exponent.

Returns

The resulting tube.

exp() [2/3]

SlicedTube< Interval > codac2::exp

(

const SlicedTube< Interval > &

x1

)

Pointwise exponential of a scalar interval tube.

\(\exp\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

log() [2/3]

SlicedTube< Interval > codac2::log

(

const SlicedTube< Interval > &

x1

)

Pointwise natural logarithm of a scalar interval tube.

\(\log\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

cos() [2/3]

SlicedTube< Interval > codac2::cos

(

const SlicedTube< Interval > &

x1

)

Pointwise cosine of a scalar interval tube.

\(\cos\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

sin() [2/3]

SlicedTube< Interval > codac2::sin

(

const SlicedTube< Interval > &

x1

)

Pointwise sine of a scalar interval tube.

\(\sin\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

tan() [2/3]

SlicedTube< Interval > codac2::tan

(

const SlicedTube< Interval > &

x1

)

Pointwise tangent of a scalar interval tube.

\(\tan\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

acos() [2/3]

SlicedTube< Interval > codac2::acos

(

const SlicedTube< Interval > &

x1

)

Pointwise arc-cosine of a scalar interval tube.

\(\arccos\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

asin() [2/3]

SlicedTube< Interval > codac2::asin

(

const SlicedTube< Interval > &

x1

)

Pointwise arc-sine of a scalar interval tube.

\(\arcsin\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

atan() [2/3]

SlicedTube< Interval > codac2::atan

(

const SlicedTube< Interval > &

x1

)

Pointwise arc-tangent of a scalar interval tube.

\(\arctan\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

atan2() [2/7]

SlicedTube< Interval > codac2::atan2	(	const SlicedTube< Interval > &	x1,
		const SlicedTube< Interval > &	x2 )

Pointwise two-argument arc-tangent of two scalar interval tubes.

\(\operatorname{atan2}\!\big([x_1](\cdot),[x_2](\cdot)\big)\)

Parameters

x1	first scalar interval tube.
x2	second scalar interval tube.

Returns

The resulting tube.

atan2() [3/7]

SlicedTube< Interval > codac2::atan2	(	const SlicedTube< Interval > &	x1,
		const Interval &	x2 )

Pointwise two-argument arc-tangent of a scalar interval tube and an interval.

\(\operatorname{atan2}\!\big([x_1](\cdot),x_2\big)\)

Parameters

x1	scalar interval tube.
x2	scalar interval.

Returns

The resulting tube.

atan2() [4/7]

SlicedTube< Interval > codac2::atan2	(	const Interval &	x1,
		const SlicedTube< Interval > &	x2 )

Pointwise two-argument arc-tangent of an interval and a scalar interval tube.

\(\operatorname{atan2}\!\big(x_1,[x_2](\cdot)\big)\)

Parameters

x1	scalar interval.
x2	scalar interval tube.

Returns

The resulting tube.

cosh() [2/3]

SlicedTube< Interval > codac2::cosh

(

const SlicedTube< Interval > &

x1

)

Pointwise hyperbolic cosine of a scalar interval tube.

\(\cosh\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

sinh() [2/3]

SlicedTube< Interval > codac2::sinh

(

const SlicedTube< Interval > &

x1

)

Pointwise hyperbolic sine of a scalar interval tube.

\(\sinh\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

tanh() [2/3]

SlicedTube< Interval > codac2::tanh

(

const SlicedTube< Interval > &

x1

)

Pointwise hyperbolic tangent of a scalar interval tube.

\(\tanh\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

acosh() [2/3]

SlicedTube< Interval > codac2::acosh

(

const SlicedTube< Interval > &

x1

)

Pointwise inverse hyperbolic cosine of a scalar interval tube.

\(\operatorname{arccosh}\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

asinh() [2/3]

SlicedTube< Interval > codac2::asinh

(

const SlicedTube< Interval > &

x1

)

Pointwise inverse hyperbolic sine of a scalar interval tube.

\(\operatorname{arcsinh}\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

atanh() [2/3]

SlicedTube< Interval > codac2::atanh

(

const SlicedTube< Interval > &

x1

)

Pointwise inverse hyperbolic tangent of a scalar interval tube.

\(\operatorname{arctanh}\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

abs() [2/4]

SlicedTube< Interval > codac2::abs

(

const SlicedTube< Interval > &

x1

)

Pointwise absolute value of a scalar interval tube.

\(\left|[x_1](\cdot)\right|\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

min() [2/7]

SlicedTube< Interval > codac2::min	(	const SlicedTube< Interval > &	x1,
		const SlicedTube< Interval > &	x2 )

Pointwise minimum of two scalar interval tubes.

\(\min\!\big([x_1](\cdot),[x_2](\cdot)\big)\)

Parameters

x1	first scalar interval tube.
x2	second scalar interval tube.

Returns

The resulting tube.

min() [3/7]

SlicedTube< Interval > codac2::min	(	const SlicedTube< Interval > &	x1,
		const Interval &	x2 )

Pointwise minimum of a scalar interval tube and an interval.

\(\min\!\big([x_1](\cdot),x_2\big)\)

Parameters

x1	scalar interval tube.
x2	scalar interval.

Returns

The resulting tube.

min() [4/7]

SlicedTube< Interval > codac2::min	(	const Interval &	x1,
		const SlicedTube< Interval > &	x2 )

Pointwise minimum of an interval and a scalar interval tube.

\(\min\!\big(x_1,[x_2](\cdot)\big)\)

Parameters

x1	scalar interval.
x2	scalar interval tube.

Returns

The resulting tube.

max() [2/7]

SlicedTube< Interval > codac2::max	(	const SlicedTube< Interval > &	x1,
		const SlicedTube< Interval > &	x2 )

Pointwise maximum of two scalar interval tubes.

\(\max\!\big([x_1](\cdot),[x_2](\cdot)\big)\)

Parameters

x1	first scalar interval tube.
x2	second scalar interval tube.

Returns

The resulting tube.

max() [3/7]

SlicedTube< Interval > codac2::max	(	const SlicedTube< Interval > &	x1,
		const Interval &	x2 )

Pointwise maximum of a scalar interval tube and an interval.

\(\max\!\big([x_1](\cdot),x_2\big)\)

Parameters

x1	scalar interval tube.
x2	scalar interval.

Returns

The resulting tube.

max() [4/7]

SlicedTube< Interval > codac2::max	(	const Interval &	x1,
		const SlicedTube< Interval > &	x2 )

Pointwise maximum of an interval and a scalar interval tube.

\(\max\!\big(x_1,[x_2](\cdot)\big)\)

Parameters

x1	scalar interval.
x2	scalar interval tube.

Returns

The resulting tube.

sign() [2/2]

SlicedTube< Interval > codac2::sign

(

const SlicedTube< Interval > &

x1

)

Pointwise sign of a scalar interval tube.

\(\operatorname{sign}\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

integer() [2/2]

SlicedTube< Interval > codac2::integer

(

const SlicedTube< Interval > &

x1

)

Pointwise integer-part operator applied to a scalar interval tube.

\(\operatorname{integer}\!\big([x_1](\cdot)\big)\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

floor() [2/3]

SlicedTube< Interval > codac2::floor

(

const SlicedTube< Interval > &

x1

)

Pointwise floor of a scalar interval tube.

\(\lfloor [x_1](\cdot) \rfloor\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

ceil() [2/3]

SlicedTube< Interval > codac2::ceil

(

const SlicedTube< Interval > &

x1

)

Pointwise ceiling of a scalar interval tube.

\(\lceil [x_1](\cdot) \rceil\)

Parameters

x1	scalar interval tube.

Returns

The resulting tube.

create_tdomain() [1/2]

std::shared_ptr< TDomain > codac2::create_tdomain

(

const Interval &

t0_tf = Interval(-oo,oo)

)

Creates a temporal domain made of a single slice.

This factory creates a TDomain containing a single TSlice over t0_tf.

Parameters

t0_tf

temporal interval \([t_0,t_f]\)

Returns

shared pointer to the created TDomain

create_tdomain() [2/2]

std::shared_ptr< TDomain > codac2::create_tdomain	(	const Interval &	t0_tf,
		double	dt,
		bool	with_gates = true )

Creates a sampled temporal domain.

This factory creates a temporal partition of t0_tf using a step dt. Optional explicit gates can be inserted at sampling times.

Parameters

t0_tf	bounded non-degenerate temporal interval \([t_0,t_f]\)
dt	sampling step
with_gates	if set to true, explicit gates are inserted

Returns

shared pointer to the created TDomain

operator<<() [7/13]

std::ostream & codac2::operator<< ( std::ostream & os, const TimePropag & x )

inline

Streams out a TimePropag.

Parameters

os	the stream to be updated
x	the time propagation to stream out

Returns

a reference to the updated stream

  {
    switch(x)
    {
      case TimePropag::FWD:
        os << "[ fwd ]";
        break;
      case TimePropag::BWD:
        os << "[ bwd ]";
        break;
      case TimePropag::FWD_BWD:
        os << "[ fwd, bwd ]";
        break;
    }
    return os;
  }

tube_cart_prod()

template<typename... X>

SlicedTube< IntervalVector > codac2::tube_cart_prod

(

const X &...

x

)

Computes the Cartesian product of several sliced tubes.

This function builds a vector-valued sliced tube whose temporal domain is shared with the input tubes. For each temporal slice, the codomain of the resulting tube is the Cartesian product of the codomains of the input tubes over the same temporal slice.

The dimension of the resulting codomain is equal to the sum of the dimensions of all input tubes.

Note

All input tubes must share the same temporal partition.

Template Parameters

X	types of the input sliced tubes

Parameters

x	input sliced tubes

Returns

a sliced tube enclosing the Cartesian product of the input tubes

  {
    static_assert(sizeof...(X) > 0, "tube_cart_prod requires at least one tube");
    Index s = 0;
    ((s += x.size()), ...);
 
    const auto& x0 = std::get<0>(std::forward_as_tuple(x...));
    auto tdomain = x0.tdomain();
    assert_release(((x.tdomain() == tdomain) && ...));
    SlicedTube v(tdomain, IntervalVector(s));
 
    for(auto it = tdomain->begin() ; it != tdomain->end() ; it++)
      v.slice(it)->codomain() = cart_prod(x.slice(it)->codomain()...);
 
    return v;
  }

map_scalar_entries() [1/3]

AnalyticFunction< ScalarType > codac2::map_scalar_entries	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarExprTransform &	transform )

Applies a scalar transformation to a scalar analytic function.

Parameters

f	Scalar function.
transform	Scalar transformation.

Returns

The transformed scalar function.

map_scalar_entries() [2/3]

AnalyticFunction< VectorType > codac2::map_scalar_entries	(	const AnalyticFunction< VectorType > &	f,
		const ScalarExprTransform &	transform )

Applies a scalar transformation componentwise to a vector analytic function.

The output shape of f is preserved.

Parameters

f	Vector function.
transform	Scalar transformation.

Returns

The transformed vector function.

map_scalar_entries() [3/3]

AnalyticFunction< MatrixType > codac2::map_scalar_entries	(	const AnalyticFunction< MatrixType > &	f,
		const ScalarExprTransform &	transform )

Applies a scalar transformation entrywise to a matrix analytic function.

The output shape of f is preserved.

Parameters

f	Matrix function.
transform	Scalar transformation.

Returns

The transformed matrix function.

operator&() [10/11]

ConvexPolygon codac2::operator&	(	const ConvexPolygon &	p1,
		const ConvexPolygon &	p2 )

Computes the intersection of two convex polygons.

The result is a new ConvexPolygon enclosing the intersection area. If the polygons do not intersect, the result is an empty convex polygon.

Parameters

p1	The first convex polygon.
p2	The second convex polygon.

Returns

A ConvexPolygon enclosing the intersection area.

operator<<() [8/13]

std::ostream & codac2::operator<< ( std::ostream & os, const OrientationInterval & x )

inline

Streams out a OrientationInterval.

Parameters

os	The stream to be updated
x	The orientation interval to stream out

Returns

A Reference to the updated stream

  {
    if(x == OrientationInterval::EMPTY)
      os << "[ empty ]";
    else if(x == OrientationInterval::COLINEAR)
      os << "[ col ]";
    else if(x == OrientationInterval::CLOCKWISE)
      os << "[ cw ]";
    else if(x == OrientationInterval::COUNTERCLOCKWISE)
      os << "[ ccw ]";
    else if(x == (OrientationInterval::COLINEAR | OrientationInterval::CLOCKWISE))
      os << "[ col, cw ]";
    else if(x == (OrientationInterval::COLINEAR | OrientationInterval::COUNTERCLOCKWISE))
      os << "[ col, ccw ]";
    else if(x == OrientationInterval::UNKNOWN)
      os << "[ col, cw, ccw ]";
    return os;
  }

orientation()

OrientationInterval codac2::orientation	(	const IntervalVector &	p1,
		const IntervalVector &	p2,
		const IntervalVector &	p3 )

Computes the orientation of an ordered triplet of 2D points.

Determines whether the oriented angle \(\widehat{p_1 p_2 p_3}\) is positive (counterclockwise), negative (clockwise), or if the points are colinear (flat or 0 angle). Depending on floating point uncertainties, the test may not be able to conclude (a UNKNOWN value would then be returned).

Parameters

p1	First point (2d IntervalVector) of the triplet.
p2	Second point (2d IntervalVector) of the triplet (vertex of the angle).
p3	Third point (2d IntervalVector) of the triplet.

Returns

An orientation of type OrientationInterval

aligned()

BoolInterval codac2::aligned	(	const IntervalVector &	p1,
		const IntervalVector &	p2,
		const IntervalVector &	p3 )

Checks whether three 2D points are aligned (colinear).

Determines if the points lie on the same straight line using an orientation test (cross product). Depending on floating point uncertainties, the test may not be able to conclude (a UNKNOWN value would then be returned).

Parameters

p1	First point (2d IntervalVector) of the triplet.
p2	Second point (2d IntervalVector) of the triplet.
p3	Third point (2d IntervalVector) of the triplet.

Returns

A BooleanInterval

convex_hull()

std::vector< IntervalVector > codac2::convex_hull

(

std::vector< IntervalVector >

pts

)

Computes the convex hull of a set of 2d points.

Given a set of 2d points enclosed in tiny boxes, the function computes their convex hull. The method is based on a Graham scan algorithm. The output list of the algorithm is a subset of the input list, with same uncertainties and a possible different order.

Parameters

pts	2d points in any order

Returns

Points on the convex hull in counterclockwise order.

rotate() [1/2]

IntervalVector codac2::rotate	(	const IntervalVector &	p,
		const Interval &	a,
		const IntervalVector &	c = Vector::zero(2) )

Rotates a 2D interval vector around a point by a given angle.

This function performs a 2D rotation of the input interval vector p by an interval angle a, optionally around a center of rotation c (default is the origin). This operation propagates uncertainties through interval arithmetic.

Parameters

p	The input 2D interval vector to be rotated.
a	The rotation angle as an interval (in radians).
c	The center of rotation as an interval vector (default is the origin (0,0)).

Returns

The rotated interval vector.

rotate() [2/2]

template<typename T>

T codac2::rotate ( const T & x, const Interval & a, const IntervalVector & c = Vector::zero(2) )

inline

Rotates a 2D object (Segment, Polygon, etc) around a point by a given angle.

This function performs a 2D rotation of the input object x by an interval angle a, optionally around a center of rotation c (default is the origin). This operation propagates uncertainties through interval arithmetic.

Parameters

x	The input 2D object to be rotated.
a	The rotation angle as an interval (in radians).
c	The center of rotation as an interval vector (default is the origin (0,0)).

Returns

The rotated object.

  {
    T x_(x);
    for(auto& ei : x_)
      ei = rotate(ei,a,c);
    return x_;
  }

merge_adjacent_points()

void codac2::merge_adjacent_points

(

std::list< IntervalVector > &

l

)

Merges overlapping or adjacent IntervalVector points within a list.

This function iteratively scans a list of IntervalVector objects and merges any pairs that intersect. The process repeats until no further merges are possible.

This operation is useful for simplifying collections of intervals or bounding boxes that may overlap due to uncertainty propagation or geometric tolerance.

Parameters

l	list of IntervalVector objects to be merged. The list is modified in-place.

operator<<() [9/13]

std::ostream & codac2::operator<<	(	std::ostream &	str,
		const Polygon &	p )

Stream output operator for Polygon.

Parameters

str	Output stream.
p	The polygon to print.

Returns

The output stream with the polygon information.

operator&() [11/11]

IntervalVector codac2::operator&	(	const Segment &	e1,
		const Segment &	e2 )

Computes the intersection of two segments.

If the segments do not intersect, an empty IntervalVector is returned. If the segments are colinear, the set of intersection points is returned as a box.

Parameters

e1	The first segment.
e2	The second segment.

Returns

An IntervalVector enclosing the intersection point.

proj_intersection()

IntervalVector codac2::proj_intersection	(	const Segment &	e1,
		const Segment &	e2 )

Computes the projected intersection of two segments.

This corresponds to the intersection of the two lines related to the two segments. Therefore, the intersection point may not belong to the segments.

If the segments are parallel but not colinear, an empty IntervalVector is returned. If the segments are colinear, the set of intersection points is returned as a box.

Parameters

e1	The first segment.
e2	The second segment.

Returns

An IntervalVector enclosing the intersection point.

colinear()

BoolInterval codac2::colinear	(	const Segment &	e1,
		const Segment &	e2 )

Checks if two segments are colinear.

Parameters

e1	The first segment.
e2	The second segment.

Returns

A BoolInterval indicating possible colinearity.

operator<<() [10/13]

std::ostream & codac2::operator<<	(	std::ostream &	str,
		const Segment &	e )

Stream output operator for Segment.

Parameters

str	Output stream.
e	The segment to print.

Returns

The output stream with the segment information.

gauss_jordan()

Matrix codac2::gauss_jordan

(

const Matrix &

A

)

Gauss Jordan band diagonalization preconditioning.

Takes a Matrix \(\mathbf{A}\) with A.cols >= A.rows and returns \(\mathbf{P}\) such that \(\mathbf{P}\mathbf{A}\) is a band matrix. The square left part of \(\mathbf{A}\) must be full-rank. This function does not involve interval computations.

Parameters

A	matrix with A.cols >= A.rows

Returns

P such that \(\mathbf{P}\mathbf{A}\) is a band matrix. Return Id if the left part of \(\mathbf{A}\) is not well-conditioned.

From https://www.ensta-bretagne.fr/jaulin/centered.html

inverse_correction()

template<LeftOrRightInv O = LEFT_INV, typename OtherDerived, typename OtherDerived_>

IntervalMatrix codac2::inverse_correction ( const Eigen::MatrixBase< OtherDerived > & A, const Eigen::MatrixBase< OtherDerived_ > & B )

inline

Correct the approximation of the inverse \(\mathbf{B}\approx\mathbf{A}^{-1}\) of a square matrix \(\mathbf{A}\) by providing a reliable enclosure \([\mathbf{A}^{-1}]\).

Precondition

\(\mathbf{A}\) and \(\mathbf{B}\) are square matrices, possibly interval matrices.

Template Parameters

O	If LEFT_INV, use the inverse of \(\mathbf{BA}\) (otherwise use the inverse of \(\mathbf{AB}\), left inverse is normally better). In Python/Matlab, this template parameter is provided as a last boolean argument, and is left_inv = True by default.

Parameters

A	A matrix expression, possibly interval.
B	An (almost punctual) approximation of its inverse.

Returns

The enclosure of the inverse.

  {
    assert_release(A.is_squared());
    assert_release(B.is_squared());
 
    auto A_ = A.template cast<Interval>();
    auto B_ = B.template cast<Interval>();
 
    Index N = A_.rows();
    assert_release(N==B_.rows());
 
    auto Id = IntervalMatrix::Identity(N,N);
    auto erMat = [&]() { if constexpr(O == LEFT_INV) return -B_*A_+Id; else return -A_*B_+Id; }();
    
    double mrad=0.0;
    IntervalMatrix E = infinite_sum_enclosure(erMat,mrad);
    IntervalMatrix Ep = Id+erMat*(Id+E); 
        /* one could use several iterations here, either
           using mrad, or directly */
 
    auto res = (O == LEFT_INV) ? IntervalMatrix(Ep*B_) : IntervalMatrix(B_*Ep);
 
    // We want the presence of non-invertible matrices to
    // result in coefficients of the form [-oo,+oo].
    if (mrad==oo) {
       for (Index c=0;c<N;c++) {
         for (Index r=0;r<N;r++) {
           if (Ep(r,c).is_unbounded()) {
              for (Index k=0;k<N;k++) {
                   if constexpr(O == LEFT_INV)
                       res(r,k) = Interval();
                   else 
                       res(k,c) = Interval();
              }
           }
         }
       }
    }
    return  res;
  }

inverse_enclosure()

template<typename OtherDerived>

IntervalMatrix codac2::inverse_enclosure ( const Eigen::MatrixBase< OtherDerived > & A )

inline

Enclosure of the inverse of a (non-singular) matrix expression, possibly an interval matrix.

Precondition

\(\mathbf{A}\) is a square matrix.

Parameters

A	A matrix expression, possibly interval.

Returns

The enclosure of the inverse. Can have \((-\infty,\infty)\) coefficients if \(\mathbf{A}\) is singular or almost singular, if the inversion "failed".

  {
    assert_release(A.is_squared());
    Index N = A.rows();
 
    if constexpr(std::is_same_v<typename OtherDerived::Scalar,Interval>)
      return inverse_correction<LEFT_INV>(A, 
        (A.mid()).fullPivLu().solve(Matrix::Identity(N,N)));
 
    else
      return inverse_correction<LEFT_INV>(A, 
        A.fullPivLu().solve(Matrix::Identity(N,N)));
  }

infinite_sum_enclosure()

IntervalMatrix codac2::infinite_sum_enclosure	(	const IntervalMatrix &	A,
		double &	mrad )

Compute an upper bound of \(\left([\mathbf{A}]+[\mathbf{A}]^2+[\mathbf{A}]^3+\dots\right)\), with \([\mathbf{A}]\) a matrix of intervals as an "error term" (uses only bounds on coefficients).

The function also returns mrad, which gives an idea of the magnification of the matrix during calculation. In particular, if mrad = \(\infty\), then the inversion calculation (e.g., performed by Eigen) has somehow failed and some coefficients of the output interval matrix are \([-\infty,\infty]\).

Precondition

\([\mathbf{A}]\) is a square matrix.

Parameters

A	A matrix of intervals (supposed around \(\mathbf{0}\)).
mrad	The maximum radius of the result added (output argument).

Returns

The sum enclosure. May be unbounded.

abs() [3/4]

template<typename OtherDerived>

auto codac2::abs ( const Eigen::MatrixBase< OtherDerived > & x )

inline

Compute the element-wise absolute value of a matrix.

This function takes an Eigen matrix expression and returns a matrix where each element is replaced by its absolute value.

For scalar type double, the standard library fabs() is used. For other scalar types, it uses the generic abs() function.

Parameters

x	Input matrix expression.

Returns

A new Eigen matrix with the absolute values of the elements of x.

  {
    using M = Eigen::MatrixBase<OtherDerived>;
    Eigen::Matrix<typename M::Scalar,M::RowsAtCompileTime,M::ColsAtCompileTime> a(x.rows(),x.cols());
 
    for(Index i = 0 ; i < x.rows() ; i++)
      for(Index j = 0 ; j < x.cols() ; j++)
      {
        if constexpr(std::is_same_v<typename M::Scalar,double>)
          a(i,j) = fabs(x(i,j));
        else
          a(i,j) = abs(x(i,j));
      }
 
    return a;
  }

floor() [3/3]

template<typename OtherDerived>

auto codac2::floor ( const Eigen::MatrixBase< OtherDerived > & x )

inline

Compute the element-wise floor of a matrix.

This function returns a matrix where each element is replaced by the largest integer not greater than that element.

Disabled for interval matrices.

Parameters

x	Input matrix expression.

Returns

A new Eigen matrix with floored elements.

  {
    return x.array().floor().matrix();
  }

ceil() [3/3]

template<typename OtherDerived>

auto codac2::ceil ( const Eigen::MatrixBase< OtherDerived > & x )

inline

Compute the element-wise ceiling of a matrix.

This function returns a matrix where each element is replaced by the smallest integer not less than that element.

Disabled for interval matrices.

Parameters

x	Input matrix expression.

Returns

A new Eigen matrix with ceiled elements.

  {
    return x.array().ceil().matrix();
  }

round()

template<typename OtherDerived>

auto codac2::round ( const Eigen::MatrixBase< OtherDerived > & x )

inline

Compute the element-wise rounding of a matrix.

This function returns a matrix where each element is replaced by the nearest integer to that element.

Disabled for interval matrices.

Parameters

x	Input matrix expression.

Returns

A new Eigen matrix with rounded elements.

  {
    return x.array().round().matrix();
  }

codac_row_fmt()

Eigen::IOFormat codac2::codac_row_fmt ( )

inline

Provides an Eigen IOFormat for formatting row vectors.

This format prints elements separated by spaces, with brackets around the entire row vector.

Returns

An Eigen::IOFormat configured for row vector formatting.

  {
    return Eigen::IOFormat(Eigen::StreamPrecision, Eigen::DontAlignCols, " ", "", "", "", "[ ", " ]");
  }

codac_vector_fmt()

Eigen::IOFormat codac2::codac_vector_fmt ( )

inline

Provides an Eigen IOFormat for formatting column vectors.

This format prints elements separated by semicolons, with brackets around the entire vector.

Returns

An Eigen::IOFormat configured for column vector formatting.

  {
    return Eigen::IOFormat(Eigen::StreamPrecision, Eigen::DontAlignCols, "", " ; ", "", "", "[ ", " ]");
  }

codac_matrix_fmt()

Eigen::IOFormat codac2::codac_matrix_fmt ( )

inline

Provides an Eigen IOFormat for formatting matrices.

This format prints elements separated by commas, rows separated by new lines, and brackets around the entire matrix.

Returns

An Eigen::IOFormat configured for matrix formatting.

  {
    return Eigen::IOFormat(Eigen::StreamPrecision, 0, " , ", "\n", "[ ", " ]", "[", "]");
  }

operator<<() [11/13]

std::ostream & codac2::operator<< ( std::ostream & os, const Matrix & x )

inline

Stream output operator for Matrix objects.

Parameters

os	The output stream to write to.
x	The matrix whose contents are to be printed.

Returns

A reference to the modified output stream.

  {
    os << x.format(codac_matrix_fmt());
    return os;
  }

operator<<() [12/13]

std::ostream & codac2::operator<< ( std::ostream & os, const Row & x )

inline

Stream output operator for Row objects.

Parameters

os	The output stream to write to.
x	The row whose contents are to be printed.

Returns

A reference to the modified output stream.

  {
    os << x.format(codac_row_fmt());
    return os;
  }

operator<<() [13/13]

std::ostream & codac2::operator<< ( std::ostream & os, const Vector & x )

inline

Stream output operator for Vector objects.

Parameters

os	The output stream to write to.
x	The vector whose contents are to be printed.

Returns

A reference to the modified output stream.

  {
    os << x.format(codac_vector_fmt());
    return os;
  }

parallelepiped_inclusion()

Parallelepiped codac2::parallelepiped_inclusion	(	const IntervalVector &	Y,
		const IntervalMatrix &	Jf,
		const Matrix &	Jf_tild,
		const AnalyticFunction< VectorType > &	psi_0,
		const OctaSym &	sigma,
		const IntervalVector &	X )

Used in PEIBOS. Compute a parallelepiped enclosing of \(\mathbf{g}([\mathbf{x}])\) where \(\mathbf{g} = \mathbf{f}\circ \sigma \circ \psi_0\).

Parameters

Y	The box enclosing \(\mathbf{f}(\sigma(\psi_0(\bar{\mathbf{x}})))\).
Jf	The interval Jacobian matrix containing \(\frac{d\mathbf{f}}{d\mathbf{y}}([\mathbf{y}])\) where \(\mathbf{y} = \sigma(\psi_0(\left[\mathbf{x}\right]))\)
Jf_tild	An approximation of \(\frac{d\mathbf{f}}{d\mathbf{y}}(\sigma(\psi_0(\bar{\mathbf{x}})))\)
psi_0	The analytic function \(\psi_0:\mathbb{R}^m\rightarrow\mathbb{R}^n\) to construct the atlas
sigma	The symmetry operator to construct the atlas
X	The box \([\mathbf{x}]\)

Returns

A Parallelepiped enclosing \(\mathbf{g}([\mathbf{x}])\)

PEIBOS() [1/4]

std::vector< Parallelepiped > codac2::PEIBOS	(	const AnalyticFunction< VectorType > &	f,
		const AnalyticFunction< VectorType > &	psi_0,
		const std::vector< OctaSym > &	Sigma,
		double	epsilon,
		bool	verbose = false )

Compute a set of parallelepipeds enclosing \(\mathbf{f}(\sigma(\psi_0([-1,1]^m)))\) for each symmetry \(\sigma\) in the set of symmetries \(\Sigma\). Note that \(\left\{\psi_0,\Sigma\right\}\) form a gnomonic atlas.

Parameters

f	The analytic function \(\mathbf{f}:\mathbb{R}^n\rightarrow\mathbb{R}^p,p\geq n\)
psi_0	The transformation function \(\psi_0:\mathbb{R}^m\rightarrow\mathbb{R}^n\) to construct the atlas
Sigma	The set of symmetry operators \(\sigma\) to construct the atlas
epsilon	The maximum diameter of the boxes to split \([-1,1]^m\) before computing the parallelepiped inclusions
verbose	If true, print the time taken to compute the parallelepiped inclusions with other statistics

Returns

A vector of Parallelepipeds enclosing \(\mathbf{f}(\sigma(\psi_0([-1,1]^m)))\) for each symmetry \(\sigma\) in the set of symmetries \(\Sigma\).

PEIBOS() [2/4]

std::vector< Parallelepiped > codac2::PEIBOS	(	const AnalyticFunction< VectorType > &	f,
		const AnalyticFunction< VectorType > &	psi_0,
		const std::vector< OctaSym > &	Sigma,
		double	epsilon,
		const Vector &	offset,
		bool	verbose = false )

Compute a set of parallelepipeds enclosing \(\mathbf{f}(\sigma(\psi_0([-1,1]^m)) + offset) \) for each symmetry \(\sigma\) in the set of symmetries \(\Sigma\). Note that \(\left\{\psi_0,\Sigma\right\}\) form a gnomonic atlas.

Parameters

f	The analytic function \(\mathbf{f}:\mathbb{R}^n\rightarrow\mathbb{R}^p,p\geq n\)
psi_0	The transformation function \(\psi_0:\mathbb{R}^m\rightarrow\mathbb{R}^n\) to construct the atlas
Sigma	The set of symmetry operators \(\sigma\) to construct the atlas
epsilon	The maximum diameter of the boxes to split \([-1,1]^m\) before computing the parallelepiped inclusions
offset	The offset to add to \(\sigma(\psi_0([-1,1]^m))\) (used to translate the initial manifold)
verbose	If true, print the time taken to compute the parallelepiped inclusions with other statistics

Returns

A vector of Parallelepipeds enclosing \(\mathbf{f}(\sigma(\psi_0([-1,1]^m))+ offset)\) for each symmetry \(\sigma\) in the set of symmetries \(\Sigma\).

split()

double codac2::split	(	const IntervalVector &	X,
		double	eps,
		std::vector< IntervalVector > &	boxes )

Recursively split a box until the maximum diameter of each box is less than eps. Note that the resulting boxes are stored in place in the vector boxes.

Parameters

X	The box to split
eps	The maximum diameter of each box
boxes	The vector to store the resulting boxes

Returns

The maximum diameter of the resulting boxes (lower or equal to eps)

error_peibos()

double codac2::error_peibos	(	const IntervalVector &	Y,
		const Vector &	z,
		const IntervalMatrix &	Jf,
		const Matrix &	A,
		const IntervalVector &	X )

Compute the error term for the parallelepiped inclusion. The error is later used to inflate the flat parallelepiped \(\mathbf{z}+\mathbf{A}\cdot(\left[\mathbf{x}\right]-\bar{\mathbf{x}})\).

Parameters

Y	The box enclosing \(\mathbf{f}(\bar{\mathbf{x}})\)
z	Any Vector with the same dimension as z. Usually we pick an approximation of \(\mathbf{f}(\bar{\mathbf{x}})\)
Jf	The interval Jacobian matrix containing \(\frac{d\mathbf{f}}{d\mathbf{x}}([\mathbf{x}])\)
A	Any Matrix with the same dimension as Jf. Usually we pick an approximation of \(\frac{d\mathbf{f}}{d\mathbf{x}}(\bar{\mathbf{x}})\)
X	The box \([\mathbf{x}]\)

inflate_flat_parallelepiped()

Matrix codac2::inflate_flat_parallelepiped	(	const Matrix &	A,
		const Vector &	e_vec,
		double	rho )

Inflate the flat parallelepiped \(\mathbf{A}\cdot e_{vec}\) by \(\rho\).

Parameters

A	The shape matrix of the flat parallelepiped (n x m matrix with m < n)
e_vec	The vector of scaling along each generator of the flat parallelepiped (m-dimensional vector)
rho	The inflation factor

Returns

The shape matrix of the inflated parallelepiped (n x n matrix)

serialize() [1/4]

template<typename T>

void codac2::serialize ( std::ostream & f, const T & x )

inline

Writes the binary representation of a trivially copyable object to the given output stream.

Binary structure:
[raw memory of x]

Warning: Using int or long may cause portability issues. Use fixed-width types like int32_t or int64_t instead.

Parameters

f	output stream
x	object/variable to be serialized

    {
      f.write(reinterpret_cast<const char*>(&x), sizeof(T));
    }

deserialize() [1/4]

template<typename T>

void codac2::deserialize ( std::istream & f, T & x )

inline

Reads the binary representation of a trivially copyable object from the given input stream.

Binary structure:
[raw memory of x]

Warning: Using int or long may cause portability issues. Use fixed-width types like int32_t or int64_t instead.

Parameters

f	input stream
x	object to be deserialized

    {
      f.read(reinterpret_cast<char*>(&x), sizeof(T));
    }

serialize() [2/4]

void codac2::serialize ( std::ostream & f, const Interval & x )

inline

Writes the binary representation of an Interval object to the given output stream.

Interval binary structure:
[double_lb][double_ub]

Parameters

f	output stream
x	Interval object to be serialized

    {
      serialize(f,x.lb());
      serialize(f,x.ub());
    }

deserialize() [2/4]

void codac2::deserialize ( std::istream & f, Interval & x )

inline

Creates an Interval object from the binary representation given in an input stream.

Interval binary structure:
[double_lb][double_ub]

Parameters

f	input stream
x	Interval object to be deserialized

    {
      double lb, ub;
      deserialize(f,lb);
      deserialize(f,ub);
      x = Interval(lb,ub);
    }

serialize() [3/4]

template<typename T, int R = -1, int C = -1>

void codac2::serialize ( std::ostream & f, const Eigen::Matrix< T, R, C > & x )

inline

Writes the binary representation of an Eigen::Matrix to the given output stream. The structure can be a matrix, a row, a vector, with double or Interval components.

Matrix binary structure:
[Index_rows][Index_cols][element_00][element_01]...[element_rc]

Parameters

f	output stream
x	matrix structure to be serialized

    {
      Index r = x.rows(), c = x.cols();
      serialize(f,r);
      serialize(f,c);
      for(Index i = 0 ; i < r ; i++)
        for(Index j = 0 ; j < c ; j++)
          serialize(f,x(i,j));
    }

deserialize() [3/4]

template<typename T, int R = -1, int C = -1>

void codac2::deserialize ( std::istream & f, Eigen::Matrix< T, R, C > & x )

inline

Reads the binary representation of an Eigen::Matrix from the given input stream. The structure can be a matrix, a row, a vector, with double or Interval components.

Matrix binary structure:
[Index_rows][Index_cols][element_00][element_01]...[element_rc]

Parameters

f	input stream
x	matrix structure to be deserialized

    {
      Index r, c;
      deserialize(f,r);
      deserialize(f,c);
 
      if constexpr(R == -1 && C == -1)
        x.resize(r,c);
      else if constexpr(R == -1 || C == -1)
        x.resize(std::max(r,c));
      else
      {
        assert_release(R == r && C == c);
      }
 
      for(Index i = 0 ; i < r ; i++)
        for(Index j = 0 ; j < c ; j++)
          deserialize(f,x(i,j));
    }

serialize() [4/4]

template<typename T>

void codac2::serialize ( std::ostream & f, const SampledTraj< T > & x )

inline

Writes the binary representation of a SampledTraj object to the given output stream.

SampledTraj binary structure:
[nb_samples][t0][x0][t1][x1]...[tn][xn]

Parameters

f	output stream
x	SampledTraj object to be serialized

    {
      Index size = x.nb_samples();
      serialize(f, size);
 
      for(const auto& [ti, xi] : x)
      {
        serialize(f, ti);
        serialize(f, xi);
      }
    }

deserialize() [4/4]

template<typename T>

void codac2::deserialize ( std::istream & f, SampledTraj< T > & x )

inline

Reads the binary representation of a SampledTraj object from the given input stream.

SampledTraj binary structure:
[nb_samples][t0][x0][t1][x1]...[tn][xn]

Parameters

f	input stream
x	SampledTraj object to be deserialized

    {
      Index size;
      x.clear();
      deserialize(f,size);
 
      for(Index i = 0 ; i < size ; i++)
      {
        double ti; deserialize(f,ti);
        T xi; deserialize(f,xi);
        x.set(xi,ti);
      }
    }

operator+() [10/13]

template<typename T>

const SampledTraj< T > & codac2::operator+ ( const SampledTraj< T > & x1 )

inline

\(x1(\cdot)\)

Parameters

x1

Returns

trajectory output

                                                                   {
    return x1;
  }

operator+() [11/13]

template<typename T>

SampledTraj< T > codac2::operator+ ( const SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

\(x_1(\cdot)+x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator+() [12/13]

template<typename T, typename Q>

SampledTraj< T > codac2::operator+ ( const SampledTraj< T > & x1, const Q & x2 )

inline

\(x_1(\cdot)+x_2\)

Parameters

x1
x2

Returns

trajectory output

operator+() [13/13]

template<typename T, typename Q>

SampledTraj< T > codac2::operator+ ( const Q & x1, const SampledTraj< T > & x2 )

inline

\(x+x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator+=() [3/4]

template<typename T, typename Q>

SampledTraj< T > & codac2::operator+= ( SampledTraj< T > & x1, const Q & x2 )

inline

Operates +=.

Parameters

x1
x2

Returns

updated output

operator+=() [4/4]

template<typename T>

SampledTraj< T > & codac2::operator+= ( SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

Operates +=.

Parameters

x1
x2

Returns

updated output

operator-() [8/11]

template<typename T>

SampledTraj< T > codac2::operator- ( const SampledTraj< T > & x1 )

inline

\(-x_1(\cdot)\)

Parameters

x1

Returns

trajectory output

                                                            {
    return -1.*x1;
  }

operator-() [9/11]

template<typename T>

SampledTraj< T > codac2::operator- ( const SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

\(x_1(\cdot)-x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator-() [10/11]

template<typename T, typename Q>

SampledTraj< T > codac2::operator- ( const SampledTraj< T > & x1, const Q & x2 )

inline

\(x_1(\cdot)-x_2\)

Parameters

x1
x2

Returns

trajectory output

operator-() [11/11]

template<typename T, typename Q>

SampledTraj< T > codac2::operator- ( const Q & x1, const SampledTraj< T > & x2 )

inline

\(x-x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator-=() [3/4]

template<typename T, typename Q>

SampledTraj< T > & codac2::operator-= ( SampledTraj< T > & x1, const Q & x2 )

inline

Operates -=.

Parameters

x1
x2

Returns

updated output

operator-=() [4/4]

template<typename T>

SampledTraj< T > & codac2::operator-= ( SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

Operates -=.

Parameters

x1
x2

Returns

updated output

operator*() [14/19]

template<typename T>

SampledTraj< T > codac2::operator* ( double x1, const SampledTraj< T > & x2 )

inline

\(x_1\cdot x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator*() [15/19]

template<typename T>

SampledTraj< T > codac2::operator* ( const SampledTraj< T > & x1, double x2 )

inline

\(x_1(\cdot)\cdot x_2\)

Parameters

x1
x2

Returns

trajectory output

operator*() [16/19]

template<typename T>

SampledTraj< T > codac2::operator* ( const SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

\(x_1(\cdot)\cdot x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator*() [17/19]

template<typename T, typename Q>

SampledTraj< T > codac2::operator* ( const SampledTraj< T > & x1, const Q & x2 )

inline

\(x_1(\cdot)\cdot x_2\)

Parameters

x1
x2

Returns

trajectory output

operator*() [18/19]

template<typename T, typename Q>

SampledTraj< T > codac2::operator* ( const Q & x1, const SampledTraj< T > & x2 )

inline

\(x\cdot x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator*() [19/19]

SampledTraj< Vector > codac2::operator* ( const SampledTraj< Matrix > & x1, const SampledTraj< Vector > & x2 )

inline

\(x_1(\cdot)\cdot x_2\)

Parameters

x1
x2

Returns

trajectory output

operator*=() [4/5]

template<typename T, typename Q>

SampledTraj< T > & codac2::operator*= ( SampledTraj< T > & x1, const Q & x2 )

inline

Operates *=.

Parameters

x1
x2

Returns

updated output

operator*=() [5/5]

template<typename T>

SampledTraj< T > & codac2::operator*= ( SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

Operates *=.

Parameters

x1
x2

Returns

updated output

operator/() [9/12]

template<typename T>

SampledTraj< T > codac2::operator/ ( const SampledTraj< T > & x1, double x2 )

inline

\(x_2(\cdot)/x_1\)

Parameters

x1
x2

Returns

trajectory output

operator/() [10/12]

template<typename T>

SampledTraj< T > codac2::operator/ ( const SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

\(x_1(\cdot)/x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator/() [11/12]

template<typename T, typename Q>

SampledTraj< T > codac2::operator/ ( const SampledTraj< T > & x1, const Q & x2 )

inline

\(x_1(\cdot)/x_2\)

Parameters

x1
x2

Returns

trajectory output

operator/() [12/12]

template<typename T, typename Q>

SampledTraj< T > codac2::operator/ ( const Q & x1, const SampledTraj< T > & x2 )

inline

\(x/x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

operator/=() [4/5]

template<typename T, typename Q>

SampledTraj< T > & codac2::operator/= ( SampledTraj< T > & x1, const Q & x2 )

inline

Operates /=.

Parameters

x1
x2

Returns

updated output

operator/=() [5/5]

template<typename T>

SampledTraj< T > & codac2::operator/= ( SampledTraj< T > & x1, const SampledTraj< T > & x2 )

inline

Operates /=.

Parameters

x1
x2

Returns

updated output

sqr() [3/3]

SampledTraj< double > codac2::sqr

(

const SampledTraj< double > &

x1

)

\(x^2(\cdot)\)

Parameters

x1

Returns

trajectory output

sqrt() [3/3]

SampledTraj< double > codac2::sqrt

(

const SampledTraj< double > &

x1

)

\(\sqrt{x_1(\cdot)}\)

Parameters

x1

Returns

trajectory output

pow() [6/7]

SampledTraj< double > codac2::pow	(	const SampledTraj< double > &	x1,
		int	x2 )

\(x^x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

pow() [7/7]

SampledTraj< double > codac2::pow	(	const SampledTraj< double > &	x1,
		double	x2 )

\(x^x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

root() [2/2]

SampledTraj< double > codac2::root	(	const SampledTraj< double > &	x1,
		int	x2 )

\(x^x_2(\cdot)\)

Parameters

x1
x2

Returns

trajectory output

exp() [3/3]

SampledTraj< double > codac2::exp

(

const SampledTraj< double > &

x1

)

\(\exp(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

log() [3/3]

SampledTraj< double > codac2::log

(

const SampledTraj< double > &

x1

)

\(\log(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

cos() [3/3]

SampledTraj< double > codac2::cos

(

const SampledTraj< double > &

x1

)

\(\cos(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

sin() [3/3]

SampledTraj< double > codac2::sin

(

const SampledTraj< double > &

x1

)

\(\sin(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

tan() [3/3]

SampledTraj< double > codac2::tan

(

const SampledTraj< double > &

x1

)

\(\tan(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

acos() [3/3]

SampledTraj< double > codac2::acos

(

const SampledTraj< double > &

x1

)

\(\arccos(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

asin() [3/3]

SampledTraj< double > codac2::asin

(

const SampledTraj< double > &

x1

)

\(\arcsin(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

atan() [3/3]

SampledTraj< double > codac2::atan

(

const SampledTraj< double > &

x1

)

\(\arctan(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

atan2() [5/7]

SampledTraj< double > codac2::atan2	(	const SampledTraj< double > &	x1,
		const SampledTraj< double > &	x2 )

\(\mathrm{arctan2}(x_1(\cdot),x_2(\cdot))\)

Parameters

x1
x2

Returns

trajectory output

atan2() [6/7]

SampledTraj< double > codac2::atan2	(	const SampledTraj< double > &	x1,
		double	x2 )

\(\mathrm{arctan2}(x_1(\cdot),x_2)\)

Parameters

x1
x2

Returns

trajectory output

atan2() [7/7]

SampledTraj< double > codac2::atan2	(	double	x1,
		const SampledTraj< double > &	x2 )

\(\mathrm{arctan2}(x_1, x_2(\cdot))\)

Parameters

x1
x2

Returns

trajectory output

cosh() [3/3]

SampledTraj< double > codac2::cosh

(

const SampledTraj< double > &

x1

)

\(\cosh(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

sinh() [3/3]

SampledTraj< double > codac2::sinh

(

const SampledTraj< double > &

x1

)

\(\sinh(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

tanh() [3/3]

SampledTraj< double > codac2::tanh

(

const SampledTraj< double > &

x1

)

\(\tanh(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

acosh() [3/3]

SampledTraj< double > codac2::acosh

(

const SampledTraj< double > &

x1

)

\(\mathrm{arccosh}(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

asinh() [3/3]

SampledTraj< double > codac2::asinh

(

const SampledTraj< double > &

x1

)

\(\mathrm{arcsinh}(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

atanh() [3/3]

SampledTraj< double > codac2::atanh

(

const SampledTraj< double > &

x1

)

\(\mathrm{arctanh}(x_1(\cdot))\)

Parameters

x1

Returns

trajectory output

abs() [4/4]

SampledTraj< double > codac2::abs

(

const SampledTraj< double > &

x1

)

\(\mid x_1(\cdot)\mid\)

Parameters

x1

Returns

trajectory output

min() [5/7]

SampledTraj< double > codac2::min	(	const SampledTraj< double > &	x1,
		const SampledTraj< double > &	x2 )

\(\min(x_1(\cdot),x_2(\cdot))\)

Parameters

x1
x2

Returns

trajectory output

min() [6/7]

SampledTraj< double > codac2::min	(	const SampledTraj< double > &	x1,
		double	x2 )

\(\min(x_1(\cdot),x_2)\)

Parameters

x1
x2

Returns

trajectory output

min() [7/7]

SampledTraj< double > codac2::min	(	double	x1,
		const SampledTraj< double > &	x2 )

\(\min(x_1, x_2(\cdot))\)

Parameters

x1
x2

Returns

trajectory output

max() [5/7]

SampledTraj< double > codac2::max	(	const SampledTraj< double > &	x1,
		const SampledTraj< double > &	x2 )

\(\max(x_1(\cdot),x_2(\cdot))\)

Parameters

x1
x2

Returns

trajectory output

max() [6/7]

SampledTraj< double > codac2::max	(	const SampledTraj< double > &	x1,
		double	x2 )

\(\max(x_1(\cdot),x_2)\)

Parameters

x1
x2

Returns

trajectory output

max() [7/7]

SampledTraj< double > codac2::max	(	double	x1,
		const SampledTraj< double > &	x2 )

\(\max(x_1, x_2(\cdot))\)

Parameters

x1
x2

Returns

trajectory output

to_capd() [1/3]

capd::Interval codac2::to_capd

(

const codac2::Interval &

x

)

Converts a Codac Interval object into an CAPD Interval object.

Parameters

x	the Codac Interval to be converted

Returns

the converted CAPD Interval

to_codac() [1/4]

codac2::Interval codac2::to_codac

(

const capd::Interval &

x

)

Converts an CAPD Interval object into a Codac Interval object.

Parameters

x	the CAPD Interval to be converted

Returns

the converted Codac Interval

to_capd() [2/3]

capd::IVector codac2::to_capd

(

const codac2::IntervalVector &

x

)

Converts a Codac IntervalVector object into an CAPD IVector object.

Parameters

x	the Codac IntervalVector to be converted

Returns

the converted CAPD IVector

to_codac() [2/4]

codac2::IntervalVector codac2::to_codac

(

const capd::IVector &

x

)

Converts an CAPD IVector object into a Codac IntervalVector object.

Parameters

x	the CAPD IVector to be converted

Returns

the converted Codac IntervalVector

to_capd() [3/3]

capd::IMatrix codac2::to_capd

(

const codac2::IntervalMatrix &

x

)

Converts a Codac IntervalMatrix object into an CAPD IMatrix object.

Parameters

x	the Codac IntervalMatrix to be converted

Returns

the converted CAPD IMatrix

to_codac() [3/4]

codac2::IntervalMatrix codac2::to_codac

(

const capd::IMatrix &

x

)

Converts an CAPD IMatrix object into a Codac IntervalMatrix object.

Parameters

x	the CAPD IMatrix to be converted

Returns

the converted Codac IntervalMatrix

to_codac() [4/4]

codac2::SlicedTube< codac2::IntervalVector > codac2::to_codac	(	const codac2::SolutionCurveWrapper &	solution_curve,
		const std::shared_ptr< TDomain > &	tdomain )

Converts a CAPD SolutionCurve into a Codac SlicedTube.

Parameters

solution_curve	the CAPD SolutionCurve to be converted
tdomain	the TDomain defining the time slices of the resulting SlicedTube

Returns

the converted Codac SlicedTube with both the time slices (and eventually gates) of Codac and the gates from CAPD

PEIBOS() [3/4]

std::map< double, std::vector< T > > codac2::PEIBOS	(	const capd::IMap &	i_map,
		double	tf,
		double	dt,
		const AnalyticFunction< VectorType > &	psi_0,
		const std::vector< OctaSym > &	Sigma,
		double	epsilon,
		bool	verbose = false )

PEIBOS algorithm using CAPD for guaranteed ODE propagation.

Parameters

i_map	The CAPD interval map representing the ODE.
tf	Final time for the propagation.
dt	Time step for the output map.
psi_0	The transformation function \(\psi_0:\mathbb{R}^m\rightarrow\mathbb{R}^n\) to construct the atlas
Sigma	The set of symmetry operators \(\sigma\) to construct the atlas
epsilon	The maximum diameter of the boxes to split \([-1,1]^m\) before computing the parallelepiped inclusions (each box is called "box" below)
verbose	If true, print the time taken to compute the parallelepiped inclusions with other statistics

Returns

A timed map of PEIBOS CAPD results. At each time \(t\), the value is a vector of tuples. Each tuple contains:

• A PEIBOS_CAPD_Key representing \(\mathbf{x}(0)= \sigma(\psi_0(\mathbf{\text{box}}))\)
• The interval vector \(\mathbf{z}\) containing the image \(\bar{\mathbf{x}}(t))\)
• The interval Jacobian matrix \(\mathbf{J_f}\) containing \(D\mathbf{\left[x\right]}(t)\)

PEIBOS() [4/4]

std::map< double, std::vector< T > > codac2::PEIBOS	(	const capd::IMap &	i_map,
		double	tf,
		double	dt,
		const AnalyticFunction< VectorType > &	psi_0,
		const std::vector< OctaSym > &	Sigma,
		double	epsilon,
		const Vector &	offset,
		bool	verbose = false )

PEIBOS algorithm using CAPD for guaranteed ODE propagation.

Parameters

i_map	The CAPD interval map representing the ODE.
tf	Final time for the propagation.
dt	Time step for the output map.
psi_0	The transformation function \(\psi_0:\mathbb{R}^m\rightarrow\mathbb{R}^n\) to construct the atlas
Sigma	The set of symmetry operators \(\sigma\) to construct the atlas
epsilon	The maximum diameter of the boxes to split \([-1,1]^m\) before computing the parallelepiped inclusions (each box is called "box" below)
offset	The offset to add to \(\sigma(\psi_0([-1,1]^m))\) (used to translate the initial manifold)
verbose	If true, print the time taken to compute the parallelepiped inclusions with other statistics

Returns

A timed map of PEIBOS CAPD results. At each time \(t\), the value is a vector of tuples. Each tuple contains:

• A PEIBOS_CAPD_Key representing \(\mathbf{x}(0)= \sigma(\psi_0(\mathbf{\text{box}})) + \text{offset}\)
• The interval vector \(\mathbf{z}\) containing the image \(\bar{\mathbf{x}}(t))\)
• The interval Jacobian matrix \(\mathbf{J_f}\) containing \(D\mathbf{\left[x\right]}(t)\)

reach_set()

std::map< double, std::vector< Parallelepiped > > codac2::reach_set

(

const std::map< double, std::vector< T > > &

peibos_output

)

Compute the reach set parallelepipeds from the PEIBOS CAPD output.

Parameters

peibos_output

The output of the PEIBOS CAPD algorithm.

Returns

A timed map of reach set parallelepipeds. At each time \(t\), the value is a vector of Parallelepipeds enclosing the reach set at time \(t\). The function parallelepiped_inclusion is used to compute each Parallelepiped from the PEIBOS CAPD output.

sympy_simplify() [1/3]

AnalyticFunction< ScalarType > codac2::sympy_simplify

(

const AnalyticFunction< ScalarType > &

f

)

Symbolically simplifies a scalar analytic function.

Parameters

f	Function to simplify.

Returns

A simplified analytic function.

sympy_simplify() [2/3]

AnalyticFunction< VectorType > codac2::sympy_simplify

(

const AnalyticFunction< VectorType > &

f

)

Symbolically simplifies a vector analytic function componentwise.

Parameters

f	Function to simplify.

Returns

A simplified analytic function.

sympy_simplify() [3/3]

AnalyticFunction< MatrixType > codac2::sympy_simplify

(

const AnalyticFunction< MatrixType > &

f

)

Symbolically simplifies a matrix analytic function componentwise.

Parameters

f	Function to simplify.

Returns

A simplified analytic function.

sympy_horner() [1/3]

AnalyticFunction< ScalarType > codac2::sympy_horner

(

const AnalyticFunction< ScalarType > &

f

)

Rewrites a scalar analytic function in Horner form when possible.

Parameters

f	Function to rewrite.

Returns

A rewritten analytic function.

sympy_horner() [2/3]

AnalyticFunction< VectorType > codac2::sympy_horner

(

const AnalyticFunction< VectorType > &

f

)

Rewrites a vector analytic function in Horner form componentwise.

Parameters

f	Function to rewrite.

Returns

A rewritten analytic function.

sympy_horner() [3/3]

AnalyticFunction< MatrixType > codac2::sympy_horner

(

const AnalyticFunction< MatrixType > &

f

)

Rewrites a matrix analytic function in Horner form componentwise.

Parameters

f	Function to rewrite.

Returns

A rewritten analytic function.

sympy_partial_diff() [1/3]

AnalyticFunction< ScalarType > codac2::sympy_partial_diff	(	const AnalyticFunction< ScalarType > &	f,
		Index	flat_input_index )

Returns the symbolic partial derivative of a scalar function.

The derivative is taken with respect to the flattened scalar input of index flat_input_index.

Parameters

f	Scalar function.
flat_input_index	Flattened input index.

Returns

The symbolic partial derivative.

sympy_partial_diff() [2/3]

AnalyticFunction< ScalarType > codac2::sympy_partial_diff	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarVar &	x )

Returns the symbolic partial derivative of a scalar function with respect to a scalar input variable.

This overload is restricted to scalar variables that appear directly in the function argument list.

Parameters

f	Scalar function.
x	Scalar input variable.

Returns

The symbolic partial derivative.

sympy_partial_diff() [3/3]

AnalyticFunction< ScalarType > codac2::sympy_partial_diff	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarExpr &	x )

Returns the symbolic partial derivative of a scalar function with respect to a scalar input expression.

This overload supports either a scalar input variable, or a direct scalar component of a vectorial or matricial input variable.

Parameters

f	Scalar function.
x	Scalar input expression.

Returns

The symbolic partial derivative.

sympy_diff() [1/7]

AnalyticFunction< ScalarType > codac2::sympy_diff

(

const AnalyticFunction< ScalarType > &

f

)

Returns the symbolic derivative of a scalar univariate function.

Parameters

f	Scalar function.

Returns

The symbolic derivative.

sympy_diff() [2/7]

AnalyticFunction< ScalarType > codac2::sympy_diff	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarVar &	x )

Returns the symbolic first derivative of a scalar function with respect to a scalar input variable.

Parameters

f	Scalar function.
x	Scalar input variable.

Returns

The symbolic derivative with respect to x.

sympy_diff() [3/7]

AnalyticFunction< ScalarType > codac2::sympy_diff	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarExpr &	x )

Returns the symbolic first derivative of a scalar function with respect to a scalar input expression.

This overload supports either a scalar input variable, or a direct scalar component of a vectorial or matricial input variable.

Parameters

f	Scalar function.
x	Scalar input expression.

Returns

The symbolic derivative with respect to x.

sympy_diff() [4/7]

AnalyticFunction< ScalarType > codac2::sympy_diff	(	const AnalyticFunction< ScalarType > &	f,
		Index	order )

Returns the symbolic derivative of given order for a scalar univariate function.

Parameters

f	Scalar function.
order	Derivation order.

Returns

The symbolic derivative of order order.

sympy_diff() [5/7]

AnalyticFunction< ScalarType > codac2::sympy_diff	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarVar &	x,
		Index	order )

Returns the symbolic derivative of given order for a scalar function with respect to a scalar input variable.

Parameters

f	Scalar function.
x	Scalar input variable.
order	Derivation order.

Returns

The symbolic derivative of order order with respect to x.

sympy_diff() [6/7]

AnalyticFunction< ScalarType > codac2::sympy_diff	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarExpr &	x,
		Index	order )

Returns the symbolic derivative of given order for a scalar function with respect to a scalar input expression.

This overload supports either a scalar input variable, or a direct scalar component of a vectorial or matricial input variable.

Parameters

f	Scalar function.
x	Scalar input expression.
order	Derivation order.

Returns

The symbolic derivative of order order with respect to x.

sympy_gradient()

AnalyticFunction< VectorType > codac2::sympy_gradient

(

const AnalyticFunction< ScalarType > &

f

)

Returns the symbolic gradient of a scalar function.

Parameters

f	Scalar function.

Returns

The symbolic gradient.

sympy_hessian()

AnalyticFunction< MatrixType > codac2::sympy_hessian

(

const AnalyticFunction< ScalarType > &

f

)

Returns the symbolic Hessian matrix of a scalar function.

Parameters

f	Scalar function.

Returns

The symbolic Hessian matrix.

sympy_diff() [7/7]

AnalyticFunction< MatrixType > codac2::sympy_diff

(

const AnalyticFunction< VectorType > &

f

)

Returns the symbolic Jacobian matrix of a vector function.

Parameters

f	Vector function.

Returns

The symbolic Jacobian matrix.

sympy_series() [1/3]

AnalyticFunction< ScalarType > codac2::sympy_series	(	const AnalyticFunction< ScalarType > &	f,
		double	center,
		Index	order )

Returns a truncated Taylor series of a scalar univariate function.

Parameters

f	Scalar function.
center	Expansion center.
order	Truncation order.

Returns

The truncated Taylor series.

sympy_series() [2/3]

AnalyticFunction< ScalarType > codac2::sympy_series	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarVar &	x,
		double	center,
		Index	order )

Returns a truncated Taylor series of a scalar function with respect to a scalar input variable.

Other input variables are treated as constants.

Parameters

f	Scalar function.
x	Scalar input variable.
center	Expansion center.
order	Truncation order.

Returns

The truncated Taylor series.

sympy_series() [3/3]

AnalyticFunction< ScalarType > codac2::sympy_series	(	const AnalyticFunction< ScalarType > &	f,
		const ScalarExpr &	x,
		double	center,
		Index	order )

Returns a truncated Taylor series of a scalar function with respect to a scalar input expression.

Other input variables are treated as constants. This overload supports either a scalar input variable, or a direct scalar component of a vectorial or matricial input variable.

Parameters

f	Scalar function.
x	Scalar input expression.
center	Expansion center.
order	Truncation order.

Returns

The truncated Taylor series.

sympy_equal() [1/3]

bool codac2::sympy_equal	(	const AnalyticFunction< ScalarType > &	f,
		const AnalyticFunction< ScalarType > &	g )

Tests symbolic equality of two scalar analytic functions through SymPy.

The two functions are compared on the same flattened domain: only the order and total number of flattened scalar inputs matter, not the original grouping into scalar, vector or matrix arguments.

Parameters

f	First scalar function.
g	Second scalar function.

Returns

True if the two functions are symbolically equal.

sympy_equal() [2/3]

bool codac2::sympy_equal	(	const AnalyticFunction< VectorType > &	f,
		const AnalyticFunction< VectorType > &	g )

Tests symbolic equality of two vector analytic functions through SymPy.

Equality is checked componentwise on the same flattened domain.

Parameters

f	First vector function.
g	Second vector function.

Returns

True if the two functions are symbolically equal.

sympy_equal() [3/3]

bool codac2::sympy_equal	(	const AnalyticFunction< MatrixType > &	f,
		const AnalyticFunction< MatrixType > &	g )

Tests symbolic equality of two matrix analytic functions through SymPy.

Equality is checked entrywise on the same flattened domain.

Parameters

f	First matrix function.
g	Second matrix function.

Returns

True if the two functions are symbolically equal.