All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Modules | Classes | Enumerations | Variables
Math module

Modules

 Compile time constraints
 
 Matrices
 
 Vectors
 
 Intrinsics
 
 Quaternion
 
 Serialization
 
 Shims
 
 Solvers
 
 Expression traits
 
 Type traits
 
 Views
 

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::AbsExpr
 Base class for all absolute value expression templates.The AbsExpr class serves as a tag for all expression templates that implement an absolute value operation. All classes, that represent an absolute value 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 absolute value expression template. Only in case a class is derived from the AbsExpr base class, the IsAbsExpr type trait recognizes the class as valid absolute value expression template. More...
 
struct  blaze::AddExpr
 Base class for all addition expression templates.The AddExpr class serves as a tag for all expression templates that implement mathematical additions. All classes, that represent a mathematical addition (vector additions and matrix additions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as addition expression template. Only in case a class is derived from the AddExpr base class, the IsAddExpr type trait recognizes the class as valid addition expression template. 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::CrossExpr
 Base class for all cross product expression templates.The CrossExpr class serves as a tag for all expression templates that implement mathematical cross products. All classes, that represent a mathematical cross product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as cross product expression template. Only in case a class is derived from the CrossExpr base class, the IsCrossExpr type trait recognizes the class as valid cross product expression template. More...
 
struct  blaze::DivExpr
 Base class for all division expression templates.The DivExpr class serves as a tag for all expression templates that implement mathematical divisions. All classes, that represent a mathematical division (vector/scalar divisions and matrix/scalar division) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as division expression template. Only in case a class is derived from the DivExpr base class, the IsDivExpr type trait recognizes the class as valid division expression template. More...
 
struct  blaze::EvalExpr
 Base class for all evaluation expression templates.The EvalExpr class serves as a tag for all expression templates that implement an evaluation operation. All classes, that represent an evaluation 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 evaluation expression template. Only in case a class is derived from the EvalExpr base class, the IsEvalExpr type trait recognizes the class as valid evaluation 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...
 
struct  blaze::MatAbsExpr
 Base class for all matrix absolute value expression templates.The MatAbsExpr class serves as a tag for all expression templates that implement a matrix absolute value operation. All classes, that represent a matrix absolute value 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 matrix absolute value expression template. Only in case a class is derived from the MatAbsExpr base class, the IsMatAbsExpr type trait recognizes the class as valid matrix absolute value expression template. More...
 
struct  blaze::MatEvalExpr
 Base class for all matrix evaluation expression templates.The MatEvalExpr class serves as a tag for all expression templates that implement a matrix evaluation operation. All classes, that represent a matrix evaluation 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 matrix evaluation expression template. Only in case a class is derived from the MatEvalExpr base class, the IsMatEvalExpr type trait recognizes the class as valid matrix evaluation expression template. More...
 
struct  blaze::MatMatAddExpr
 Base class for all matrix/matrix addition expression templates.The MatMatAddExpr class serves as a tag for all expression templates that implement a matrix/matrix addition. All classes, that represent a matrix addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix addition expression template. Only in case a class is derived from the MatMatAddExpr base class, the IsMatMatAddExpr type trait recognizes the class as valid matrix addition expression template. More...
 
struct  blaze::MatMatMultExpr
 Base class for all matrix/matrix multiplication expression templates.The MatMatMultExpr class serves as a tag for all expression templates that implement a matrix/matrix multiplication. All classes, that represent a matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix multiplication expression template. Only in case a class is derived from the MatMatMultExpr base class, the IsMatMatMultExpr type trait recognizes the class as valid matrix multiplication expression template. More...
 
struct  blaze::MatMatSubExpr
 Base class for all matrix/matrix subtraction expression templates.The MatMatSubExpr class serves as a tag for all expression templates that implement a matrix/matrix subtraction. All classes, that represent a matrix subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix subtraction expression template. Only in case a class is derived from the MatMatSubExpr base class, the IsMatMatSubExpr type trait recognizes the class as valid matrix subtraction expression template. More...
 
struct  blaze::MatScalarDivExpr
 Base class for all matrix/scalar divsion expression templates.The MatScalarDivExpr class serves as a tag for all expression templates that implement a matrix/scalar divsion. All classes, that represent a matrix/scalar divsion and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar divsion expression template. Only in case a class is derived from the MatScalarDivExpr base class, the IsMatScalarDivExpr type trait recognizes the class as valid matrix/scalar divsion expression template. More...
 
struct  blaze::MatScalarMultExpr
 Base class for all matrix/scalar multiplication expression templates.The MatScalarMultExpr class serves as a tag for all expression templates that implement a matrix/scalar multiplication. All classes, that represent a matrix/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/scalar multiplication expression template. Only in case a class is derived from the MatScalarMultExpr base class, the IsMatScalarMultExpr type trait recognizes the class as valid matrix/scalar multiplication expression template. More...
 
struct  blaze::MatTransExpr
 Base class for all matrix transposition expression templates.The MatTransExpr class serves as a tag for all expression templates that implement a matrix transposition operation. All classes, that represent a matrix transposition 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 matrix transposition expression template. Only in case a class is derived from the MatTransExpr base class, the IsMatTransExpr type trait recognizes the class as valid matrix transposition expression template. More...
 
struct  blaze::MatVecMultExpr
 Base class for all matrix/vector multiplication expression templates.The MatVecMultExpr class serves as a tag for all expression templates that implement a matrix/vector multiplication. All classes, that represent a matrix/vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as matrix/vector multiplication expression template. Only in case a class is derived from the MatVecMultExpr base class, the IsMatVecMultExpr type trait recognizes the class as valid matrix/vector multiplication expression template. More...
 
struct  blaze::MultExpr
 Base class for all multiplication expression templates.The MultExpr class serves as a tag for all expression templates that implement mathematical multiplications. All classes, that represent a mathematical multiplication (element-wise vector multiplications, matrix/vector multiplications, vector/matrix multiplications and matrix/matrix multiplications) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as multiplication expression template. Only in case a class is derived from the MultExpr base class, the IsMultExpr type trait recognizes the class as valid multiplication expression template. More...
 
struct  blaze::SubExpr
 Base class for all subtraction expression templates.The SubExpr class serves as a tag for all expression templates that implement mathematical subtractions. All classes, that represent a mathematical subtraction (vector subtractions and matrix subtractions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as subtraction expression template. Only in case a class is derived from the SubExpr base class, the IsSubExpr type trait recognizes the class as valid subtraction expression template. More...
 
struct  blaze::TransExpr
 Base class for all transposition expression templates.The TransExpr class serves as a tag for all expression templates that implement mathematical transpositions. All classes, that represent a mathematical transposition (vector transpositions and matrix transpositions) and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as transposition expression template. Only in case a class is derived from the TransExpr base class, the IsTransExpr type trait recognizes the class as valid transposition expression template. More...
 
struct  blaze::TVecMatMultExpr
 Base class for all vector/matrix multiplication expression templates.The TVecMatMultExpr class serves as a tag for all expression templates that implement a vector/matrix multiplication. All classes, that represent a vector/matrix multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/matrix multiplication expression template. Only in case a class is derived from the TVecMatMultExpr base class, the IsTVecMatMultExpr type trait recognizes the class as valid vector/matrix multiplication expression template. More...
 
struct  blaze::VecAbsExpr
 Base class for all vector absolute value expression templates.The VecAbsExpr class serves as a tag for all expression templates that implement a vector absolute value operation. All classes, that represent a vector absolute value 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 vector absolute value expression template. Only in case a class is derived from the VecAbsExpr base class, the IsVecAbsExpr type trait recognizes the class as valid vector absolute value expression template. More...
 
struct  blaze::VecEvalExpr
 Base class for all vector evaluation expression templates.The VecEvalExpr class serves as a tag for all expression templates that implement a vector evaluation operation. All classes, that represent a vector evaluation 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 vector evaluation expression template. Only in case a class is derived from the VecEvalExpr base class, the IsVecEvalExpr type trait recognizes the class as valid vector evaluation expression template. More...
 
struct  blaze::VecScalarDivExpr
 Base class for all vector/scalar division expression templates.The VecScalarDivExpr class serves as a tag for all expression templates that implement a vector/scalar division. All classes, that represent a vector/scalar division and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar division expression template. Only in case a class is derived from the VecScalarDivExpr base class, the IsVecScalarDivExpr type trait recognizes the class as valid vector/scalar division expression template. More...
 
struct  blaze::VecScalarMultExpr
 Base class for all vector/scalar multiplication expression templates.The VecScalarMultExpr class serves as a tag for all expression templates that implement a vector/scalar multiplication. All classes, that represent a vector/scalar multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector/scalar multiplication expression template. Only in case a class is derived from the VecScalarMultExpr base class, the IsVecScalarMultExpr type trait recognizes the class as valid vector/scalar multiplication expression template. More...
 
struct  blaze::VecTransExpr
 Base class for all vector transposition expression templates.The VecTransExpr class serves as a tag for all expression templates that implement a vector transposition operation. All classes, that represent a vector transposition 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 vector transposition expression template. Only in case a class is derived from the VecTransExpr base class, the IsVecTransExpr type trait recognizes the class as valid vector transposition expression template. More...
 
struct  blaze::VecTVecMultExpr
 Base class for all outer product expression templates.The VecTVecMultExpr class serves as a tag for all expression templates that implement mathematical outer products (i.e. multiplications between a column vector and a row vector). All classes, that represent a mathematical outer product and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as outer product expression template. Only in case a class is derived from the VecTVecMultExpr base class, the IsVecTVecMultExpr type trait recognizes the class as valid outer product expression template. More...
 
struct  blaze::VecVecAddExpr
 Base class for all vector/vector addition expression templates.The VecVecAddExpr class serves as a tag for all expression templates that implement a vector/vector addition. All classes, that represent a vector addition and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector addition expression template. Only in case a class is derived from the VecVecAddExpr base class, the IsVecVecAddExpr type trait recognizes the class as valid vector addition expression template. More...
 
struct  blaze::VecVecMultExpr
 Base class for all vector/vector multiplication expression templates.The VecVecMultExpr class serves as a tag for all expression templates that implement a vector/vector multiplication. All classes, that represent a vector multiplication and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector multiplication expression template. Only in case a class is derived from the VecVecMultExpr base class, the IsVecVecMultExpr type trait recognizes the class as valid vector multiplication expression template. More...
 
struct  blaze::VecVecSubExpr
 Base class for all vector/vector subtraction expression templates.The VecVecSubExpr class serves as a tag for all expression templates that implement a vector/vector subtraction. All classes, that represent a vector subtraction and that are used within the expression template environment of the Blaze library have to derive from this class in order to qualify as vector subtraction expression template. Only in case a class is derived from the VecVecSubExpr base class, the IsVecVecSubExpr type trait recognizes the class as valid vector subtraction 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 $ A \cdot x + b \leq 0 \quad\perp\quad \underline{x} \leq x \leq \bar{x} $. More...
 
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 $ A \cdot x + b \leq 0 \quad\perp\quad x \geq 0 $. More...
 
struct  blaze::LSE
 A linear system of equations (LSE) data structure.The LSE class represent a linear system of equations of the form $ A \cdot x + b = 0 $. More...
 
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, $ M \times N $ matrices.The MatrixAccessProxy provides safe access to the elements of a non-const sparse matrices.
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::ColumnTrait< MT >
 Base template for the ColumnTrait class. 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::RowTrait< MT >
 Base template for the RowTrait 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 $ e $.
 
const real blaze::M_LOG2E = 1.4426950408889634073599246810018921
 Definition of the mathematical constant $ \log_2 e $.
 
const real blaze::M_LOG10E = 0.4342944819032518276511289189166051
 Definition of the mathematical constant $ \log_{10} e $.
 
const real blaze::M_LN2 = 0.6931471805599453094172321214581766
 Definition of the mathematical constant $ \ln 2 $.
 
const real blaze::M_LN10 = 2.3025850929940456840179914546843642
 Definition of the mathematical constant $ \ln 10 $.
 
const real blaze::M_PI = 3.1415926535897932384626433832795029
 Definition of the mathematical constant $ \pi $.
 
const real blaze::M_SQRT2 = 1.4142135623730950488016887242096981
 Definition of the mathematical constant $ \sqrt{2} $.
 
const real blaze::M_SQRT3 = 1.7320508075688772935274463415058724
 Definition of the mathematical constant $ \sqrt{3} $.
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
bool blaze::operator== (const Accuracy &, const T &rhs)
 Equality comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator== (const T &lhs, const Accuracy &)
 Equality comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
bool blaze::operator!= (const Accuracy &, const T &rhs)
 Inequality comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator!= (const T &lhs, const Accuracy &)
 Inequality comparison between a floating point value and an Accuracy object. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename T >
bool blaze::operator< (const Accuracy &, const T &rhs)
 Less-than comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator< (const T &lhs, const Accuracy &)
 Less-than comparison between a floating point value and an Accuracy object. More...
 
template<typename T >
bool blaze::operator> (const Accuracy &, const T &rhs)
 Greater-than comparison between an Accuracy object and a floating point value. More...
 
template<typename T >
bool blaze::operator> (const T &lhs, const Accuracy &)
 Greater-than comparison between a floating point value and an Accuracy object. More...
 

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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 
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. More...
 

Epsilon operators

template<typename T >
bool blaze::operator== (const Epsilon &, const T &rhs)
 Equality comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator== (const T &lhs, const Epsilon &)
 Equality comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool blaze::operator!= (const Epsilon &, const T &rhs)
 Inequality comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator!= (const T &lhs, const Epsilon &)
 Inequality comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool blaze::operator< (const Epsilon &, const T &rhs)
 Less-than comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator< (const T &lhs, const Epsilon &)
 Less-than comparison between a floating point value and an Epsilon object. More...
 
template<typename T >
bool blaze::operator> (const Epsilon &, const T &rhs)
 Greater-than comparison between an Epsilon object and a floating point value. More...
 
template<typename T >
bool blaze::operator> (const T &lhs, const Epsilon &)
 Greater-than comparison between a floating point value and an Epsilon object. More...
 

Mathematical utility functions

template<typename T >
const T blaze::sign (T a)
 Sign function. More...
 
template<typename T >
size_t blaze::digits (T a)
 Returns the number of valid digits of an integral value. More...
 
template<typename T1 , typename T2 >
const MathTrait< T1, T2 >::HighType blaze::min (const T1 &a, const T2 &b)
 Minimum function for two arguments. More...
 
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. More...
 
template<typename T1 , typename T2 >
const MathTrait< T1, T2 >::HighType blaze::max (const T1 &a, const T2 &b)
 Maximum function for two arguments. More...
 
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. More...
 
template<typename T >
blaze::round (T a)
 Rounds the given input value. More...
 
template<typename T1 , typename T2 >
bool blaze::lessThan (T1 a, T2 b)
 Generic less-than comparison. More...
 

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. More...
 
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. More...
 
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. More...
 
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. More...
 

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. More...
 
template<typename T >
bool blaze::operator== (const T &lhs, const Infinity &rhs)
 Equality comparison between a built-in data type and an Infinity object. More...
 
template<typename T >
bool blaze::operator!= (const Infinity &lhs, const T &rhs)
 Inequality comparison between an Infinity object and a built-in data type. More...
 
template<typename T >
bool blaze::operator!= (const T &lhs, const Infinity &rhs)
 Inequality comparison between a built-in data type and an Infinity object. More...
 

Detailed Description

Enumeration Type Documentation

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.

Enumerator
XYZs 

Rotation order x, y, z in a static frame.

ZYXr 

Rotation order z, y, x in a rotating frame.

XYXs 

Rotation order x, y, x in a static frame.

XYXr 

Rotation order x, y, z in a rotating frame.

XZYs 

Rotation order x, z, y in a static frame.

YZXr 

Rotation order y, z, x in a rotating frame.

XZXs 

Rotation order x, z, x in a static frame.

XZXr 

Rotation order x, z, x in a rotating frame.

YZXs 

Rotation order y, z, x in a static frame.

XZYr 

Rotation order x, z, y in a rotating frame.

YZYs 

Rotation order y, z, y in a static frame.

YZYr 

Rotation order y, z, y in a rotating frame.

YXZs 

Rotation order y, x, z in a static frame.

ZXYr 

Rotation order z, x, y in a rotating frame.

YXYs 

Rotation order y, x, y in a static frame.

YXYr 

Rotation order y, x, y in a rotating frame.

ZXYs 

Rotation order z, x, y in a static frame.

YXZr 

Rotation order y, x, z in a rotating frame.

ZXZs 

Rotation order z, x, z in a static frame.

ZXZr 

Rotation order z, x, z in a rotating frame.

ZYXs 

Rotation order z, y, x in a static frame.

XYZr 

Rotation order x, y, z in a rotating frame.

ZYZs 

Rotation order z, y, z in a static frame.

ZYZr 

Rotation order z, y, z in a rotating frame.

Function Documentation

template<typename T >
size_t blaze::digits ( a)
inline

Returns the number of valid digits of an integral value.

Parameters
aThe integral value.
Returns
The number of valid digits.

This function counts the number of valid digits in the given integral value.

digits( 100 ); // Returns 3
digits( 12345 ); // Returns 5
digits( 0 ); // Returns 0

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.

template<typename T1 , typename T2 >
bool blaze::lessThan ( T1  a,
T2  b 
)
inline

Generic less-than comparison.

Parameters
aFirst value.
bSecond value.
Returns
true if the first value is smaller than the second, false if not.

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.

template<typename T1 , typename T2 >
const MathTrait< T1, T2 >::HighType blaze::max ( const T1 &  a,
const T2 &  b 
)
inline

Maximum function for two arguments.

Parameters
aFirst value.
bSecond value.
Returns
The maximum of the two values.

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).

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 
)
inline

