codac 2.0.0
|
Classes | |
struct | Color |
Color structure, in RGBA or HSVA format. More... | |
struct | ColorMap |
Represents a set of RGB or HSV values. More... | |
class | ConvexPolygon |
Represents a convex polygon defined by vertices enclosed in IntervalVector s. 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 | 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 | 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 | DefaultFigure |
Default view class, used to manage the default figure. More... | |
class | Ellipsoid |
Ellipsoid representation. More... | |
class | ExprBase |
Abstract base class for representing an expression. More... | |
class | ExprID |
A class representing a unique identifier for expressions. More... | |
class | Figure2D |
Figure2D class, used for 2D display. More... | |
class | Figure2D_IPE |
IPE output class. More... | |
class | Figure2D_VIBes |
VIBes output class. More... | |
class | Figure2DInterface |
Interface for 2D figures. More... | |
class | Figure3D |
Figure3D class, used for 3D figures. 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 | Interval |
Interval class, for representing closed and connected subsets of \(\mathbb{R}\). More... | |
class | IntvFullPivLU |
Full pivot LU decomposition for matrix of interval, based on Eigen decomposition. The decomposition is of the form M = P{-1} [L][U] Q{-1} where P and Q are permutation matrices, and [L] and [U] are lower and upper interval matrices ([L] diagonal is 1). More... | |
class | OperationExprBase |
A base class for expressions representing operations with multiple operands. More... | |
class | OutputFigure2D |
Output figure class, used to manage the output figures. More... | |
class | Polygon |
Represents a polygon (convex or non-convex) defined by its vertices enclosed in IntervalVector s. More... | |
class | Segment |
Represents a geometric segment defined by two points enclosed in IntervalVector s. More... | |
class | SepChi |
A separator on the Chi constraint If [x] in Sa, then Sb, else Sc. More... | |
struct | StyleProperties |
Style properties structure, to specify the style of a shape. More... | |
class | VarBase |
Abstract base class for representing variables in analytic or set functions. 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 | 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 | 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 | |
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 | previous_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. | |
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. | |
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 . | |
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> requires (!Eigen::IsIntervalDomain<typename OtherDerived::Scalar>) | |
auto | floor (const Eigen::MatrixBase< OtherDerived > &x) |
Compute the element-wise floor of a matrix. | |
template<typename OtherDerived> requires (!Eigen::IsIntervalDomain<typename OtherDerived::Scalar>) | |
auto | ceil (const Eigen::MatrixBase< OtherDerived > &x) |
Compute the element-wise ceiling of a matrix. | |
template<typename OtherDerived> requires (!Eigen::IsIntervalDomain<typename OtherDerived::Scalar>) | |
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. | |
template<typename T> requires (std::is_trivially_copyable_v<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> requires (std::is_trivially_copyable_v<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> requires (!std::is_same_v<T,double>) | |
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> requires (!std::is_same_v<T,double>) | |
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> requires (!std::is_same_v<T,double>) | |
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. | |
void | draw_while_paving (const IntervalVector &x0, std::shared_ptr< const CtcBase< IntervalVector > > c, double eps, std::shared_ptr< Figure2D > fig=nullptr) |
Draws the paving while it is being computed. | |
void | draw_while_paving (const IntervalVector &x0, const CtcBase< IntervalVector > &c, double eps, std::shared_ptr< Figure2D > fig=nullptr) |
Draws the paving while it is being computed. | |
void | draw_while_paving (const IntervalVector &x0, std::shared_ptr< const SepBase > s, double eps, std::shared_ptr< Figure2D > fig=nullptr) |
Draws the paving while it is being computed. | |
void | draw_while_paving (const IntervalVector &x0, const SepBase &s, double eps, std::shared_ptr< Figure2D > fig=nullptr) |
Draws the paving while it is being computed. | |
using codac2::IntervalMatrix = Eigen::Matrix<Interval,-1,-1> |
using codac2::IntervalRow = Eigen::Matrix<Interval,1,-1> |
using codac2::IntervalVector = Eigen::Matrix<Interval,-1,1> |
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>
.
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>
.
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>
.
|
strong |
Enumeration representing a boolean interval.
The logical operators &
and |
can be used to combine BoolInterval
values.
Enumerator | |
---|---|
EMPTY |
|
UNKNOWN |
|
|
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 |
|
enum codac2::Model |
Color model (RGB or HSV)
This enum is used to specify the color model of a color, either RGB or HSV.
|
inline |
Returns the complementary of a BoolInterval.
x | the boolean interval |
|
inline |
Streams out a BoolInterval.
os | the stream to be updated |
x | the boolean interval to stream out |
Compute the Minkowski sum of two ellipsoids.
e1 | first ellipsoid |
e2 | second ellipsoid |
Guaranteed linear evaluation A*e+b, considering the rounding errors.
e | input ellipsoid |
A | matrix |
b | vector |
Ellipsoid codac2::unreliable_linear_mapping | ( | const Ellipsoid & | e, |
const Matrix & | A, | ||
const Vector & | b ) |
Nonrigorous linear evaluation A*e+b.
e | input ellipsoid |
A | matrix |
b | vector |
Ellipsoid codac2::nonlinear_mapping | ( | const Ellipsoid & | e, |
const AnalyticFunction< VectorType > & | f ) |
(Rigorous?) non-linear evaluation f(e)
e | input ellipsoid |
f | non-linear analytical function |
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
e | input ellipsoid |
f | non-linear analytical function |
trig | (?) |
q | (?) |
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
G | (?) |
J | approximated Jacobian matrix of f |
J_box | reliable enclosure of the Jacobian matrix of f |
trig | (?) |
q | (?) |
std::ostream & codac2::operator<< | ( | std::ostream & | os, |
const Ellipsoid & | e ) |
Streams out an Ellipsoid.
os | the stream to be updated |
e | the ellipsoid stream out |
BoolInterval codac2::stability_analysis | ( | const AnalyticFunction< VectorType > & | f, |
unsigned int | alpha_max, | ||
Ellipsoid & | e, | ||
Ellipsoid & | e_out, | ||
bool | verbose = false ) |
...
f | ... |
alpha_max | ... |
e | ... |
e_out | ... |
verbose | ... |
...
A | ... |
Q | ... |
|
inline |
Streams out this.
os | the stream to be updated |
x | the interval to stream out |
|
inline |
Codac defined literals allowing to produce an interval from a double.
x | value to convert into an interval object |
|
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.
next_float()
.x | The input double value. |
|
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.
previous_float()
.x | The input double value. |
Returns the intersection of two intervals: \([x]\cap[y]\).
x | interval value |
y | interval value |
Returns the squared-union of an interval and a real: \([x]\sqcup\{y\}\).
x | interval value |
y | real value |
Returns the squared-union of two intervals: \([x]\sqcup[y]\).
x | interval value |
y | interval value |
Returns this.
x | interval value |
Returns \([x]+y\) with \(y\in\mathbb{R}\).
x | interval value |
y | real value |
Returns \(x+[y]\) with \(x\in\mathbb{R}\).
x | real value |
y | interval value |
Returns \([x]+[y]\).
x | interval value |
y | interval value |
Returns \([x]-y\) with \(y\in\mathbb{R}\).
x | interval value |
y | real value |
Returns \(x-[y]\) with \(x\in\mathbb{R}\).
x | real value |
y | interval value |
Returns \([x]-[y]\).
x | interval value |
y | interval value |
Returns \([x]*y\) with \(y\in\mathbb{R}\).
x | interval value |
y | real value |
Returns \(x*[y]\) with \(x\in\mathbb{R}\).
x | real value |
y | interval value |
Returns \([x]*[y]\).
x | interval value |
y | interval value |
Returns \([x]/y\) with \(y\in\mathbb{R}\).
x | interval value |
y | real value |
Returns \(x/[y]\) with \(x\in\mathbb{R}\).
x | real value |
y | interval value |
Returns \([x]/[y]\).
x | interval value |
y | interval value |
Returns \([x]^2\).
x | interval value |
Returns \(\sqrt{[x]}\).
x | interval value |
Returns \([x]^n\), \(n\in\mathbb{Z}\).
x | interval value |
n | integer power value |
Returns \([x]^p\), \(p\in\mathbb{R}\).
x | interval value |
p | real power value |
Returns \([x]^{[p]}\), \(p\in\mathbb{IR}\).
x | interval value |
p | interval power value |
Returns the p-th root: \(\sqrt[p]{[x]}\).
x | interval value |
p | integer root |
Returns \(\exp([x])\).
x | interval value |
Returns \(\log([x])\).
x | interval value |
Returns \(\cos([x])\).
x | interval value |
Returns \(\sin([x])\).
x | interval value |
Returns \(\tan([x])\).
x | interval value |
Returns \(\acos([x])\).
x | interval value |
Returns \(\asin([x])\).
x | interval value |
Returns \(\atan([x])\).
x | interval value |
Returns \(\mathrm{arctan2}([y],[x])\).
y | interval value |
x | interval value |
Returns \(\cosh([x])\).
x | interval value |
Returns \(\sinh([x])\).
x | interval value |
Returns \(\tanh([x])\).
x | interval value |
Returns \(\acosh([x])\).
x | interval value |
Returns \(\asinh([x])\).
x | interval value |
Returns \(\atanh([x])\).
x | interval value |
Returns \(\mid[x]\mid = \left\{\mid x \mid, x\in[x]\right\}\).
x | interval value |
Returns \(\min([x],[y])=\left\{\min(x,y), x\in[x], y\in[y]\right\}\).
x | interval value |
y | interval value |
Returns \(\max([x],[y])=\left\{\max(x,y), x\in[x], y\in[y]\right\}\).
x | interval value |
y | interval value |
Returns the largest integer interval included in \([x]\).
The result is a subset interval of x.
x | interval value |
Returns floor of \([x]\).
x | interval value |
Returns ceil of \([x]\).
x | interval value |
|
inline |
Stream output operator for IntervalMatrix
objects.
os | The output stream to write to. |
x | The interval matrix whose contents are to be printed. |
|
inline |
Stream output operator for IntervalRow
objects.
os | The output stream to write to. |
x | The interval row whose contents are to be printed. |
|
inline |
Stream output operator for IntervalVector
objects.
os | The output stream to write to. |
x | The interval vector whose contents are to be printed. |
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.
p1 | The first convex polygon. |
p2 | The second convex polygon. |
ConvexPolygon
enclosing the intersection area.
|
inline |
Streams out a OrientationInterval.
os | The stream to be updated |
x | The orientation interval to stream out |
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).
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. |
OrientationInterval
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).
p1 | First point (2d IntervalVector ) of the triplet. |
p2 | Second point (2d IntervalVector ) of the triplet. |
p3 | Third point (2d IntervalVector ) of the triplet. |
BooleanInterval
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.
pts | 2d points in any order |
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.
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)). |
|
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.
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)). |
std::ostream & codac2::operator<< | ( | std::ostream & | str, |
const Polygon & | p ) |
Stream output operator for Polygon
.
str | Output stream. |
p | The polygon to print. |
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.
e1 | The first segment. |
e2 | The second segment. |
IntervalVector
enclosing the intersection point. 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.
e1 | The first segment. |
e2 | The second segment. |
IntervalVector
enclosing the intersection point. BoolInterval codac2::colinear | ( | const Segment & | e1, |
const Segment & | e2 ) |
Checks if two segments are colinear.
e1 | The first segment. |
e2 | The second segment. |
BoolInterval
indicating possible colinearity. std::ostream & codac2::operator<< | ( | std::ostream & | str, |
const Segment & | e ) |
Stream output operator for Segment
.
str | Output stream. |
e | The segment to print. |
|
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}]\).
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. |
A | A matrix expression, possibly interval. |
B | An (almost punctual) approximation of its inverse. |
|
inline |
Enclosure of the inverse of a (non-singular) matrix expression, possibly an interval matrix.
A | A matrix expression, possibly interval. |
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]\).
A | A matrix of intervals (supposed around \(\mathbf{0}\)). |
mrad | The maximum radius of the result added (output argument). |
|
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.
x | Input matrix expression. |
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.
x | Input matrix expression. |
|
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.
x | Input matrix expression. |
|
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.
x | Input matrix expression. |
|
inline |
Provides an Eigen IOFormat for formatting row vectors.
This format prints elements separated by spaces, with brackets around the entire row vector.
|
inline |
Provides an Eigen IOFormat for formatting column vectors.
This format prints elements separated by semicolons, with brackets around the entire vector.
|
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.
|
inline |
Stream output operator for Matrix
objects.
os | The output stream to write to. |
x | The matrix whose contents are to be printed. |
|
inline |
Stream output operator for Row
objects.
os | The output stream to write to. |
x | The row whose contents are to be printed. |
|
inline |
Stream output operator for Vector
objects.
os | The output stream to write to. |
x | The vector whose contents are to be printed. |
|
inline |
Writes the binary representation of a trivially copyable object to the given output stream.
Binary structure:
[raw memory of x]
f | output stream |
x | object/variable to be serialized |
|
inline |
Reads the binary representation of a trivially copyable object from the given input stream.
Binary structure:
[raw memory of x]
f | input stream |
x | object to be deserialized |
|
inline |
Writes the binary representation of an Interval
object to the given output stream.
Interval binary structure:
[double_lb][double_ub]
f | output stream |
x | Interval object to be serialized |
|
inline |
Creates an Interval
object from the binary representation given in an input stream.
Interval binary structure:
[double_lb][double_ub]
f | input stream |
x | Interval object to be deserialized |
|
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]
f | output stream |
x | matrix structure to be serialized |
|
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]
f | input stream |
x | matrix structure to be deserialized |
|
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]
f | output stream |
x | SampledTraj object to be serialized |
|
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]
f | input stream |
x | SampledTraj object to be deserialized |
|
inline |
\(x1(\cdot)\)
x1 |
|
inline |
\(x_1(\cdot)+x_2(\cdot)\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)+x_2\)
x1 | |
x2 |
|
inline |
\(x+x_2(\cdot)\)
x1 | |
x2 |
|
inline |
Operates +=.
x1 | |
x2 |
|
inline |
Operates +=.
x1 | |
x2 |
|
inline |
\(-x_1(\cdot)\)
x1 |
|
inline |
\(x_1(\cdot)-x_2(\cdot)\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)-x_2\)
x1 | |
x2 |
|
inline |
\(x-x_2(\cdot)\)
x1 | |
x2 |
|
inline |
Operates -=.
x1 | |
x2 |
|
inline |
Operates -=.
x1 | |
x2 |
|
inline |
\(x_1\cdot x_2(\cdot)\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)\cdot x_2\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)\cdot x_2(\cdot)\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)\cdot x_2\)
x1 | |
x2 |
|
inline |
\(x\cdot x_2(\cdot)\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)\cdot x_2\)
x1 | |
x2 |
|
inline |
Operates *=.
x1 | |
x2 |
|
inline |
Operates *=.
x1 | |
x2 |
|
inline |
\(x_2(\cdot)/x_1\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)/x_2(\cdot)\)
x1 | |
x2 |
|
inline |
\(x_1(\cdot)/x_2\)
x1 | |
x2 |
|
inline |
\(x/x_2(\cdot)\)
x1 | |
x2 |
|
inline |
Operates /=.
x1 | |
x2 |
|
inline |
Operates /=.
x1 | |
x2 |
SampledTraj< double > codac2::sqr | ( | const SampledTraj< double > & | x1 | ) |
\(x^2(\cdot)\)
x1 |
SampledTraj< double > codac2::sqrt | ( | const SampledTraj< double > & | x1 | ) |
\(\sqrt{x_1(\cdot)}\)
x1 |
SampledTraj< double > codac2::pow | ( | const SampledTraj< double > & | x1, |
int | x2 ) |
\(x^x_2(\cdot)\)
x1 | |
x2 |
SampledTraj< double > codac2::pow | ( | const SampledTraj< double > & | x1, |
double | x2 ) |
\(x^x_2(\cdot)\)
x1 | |
x2 |
SampledTraj< double > codac2::root | ( | const SampledTraj< double > & | x1, |
int | x2 ) |
\(x^x_2(\cdot)\)
x1 | |
x2 |
SampledTraj< double > codac2::exp | ( | const SampledTraj< double > & | x1 | ) |
\(\exp(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::log | ( | const SampledTraj< double > & | x1 | ) |
\(\log(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::cos | ( | const SampledTraj< double > & | x1 | ) |
\(\cos(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::sin | ( | const SampledTraj< double > & | x1 | ) |
\(\sin(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::tan | ( | const SampledTraj< double > & | x1 | ) |
\(\tan(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::acos | ( | const SampledTraj< double > & | x1 | ) |
\(\arccos(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::asin | ( | const SampledTraj< double > & | x1 | ) |
\(\arcsin(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::atan | ( | const SampledTraj< double > & | x1 | ) |
\(\arctan(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::atan2 | ( | const SampledTraj< double > & | x1, |
const SampledTraj< double > & | x2 ) |
\(\mathrm{arctan2}(x_1(\cdot),x_2(\cdot))\)
x1 | |
x2 |
SampledTraj< double > codac2::atan2 | ( | const SampledTraj< double > & | x1, |
double | x2 ) |
\(\mathrm{arctan2}(x_1(\cdot),x_2)\)
x1 | |
x2 |
SampledTraj< double > codac2::atan2 | ( | double | x1, |
const SampledTraj< double > & | x2 ) |
\(\mathrm{arctan2}(x_1, x_2(\cdot))\)
x1 | |
x2 |
SampledTraj< double > codac2::cosh | ( | const SampledTraj< double > & | x1 | ) |
\(\cosh(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::sinh | ( | const SampledTraj< double > & | x1 | ) |
\(\sinh(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::tanh | ( | const SampledTraj< double > & | x1 | ) |
\(\tanh(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::acosh | ( | const SampledTraj< double > & | x1 | ) |
\(\mathrm{arccosh}(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::asinh | ( | const SampledTraj< double > & | x1 | ) |
\(\mathrm{arcsinh}(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::atanh | ( | const SampledTraj< double > & | x1 | ) |
\(\mathrm{arctanh}(x_1(\cdot))\)
x1 |
SampledTraj< double > codac2::abs | ( | const SampledTraj< double > & | x1 | ) |
\(\mid x_1(\cdot)\mid\)
x1 |
SampledTraj< double > codac2::min | ( | const SampledTraj< double > & | x1, |
const SampledTraj< double > & | x2 ) |
\(\min(x_1(\cdot),x_2(\cdot))\)
x1 | |
x2 |
SampledTraj< double > codac2::min | ( | const SampledTraj< double > & | x1, |
double | x2 ) |
\(\min(x_1(\cdot),x_2)\)
x1 | |
x2 |
SampledTraj< double > codac2::min | ( | double | x1, |
const SampledTraj< double > & | x2 ) |
\(\min(x_1, x_2(\cdot))\)
x1 | |
x2 |
SampledTraj< double > codac2::max | ( | const SampledTraj< double > & | x1, |
const SampledTraj< double > & | x2 ) |
\(\max(x_1(\cdot),x_2(\cdot))\)
x1 | |
x2 |
SampledTraj< double > codac2::max | ( | const SampledTraj< double > & | x1, |
double | x2 ) |
\(\max(x_1(\cdot),x_2)\)
x1 | |
x2 |
SampledTraj< double > codac2::max | ( | double | x1, |
const SampledTraj< double > & | x2 ) |
\(\max(x_1, x_2(\cdot))\)
x1 | |
x2 |
capd::Interval codac2::to_capd | ( | const codac2::Interval & | x | ) |
codac2::Interval codac2::to_codac | ( | const capd::Interval & | x | ) |
capd::IVector codac2::to_capd | ( | const codac2::IntervalVector & | x | ) |
Converts a Codac IntervalVector object into an CAPD IVector object.
x | the Codac IntervalVector to be converted |
codac2::IntervalVector codac2::to_codac | ( | const capd::IVector & | x | ) |
Converts an CAPD IVector object into a Codac IntervalVector object.
x | the CAPD IVector to be converted |
capd::IMatrix codac2::to_capd | ( | const codac2::IntervalMatrix & | x | ) |
Converts a Codac IntervalMatrix object into an CAPD IMatrix object.
x | the Codac IntervalMatrix to be converted |
codac2::IntervalMatrix codac2::to_codac | ( | const capd::IMatrix & | x | ) |
Converts an CAPD IMatrix object into a Codac IntervalMatrix object.
x | the CAPD IMatrix to be converted |
void codac2::draw_while_paving | ( | const IntervalVector & | x0, |
std::shared_ptr< const CtcBase< IntervalVector > > | c, | ||
double | eps, | ||
std::shared_ptr< Figure2D > | fig = nullptr ) |
Draws the paving while it is being computed.
x0 | Initial box |
c | Contractor to use |
eps | Accuracy of the paving algorithm (the undefined boxes will have their max_diam <= eps) |
fig | Figure to draw on (optionnal, if not provided, the default figure will be used) |
void codac2::draw_while_paving | ( | const IntervalVector & | x0, |
const CtcBase< IntervalVector > & | c, | ||
double | eps, | ||
std::shared_ptr< Figure2D > | fig = nullptr ) |
Draws the paving while it is being computed.
x0 | Initial box |
c | Contractor to use |
eps | Accuracy of the paving algorithm (the undefined boxes will have their max_diam <= eps) |
fig | Figure to draw on (optionnal, if not provided, the default figure will be used) |
void codac2::draw_while_paving | ( | const IntervalVector & | x0, |
std::shared_ptr< const SepBase > | s, | ||
double | eps, | ||
std::shared_ptr< Figure2D > | fig = nullptr ) |
Draws the paving while it is being computed.
x0 | Initial box |
s | Separator to use |
eps | Accuracy of the paving algorithm (the undefined boxes will have their max_diam <= eps) |
fig | Figure to draw on (optionnal, if not provided, the default figure will be used) |
void codac2::draw_while_paving | ( | const IntervalVector & | x0, |
const SepBase & | s, | ||
double | eps, | ||
std::shared_ptr< Figure2D > | fig = nullptr ) |
Draws the paving while it is being computed.
x0 | Initial box |
s | Separator to use |
eps | Accuracy of the paving algorithm (the undefined boxes will have their max_diam <= eps) |
fig | Figure to draw on (optionnal, if not provided, the default figure will be used) |