![]() |
Modules | |
Compile time constraints | |
Matrices | |
Vectors | |
Intrinsics | |
Quaternion | |
Shims | |
Solvers | |
Expression traits | |
Type traits | |
Classes | |
class | blaze::NegativeAccuracy< A > |
Negative computation accuracy for floating point data types.The NegativeAccuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative computation accuracy of the Blaze library for any floating point data type. In order to assign a negative accuracy value, the NegativeAccuracy class can be implicitly converted to the three built-in floating point data types float, double and long double. More... | |
class | blaze::Accuracy |
Computation accuracy for floating point data types.The Accuracy class is a wrapper class around the functionality of the blaze::Limits class. It represents the computation accuracy of the Blaze library for any floating point data type. In order to assign an accuracy value, the Accuracy class can be implicitly converted to the three built-in floating point data types float, double and long double. In order to handle accuracy values conveniently, the global Accuracy instance blaze::accuracy is provided, which can be used wherever a floating point data value is required. More... | |
class | blaze::NegativeEpsilon< E > |
Negative epsilon value for floating point data types.The NegativeEpsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the negative smallest difference between two values of any floating point data type. In order to assign a negative epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double. More... | |
class | blaze::Epsilon |
Numerical epsilon value for floating point data types.The Epsilon class is a wrapper class around the functionality of the blaze::Limits class. It represents the smallest difference between two values of any floating point data type. In order to assign an epsilon value, the Epsilon class can be implicitly converted to the three built-in floating point data types float, double and long double. In order to handle epsilon values conveniently, the global Epsilon instance blaze::epsilon is provided, which can be used wherever a floating point data type is required. More... | |
struct | blaze::Computation |
Base class for all compute expression templates.The Computation class serves as a tag for all computational expression templates. All classes, that represent a mathematical computation (addition, subtraction, multiplication, division, absolute value calculation, ...) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as computational expression template. Only in case a class is derived from the Computation base class, the IsComputation type trait recognizes the class as valid computational expression template. More... | |
struct | blaze::Expression |
Base class for all expression templates.The Expression class is the base class for all expression templates. All classes, that represent a mathematical operation and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as expression template. Only in case a class is derived from the Expression base class, the IsExpression type trait recognizes the class as valid expression template. More... | |
class | blaze::NegativeInfinity< I > |
Negative infinity for built-in data types.The NegativeInfinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possibility to assign negative infinity values to built-in data types. As negative infinity value, the largest possible negative value of the corresponding data type is used. In order to assign the negative infinity value, the NegativeInfinity class can be implicitly converted to all signed integral and floating point data types: More... | |
class | blaze::Infinity |
Positive infinity for built-in data types.The Infinity class is a wrapper class around the functionality of the blaze::Limits class to provide the possiblity to assign a positive infinity value to built-in data types. As positive infinity value, the largest possible positive value of the corresponding data type is used. In order to assign the positive infinity value, the Infinity class can be implicitly converted to the following 13 built-in integral and floating point data types: More... | |
struct | blaze::BoxLCP |
A box linear complementarity problem (BLCP) data structure.The BoxLCP class represent a box linear complementarity problem (BLCP) of the form ![]() | |
struct | blaze::ContactLCP |
A data structure for linear complementarity problems (LCPs) for contact mechanics.TODO. More... | |
struct | blaze::LCP |
A linear complementarity problem (LCP) data structure.The LCP class represent a linear complementarity problem of the form ![]() | |
struct | blaze::LSE |
A linear system of equations (LSE) data structure.The LSE class represent a linear system of equations of the form ![]() | |
struct | blaze::MixedLCP |
A mixed linear complementarity problem (MLCP) data structure.The LCP class represent a mixed linear complementarity problem of the form. More... | |
struct | blaze::ModifiedBoxLCP |
A modified box linear complementarity problem (MBLCP) data structure.The ModifiedBoxLCP class represent a modified box linear complementarity problem (MBLCP) of the form. More... | |
class | blaze::MatrixAccessProxy< MT > |
Access proxy for sparse, ![]() The proxied access to the elements of a sparse matrix is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedMatrix class: More... | |
class | blaze::SparseElement< Type > |
Index-value-pair for the sparse vectors and matrices.The SparseElement class represents a single index-value-pair of a sparse vector or sparse matrix. More... | |
class | blaze::VectorAccessProxy< VT > |
Access proxy for sparse, N-dimensional vectors.The VectorAccessProxy provides safe access to the elements of a non-const sparse vector. The proxied access to the elements of a sparse vector is necessary since it may be possible that several insertion operations happen in the same statement. The following code illustrates this with two examples by means of the CompressedVector class: More... | |
struct | blaze::AddTrait< T1, T2 > |
Base template for the AddTrait class. More... | |
struct | blaze::CMathTrait< T > |
Base template for the CMathTrait class.The CMathTrait template evaluates the return type of the mathematical functions defined in the C++ header <cmath> depending on the type of the template argument. In case of an integral data type or double precision argument, the return value of the functions is double, whereas the return type is float for single precision arguments and long double for long double precision arguments. More... | |
struct | blaze::CrossTrait< T1, T2 > |
Base template for the CrossTrait class. More... | |
struct | blaze::DivTrait< T1, T2 > |
Base template for the DivTrait class. More... | |
struct | blaze::MathTrait< T1, T2 > |
Base template for the MathTrait class. More... | |
struct | blaze::MultTrait< T1, T2 > |
Base template for the MultTrait class. More... | |
struct | blaze::SubTrait< T1, T2 > |
Base template for the SubTrait class. More... | |
Enumerations | |
enum | blaze::EulerRotation { blaze::XYZs = 0, blaze::ZYXr = 1, blaze::XYXs = 2, blaze::XYXr = 3, blaze::XZYs = 4, blaze::YZXr = 5, blaze::XZXs = 6, blaze::XZXr = 7, blaze::YZXs = 8, blaze::XZYr = 9, blaze::YZYs = 10, blaze::YZYr = 11, blaze::YXZs = 12, blaze::ZXYr = 13, blaze::YXYs = 14, blaze::YXYr = 15, blaze::ZXYs = 16, blaze::YXZr = 17, blaze::ZXZs = 18, blaze::ZXZr = 19, blaze::ZYXs = 20, blaze::XYZr = 21, blaze::ZYZs = 22, blaze::ZYZr = 23 } |
Order of the Euler rotationThis codes are needed for the EulerAngles function in order to calculate the Euler angles for a specific combination of rotations. More... | |
Variables | |
const Accuracy | blaze::accuracy |
Global Accuracy instance.The blaze::accuracy instance can be used wherever a floating point data type is expected. It is implicitly converted to the corresponding floating point data type and represents the computation accuracy of the Blaze library for the according data type. | |
const real | blaze::M_E = 2.7182818284590452353602874713526625 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LOG2E = 1.4426950408889634073599246810018921 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LOG10E = 0.4342944819032518276511289189166051 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LN2 = 0.6931471805599453094172321214581766 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_LN10 = 2.3025850929940456840179914546843642 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_PI = 3.1415926535897932384626433832795029 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_SQRT2 = 1.4142135623730950488016887242096981 |
Definition of the mathematical constant ![]() | |
const real | blaze::M_SQRT3 = 1.7320508075688772935274463415058724 |
Definition of the mathematical constant ![]() | |
const Epsilon | blaze::epsilon |
Global Epsilon instance.The blaze::epsilon instance can be used wherever a floating point data type is expected. It is implicitly converted to the corresponding floating point data type and represents the smallest possible difference between two values of the according data type. | |
const Infinity | blaze::inf |
Global Infinity instance.The blaze::inf instance can be used wherever a built-in data type is expected. It is implicitly converted to the corresponding built-in data type and represents its largest possible data value. | |
Accuracy operators | |
template<typename A , typename T > | |
bool | blaze::operator== (const NegativeAccuracy< A > &, const T &rhs) |
Equality comparison between a NegativeAccuracy object and a floating point value. | |
template<typename A , typename T > | |
bool | blaze::operator== (const T &lhs, const NegativeAccuracy< A > &) |
Equality comparison between a floating point value and a NegativeAccuracy object. | |
template<typename A , typename T > | |
bool | blaze::operator!= (const NegativeAccuracy< A > &, const T &rhs) |
Inequality comparison between a NegativeAccuracy object and a floating point value. | |
template<typename A , typename T > | |
bool | blaze::operator!= (const T &lhs, const NegativeAccuracy< A > &) |
Inequality comparison between a floating point value and a NegativeAccuracy object. | |
template<typename T > | |
bool | blaze::operator== (const Accuracy &, const T &rhs) |
Equality comparison between an Accuracy object and a floating point value. | |
template<typename T > | |
bool | blaze::operator== (const T &lhs, const Accuracy &) |
Equality comparison between a floating point value and an Accuracy object. | |
template<typename T > | |
bool | blaze::operator!= (const Accuracy &, const T &rhs) |
Inequality comparison between an Accuracy object and a floating point value. | |
template<typename T > | |
bool | blaze::operator!= (const T &lhs, const Accuracy &) |
Inequality comparison between a floating point value and an Accuracy object. | |
template<typename A , typename T > | |
bool | blaze::operator< (const NegativeAccuracy< A > &, const T &rhs) |
Less-than comparison between a NegativeAccuracy object and a floating point value. | |
template<typename A , typename T > | |
bool | blaze::operator< (const T &lhs, const NegativeAccuracy< A > &) |
Less-than comparison between a floating point value and a NegativeAccuracy object. | |
template<typename A , typename T > | |
bool | blaze::operator> (const NegativeAccuracy< A > &, const T &rhs) |
Greater-than comparison between a NegativeAccuracy object and a floating point value. | |
template<typename A , typename T > | |
bool | blaze::operator> (const T &lhs, const NegativeAccuracy< A > &) |
Greater-than comparison between a floating point value and a NegativeAccuracy object. | |
template<typename T > | |
bool | blaze::operator< (const Accuracy &, const T &rhs) |
Less-than comparison between an Accuracy object and a floating point value. | |
template<typename T > | |
bool | blaze::operator< (const T &lhs, const Accuracy &) |
Less-than comparison between a floating point value and an Accuracy object. | |
template<typename T > | |
bool | blaze::operator> (const Accuracy &, const T &rhs) |
Greater-than comparison between an Accuracy object and a floating point value. | |
template<typename T > | |
bool | blaze::operator> (const T &lhs, const Accuracy &) |
Greater-than comparison between a floating point value and an Accuracy object. | |
NegativeEpsilon operators | |
template<typename E , typename T > | |
bool | blaze::operator== (const NegativeEpsilon< E > &, const T &rhs) |
Equality comparison between a NegativeEpsilon object and a floating point value. | |
template<typename E , typename T > | |
bool | blaze::operator== (const T &lhs, const NegativeEpsilon< E > &) |
Equality comparison between a floating point value and a NegativeEpsilon object. | |
template<typename E , typename T > | |
bool | blaze::operator!= (const NegativeEpsilon< E > &, const T &rhs) |
Inequality comparison between a NegativeEpsilon object and a floating point value. | |
template<typename E , typename T > | |
bool | blaze::operator!= (const T &lhs, const NegativeEpsilon< E > &) |
Inequality comparison between a floating point value and a NegativeEpsilon object. | |
template<typename E , typename T > | |
bool | blaze::operator< (const NegativeEpsilon< E > &, const T &rhs) |
Less-than comparison between a NegativeEpsilon object and a floating point value. | |
template<typename E , typename T > | |
bool | blaze::operator< (const T &lhs, const NegativeEpsilon< E > &) |
Less-than comparison between a floating point value and a NegativeEpsilon object. | |
template<typename E , typename T > | |
bool | blaze::operator> (const NegativeEpsilon< E > &, const T &rhs) |
Greater-than comparison between a NegativeEpsilon object and a floating point value. | |
template<typename E , typename T > | |
bool | blaze::operator> (const T &lhs, const NegativeEpsilon< E > &) |
Greater-than comparison between a floating point value and a NegativeEpsilon object. | |
Epsilon operators | |
template<typename T > | |
bool | blaze::operator== (const Epsilon &, const T &rhs) |
Equality comparison between an Epsilon object and a floating point value. | |
template<typename T > | |
bool | blaze::operator== (const T &lhs, const Epsilon &) |
Equality comparison between a floating point value and an Epsilon object. | |
template<typename T > | |
bool | blaze::operator!= (const Epsilon &, const T &rhs) |
Inequality comparison between an Epsilon object and a floating point value. | |
template<typename T > | |
bool | blaze::operator!= (const T &lhs, const Epsilon &) |
Inequality comparison between a floating point value and an Epsilon object. | |
template<typename T > | |
bool | blaze::operator< (const Epsilon &, const T &rhs) |
Less-than comparison between an Epsilon object and a floating point value. | |
template<typename T > | |
bool | blaze::operator< (const T &lhs, const Epsilon &) |
Less-than comparison between a floating point value and an Epsilon object. | |
template<typename T > | |
bool | blaze::operator> (const Epsilon &, const T &rhs) |
Greater-than comparison between an Epsilon object and a floating point value. | |
template<typename T > | |
bool | blaze::operator> (const T &lhs, const Epsilon &) |
Greater-than comparison between a floating point value and an Epsilon object. | |
Mathematical utility functions | |
template<typename T > | |
const T | blaze::sign (T a) |
Sign function. | |
template<typename T > | |
size_t | blaze::digits (T a) |
Returns the number of valid digits of an integral value. | |
template<typename T1 , typename T2 > | |
const MathTrait< T1, T2 >::HighType | blaze::min (const T1 &a, const T2 &b) |
Minimum function for two arguments. | |
template<typename T1 , typename T2 , typename T3 > | |
const MathTrait< typename MathTrait< T1, T2 >::HighType, T3 >::HighType | blaze::min (const T1 &a, const T2 &b, const T3 &c) |
Minimum function for three arguments. | |
template<typename T1 , typename T2 > | |
const MathTrait< T1, T2 >::HighType | blaze::max (const T1 &a, const T2 &b) |
Maximum function for two arguments. | |
template<typename T1 , typename T2 , typename T3 > | |
const MathTrait< typename MathTrait< T1, T2 >::HighType, T3 >::HighType | blaze::max (const T1 &a, const T2 &b, const T3 &c) |
Maximum function for three arguments. | |
template<typename T > | |
T | blaze::round (T a) |
Rounds the given input value. | |
template<typename T1 , typename T2 > | |
bool | blaze::lessThan (T1 a, T2 b) |
Generic less-than comparison. | |
NegativeInfinity operators | |
template<typename I , typename T > | |
bool | blaze::operator== (const NegativeInfinity< I > &lhs, const T &rhs) |
Equality comparison between an NegativeInfinity object and a built-in data type. | |
template<typename I , typename T > | |
bool | blaze::operator== (const T &lhs, const NegativeInfinity< I > &rhs) |
Equality comparison between a built-in data type and an NegativeInfinity object. | |
template<typename I , typename T > | |
bool | blaze::operator!= (const NegativeInfinity< I > &lhs, const T &rhs) |
Inequality comparison between an NegativeInfinity object and a built-in data type. | |
template<typename I , typename T > | |
bool | blaze::operator!= (const T &lhs, const NegativeInfinity< I > &rhs) |
Inequality comparison between a built-in data type and an NegativeInfinity object. | |
Infinity operators | |
template<typename T > | |
bool | blaze::operator== (const Infinity &lhs, const T &rhs) |
Equality comparison between an Infinity object and a built-in data type. | |
template<typename T > | |
bool | blaze::operator== (const T &lhs, const Infinity &rhs) |
Equality comparison between a built-in data type and an Infinity object. | |
template<typename T > | |
bool | blaze::operator!= (const Infinity &lhs, const T &rhs) |
Inequality comparison between an Infinity object and a built-in data type. | |
template<typename T > | |
bool | blaze::operator!= (const T &lhs, const Infinity &rhs) |
Inequality comparison between a built-in data type and an Infinity object. | |
enum blaze::EulerRotation |
Order of the Euler rotationThis codes are needed for the EulerAngles function in order to calculate the Euler angles for a specific combination of rotations.
|
inline |
Returns the number of valid digits of an integral value.
a | The integral value. |
This function counts the number of valid digits in the given integral value.
The digits function only works for integral built-in data types. The attempt to use any other type will result in a compile time error.
|
inline |
Generic less-than comparison.
a | First value. |
b | Second value. |
Generic less-than comparison between to numeric values. Depending on the types of the two arguments, a special comparison for floating point values is selected that takes the limited machine accuracy into account.
|
inline |
Maximum function for two arguments.
a | First value. |
b | Second value. |
This function returns the maximum of the two given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
|
inline |
Maximum function for three arguments.
a | First value. |
b | Second value. |
c | Third value. |
This function returns the maximum of the three given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
|
inline |
Minimum function for two arguments.
a | First value. |
b | Second value. |
This function returns the minimum of the two given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
|
inline |
Minimum function for three arguments.
a | First value. |
b | Second value. |
c | Third value |
This function returns the minimum of the three given data values. The return type of the function is determined by the data types of the given arguments (for further detail see the MathTrait class description).
|
inline |
Inequality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Inequality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Less-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between an NegativeInfinity object and a built-in data type.
lhs | The left-hand side NegativeInfinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a built-in data type and an NegativeInfinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side NegativeInfinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Equality comparison between an Infinity object and a built-in data type.
lhs | The left-hand side Infinity object. |
rhs | The right-hand side built-in data value. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Equality comparison between a built-in data type and an Infinity object.
lhs | The left-hand side built-in data value. |
rhs | The right-hand side Infinity object. |
This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a NegativeAccuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a NegativeEpsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and a NegativeEpsilon object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and a NegativeAccuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between an Epsilon object and a floating point value.
rhs | The right-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between an Accuracy object and a floating point value.
rhs | The right-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and an Epsilon object.
lhs | The left-hand side floating point value. |
This operator works only for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Greater-than comparison between a floating point value and an Accuracy object.
lhs | The left-hand side floating point value. |
This operator exclusively works for floating point data types. The attempt to compare any integral data type or user-defined class types will result in a compile time error.
|
inline |
Rounds the given input value.
a | Value to be rounded. |
This function rounds the given input value. In case the first digit after the comma is smaller than five the value is rounded down. Otherwise it is rounded up. Note that this function only works for integral and floating point types. The attempt to use the function for any other type will result in a compile time error.
|
inline |
Sign function.
a | The signed value. |
The sign function only works for signed built-in data types. The attempt to use unsigned data types or user-defined class types will result in a compile time error.