Maximum function for three arguments.

Parameters
aFirst value.
bSecond value.
cThird value.
Returns
The maximum of the three values.

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).

template<typename T1 , typename T2 >
const MathTrait< T1, T2 >::HighType blaze::min ( const T1 &  a,
const T2 &  b 
)
inline

Minimum function for two arguments.

Parameters
aFirst value.
bSecond value.
Returns
The minimum of the two values.

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).

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 
)
inline

Minimum function for three arguments.

Parameters
aFirst value.
bSecond value.
cThird value
Returns
The minimum of the three values.

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).

template<typename A , typename T >
bool blaze::operator!= ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
inline

Inequality comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is unequal to the negative accuracy, false if not.

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.

template<typename E , typename T >
bool blaze::operator!= ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
inline

Inequality comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is unequal to the negative epsilon, false if not.

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.

template<typename A , typename T >
bool blaze::operator!= ( const T &  lhs,
const NegativeAccuracy< A > &   
)
inline

Inequality comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is unequal to the negative accuracy, false if not.

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.

template<typename E , typename T >
bool blaze::operator!= ( const T &  lhs,
const NegativeEpsilon< E > &   
)
inline

Inequality comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is unequal to the negative epsilon, false if not.

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.

template<typename I , typename T >
bool blaze::operator!= ( const NegativeInfinity< I > &  lhs,
const T &  rhs 
)
inline

