|
sigma
1.0.0
|
The primary namespace for the sigma library. More...
Namespaces | |
| namespace | detail_ |
| The namespace that contains the implementation details of the library. | |
Classes | |
| class | Affine |
| Implements affine arithmetic. More... | |
| class | ThresholdedAffine |
| Implements affine arithmetic that drops negligible error terms. More... | |
| class | Interval |
| Models a closed numeric interval. More... | |
| class | GeneralInterval |
| Models an interval whose bounds may be open. More... | |
| struct | is_general_interval |
Is T a GeneralInterval? False for everything else. More... | |
| struct | is_general_interval< GeneralInterval< T > > |
| Specialization of is_general_interval for GeneralInterval. More... | |
| class | Taylor |
| Implements truncated multivariate polynomial algebra. More... | |
| class | TaylorModel |
| Pairs a Taylor polynomial with a remainder interval to guarantee Eq. \(\eqref{eq:tm-inclusion}\). More... | |
| class | Monomial |
| Represents a sparse multi-index exponent. More... | |
| class | Triplex |
| Models an interval together with a best estimate inside it. More... | |
| class | Uncertain |
| Models an unceratin variable. More... | |
Typedefs | |
| using | AFloat = Affine<float> |
| Typedef for an affine form of floats. | |
| using | ADouble = Affine<double> |
| Typedef for an affine form of doubles. | |
| using | TAFloat = ThresholdedAffine<float> |
| Typedef for a thresholded affine form of floats. | |
| using | TADouble = ThresholdedAffine<double> |
| Typedef for a thresholded affine form of doubles. | |
| using | GIFloat = GeneralInterval<float> |
| Typedef for a general interval of floats. | |
| using | GIDouble = GeneralInterval<double> |
| Typedef for a general interval of doubles. | |
| using | IFloat = Interval<float> |
| Typedef for an interval of floats. | |
| using | IDouble = Interval<double> |
| Typedef for an interval of doubles. | |
| using | TFloat = Taylor<float> |
| Typedef for a Taylor polynomial of floats. | |
| using | TDouble = Taylor<double> |
| Typedef for a Taylor polynomial of doubles. | |
| using | TMFloat = TaylorModel<float> |
| Typedef for a Taylor model of floats. | |
| using | TMDouble = TaylorModel<double> |
| Typedef for a Taylor model of doubles. | |
| using | TPFloat = Triplex<Interval<float>> |
| Typedef for a triplex with closed float bounds. | |
| using | TPDouble = Triplex<Interval<double>> |
| Typedef for a triplex with closed double bounds. | |
| using | UFloat = Uncertain<float> |
| Typedef for an uncertain float. | |
| using | UDouble = Uncertain<double> |
| Typedef for an uncertain double. | |
Functions | |
| template<typename T> | |
| Affine< T > | abs (const Affine< T > &a) |
| Absolute Value of an affine form. | |
| template<typename T> | |
| Affine< T > | fabs (const Affine< T > &a) |
| Absolute Value of an affine form. | |
| template<typename T> | |
| Affine< T > | sqrt (const Affine< T > &a) |
| Calculate the square root of an affine form. | |
| template<typename T> | |
| Affine< T > | exp (const Affine< T > &a) |
| Calculate the exponential of an affine form. | |
| template<typename T> | |
| Affine< T > | log (const Affine< T > &a) |
| Calculate the natural logarithm of an affine form. | |
| template<typename T, typename U> | |
| Affine< T > | pow (const Affine< T > &a, const U &exp) |
| Calculate the power of an affine form. | |
| template<typename T> | |
| GeneralInterval< T > | abs (const GeneralInterval< T > &a) |
| Absolute Value of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | fabs (const GeneralInterval< T > &a) |
| Absolute Value of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | sqrt (const GeneralInterval< T > &a) |
| Calculate the square root of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | exp (const GeneralInterval< T > &a) |
| Calculate Euler's number raised to the power of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | log (const GeneralInterval< T > &a) |
| Calculate the natural logarithm of a general interval. | |
| template<typename T, typename U> | |
| GeneralInterval< T > | pow (const GeneralInterval< T > &a, const U &exp) |
| Exponentiation of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | pow (const GeneralInterval< T > &a, const GeneralInterval< T > &exponent) |
| Exponentiation of a general interval by an interval exponent. | |
| template<typename T> | |
| GeneralInterval< T > | sinh (const GeneralInterval< T > &a) |
| Calculate the hyperbolic sine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | cosh (const GeneralInterval< T > &a) |
| Calculate the hyperbolic cosine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | tanh (const GeneralInterval< T > &a) |
| Calculate the hyperbolic tangent of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | asinh (const GeneralInterval< T > &a) |
| Calculate the inverse hyperbolic sine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | acosh (const GeneralInterval< T > &a) |
| Calculate the inverse hyperbolic cosine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | atanh (const GeneralInterval< T > &a) |
| Calculate the inverse hyperbolic tangent of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | sin (const GeneralInterval< T > &a) |
| Calculate the sine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | cos (const GeneralInterval< T > &a) |
| Calculate the cosine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | tan (const GeneralInterval< T > &a) |
| Calculate the tangent of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | asin (const GeneralInterval< T > &a) |
| Calculate the arcsine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | acos (const GeneralInterval< T > &a) |
| Calculate the arccosine of a general interval. | |
| template<typename T> | |
| GeneralInterval< T > | atan (const GeneralInterval< T > &a) |
| Calculate the arctangent of a general interval. | |
| template<typename T> | |
| Interval< T > | operator+ (Interval< T > lhs, T rhs) |
| template<typename T> | |
| Interval< T > | operator+ (T lhs, const Interval< T > &rhs) |
| template<typename T> | |
| Interval< T > | operator- (Interval< T > lhs, T rhs) |
| template<typename T> | |
| Interval< T > | operator- (T lhs, const Interval< T > &rhs) |
| template<typename T> | |
| Interval< T > | operator* (Interval< T > lhs, T rhs) |
| template<typename T> | |
| Interval< T > | operator* (T lhs, const Interval< T > &rhs) |
| template<typename T> | |
| Interval< T > | operator/ (Interval< T > lhs, T rhs) |
| template<typename T> | |
| Interval< T > | operator/ (T lhs, const Interval< T > &rhs) |
| template<typename T> | |
| Interval< T > | abs (const Interval< T > &a) |
| Absolute Value of an interval. | |
| template<typename T> | |
| Interval< T > | fabs (const Interval< T > &a) |
| Absolute Value of an interval. | |
| template<typename T> | |
| Interval< T > | sqrt (const Interval< T > &a) |
| Calculate the square root of an interval. | |
| template<typename T> | |
| Interval< T > | exp (const Interval< T > &a) |
| Calculate Euler's number raised to the power of an interval. | |
| template<typename T> | |
| Interval< T > | log (const Interval< T > &a) |
| Calculate the natural logarithm of an interval. | |
| template<typename T, typename U> | |
| Interval< T > | pow (const Interval< T > &a, const U &exp) |
| Exponentiation of a variable. | |
| template<typename T> | |
| Interval< T > | pow (const Interval< T > &a, const Interval< T > &exponent) |
| Exponentiation of an interval by an interval-valued exponent. | |
| template<typename T> | |
| Interval< T > | sinh (const Interval< T > &a) |
| Calculate the hyperbolic sine of an interval. | |
| template<typename T> | |
| Interval< T > | cosh (const Interval< T > &a) |
| Calculate the hyperbolic cosine of an interval. | |
| template<typename T> | |
| Interval< T > | tanh (const Interval< T > &a) |
| Calculate the hyperbolic tangent of an interval. | |
| template<typename T> | |
| Interval< T > | asinh (const Interval< T > &a) |
| Calculate the inverse hyperbolic sine of an interval. | |
| template<typename T> | |
| Interval< T > | acosh (const Interval< T > &a) |
| Calculate the inverse hyperbolic cosine of an interval. | |
| template<typename T> | |
| Interval< T > | atanh (const Interval< T > &a) |
| Calculate the inverse hyperbolic tangent of an interval. | |
| template<typename T> | |
| Interval< T > | sin (const Interval< T > &a) |
| Calculate the sine of an interval. | |
| template<typename T> | |
| Interval< T > | cos (const Interval< T > &a) |
| Calculate the cosine of an interval. | |
| template<typename T> | |
| Interval< T > | tan (const Interval< T > &a) |
| Calculate the tangent of an interval. | |
| template<typename T> | |
| Interval< T > | asin (const Interval< T > &a) |
| Calculate the arcsine of an interval. | |
| template<typename T> | |
| Interval< T > | acos (const Interval< T > &a) |
| Calculate the arccosine of an interval. | |
| template<typename T> | |
| Interval< T > | atan (const Interval< T > &a) |
| Calculate the arctangent of an interval. | |
| template<typename T> | |
| Taylor< T > | abs (const Taylor< T > &a) |
| Absolute value of a Taylor polynomial. | |
| template<typename T> | |
| Taylor< T > | fabs (const Taylor< T > &a) |
| Absolute value of a Taylor polynomial. | |
| template<typename T> | |
| Taylor< T > | sqrt (const Taylor< T > &a) |
| Calculate the square root of a Taylor polynomial. | |
| template<typename T> | |
| Taylor< T > | exp (const Taylor< T > &a) |
| Calculate the exponential of a Taylor polynomial. | |
| template<typename T> | |
| Taylor< T > | log (const Taylor< T > &a) |
| Calculate the natural logarithm of a Taylor polynomial. | |
| template<typename T, typename U> | |
| Taylor< T > | pow (const Taylor< T > &a, const U &exp) |
| Calculate the power of a Taylor polynomial. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | abs (const Triplex< IntervalType > &a) |
| Absolute value of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | fabs (const Triplex< IntervalType > &a) |
| Absolute value of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | sqrt (const Triplex< IntervalType > &a) |
| Calculate the square root of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | exp (const Triplex< IntervalType > &a) |
| Calculate Euler's number raised to the power of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | log (const Triplex< IntervalType > &a) |
| Calculate the natural logarithm of a triplex. | |
| template<typename IntervalType, typename U> | |
| Triplex< IntervalType > | pow (const Triplex< IntervalType > &a, const U &exp) |
| Exponentiation of a triplex by a scalar. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | pow (const Triplex< IntervalType > &a, const Triplex< IntervalType > &exponent) |
| Exponentiation of a triplex by a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | sinh (const Triplex< IntervalType > &a) |
| Calculate the hyperbolic sine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | cosh (const Triplex< IntervalType > &a) |
| Calculate the hyperbolic cosine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | tanh (const Triplex< IntervalType > &a) |
| Calculate the hyperbolic tangent of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | asinh (const Triplex< IntervalType > &a) |
| Calculate the inverse hyperbolic sine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | acosh (const Triplex< IntervalType > &a) |
| Calculate the inverse hyperbolic cosine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | atanh (const Triplex< IntervalType > &a) |
| Calculate the inverse hyperbolic tangent of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | sin (const Triplex< IntervalType > &a) |
| Calculate the sine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | cos (const Triplex< IntervalType > &a) |
| Calculate the cosine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | tan (const Triplex< IntervalType > &a) |
| Calculate the tangent of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | asin (const Triplex< IntervalType > &a) |
| Calculate the arcsine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | acos (const Triplex< IntervalType > &a) |
| Calculate the arccosine of a triplex. | |
| template<typename IntervalType> | |
| Triplex< IntervalType > | atan (const Triplex< IntervalType > &a) |
| Calculate the arctangent of a triplex. | |
| template<typename T> | |
| Uncertain< T > | operator- (const Uncertain< T > &a) |
| Negation Operation. | |
| template<typename T> | |
| Uncertain< T > | operator+ (const Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Addition Operation. | |
| template<typename T> | |
| Uncertain< T > | operator+ (const Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > | operator+ (double lhs, const Uncertain< T > &rhs) |
| template<typename T> | |
| Uncertain< T > & | operator+= (Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Inplace Addition Operation. | |
| template<typename T> | |
| Uncertain< T > & | operator+= (Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > | operator- (const Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Subtraction Operation. | |
| template<typename T> | |
| Uncertain< T > | operator- (const Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > | operator- (double lhs, const Uncertain< T > &rhs) |
| template<typename T> | |
| Uncertain< T > & | operator-= (Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Inplace Subtraction Operation. | |
| template<typename T> | |
| Uncertain< T > & | operator-= (Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > | operator* (const Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Multiplication Operation. | |
| template<typename T> | |
| Uncertain< T > | operator* (const Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > | operator* (double lhs, const Uncertain< T > &rhs) |
| template<typename T> | |
| Uncertain< T > & | operator*= (Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Inplace Multiplication Operation. | |
| template<typename T> | |
| Uncertain< T > & | operator*= (Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > | operator/ (const Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Division Operation. | |
| template<typename T> | |
| Uncertain< T > | operator/ (double lhs, const Uncertain< T > &rhs) |
| template<typename T> | |
| Uncertain< T > | operator/ (const Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > & | operator/= (Uncertain< T > &lhs, const Uncertain< T > &rhs) |
| Inplace Division Operation. | |
| template<typename T> | |
| Uncertain< T > & | operator/= (Uncertain< T > &lhs, double rhs) |
| template<typename T> | |
| Uncertain< T > | abs (const Uncertain< T > &a) |
| Absolute Value. | |
| template<typename T> | |
| Uncertain< T > | fabs (const Uncertain< T > &a) |
| Absolute Value. | |
| template<typename T> | |
| Uncertain< T > | abs2 (const Uncertain< T > &a) |
| The Square of the Absolute Value. | |
| template<typename T> | |
| Uncertain< T > | ceil (const Uncertain< T > &a) |
| Nearest integer not less than the given value. | |
| template<typename T> | |
| Uncertain< T > | floor (const Uncertain< T > &a) |
| Nearest integer not greater than the given value. | |
| template<typename T> | |
| Uncertain< T > | fmod (const Uncertain< T > &a, const Uncertain< T > &b) |
| Floating point module. | |
| template<typename T> | |
| Uncertain< T > | fmod (const Uncertain< T > &a, double b) |
| template<typename T> | |
| Uncertain< T > | fmod (double a, const Uncertain< T > &b) |
| template<typename T> | |
| Uncertain< T > | copysign (const Uncertain< T > &a, const Uncertain< T > &b) |
| Copy the sign of one value to another. | |
| template<typename T, typename U> | |
| Uncertain< T > | copysign (const Uncertain< T > &a, const U &b) |
| Copy the sign of one value to another. | |
| template<typename T, typename U> | |
| U | copysign (const U &a, const Uncertain< T > &b) |
| Copy the sign of one value to another. | |
| template<typename T> | |
| Uncertain< T > | trunc (const Uncertain< T > &a) |
| Remove the fractional part from a variable. | |
| template<typename T> | |
| Uncertain< T > | round (const Uncertain< T > &a) |
| Round to the nearest integar, away from zero in halfway case. | |
| template<typename T> | |
| const Uncertain< T > & | conj (const Uncertain< T > &a) |
| Complex Conjugate. | |
| template<typename T> | |
| const Uncertain< T > & | real (const Uncertain< T > &a) |
| Get the real part of a value. | |
| template<typename T> | |
| Uncertain< T > | imag (const Uncertain< T > &a) |
| Get the imaginary part of a value. | |
| template<typename T> | |
| Uncertain< T > | erf (const Uncertain< T > &a) |
| Error function. | |
| template<typename T> | |
| Uncertain< T > | erfc (const Uncertain< T > &a) |
| Complementary error function. | |
| template<typename T> | |
| Uncertain< T > | tgamma (const Uncertain< T > &a) |
| Gamma function. | |
| template<typename T> | |
| Uncertain< T > | lgamma (const Uncertain< T > &a) |
| Gamma function Natural Logarithm. | |
| template<typename T, typename U> | |
| Uncertain< T > | pow (const Uncertain< T > &a, const U &exp) |
| Exponentiation of a variable. | |
| template<typename T> | |
| Uncertain< T > | pow (const Uncertain< T > &a, const Uncertain< T > &exp) |
| Exponentiation of a variable by an uncertain variable. | |
| template<typename T> | |
| Uncertain< T > | sqrt (const Uncertain< T > &a) |
| Calculate the square root of an uncertain variable. | |
| template<typename T> | |
| Uncertain< T > | cbrt (const Uncertain< T > &a) |
| Calculate the cube root of an uncertain variable. | |
| template<typename T> | |
| Uncertain< T > | exp (const Uncertain< T > &a) |
| Calculate the Euler's number raised to the power of an uncertain variable. | |
| template<typename T> | |
| Uncertain< T > | exp2 (const Uncertain< T > &a) |
| Calculate 2 raised to the power of an uncertain variable. | |
| template<typename T> | |
| Uncertain< T > | expm1 (const Uncertain< T > &a) |
| Calculate the Euler's number raised to the power of an uncertain variable, then subtract 1. | |
| template<typename T> | |
| Uncertain< T > | log (const Uncertain< T > &a) |
| Calculate the natural logarithm of a variable. | |
| template<typename T> | |
| Uncertain< T > | log10 (const Uncertain< T > &a) |
| Calculate the base 10 logarithm of a variable. | |
| template<typename T> | |
| Uncertain< T > | log2 (const Uncertain< T > &a) |
| Calculate the base 2 logarithm of a variable. | |
| template<typename T> | |
| Uncertain< T > | log1p (const Uncertain< T > &a) |
| Calculate the natural logarithm of one plus a variable. | |
| template<typename T> | |
| Uncertain< T > | hypot (const Uncertain< T > &a, const Uncertain< T > &b) |
| Calculate the square root of the sum of squared arguments. | |
| template<typename T, typename U> | |
| Uncertain< T > | hypot (const Uncertain< T > &a, const U &b) |
| Calculate the square root of the sum of squared arguments. | |
| template<typename T, typename U> | |
| Uncertain< T > | hypot (const U &a, const Uncertain< T > &b) |
| Calculate the square root of the sum of squared arguments. | |
| template<typename T> | |
| Uncertain< T > | sinh (const Uncertain< T > &a) |
| Hyperbolic sine of the variable. | |
| template<typename T> | |
| Uncertain< T > | cosh (const Uncertain< T > &a) |
| Hyperbolic cosine of the variable. | |
| template<typename T> | |
| Uncertain< T > | tanh (const Uncertain< T > &a) |
| Hyperbolic tangent of the variable. | |
| template<typename T> | |
| Uncertain< T > | asinh (const Uncertain< T > &a) |
| Hyperbolic arcsine of the variable. | |
| template<typename T> | |
| Uncertain< T > | acosh (const Uncertain< T > &a) |
| Hyperbolic arccosine of the variable. | |
| template<typename T> | |
| Uncertain< T > | atanh (const Uncertain< T > &a) |
| Hyperbolic arctangent of the variable. | |
| template<typename T> | |
| Uncertain< T > | degrees (const Uncertain< T > &a) |
| Convert from radians to degrees. | |
| template<typename T> | |
| Uncertain< T > | radians (const Uncertain< T > &a) |
| Convert from degrees to radians. | |
| template<typename T> | |
| Uncertain< T > | sin (const Uncertain< T > &a) |
| Sine of the variable. | |
| template<typename T> | |
| Uncertain< T > | cos (const Uncertain< T > &a) |
| Cosine of the variable. | |
| template<typename T> | |
| Uncertain< T > | tan (const Uncertain< T > &a) |
| Tangent of the variable. | |
| template<typename T> | |
| Uncertain< T > | asin (const Uncertain< T > &a) |
| Arcsine of the variable. | |
| template<typename T> | |
| Uncertain< T > | acos (const Uncertain< T > &a) |
| Arccosine of the variable. | |
| template<typename T> | |
| Uncertain< T > | atan (const Uncertain< T > &a) |
| Arctangent of the variable. | |
| template<typename T> | |
| Uncertain< T > | atan2 (const Uncertain< T > &y, const Uncertain< T > &x) |
| Two argument arctangent. | |
| template<typename T, typename U> | |
| Uncertain< T > | atan2 (const Uncertain< T > &y, const U &x) |
| Two argument arctangent. | |
| template<typename T, typename U> | |
| Uncertain< T > | atan2 (const U &y, const Uncertain< T > &x) |
| Two argument arctangent. | |
| template<typename ValueType> | |
| std::ostream & | operator<< (std::ostream &os, const Affine< ValueType > &a) |
| Outputs the range of an affine form to an output stream. | |
| template<typename ValueType> | |
| Affine< ValueType > | operator* (ValueType value, const Affine< ValueType > &a) |
| Multiplies a scalar by an affine form. | |
| template<typename ValueType> | |
| std::ostream & | operator<< (std::ostream &os, const ThresholdedAffine< ValueType > &a) |
| Outputs the range of a ThresholdedAffine to a stream. | |
| template<typename ValueType> | |
| ThresholdedAffine< ValueType > | operator* (ValueType value, const ThresholdedAffine< ValueType > &a) |
| Multiplies a scalar by a ThresholdedAffine. | |
| template<typename T> | |
| ThresholdedAffine< T > | abs (const ThresholdedAffine< T > &a) |
| Absolute value of a ThresholdedAffine. | |
| template<typename T> | |
| ThresholdedAffine< T > | fabs (const ThresholdedAffine< T > &a) |
| Absolute value of a ThresholdedAffine (alias for abs). | |
| template<typename T> | |
| ThresholdedAffine< T > | sqrt (const ThresholdedAffine< T > &a) |
| Square root of a ThresholdedAffine. | |
| template<typename T> | |
| ThresholdedAffine< T > | exp (const ThresholdedAffine< T > &a) |
| Exponential of a ThresholdedAffine. | |
| template<typename T> | |
| ThresholdedAffine< T > | log (const ThresholdedAffine< T > &a) |
| Natural logarithm of a ThresholdedAffine. | |
| template<typename T, typename U> | |
| ThresholdedAffine< T > | pow (const ThresholdedAffine< T > &a, const U &exp) |
| Power of a ThresholdedAffine. | |
| template<typename ValueType> | |
| std::ostream & | operator<< (std::ostream &os, const GeneralInterval< ValueType > &i) |
| Overload stream insertion to print an interval. | |
| template<typename T1, typename T2> | |
| bool | operator== (const GeneralInterval< T1 > &lhs, const GeneralInterval< T2 > &rhs) |
| Compare two intervals for equality. | |
| template<typename T1, typename T2> | |
| bool | operator!= (const GeneralInterval< T1 > &lhs, const GeneralInterval< T2 > &rhs) |
| Compare two intervals for inequality. | |
| template<typename T> | |
| bool | operator< (const GeneralInterval< T > &lhs, const GeneralInterval< T > &rhs) |
| Orders two intervals, primarily by their median. | |
| template<typename T> | |
| bool | operator> (const GeneralInterval< T > &lhs, const GeneralInterval< T > &rhs) |
| Same ordering as operator<, with the operands reversed. | |
| template<typename T> | |
| bool | operator<= (const GeneralInterval< T > &lhs, const GeneralInterval< T > &rhs) |
| Same ordering as operator<, negated. | |
| template<typename T> | |
| bool | operator>= (const GeneralInterval< T > &lhs, const GeneralInterval< T > &rhs) |
| Same ordering as operator<, negated and reversed. | |
| template<typename T> | |
| GeneralInterval< T > | widen (const GeneralInterval< T > &a, typename GeneralInterval< T >::value_t point) |
| Widens an interval just enough to contain a point. | |
| template<typename ValueType> | |
| std::ostream & | operator<< (std::ostream &os, const Interval< ValueType > &i) |
| Overload stream insertion to print an interval. | |
| template<typename T1, typename T2> | |
| bool | operator== (const Interval< T1 > &lhs, const Interval< T2 > &rhs) |
| Compare two intervals for equality. | |
| template<typename T1, typename T2> | |
| bool | operator!= (const Interval< T1 > &lhs, const Interval< T2 > &rhs) |
| Compare two intervals for inequality. | |
| template<typename T> | |
| bool | operator< (const Interval< T > &lhs, const Interval< T > &rhs) |
| Orders two intervals, primarily by their median. | |
| template<typename T> | |
| bool | operator> (const Interval< T > &lhs, const Interval< T > &rhs) |
| Same ordering as operator<, with the operands reversed. | |
| template<typename T> | |
| bool | operator<= (const Interval< T > &lhs, const Interval< T > &rhs) |
| Same ordering as operator<, negated. | |
| template<typename T> | |
| bool | operator>= (const Interval< T > &lhs, const Interval< T > &rhs) |
| Same ordering as operator<, negated and reversed. | |
| template<typename T> | |
| Interval< T > | widen (const Interval< T > &a, typename Interval< T >::value_t point) |
| Widens an interval just enough to contain a point. | |
| template<typename T> | |
| Interval< T > | operator+ (Interval< T > lhs, const Interval< T > &rhs) |
| Addition of two intervals. | |
| template<typename T> | |
| Interval< T > | operator- (Interval< T > lhs, const Interval< T > &rhs) |
| Subtraction of two intervals. | |
| template<typename T> | |
| Interval< T > | operator* (Interval< T > lhs, const Interval< T > &rhs) |
| Multiplication of two intervals. | |
| template<typename T> | |
| Interval< T > | operator/ (Interval< T > lhs, const Interval< T > &rhs) |
| Division of two intervals. | |
| std::ostream & | operator<< (std::ostream &os, const Monomial &m) |
| Outputs a monomial to an output stream. | |
| template<typename ValueType> | |
| std::ostream & | operator<< (std::ostream &os, const Taylor< ValueType > &t) |
| Outputs the range of a Taylor polynomial to an output stream. | |
| template<typename ValueType> | |
| Taylor< ValueType > | operator* (ValueType value, const Taylor< ValueType > &t) |
| Multiplies a scalar by a Taylor polynomial. | |
| template<typename ValueType> | |
| std::ostream & | operator<< (std::ostream &os, const TaylorModel< ValueType > &t) |
| Outputs the range of a TaylorModel to an output stream. | |
| template<typename ValueType> | |
| TaylorModel< ValueType > | operator* (ValueType value, const TaylorModel< ValueType > &t) |
| Multiplies a scalar by a TaylorModel. | |
| template<typename T> | |
| TaylorModel< T > | abs (const TaylorModel< T > &a) |
| Absolute value of a TaylorModel. | |
| template<typename T> | |
| TaylorModel< T > | fabs (const TaylorModel< T > &a) |
| Absolute value of a TaylorModel. | |
| template<typename T> | |
| TaylorModel< T > | sqrt (const TaylorModel< T > &a) |
| Square root of a TaylorModel. | |
| template<typename T> | |
| TaylorModel< T > | exp (const TaylorModel< T > &a) |
| Exponential of a TaylorModel. | |
| template<typename T> | |
| TaylorModel< T > | log (const TaylorModel< T > &a) |
| Natural logarithm of a TaylorModel. | |
| template<typename T, typename U> | |
| TaylorModel< T > | pow (const TaylorModel< T > &a, const U &exp) |
| Power of a TaylorModel. | |
| template<typename IntervalType> | |
| std::ostream & | operator<< (std::ostream &os, const Triplex< IntervalType > &t) |
| Overload stream insertion to print a triplex. | |
| template<typename I1, typename I2> | |
| bool | operator== (const Triplex< I1 > &lhs, const Triplex< I2 > &rhs) |
| Compare two triplex numbers for equality. | |
| template<typename I1, typename I2> | |
| bool | operator!= (const Triplex< I1 > &lhs, const Triplex< I2 > &rhs) |
| Compare two triplex numbers for inequality. | |
| template<typename IntervalType> | |
| bool | operator< (const Triplex< IntervalType > &lhs, const Triplex< IntervalType > &rhs) |
| Orders two triplex numbers, primarily by their nominal values. | |
| template<typename IntervalType> | |
| bool | operator> (const Triplex< IntervalType > &lhs, const Triplex< IntervalType > &rhs) |
| Same ordering as operator<, with the operands reversed. | |
| template<typename IntervalType> | |
| bool | operator<= (const Triplex< IntervalType > &lhs, const Triplex< IntervalType > &rhs) |
| Same ordering as operator<, negated. | |
| template<typename IntervalType> | |
| bool | operator>= (const Triplex< IntervalType > &lhs, const Triplex< IntervalType > &rhs) |
| Same ordering as operator<, negated and reversed. | |
| template<typename ValueType> | |
| std::ostream & | operator<< (std::ostream &os, const Uncertain< ValueType > &u) |
| Overload stream insertion to print uncertain variable. | |
| template<typename ValueType1, typename ValueType2> | |
| bool | operator== (const Uncertain< ValueType1 > &lhs, const Uncertain< ValueType2 > &rhs) |
| Compare two uncertain variables for equality. | |
| template<typename ValueType1, typename ValueType2> | |
| bool | operator!= (const Uncertain< ValueType1 > &lhs, const Uncertain< ValueType2 > &rhs) |
| Compare two uncertain variables for inequality. | |
| template<typename ValueType1, typename ValueType2> | |
| bool | operator< (const Uncertain< ValueType1 > &lhs, const Uncertain< ValueType2 > &rhs) |
| Whether one uncertain variable is less than another. | |
| template<typename ValueType1, typename ValueType2> | |
| bool | operator> (const Uncertain< ValueType1 > &lhs, const Uncertain< ValueType2 > &rhs) |
| Whether one uncertain variable is greater than another. | |
| template<typename ValueType1, typename ValueType2> | |
| bool | operator<= (const Uncertain< ValueType1 > &lhs, const Uncertain< ValueType2 > &rhs) |
| Whether one uncertain variable is less than or equal to another. | |
| template<typename ValueType1, typename ValueType2> | |
| bool | operator>= (const Uncertain< ValueType1 > &lhs, const Uncertain< ValueType2 > &rhs) |
| Whether one uncertain variable is greater than or equal to another. | |
Variables | |
| template<typename T> | |
| constexpr bool | is_general_interval_v = is_general_interval<T>::value |
| Convenience variable for the value of is_general_interval. | |
The primary namespace for the sigma library.
This is the primary namespace that contains the class used to represent uncertain variables and the functions that act on them.
Absolute Value of an affine form.
| T | The value type of the interval |
Let \(\hat{x}\) be an affine form with range \([\mathrm{lo}, \mathrm{hi}]\). The absolute value of the affine form is defined as:
\[ |\hat{x}| = \begin{cases} \hat{x} & \text{if } \mathrm{lo} \geq 0 \\ -\hat{x}& \text{if } \mathrm{hi} \leq 0 \\ [0,\, \max(|\mathrm{lo}|, \mathrm{hi})] & \text{otherwise} \end{cases} \]
The first two cases are exact, since \(|\cdot|\) is linear (the identity or its negation) once its sign is fixed. The third case is not built from an affine transformation of \(\hat{x}\) at all: \(|\cdot|\) is not differentiable at 0, so no such transformation both agrees with it locally and stays a valid enclosure, and picking one anyway (e.g. naively halving the center and every error term) produces a result that does not actually contain every value \(|\hat{x}|\) can take. \([0, \max(|\mathrm{lo}|, \mathrm{hi})]\) is instead the exact range of \(|\cdot|\) over \([\mathrm{lo}, \mathrm{hi}]\), returned as a fresh single-error-term affine form via the interval constructor.
| [in] | a | The interval |
a | std::bad_alloc | If memory allocation for the new affine form fails. Strong throw guarantee. |
| GeneralInterval< T > sigma::abs | ( | const GeneralInterval< T > & | a | ) |
Absolute Value of a general interval.
As for abs(const Interval<T>&). When a straddles zero the lower bound of the result is the attained zero, and so is closed.
| T | The value type of the interval |
| a | The interval |
a | none | No throw guarantee |
Absolute Value of an interval.
Returns the interval {|x| : x ∈ a}, i.e.:
| T | The value type of the interval |
| a | The interval |
a | none | No throw guarantee |
Absolute value of a Taylor polynomial.
| T | The value type of the polynomial |
Let \(P\) be a Taylor polynomial with bound (see Taylor::bound()) \([\mathrm{lo}, \mathrm{hi}]\). Mirroring Affine::abs, the absolute value is defined as:
\[ |P| = \begin{cases} P & \text{if } \mathrm{lo} \geq 0 \\ -P & \text{if } \mathrm{hi} \leq 0 \\ [0,\, \max(|\mathrm{lo}|, \mathrm{hi})] & \text{otherwise} \end{cases} \]
As with Affine::abs, the third case is not a polynomial approximation of \(|\cdot|\) – \(|\cdot|\) is not differentiable at 0, so it has no Taylor series to compose_() with there – but the exact range of \(|\cdot|\) over \([\mathrm{lo}, \mathrm{hi}]\), returned via the interval constructor (Taylor(const interval_t&, Order)).
| [in] | a | The Taylor polynomial |
a | std::domain_error | If a is empty. Strong throw guarantee. |
| std::bad_alloc | If memory allocation for the new polynomial fails. Strong throw guarantee. |
| Triplex< IntervalType > sigma::abs | ( | const Triplex< IntervalType > & | a | ) |
Absolute value of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | none | No throw guarantee |
Absolute Value.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
The Square of the Absolute Value.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::acos | ( | const GeneralInterval< T > & | a | ) |
Calculate the arccosine of a general interval.
Arccosine is decreasing, so the openness of the bounds exchanges places.
| T | The value type of the interval |
| a | The interval whose arccosine is computed |
a | std::domain_error | if a contains a value outside \( [-1, 1] \). Strong throw guarantee. |
Calculate the arccosine of an interval.
Arccosine is only defined on \( [-1, 1] \), so a must not contain a value outside it. Arccosine is decreasing, so the bounds of a exchange places. The empty interval contains nothing and is returned unchanged.
| T | The value type of the interval |
| a | The interval whose arccosine is computed |
a | std::domain_error | if a contains a value outside \( [-1, 1] \). Strong throw guarantee. |
| Triplex< IntervalType > sigma::acos | ( | const Triplex< IntervalType > & | a | ) |
Calculate the arccosine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a, in radians| std::domain_error | if a contains a value outside \( [-1, 1] \). Strong throw guarantee. |
Arccosine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::acosh | ( | const GeneralInterval< T > & | a | ) |
Calculate the inverse hyperbolic cosine of a general interval.
| T | The value type of the interval |
| a | The interval whose inverse hyperbolic cosine is computed |
a | std::domain_error | if a contains a value below one. Strong throw guarantee. |
Calculate the inverse hyperbolic cosine of an interval.
Inverse hyperbolic cosine is only defined for values of at least one, so a must not contain a value below one. The empty interval contains nothing and is returned unchanged.
| T | The value type of the interval |
| a | The interval whose inverse hyperbolic cosine is computed |
a | std::domain_error | if a contains a value below one. Strong throw guarantee. |
| Triplex< IntervalType > sigma::acosh | ( | const Triplex< IntervalType > & | a | ) |
Calculate the inverse hyperbolic cosine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | std::domain_error | if a contains a value below one. Strong throw guarantee. |
Hyperbolic arccosine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::asin | ( | const GeneralInterval< T > & | a | ) |
Calculate the arcsine of a general interval.
| T | The value type of the interval |
| a | The interval whose arcsine is computed |
a | std::domain_error | if a contains a value outside \( [-1, 1] \). Strong throw guarantee. |
Calculate the arcsine of an interval.
Arcsine is only defined on \( [-1, 1] \), so a must not contain a value outside it. The empty interval contains nothing and is returned unchanged.
| T | The value type of the interval |
| a | The interval whose arcsine is computed |
a | std::domain_error | if a contains a value outside \( [-1, 1] \). Strong throw guarantee. |
| Triplex< IntervalType > sigma::asin | ( | const Triplex< IntervalType > & | a | ) |
Calculate the arcsine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a, in radians| std::domain_error | if a contains a value outside \( [-1, 1] \). Strong throw guarantee. |
Arcsine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::asinh | ( | const GeneralInterval< T > & | a | ) |
Calculate the inverse hyperbolic sine of a general interval.
| T | The value type of the interval |
| a | The interval whose inverse hyperbolic sine is computed |
a | none | No throw guarantee |
Calculate the inverse hyperbolic sine of an interval.
| T | The value type of the interval |
| a | The interval whose inverse hyperbolic sine is computed |
a | none | No throw guarantee |
| Triplex< IntervalType > sigma::asinh | ( | const Triplex< IntervalType > & | a | ) |
Calculate the inverse hyperbolic sine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | none | No throw guarantee |
Hyperbolic arcsine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::atan | ( | const GeneralInterval< T > & | a | ) |
Calculate the arctangent of a general interval.
| T | The value type of the interval |
| a | The interval whose arctangent is computed |
a | none | No throw guarantee |
Calculate the arctangent of an interval.
| T | The value type of the interval |
| a | The interval whose arctangent is computed |
a | none | No throw guarantee |
| Triplex< IntervalType > sigma::atan | ( | const Triplex< IntervalType > & | a | ) |
Calculate the arctangent of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a, in radians| none | No throw guarantee |
Arctangent of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| Uncertain< T > sigma::atan2 | ( | const U & | y, |
| const Uncertain< T > & | x ) |
Two argument arctangent.
| T | The value type of the variable |
| U | The numeric type of y |
| y | The first variable |
| x | The first variable |
y and x | none | No throw guarantee |
| Uncertain< T > sigma::atan2 | ( | const Uncertain< T > & | y, |
| const U & | x ) |
Two argument arctangent.
| T | The value type of the variable |
| U | The numeric type of x |
| y | The first variable |
| x | The first variable |
y and x | none | No throw guarantee |
| Uncertain< T > sigma::atan2 | ( | const Uncertain< T > & | y, |
| const Uncertain< T > & | x ) |
Two argument arctangent.
| T | The value type of the variable |
| y | The first variable |
| x | The first variable |
y and x | none | No throw guarantee |
| GeneralInterval< T > sigma::atanh | ( | const GeneralInterval< T > & | a | ) |
Calculate the inverse hyperbolic tangent of a general interval.
The domain is the open \( (-1, 1) \), so a bound at plus or minus one is only out of domain if it is closed, and an open bound there leaves the result unbounded on that side.
| T | The value type of the interval |
| a | The interval whose inverse hyperbolic tangent is computed |
a | std::domain_error | if a contains a value outside \( (-1, 1) \). Strong throw guarantee. |
Calculate the inverse hyperbolic tangent of an interval.
Inverse hyperbolic tangent is only defined on the OPEN interval \( (-1, 1) \), so a must not contain a value outside it – plus and minus one included. A bound is a member of the interval, so a bound at either of those is out of domain; an argument that only approaches them needs a GeneralInterval. The empty interval contains nothing and is returned unchanged.
| T | The value type of the interval |
| a | The interval whose inverse hyperbolic tangent is computed |
a | std::domain_error | if a contains a value outside \( (-1, 1) \). Strong throw guarantee. |
| Triplex< IntervalType > sigma::atanh | ( | const Triplex< IntervalType > & | a | ) |
Calculate the inverse hyperbolic tangent of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | std::domain_error | if a contains a value outside \( (-1, 1) \). Strong throw guarantee. |
Hyperbolic arctangent of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Calculate the cube root of an uncertain variable.
| T | The value type of the variable |
| a | The variable whose root is computed |
a | none | No throw guarantee |
Nearest integer not less than the given value.
Note that this returns an Uncertain<T> value with no dependencies
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Complex Conjugate.
This is a stub to satisfy Eigen
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| U sigma::copysign | ( | const U & | a, |
| const Uncertain< T > & | b ) |
Copy the sign of one value to another.
| T | The value type of b |
| U | The numeric type of a |
| a | The variable whose magnitude is copied |
| b | The variable whose sign is copied |
a with the sign of b | none | No throw guarantee |
| Uncertain< T > sigma::copysign | ( | const Uncertain< T > & | a, |
| const U & | b ) |
Copy the sign of one value to another.
| T | The value type of a |
| U | The numeric type of b |
| a | The variable whose magnitude is copied |
| b | The variable whose sign is copied |
a with the sign of b | none | No throw guarantee |
| Uncertain< T > sigma::copysign | ( | const Uncertain< T > & | a, |
| const Uncertain< T > & | b ) |
Copy the sign of one value to another.
| T | The value type of the variable |
| a | The variable whose magnitude is copied |
| b | The variable whose sign is copied |
a with the sign of b | none | No throw guarantee |
| GeneralInterval< T > sigma::cos | ( | const GeneralInterval< T > & | a | ) |
Calculate the cosine of a general interval.
The bounds of the result are always closed, since either may come from a peak interior to a.
| T | The value type of the interval |
| a | The interval whose cosine is computed |
a | none | No throw guarantee |
Calculate the cosine of an interval.
Cosine is not monotonic, so the result is not in general the cosine of the bounds: an interval spanning a peak encloses the peak.
| T | The value type of the interval |
| a | The interval whose cosine is computed |
a | none | No throw guarantee |
| Triplex< IntervalType > sigma::cos | ( | const Triplex< IntervalType > & | a | ) |
Calculate the cosine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex, in radians |
a | none | No throw guarantee |
Cosine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::cosh | ( | const GeneralInterval< T > & | a | ) |
Calculate the hyperbolic cosine of a general interval.
An argument spanning zero has a result whose lower bound is the attained minimum, one, which is closed.
| T | The value type of the interval |
| a | The interval whose hyperbolic cosine is computed |
a | none | No throw guarantee |
Calculate the hyperbolic cosine of an interval.
Hyperbolic cosine has a minimum of one at the origin, so an interval spanning zero has a result whose lower bound is one rather than the hyperbolic cosine of either bound.
| T | The value type of the interval |
| a | The interval whose hyperbolic cosine is computed |
a | none | No throw guarantee |
| Triplex< IntervalType > sigma::cosh | ( | const Triplex< IntervalType > & | a | ) |
Calculate the hyperbolic cosine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | none | No throw guarantee |
Hyperbolic cosine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Convert from radians to degrees.
| T | The value type of the variable |
| a | The variable |
a in degrees| none | No throw guarantee |
Error function.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Complementary error function.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Calculate the exponential of an affine form.
| T | The value type of the affine form |
The exponential of an affine form is obtained by applying an affine transformation. We use the following affine transformation:
\[\begin{align} \alpha &= \frac{e^b - e^a}{b - a} \\ \zeta &= \frac{e^a - \alpha*a + \alpha*(1-\log(\alpha))}{2} \\ \delta &= \frac{e^a - \alpha*a - \alpha*(1-\log(\alpha))}{2} \end{align} \]
where \(a\) and \(b\) are the lower and upper bounds of the range of the affine form, respectively. N.b. the affapy formula is wrong.
| [in] | a | The affine form whose exponential is computed |
a | std::bad_alloc | if memory allocation fails |
| GeneralInterval< T > sigma::exp | ( | const GeneralInterval< T > & | a | ) |
Calculate Euler's number raised to the power of a general interval.
| T | The value type of the interval |
| a | The interval that is the exponent |
a | none | No throw guarantee |
Calculate Euler's number raised to the power of an interval.
| T | The value type of the interval |
| a | The interval that is the exponent |
a | none | No throw guarantee |
Calculate the exponential of a Taylor polynomial.
| T | The value type of the polynomial |
Composes the Taylor series of exp about a.constant() with a.
| [in] | a | The Taylor polynomial whose exponential is computed |
a | std::domain_error | If a is empty. Strong throw guarantee. |
| std::bad_alloc | If memory allocation fails. Strong throw guarantee. |
| Triplex< IntervalType > sigma::exp | ( | const Triplex< IntervalType > & | a | ) |
Calculate Euler's number raised to the power of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex that is the exponent |
a | none | No throw guarantee |
Calculate the Euler's number raised to the power of an uncertain variable.
| T | The value type of the variable |
| a | The variable that is the exponent |
a | none | No throw guarantee |
Calculate 2 raised to the power of an uncertain variable.
| T | The value type of the variable |
| a | The variable that is the exponent |
a | none | No throw guarantee |
Calculate the Euler's number raised to the power of an uncertain variable, then subtract 1.
| T | The value type of the variable |
| a | The variable that is the exponent |
a, then subtract 1.| none | No throw guarantee |
Absolute Value of an affine form.
| T | The value type of the interval |
This function is an alias for abs(const Affine<T>&). See the documentation for abs(const Affine<T>&) for details on how the absolute value of an affine form is defined and computed.
| [in] | a | The interval |
a | std::bad_alloc | If memory allocation for the new affine form fails. Strong throw guarantee. |
| GeneralInterval< T > sigma::fabs | ( | const GeneralInterval< T > & | a | ) |
Absolute Value of a general interval.
| T | The value type of the interval |
| a | The interval |
a | none | No throw guarantee |
Absolute Value of an interval.
| T | The value type of the interval |
| a | The interval |
a | none | No throw guarantee |
Absolute value of a Taylor polynomial.
| T | The value type of the polynomial |
This function is an alias for abs(const Taylor<T>&). See the documentation for abs(const Taylor<T>&) for details.
| [in] | a | The Taylor polynomial |
a | std::domain_error | If a is empty. Strong throw guarantee. |
| std::bad_alloc | If memory allocation for the new polynomial fails. Strong throw guarantee. |
| Triplex< IntervalType > sigma::fabs | ( | const Triplex< IntervalType > & | a | ) |
Absolute value of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | none | No throw guarantee |
Absolute Value.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Nearest integer not greater than the given value.
Note that this returns an Uncertain<T> value with no dependencies
| T | The value type of the variable |
| a | The variable |
u | none | No throw guarantee |
| Uncertain< T > sigma::fmod | ( | const Uncertain< T > & | a, |
| const Uncertain< T > & | b ) |
Floating point module.
| T | The value type of the variable |
| a | The first variable |
| b | The first variable |
a / b | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Uncertain< T > sigma::hypot | ( | const U & | a, |
| const Uncertain< T > & | b ) |
Calculate the square root of the sum of squared arguments.
| T | The value type of the variable |
| U | The numeric type of a |
| a | The first variable |
| b | The second variable |
a | none | No throw guarantee |
| Uncertain< T > sigma::hypot | ( | const Uncertain< T > & | a, |
| const U & | b ) |
Calculate the square root of the sum of squared arguments.
| T | The value type of the variable |
| U | The numeric type of b |
| a | The first variable |
| b | The second variable |
a | none | No throw guarantee |
| Uncertain< T > sigma::hypot | ( | const Uncertain< T > & | a, |
| const Uncertain< T > & | b ) |
Calculate the square root of the sum of squared arguments.
| T | The value type of the variable |
| a | The first variable |
| b | The second variable |
a | none | No throw guarantee |
Get the imaginary part of a value.
This is a stub to satisfy Eigen
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Gamma function Natural Logarithm.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Calculate the natural logarithm of an affine form.
| T | The value type of the affine form |
The natural logarithm of an affine form is obtained by applying an affine transformation. We use the following affine transformation:
\[\begin{align} \alpha &= \frac{\log(b) - \log(a)}{b - a} \\ \zeta &= \frac{\log(x_s) + y_s}{2} - \alpha * x_s \\ \delta &= \frac{\log(x_s) - y_s}{2} \end{align} \]
where \(a\) and \(b\) are the lower and upper bounds of the range of the affine form, respectively, and:
\[\begin{align} x_s &= \frac{1}{\alpha} \\ y_s &= \alpha * (x_s - a) + \log(a) \end{align} \]
Note that the affapy formula for zeta is rendered wrong.
| [in] | a | The affine form whose natural logarithm is computed |
a | std::domain_error | if the range of a contains non-positive values |
| GeneralInterval< T > sigma::log | ( | const GeneralInterval< T > & | a | ) |
Calculate the natural logarithm of a general interval.
A bound at zero is only out of domain if it is closed: \( (0, 1\rbrack \) contains no non-positive value, and its logarithm is unbounded below.
| T | The value type of the interval |
| a | The interval whose logarithm is determined |
a | std::domain_error | if a contains a non-positive value, i.e., if its lower bound is negative, or is a closed zero. Strong throw guarantee. |
Calculate the natural logarithm of an interval.
The logarithm is only defined for positive values, so a must not contain zero or any negative value. A bound is a member of the interval, so a lower bound at zero is out of domain; an argument that only approaches zero needs a GeneralInterval. The empty interval contains nothing and is returned unchanged.
| T | The value type of the interval |
| a | The interval whose logarithm is determined |
a | std::domain_error | if a contains a non-positive value, i.e., if its lower bound is not positive. Strong throw guarantee. |
Calculate the natural logarithm of a Taylor polynomial.
| T | The value type of the polynomial |
Composes the Taylor series of log about a.constant() with a.
| [in] | a | The Taylor polynomial whose natural logarithm is computed |
a | std::domain_error | If a is empty or bound(a) contains non-positive values. Strong throw guarantee. |
| std::bad_alloc | If memory allocation fails. Strong throw guarantee. |
| Triplex< IntervalType > sigma::log | ( | const Triplex< IntervalType > & | a | ) |
Calculate the natural logarithm of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex whose logarithm is determined |
a | std::domain_error | if a contains a non-positive value. Strong throw guarantee. |
Calculate the natural logarithm of a variable.
| T | The value type of the variable |
| a | The variable whose logarithm is determined |
a | none | No throw guarantee |
Calculate the base 10 logarithm of a variable.
| T | The value type of the variable |
| a | The variable whose logarithm is determined |
a | none | No throw guarantee |
Calculate the natural logarithm of one plus a variable.
| T | The value type of the variable |
| a | The variable whose logarithm is determined |
a + 1| none | No throw guarantee |
Calculate the base 2 logarithm of a variable.
| T | The value type of the variable |
| a | The variable whose logarithm is determined |
a | none | No throw guarantee |
| Uncertain< T > sigma::operator* | ( | const Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Multiplication Operation.
| T | The value type of the variables |
| lhs | The left-hand variable |
| rhs | The right-hand variable |
lhs and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Uncertain< T > & sigma::operator*= | ( | Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Inplace Multiplication Operation.
| T | The value type of the variables |
| lhs | The left-hand variable being modified |
| rhs | The right-hand variable |
lhs as the product of itself and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Uncertain< T > sigma::operator+ | ( | const Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Addition Operation.
| T | The value type of the variables |
| lhs | The left-hand variable |
| rhs | The right-hand variable |
lhs and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Uncertain< T > & sigma::operator+= | ( | Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Inplace Addition Operation.
| T | The value type of the variables |
| lhs | The left-hand variable being modified |
| rhs | The right-hand variable |
lhs as the sum of itself and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Negation Operation.
| T | The value type of the variable |
| a | The variable being negated |
a, but with the sign of the mean reversed| none | No throw guarantee |
| Uncertain< T > sigma::operator- | ( | const Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Subtraction Operation.
| T | The value type of the variables |
| lhs | The left-hand variable |
| rhs | The right-hand variable |
lhs and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Uncertain< T > & sigma::operator-= | ( | Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Inplace Subtraction Operation.
| T | The value type of the variables |
| lhs | The left-hand variable being modified |
| rhs | The right-hand variable |
lhs as the difference of itself and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Uncertain< T > sigma::operator/ | ( | const Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Division Operation.
| T | The value type of the variables |
| lhs | The left-hand variable |
| rhs | The right-hand variable |
lhs and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
| Uncertain< T > & sigma::operator/= | ( | Uncertain< T > & | lhs, |
| const Uncertain< T > & | rhs ) |
Inplace Division Operation.
| T | The value type of the variables |
| lhs | The left-hand variable being modified |
| rhs | The right-hand variable |
lhs as the quotient of itself and rhs | none | No throw guarantee |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
Calculate the power of an affine form.
| T | The value type of the affine form |
| U | The type of the exponent |
For a strictly one-signed range this method takes advantage of the fact that:
\[x^y = e^{y \log(x)} \]
If the range of a straddles or touches 0 (and is not exactly the point 0, where \(0^y = 0\) for any \(y > 0\)), neither \(\log(x)\) nor \(\log(-x)\) is valid, so exp must be a positive integer – a negative base raised to a fractional power is not a real number – and the result is computed by repeated multiplication instead.
| [in] | a | The affine form whose power is computed |
| [in] | exp | The exponent |
a | std::domain_error | if the range of a contains non-positive values (and is not exactly the point 0) and the exponent is not an integer. Strong throw guarantee. |
| std::domain_error | if the range of a contains 0 and the exponent is negative. Strong throw guarantee. |
| std::bad_alloc | if memory allocation fails. Strong throw guarantee. |
| GeneralInterval< T > sigma::pow | ( | const GeneralInterval< T > & | a, |
| const GeneralInterval< T > & | exponent ) |
Exponentiation of a general interval by an interval exponent.
As for pow(const Interval<T>&, const Interval<T>&): a point exponent is forwarded to the scalar overload, and any other exponent is evaluated as \( e^{y \ln x} \), which restricts the base to positive values.
| T | The value type of the base and exponent |
| a | The interval base |
| exponent | The interval exponent to raise the base by |
a raised to every power in exponent | std::domain_error | if exponent has width and a contains a non-positive value. If exponent is a point, throws under the same conditions as the scalar overload instead. Strong throw guarantee. |
| GeneralInterval< T > sigma::pow | ( | const GeneralInterval< T > & | a, |
| const U & | exp ) |
Exponentiation of a general interval.
A negative base has no real fractional power, and a zero base has no negative power. An open bound is not a value the interval contains, so \( (0, 1\rbrack \) may be raised to a negative power even though \( [0, 1] \) may not.
| T | The value type of the variable |
| U | The numeric type of the exponent |
| a | The interval base |
| exp | The exponent to raise the base by |
a raised to the power exp | std::domain_error | if exp is negative and a contains zero, or if exp is not an integer and a contains a negative value. Strong throw guarantee. |
| Interval< T > sigma::pow | ( | const Interval< T > & | a, |
| const Interval< T > & | exponent ) |
Exponentiation of an interval by an interval-valued exponent.
Overload of pow(const Interval<T>&, const U&) for the case where the exponent is itself an Interval<T> rather than a plain scalar – as happens, for example, when a caller's exponent is a tuning parameter stored as the same type T as the base rather than as a raw scalar (a common pattern for values that don't need their own uncertainty tracking but end up typed T anyway for API convenience). A general real power with a real exponent is computed as \( x^y = e^{y \ln x} \), which only needs exp/log/multiplication – all already sound enclosures – so this holds for any exponent range, not just the integer/scalar cases the other overload special-cases; the tradeoff is that it's looser than the scalar overload's tighter, case-analyzed bounds, and it inherits log's domain restriction to strictly positive bases (a negative or zero base has no general real power).
A point exponent (exponent has zero width) is expected to be the common case – a caller passing a genuinely uncertain exponent is the exception – so it is forwarded to the scalar overload instead of going through log/exp, both for tighter bounds and to avoid needlessly rejecting a negative base raised to, e.g., an integer point exponent. The strictly-positive-base restriction below therefore only kicks in once exponent actually has width; a point exponent instead follows the scalar overload's domain restrictions.
| T | The value type of the base and exponent |
| a | The interval base |
| exponent | The interval exponent to raise the base by |
a raised to every power in exponent | std::domain_error | if exponent has width and a contains a non-positive value, i.e., if its lower bound is not positive. If exponent is a point, throws under the same conditions as the scalar overload instead. Strong throw guarantee. |
| Interval< T > sigma::pow | ( | const Interval< T > & | a, |
| const U & | exp ) |
Exponentiation of a variable.
Two combinations of base and exponent have no real value, and a must not contain a value in either. A negative base has no real fractional power, and a zero base has no negative power, so \( [0, 1] \) may not be raised to a negative power. The empty interval contains nothing and is returned unchanged.
| T | The value type of the variable |
| U | The numeric type of the exponent |
| a | The interval base |
| exp | The exponent to raise the base by |
a raised to the power exp | std::domain_error | if exp is negative and a contains zero, or if exp is not an integer and a contains a negative value. Strong throw guarantee. |
Calculate the power of a Taylor polynomial.
| T | The value type of the polynomial |
| U | The type of the exponent |
For a strictly one-signed bound this method takes advantage of the fact that:
\[x^y = e^{y \log(x)} \]
mirroring Affine::pow. If bound(a) straddles or touches 0 (and is not exactly the point 0, where \(0^y = 0\) for any \(y > 0\)), neither \(\log\) branch is valid, so exp must be a positive integer, and the result is computed by repeated multiplication instead.
a raised to exp | std::domain_error | If bound(a) contains 0 and exp is negative, or if bound(a) contains non-positive values (and is not exactly the point 0) and exp is not an integer. Strong throw guarantee. |
| std::bad_alloc | If memory allocation fails. Strong throw guarantee. |
| Triplex< IntervalType > sigma::pow | ( | const Triplex< IntervalType > & | a, |
| const Triplex< IntervalType > & | exponent ) |
Exponentiation of a triplex by a triplex.
The bounds are those of the interval overload of pow, which forwards a point exponent to the scalar overload and otherwise requires a positive base. The nominal value is std::pow applied to the two nominal values.
| IntervalType | The interval type of the triplex numbers |
| a | The triplex base |
| exponent | The triplex exponent to raise the base by |
a raised to the power exponent. Empty if either argument is.| std::domain_error | if exponent has width and a contains a non-positive value. If exponent is a point, throws under the same conditions as the scalar overload instead. Strong throw guarantee. |
| Triplex< IntervalType > sigma::pow | ( | const Triplex< IntervalType > & | a, |
| const U & | exp ) |
Exponentiation of a triplex by a scalar.
The nominal value is std::pow applied to the nominal value of a and to exp.
| IntervalType | The interval type of the triplex |
| U | The numeric type of the exponent |
| a | The triplex base |
| exp | The exponent to raise the base by |
a raised to the power exp | std::domain_error | if exp is negative and a contains zero, or if exp is not an integer and a contains a negative value. Strong throw guarantee. |
| Uncertain< T > sigma::pow | ( | const Uncertain< T > & | a, |
| const U & | exp ) |
Exponentiation of a variable.
| T | The value type of the variable |
| U | The numeric type of the exponent |
| a | The base variable |
| exp | The exponent to raise the base by |
a raise to the power exp | none | No throw guarantee |
| Uncertain< T > sigma::pow | ( | const Uncertain< T > & | a, |
| const Uncertain< T > & | exp ) |
Exponentiation of a variable by an uncertain variable.
| T | The value type of the variables |
| a | The base variable |
| exp | The uncertain exponent to raise the base by |
a raise to the power exp | none | No throw guarantee |
Convert from degrees to radians.
| T | The value type of the variable |
| a | The variable |
a in radians| none | No throw guarantee |
Get the real part of a value.
This is a stub to satisfy Eigen
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Round to the nearest integar, away from zero in halfway case.
| T | The value type of the variable |
| a | The variable whose value is truncated |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::sin | ( | const GeneralInterval< T > & | a | ) |
Calculate the sine of a general interval.
The bounds of the result are always closed, since either may come from a peak interior to a.
| T | The value type of the interval |
| a | The interval whose sine is computed |
a | none | No throw guarantee |
Calculate the sine of an interval.
Sine is not monotonic, so the result is not in general the sine of the bounds: an interval spanning a peak encloses the peak.
| T | The value type of the interval |
| a | The interval whose sine is computed |
a | none | No throw guarantee |
| Triplex< IntervalType > sigma::sin | ( | const Triplex< IntervalType > & | a | ) |
Calculate the sine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex, in radians |
a | none | No throw guarantee |
Sine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::sinh | ( | const GeneralInterval< T > & | a | ) |
Calculate the hyperbolic sine of a general interval.
| T | The value type of the interval |
| a | The interval whose hyperbolic sine is computed |
a | none | No throw guarantee |
Calculate the hyperbolic sine of an interval.
| T | The value type of the interval |
| a | The interval whose hyperbolic sine is computed |
a | none | No throw guarantee |
| Triplex< IntervalType > sigma::sinh | ( | const Triplex< IntervalType > & | a | ) |
Calculate the hyperbolic sine of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | none | No throw guarantee |
Hyperbolic sine of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Calculate the square root of an affine form.
| T | The value type of the affine form |
The square root of an affine form is obtained by applying an affine transformation. We use the following affine transformation:
\[\begin{align} \alpha &= \frac{1}{\sqrt{a} + \sqrt{b}}\\ \zeta &= \frac{\sqrt{a} + \sqrt{b}}{8} + \frac{\sqrt{ab}}{2(\sqrt{a} + \sqrt{b})}\\ \delta &= \frac{(\sqrt{b} - \sqrt{a})^2}{8(\sqrt{a} + \sqrt{b})} \end{align} \]
where \(a\) and \(b\) are the lower and upper bounds of the range of the affine form, respectively.
| [in] | a | The affine form whose square root is computed |
a | std::bad_alloc | if |
| GeneralInterval< T > sigma::sqrt | ( | const GeneralInterval< T > & | a | ) |
Calculate the square root of a general interval.
| T | The value type of the interval |
| a | The interval whose square root is computed |
a | std::domain_error | if a contains a negative value. Strong throw guarantee. |
Calculate the square root of an interval.
The square root is only defined for non-negative values, so a must not contain any negative value. The empty interval contains nothing and is returned unchanged.
| T | The value type of the interval |
| a | The interval whose square root is computed |
a | std::domain_error | if a contains a negative value, i.e., if its lower bound is negative. Strong throw guarantee. |
Calculate the square root of a Taylor polynomial.
| T | The value type of the polynomial |
Composes the binomial series of sqrt about a.constant() with a.
| [in] | a | The Taylor polynomial whose square root is computed |
a | std::domain_error | If a is empty or bound(a) contains non-positive values. Strong throw guarantee. |
| std::bad_alloc | If memory allocation fails. Strong throw guarantee. |
| Triplex< IntervalType > sigma::sqrt | ( | const Triplex< IntervalType > & | a | ) |
Calculate the square root of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex whose square root is computed |
a | std::domain_error | if a contains a negative value. Strong throw guarantee. |
Calculate the square root of an uncertain variable.
| T | The value type of the variable |
| a | The variable whose root is computed |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::tan | ( | const GeneralInterval< T > & | a | ) |
Calculate the tangent of a general interval.
Openness cannot rescue an argument that reaches a pole: the poles are not representable, so a bound within rounding distance of one cannot be shown to exclude it.
| T | The value type of the interval |
| a | The interval whose tangent is computed |
a | std::domain_error | if a contains, or cannot be shown to exclude, an odd multiple of \( \pi/2 \). Strong throw guarantee. |
Calculate the tangent of an interval.
Tangent is undefined at odd multiples of \( \pi/2 \), so a must not contain one. Such a point is not representable, so an argument whose bound falls within rounding distance of one is refused as well: it cannot be shown to exclude the pole. The empty interval contains nothing and is returned unchanged.
Every acceptable argument lies within a single branch, on which the tangent is increasing.
| T | The value type of the interval |
| a | The interval whose tangent is computed |
a | std::domain_error | if a contains, or cannot be shown to exclude, an odd multiple of \( \pi/2 \). Strong throw guarantee. |
| Triplex< IntervalType > sigma::tan | ( | const Triplex< IntervalType > & | a | ) |
Calculate the tangent of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex, in radians |
a | std::domain_error | if a contains, or cannot be shown to exclude, an odd multiple of \( \pi/2 \). Strong throw guarantee. |
Tangent of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
| GeneralInterval< T > sigma::tanh | ( | const GeneralInterval< T > & | a | ) |
Calculate the hyperbolic tangent of a general interval.
| T | The value type of the interval |
| a | The interval whose hyperbolic tangent is computed |
a | none | No throw guarantee |
Calculate the hyperbolic tangent of an interval.
| T | The value type of the interval |
| a | The interval whose hyperbolic tangent is computed |
a | none | No throw guarantee |
| Triplex< IntervalType > sigma::tanh | ( | const Triplex< IntervalType > & | a | ) |
Calculate the hyperbolic tangent of a triplex.
| IntervalType | The interval type of the triplex |
| a | The triplex |
a | none | No throw guarantee |
Hyperbolic tangent of the variable.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Gamma function.
| T | The value type of the variable |
| a | The variable |
a | none | No throw guarantee |
Remove the fractional part from a variable.
| T | The value type of the variable |
| a | The variable whose value is truncated |
a | none | No throw guarantee |