Inequality comparison between an NegativeInfinity object and a built-in data type.

Parameters
lhsThe left-hand side NegativeInfinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is not negative infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename I , typename T >
bool blaze::operator!= ( const T &  lhs,
const NegativeInfinity< I > &  rhs 
)
inline

Inequality comparison between a built-in data type and an NegativeInfinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side NegativeInfinity object.
Returns
true if the built-in data value is not negative infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename T >
bool blaze::operator!= ( const Accuracy &  ,
const T &  rhs 
)
inline

Inequality comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is unequal to the accuracy, false if not.

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.

template<typename T >
bool blaze::operator!= ( const Epsilon &  ,
const T &  rhs 
)
inline

Inequality comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is unequal to epsilon, false if not.

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.

template<typename T >
bool blaze::operator!= ( const T &  lhs,
const Epsilon &   
)
inline

Inequality comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is unequal to epsilon, false if not.

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.

template<typename T >
bool blaze::operator!= ( const T &  lhs,
const Accuracy &   
)
inline

Inequality comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is unequal to the accuracy, false if not.

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.

template<typename T >
bool blaze::operator!= ( const Infinity &  lhs,
const T &  rhs 
)
inline

Inequality comparison between an Infinity object and a built-in data type.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is not infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename T >
bool blaze::operator!= ( const T &  lhs,
const Infinity &  rhs 
)
inline

Inequality comparison between a built-in data type and an Infinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side Infinity object.
Returns
true if the built-in data value is not infinity, false if it is.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename A , typename T >
bool blaze::operator< ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
inline

Less-than comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is greater than the negative accuracy, false if not.

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.

template<typename E , typename T >
bool blaze::operator< ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
inline

Less-than comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is greater than the negative epsilon, false if not.

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.

template<typename A , typename T >
bool blaze::operator< ( const T &  lhs,
const NegativeAccuracy< A > &   
)
inline

Less-than comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is smaller than the negative accuracy, false if not.

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.

template<typename E , typename T >
bool blaze::operator< ( const T &  lhs,
const NegativeEpsilon< E > &   
)
inline

Less-than comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is smaller than the negative epsilon, false if not.

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.

template<typename T >
bool blaze::operator< ( const Accuracy &  ,
const T &  rhs 
)
inline

Less-than comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floatin point value is greater than the accuracy, false if not.

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.

template<typename T >
bool blaze::operator< ( const Epsilon &  ,
const T &  rhs 
)
inline

Less-than comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is greater than epsilon, false if not.

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.

template<typename T >
bool blaze::operator< ( const T &  lhs,
const Accuracy &   
)
inline

Less-than comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is smaller than the accuracy, false if not.

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.

template<typename T >
bool blaze::operator< ( const T &  lhs,
const Epsilon &   
)
inline

Less-than comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is smaller than epsilon, false if not.

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.

template<typename E , typename T >
bool blaze::operator== ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
inline

Equality comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is equal to the negative epsilon, false if not.

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.

template<typename A , typename T >
bool blaze::operator== ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
inline

Equality comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is equal to the negative accuracy, false if not.

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.

template<typename A , typename T >
bool blaze::operator== ( const T &  lhs,
const NegativeAccuracy< A > &   
)
inline

Equality comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is equal to the negative accuracy, false if not.

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.

template<typename E , typename T >
bool blaze::operator== ( const T &  lhs,
const NegativeEpsilon< E > &   
)
inline

Equality comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is equal to the negative epsilon, false if not.

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.

template<typename I , typename T >
bool blaze::operator== ( const NegativeInfinity< I > &  lhs,
const T &  rhs 
)
inline

Equality comparison between an NegativeInfinity object and a built-in data type.

Parameters
lhsThe left-hand side NegativeInfinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is negative infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename I , typename T >
bool blaze::operator== ( const T &  lhs,
const NegativeInfinity< I > &  rhs 
)
inline

Equality comparison between a built-in data type and an NegativeInfinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side NegativeInfinity object.
Returns
true if the built-in data value is negative infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename T >
bool blaze::operator== ( const Epsilon &  ,
const T &  rhs 
)
inline

Equality comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is equal to epsilon, false if not.

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.

template<typename T >
bool blaze::operator== ( const Accuracy &  ,
const T &  rhs 
)
inline

Equality comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is equal to the accuracy, false if not.

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.

template<typename T >
bool blaze::operator== ( const T &  lhs,
const Accuracy &   
)
inline

Equality comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is equal to the accuracy, false if not.

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.

template<typename T >
bool blaze::operator== ( const T &  lhs,
const Epsilon &   
)
inline

Equality comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is equal to epsilon, false if not.

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.

template<typename T >
bool blaze::operator== ( const Infinity &  lhs,
const T &  rhs 
)
inline

Equality comparison between an Infinity object and a built-in data type.

Parameters
lhsThe left-hand side Infinity object.
rhsThe right-hand side built-in data value.
Returns
true if the built-in data value is infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename T >
bool blaze::operator== ( const T &  lhs,
const Infinity &  rhs 
)
inline

Equality comparison between a built-in data type and an Infinity object.

Parameters
lhsThe left-hand side built-in data value.
rhsThe right-hand side Infinity object.
Returns
true if the built-in data value is infinity, false if not.

This operator works only for built-in data types. The attempt to compare user-defined class types will result in a compile time error.

template<typename A , typename T >
bool blaze::operator> ( const NegativeAccuracy< A > &  ,
const T &  rhs 
)
inline

Greater-than comparison between a NegativeAccuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is smaller than the negative accuracy, false if not.

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.

template<typename E , typename T >
bool blaze::operator> ( const NegativeEpsilon< E > &  ,
const T &  rhs 
)
inline

Greater-than comparison between a NegativeEpsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the value is smaller than the negative epsilon, false if not.

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.

template<typename E , typename T >
bool blaze::operator> ( const T &  lhs,
const NegativeEpsilon< E > &   
)
inline

Greater-than comparison between a floating point value and a NegativeEpsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is greater than the negative epsilon, false if not.

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.

template<typename A , typename T >
bool blaze::operator> ( const T &  lhs,
const NegativeAccuracy< A > &   
)
inline

Greater-than comparison between a floating point value and a NegativeAccuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the value is greater than the negative accuracy, false if not.

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.

template<typename T >
bool blaze::operator> ( const Epsilon &  ,
const T &  rhs 
)
inline

Greater-than comparison between an Epsilon object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is smaller than epsilon, false if not.

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.

template<typename T >
bool blaze::operator> ( const Accuracy &  ,
const T &  rhs 
)
inline

Greater-than comparison between an Accuracy object and a floating point value.

Parameters
rhsThe right-hand side floating point value.
Returns
true if the floating point value is smaller than the accuracy, false if not.

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.

template<typename T >
bool blaze::operator> ( const T &  lhs,
const Epsilon &   
)
inline

Greater-than comparison between a floating point value and an Epsilon object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is greater than epsilon, false if not.

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.

template<typename T >
bool blaze::operator> ( const T &  lhs,
const Accuracy &   
)
inline

Greater-than comparison between a floating point value and an Accuracy object.

Parameters
lhsThe left-hand side floating point value.
Returns
true if the floating point value is greater than the accuracy, false if not.

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.

template<typename T >
T blaze::round ( a)
inline

Rounds the given input value.

Parameters
aValue to be rounded.
Returns
The rounded value.

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.

template<typename T >
const T blaze::sign ( a)
inline

Sign function.

Parameters
aThe signed value.
Returns
1 if the value is greater than or equal to zero, -1 if the value is smaller than zero.

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.