Classes | Macros | Typedefs | Functions | Variables
Type traits

Classes

struct  blaze::HasAbs< T, typename >
 Availability of the abs() operation for the given data types.This type trait provides the information whether the abs() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAcos< T, typename >
 Availability of the acos() operation for the given data types.This type trait provides the information whether the acos() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAcosh< T, typename >
 Availability of the acosh() operation for the given data types.This type trait provides the information whether the acosh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAdd< T1, T2, typename >
 Availability of an addition operator for the given data types.This type trait provides the information whether an addition operator (i.e. operator+) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAsin< T, typename >
 Availability of the asin() operation for the given data types.This type trait provides the information whether the asin() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAsinh< T, typename >
 Availability of the asinh() operation for the given data types.This type trait provides the information whether the asinh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAtan< T, typename >
 Availability of the atan() operation for the given data types.This type trait provides the information whether the atan() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAtan2< T1, T2, typename >
 Availability of the atan2() operation for the given data types.This type trait provides the information whether the atan2() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasAtanh< T, typename >
 Availability of the atanh() operation for the given data types.This type trait provides the information whether the atanh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasCbrt< T, typename >
 Availability of the cbrt() operation for the given data types.This type trait provides the information whether the cbrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasCeil< T, typename >
 Availability of the ceil() operation for the given data types.This type trait provides the information whether the ceil() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasClamp< T, typename >
 Availability of the clamp() operation for the given data types.This type trait provides the information whether the clamp() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasConj< T, typename >
 Availability of the conj() operation for the given data types.This type trait provides the information whether the conj() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasConstDataAccess< T >
 Compile time check for low-level access to constant data.This type trait tests whether the given data type provides a low-level access to constant data via a const 'data' member function. In case the according member function is provided, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::HasCos< T, typename >
 Availability of the cos() operation for the given data types.This type trait provides the information whether the cos() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasCosh< T, typename >
 Availability of the cosh() operation for the given data types.This type trait provides the information whether the cosh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasDiv< T1, T2, typename >
 Availability of a division operator for the given data types.This type trait provides the information whether a division operator (i.e. operator/) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasErf< T, typename >
 Availability of the erf() operation for the given data types.This type trait provides the information whether the erf() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasErfc< T, typename >
 Availability of the erfc() operation for the given data types.This type trait provides the information whether the erfc() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasExp< T, typename >
 Availability of the exp() operation for the given data types.This type trait provides the information whether the exp() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasExp10< T, typename >
 Availability of the exp10() operation for the given data types.This type trait provides the information whether the exp10() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasExp2< T, typename >
 Availability of the exp2() operation for the given data types.This type trait provides the information whether the exp2() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasFloor< T, typename >
 Availability of the floor() operation for the given data types.This type trait provides the information whether the floor() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasHypot< T1, T2, typename >
 Availability of the hypot() operation for the given data types.This type trait provides the information whether the hypot() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasImag< T, typename >
 Availability of the imag() operation for the given data types.This type trait provides the information whether the imag() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasInvCbrt< T, typename >
 Availability of the invcbrt() operation for the given data types.This type trait provides the information whether the invcbrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasInvSqrt< T, typename >
 Availability of the invsqrt() operation for the given data types.This type trait provides the information whether the invsqrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasLog< T, typename >
 Availability of the log() operation for the given data types.This type trait provides the information whether the log() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasLog10< T, typename >
 Availability of the log10() operation for the given data types.This type trait provides the information whether the log10() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasLog2< T, typename >
 Availability of the log2() operation for the given data types.This type trait provides the information whether the log2() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasMax< T1, T2, typename >
 Availability of a max() operation for the given data types.This type trait provides the information whether a binary max() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case a binary max() operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasMin< T1, T2, typename >
 Availability of a min() operation for the given data types.This type trait provides the information whether a binary min() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case a binary min() operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasMult< T1, T2, typename >
 Availability of a multiplication operator for the given data types.This type trait provides the information whether a multiplication operator (i.e. operator*) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasMutableDataAccess< T >
 Compile time check for low-level access to mutable data.This type trait tests whether the given data type provides a low-level access to mutable data via a non-const 'data' member function. In case the according member function is provided, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::HasPow< T1, T2, typename >
 Availability of the pow() operation for the given data types.This type trait provides the information whether the pow() operation exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasReal< T, typename >
 Availability of the real() operation for the given data types.This type trait provides the information whether the real() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasRound< T, typename >
 Availability of the round() operation for the given data types.This type trait provides the information whether the round() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasSign< T, typename >
 Availability of the sign() operation for the given data types.This type trait provides the information whether the sign() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasSIMDAbs< T >
 Availability of a SIMD absolute value operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD absolute value operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDAcos< T >
 Availability of a SIMD inverse cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDAcosh< T >
 Availability of a SIMD inverse hyperbolic cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse hyperbolic cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDAdd< T1, T2, typename >
 Availability of a SIMD addition for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD addition operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD addition is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDAsin< T >
 Availability of a SIMD inverse sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDAsinh< T >
 Availability of a SIMD inverse hyperbolic sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic inverse sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDAtan< T >
 Availability of a SIMD inverse tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDAtan2< T1, T2 >
 Availability of a SIMD inverse tangent operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD multi-valued inverse tangent operation exists for the given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDAtanh< T >
 Availability of a SIMD inverse hyperbolic tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse hyperbolic tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDCbrt< T >
 Availability of a SIMD cubic root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD cubic root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDCeil< T >
 Availability of a SIMD ceil operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD ceil operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDConj< T >
 Availability of a SIMD conjugate operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD conjugate operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDCos< T >
 Availability of a SIMD cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDCosh< T >
 Availability of a SIMD hyperbolic cosine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic cosine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDDiv< T1, T2, typename >
 Availability of a SIMD division for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD division operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD division is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDEqual< T1, T2, typename >
 Availability of a SIMD equality comparison for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD equality comparison exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD equality comparison is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDErf< T >
 Availability of a SIMD error function (erf) operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD error function (erf) operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDErfc< T >
 Availability of a SIMD complementary error function (erfc) operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD complementary error function (erfc) operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDExp< T >
 Availability of a SIMD exp() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDExp10< T >
 Availability of a SIMD exp10() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp10() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDExp2< T >
 Availability of a SIMD exp2() operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD exp2() operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDFloor< T >
 Availability of a SIMD floor operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD floor operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDHypot< T1, T2 >
 Availability of a SIMD hypotenous operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hypotenous operation exists for the given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDInvCbrt< T >
 Availability of a SIMD inverse cubic root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse cubic root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDInvSqrt< T >
 Availability of a SIMD inverse square root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD inverse square root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDLog< T >
 Availability of a SIMD natural logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD natural logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDLog10< T >
 Availability of a SIMD common logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD common logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDLog2< T >
 Availability of a SIMD binary logarithm operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD binary logarithm operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDMax< T1, T2, typename >
 Availability of a SIMD max operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD max operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDMin< T1, T2, typename >
 Availability of a SIMD min operation for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), and the used compiler, this type trait provides the information whether a SIMD min operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDMult< T1, T2, typename >
 Availability of a SIMD multiplication for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD multiplication operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD multiplication is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDPow< T1, T2 >
 Availability of a SIMD power operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD power operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDRound< T >
 Availability of a SIMD round operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD round operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDSign< T >
 Availability of a SIMD sign operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD sign operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDSin< T >
 Availability of a SIMD sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDSinh< T >
 Availability of a SIMD hyperbolic sine operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic sine operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDSqrt< T >
 Availability of a SIMD square root operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD square root operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDSub< T1, T2, typename >
 Availability of a SIMD subtraction for the given data types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD subtraction operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD subtraction is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that AVX is available: More...
 
struct  blaze::HasSIMDTan< T >
 Availability of a SIMD tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDTanh< T >
 Availability of a SIMD hyperbolic tangent operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD hyperbolic tangent operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSIMDTrunc< T >
 Availability of a SIMD trunc operation for the given data type.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...) and the used compiler, this type trait provides the information whether a SIMD trunc operation exists for the given data type T (ignoring the cv-qualifiers). In case the SIMD operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example assumes that the Intel SVML is available: More...
 
struct  blaze::HasSin< T, typename >
 Availability of the sin() operation for the given data types.This type trait provides the information whether the sin() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasSinh< T, typename >
 Availability of the sinh() operation for the given data types.This type trait provides the information whether the sinh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasSqrt< T, typename >
 Availability of the sqrt() operation for the given data types.This type trait provides the information whether the sqrt() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasSub< T1, T2, typename >
 Availability of a subtraction operator for the given data types.This type trait provides the information whether a subtraction operator (i.e. operator+) exists for the two given data types T1 and T2 (taking the cv-qualifiers into account). In case the operator is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasTan< T, typename >
 Availability of the tan() operation for the given data types.This type trait provides the information whether the tan() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasTanh< T, typename >
 Availability of the tanh() operation for the given data types.This type trait provides the information whether the tanh() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::HasTrunc< T, typename >
 Availability of the trunc() operation for the given data types.This type trait provides the information whether the trunc() operation exists for the given data type T (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsAdaptor< T >
 Compile time check for adaptors.This type trait tests whether the given template parameter is an adaptor type (for instance LowerMatrix, UpperMatrix, or SymmetricMatrix). In case the type is an adaptor type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. The following example demonstrates this by means of the mentioned matrix adaptors: More...
 
struct  blaze::IsAddExpr< T >
 Compile time check whether the given type is an addition expression template.This type trait class tests whether or not the given type Type is an addition expression template (i.e. an expression representing a vector addition or a matrix addition). In order to qualify as a valid addition expression template, the given type has to derive publicly from the AddExpr base class. In case the given type is a valid addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsAligned< T >
 Compile time check for the alignment of data types.This type trait tests whether the given data type guarantees to provide aligned data values with respect to the requirements of the available instruction set. For instance, vectorizable data types such as built-in and complex data types are required to be 16-bit aligned for SSE, 32-bit aligned for AVX, and 64-bit aligned for MIC. In case the data type is properly aligned, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsBand< T >
 Compile time check for bands.This type trait tests whether or not the given template parameter is a band (i.e. dense or sparse band). In case the type is a band, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsBinaryMapExpr< T >
 Compile time check whether the given type is a binary map expression template.This type trait class tests whether or not the given type Type is a binary map expression template. In order to qualify as a valid binary map expression template, the given type has to derive publicly from the BinaryMapExpr base class. In case the given type is a valid binary map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsBLASCompatible< T >
 Compile time check for data types.This type trait tests whether or not the given template parameter is a data type compatible to the BLAS standard. The BLAS standard supports float, double, complex<float> and complex<double> values. If the type is BLAS compatible, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsColumn< T >
 Compile time check for columns.This type trait tests whether or not the given template parameter is a column (i.e. dense or sparse column). In case the type is a column, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsColumnMajorMatrix< T >
 Compile time check for column-major matrix types.This type trait tests whether or not the given template argument is a column-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a column-major matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsColumns< T >
 Compile time check for column selections.This type trait tests whether or not the given template parameter is a column selection (i.e. a view on columns of a dense or sparse matrix). In case the type is a column selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsColumnVector< T >
 Compile time check for column vector types.This type trait tests whether or not the given template argument is a column dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::columnVector). In case the type is a column vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsCommutative< T1, T2, typename >
 Compile time check for the commutativity of data types.This type trait tests whether or not the two given data types T1 and T2 are commutative with respect to mathematical operations. If the types are commutative, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsComputation< T >
 Compile time check whether the given type is a computational expression template.This type trait class tests whether or not the given type Type is a computational expression template (i.e. a mathematical operation such as an addition, a subtraction, a multiplication, a division, an absolute value calculation, ...). In order to qualify as a valid computational expression template, the given type has to derive (publicly or privately) from the Computation base class. In case the given type is a valid computational expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsContiguous< T >
 Compile time check for the memory layout of data types.This type trait tests whether the given data type is array-like and all its elements lie contiguous in memory. In case the data type has contiguous elements, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsCrossExpr< T >
 Compile time check whether the given type is a cross product expression template.This type trait class tests whether or not the given type Type is a cross product expression template. In order to qualify as a valid cross product expression template, the given type has to derive publicly from the CrossExpr base class. In case the given type is a valid cross product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsCustom< T >
 Compile time check for custom data types.This type trait tests whether the given data type is a custom data type, i.e. a custom vector or a custom matrix. In case the data type a custom data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsDeclaration< T >
 Compile time check whether the given type is a declaration expression template.This type trait class tests whether the given type Type is a declaration expression template. In order to qualify as a valid declaration expression template, the given type has to derive publicly from the Declaration base class. In case the given type is a valid declaration expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDeclDiagExpr< T >
 Compile time check whether the given type is a decldiag expression template.This type trait class tests whether or not the given type Type is a decldiag expression template. In order to qualify as a valid decldiag expression template, the given type has to derive publicly from the DeclDiagExpr base class. In case the given type is a valid decldiag expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDeclExpr< T >
 Compile time check whether the given type is a declaration expression template.This type trait class tests whether or not the given type Type is a declaration expression template. In order to qualify as a valid declaration expression template, the given type has to derive publicly from the DeclExpr base class. In case the given type is a valid declaration expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDeclHermExpr< T >
 Compile time check whether the given type is a declherm expression template.This type trait class tests whether or not the given type Type is a declherm expression template. In order to qualify as a valid declherm expression template, the given type has to derive publicly from the DeclHermExpr base class. In case the given type is a valid declherm expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDeclLowExpr< T >
 Compile time check whether the given type is a decllow expression template.This type trait class tests whether or not the given type Type is a decllow expression template. In order to qualify as a valid decllow expression template, the given type has to derive publicly from the DeclLowExpr base class. In case the given type is a valid decllow expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDeclSymExpr< T >
 Compile time check whether the given type is a declsym expression template.This type trait class tests whether or not the given type Type is a declsym expression template. In order to qualify as a valid declsym expression template, the given type has to derive publicly from the DeclSymExpr base class. In case the given type is a valid declsym expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDeclUppExpr< T >
 Compile time check whether the given type is a declupp expression template.This type trait class tests whether or not the given type Type is a declupp expression template. In order to qualify as a valid declupp expression template, the given type has to derive publicly from the DeclUppExpr base class. In case the given type is a valid declupp expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDenseMatrix< T >
 Compile time check for dense matrix types.This type trait tests whether or not the given template parameter is a dense, N-dimensional matrix type. In case the type is a dense matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDenseVector< T >
 Compile time check for dense vector types.This type trait tests whether or not the given template parameter is a dense, N-dimensional vector type. In case the type is a dense vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDiagonal< T >
 Compile time check for diagonal matrices.This type trait tests whether or not the given template parameter is a diagonal matrix type (i.e. a matrix type that is guaranteed to be diagonal at compile time). In case the type is a diagonal matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDivExpr< T >
 Compile time check whether the given type is a division expression template.This type trait class tests whether or not the given type Type is a division expression template (i.e. an expression representing a vector/scalar division or a matrix/scalar division). In order to qualify as a valid division expression template, the given type has to derive publicly from the DivExpr base class. In case the given type is a valid division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsElements< T >
 Compile time check for element selections.This type trait tests whether or not the given template parameter is an element selection (i.e. a view on elements of a dense or sparse vector). In case the type is an element selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsEvalExpr< T >
 Compile time check whether the given type is an evaluation expression template.This type trait class tests whether or not the given type Type is an evaluation expression template. In order to qualify as a valid evaluation expression template, the given type has to derive publicly from the EvalExpr base class. In case the given type is a valid evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsExpandExpr< T >
 Compile time check whether the given type is an expansion expression template.This type trait class tests whether or not the given type Type is an expansion expression template. In order to qualify as a valid expansion expression template, the given type has to derive publicly from the ExpandExpr base class. In case the given type is a valid expansion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsExpression< T >
 Compile time check whether the given type is an expression template.This type trait class tests whether or not the given type Type is a Blaze expression template. In order to qualify as a valid expression template, the given type has to derive publicly from the Expression base class. In case the given type is a valid expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsGeneral< T >
 Compile time check for general matrices.This type trait tests whether or not the given template parameter is a general matrix type (i.e. a matrix type that is neither symmetric, Hermitian, lower triangular or upper triangular at compile time). In case the type is a general matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsHermitian< T >
 Compile time check for Hermitian matrices.This type trait tests whether or not the given template parameter is an Hermitian matrix type (i.e. a matrix type that is guaranteed to be Hermitian at compile time). In case the type is a Hermitian matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsIdentity< T >
 Compile time check for identity matrices.This type trait tests whether or not the given template parameter is an identity matrix type (i.e. a matrix type that is guaranteed to be an identity matrix at compile time). In case the type is an identity matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsInitializer< T >
 Compile time check for custom data types.This type trait tests whether the given data type represents an initializer list, i.e. is an initializer vector or an initializer matrix. In case the data type represents an initializer list, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsInvertible< T >
 Compile time check for data types.This type trait tests whether or not the given template parameter is invertible. The type is considered to be invertible if it is either BLAS compatible (i.e. float, double, complex<float>, or complex<double>), long double, complex<long double> or any dense matrix type with a BLAS compatible element type. If the given type is invertible, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsLower< T >
 Compile time check for lower triangular matrices.This type trait tests whether or not the given template parameter is a lower triangular matrix type (i.e. a matrix type that is guaranteed to be lower triangular at compile time). This also includes lower unitriangular and strictly lower triangular matrices. In case the type is a lower triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatEvalExpr< T >
 Compile time check whether the given type is a matrix evaluation expression template.This type trait class tests whether or not the given type Type is a matrix evaluation expression template. In order to qualify as a valid matrix evaluation expression template, the given type has to derive publicly from the MatEvalExpr base class. In case the given type is a valid matrix evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatInvExpr< T >
 Compile time check whether the given type is a matrix inversion expression template.This type trait class tests whether or not the given type Type is a matrix inversion expression template. In order to qualify as a valid matrix inversion expression template, the given type has to derive publicly from the MatInvExpr base class. In case the given type is a valid matrix inversion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatMapExpr< T >
 Compile time check whether the given type is a unary matrix map expression template.This type trait class tests whether or not the given type Type is a unary matrix map expression template. In order to qualify as a valid unary matrix map expression template, the given type has to derive publicly from the MatMapExpr base class. In case the given type is a valid unary matrix map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatMatAddExpr< T >
 Compile time check whether the given type is a matrix/matrix addition expression template.This type trait class tests whether or not the given type Type is a matrix/matrix addition expression template. In order to qualify as a valid matrix addition expression template, the given type has to derive publicly from the MatMatAddExpr base class. In case the given type is a valid matrix addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatMatMapExpr< T >
 Compile time check whether the given type is a binary matrix map expression template.This type trait class tests whether or not the given type Type is a binary matrix map expression template. In order to qualify as a valid binary matrix map expression template, the given type has to derive publicly from the MatMatMapExpr base class. In case the given type is a valid binary matrix map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatMatMultExpr< T >
 Compile time check whether the given type is a matrix/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/matrix multiplication expression template. In order to qualify as a valid matrix multiplication expression template, the given type has to derive publicly from the MatMatMultExpr base class. In case the given type is a valid matrix multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatMatSubExpr< T >
 Compile time check whether the given type is a matrix/matrix subtraction expression template.This type trait class tests whether or not the given type Type is a matrix/matrix subtraction expression template. In order to qualify as a valid matrix subtraction expression template, the given type has to derive publicly from the MatMatSubExpr base class. In case the given type is a valid matrix subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatReduceExpr< T >
 Compile time check whether the given type is a reduction expression template.This type trait class tests whether or not the given type Type is a matrix reduction expression template. In order to qualify as a valid matrix reduction expression template, the given type has to derive publicly from the MatReduceExpr base class. In case the given type is a valid reduction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatrix< T >
 Compile time check for matrix types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse matrix type. In case the type is a matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatScalarDivExpr< T >
 Compile time check whether the given type is a matrix/scalar division expression template.This type trait class tests whether or not the given type Type is a matrix/scalar division expression template. In order to qualify as a valid matrix/scalar division expression template, the given type has to derive publicly from the MatScalarDivExpr base class. In case the given type is a valid matrix/scalar division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatScalarMultExpr< T >
 Compile time check whether the given type is a matrix/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/scalar multiplication expression template. In order to qualify as a valid matrix/scalar multiplication expression template, the given type has to derive publicly from the MatScalarMultExpr base class. In case the given type is a valid matrix/scalar multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatSerialExpr< T >
 Compile time check whether the given type is a matrix serial evaluation expression template.This type trait class tests whether or not the given type Type is a matrix serial evaluation expression template. In order to qualify as a valid matrix serial evaluation expression template, the given type has to derive publicly from the MatSerialExpr base class. In case the given type is a valid matrix serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatTransExpr< T >
 Compile time check whether the given type is a matrix transposition expression template.This type trait class tests whether or not the given type Type is a matrix transposition expression template. In order to qualify as a valid matrix transposition expression template, the given type has to derive publicly from the MatTransExpr base class. In case the given type is a valid matrix transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMatVecMultExpr< T >
 Compile time check whether the given type is a matrix/vector multiplication expression template.This type trait class tests whether or not the given type Type is a matrix/vector multiplication expression template. In order to qualify as a valid matrix/vector multiplication expression template, the given type has to derive publicly from the MatVecMultExpr base class. In case the given type is a valid matrix/vector multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsMultExpr< T >
 Compile time check whether the given type is a multiplication expression template.This type trait class tests whether or not the given type Type is a multiplication expression template (i.e. an expression representing an element-wise vector multiplication, a matrix/vector multiplication, a vector/matrix multiplication, or a matrix multiplication). In order to qualify as a valid multiplication expression template, the given type has to derive publicly from the MultExpr base class. In case the given type is a valid multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsNumericMatrix< T >
 Compile time check for numeric matrix types.This type trait tests whether or not the given template parameter is a numeric matrix type, i.e. a matrix with numeric element type. In case the type is a numeric matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsNumericVector< T >
 Compile time check for numeric vector types.This type trait tests whether or not the given template parameter is a numeric vector type, i.e. a vector with numeric element type. In case the type is a numeric vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsOperation< T >
 Compile time check whether the given type is an operational expression template.This type trait class tests whether or not the given type Type is either a transformation or a computational expression template. In order to qualify as a valid operational expression template, the given type has to derive (publicly or privately) from the Operation base class. In case the given type is a valid operational expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsOpposedView< T >
 Compile time check for resizable data types.This type trait tests whether the given data type is an opposed view, i.e. a view that is opposed to the natural storage order of its underlying type. In case the data type is an opposed view, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsPadded< T >
 Compile time check for data types with padding.This type trait tests whether the given data type employs or simulates padding such that no special treatment of remainder elements is necessary for vectorized operations on the type. In case the data type is padded, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsPaddingEnabled< T >
 Compile time check for data types.This type trait queries the nested paddingEnabled member of the given data type T, which indicates whether the type provides support for padding (i.e. can properly deal with zeros). If the type is supporting padding, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsProxy< T >
 Compile time check for proxy types.This type trait tests whether or not the given template parameter is a proxy type (i.e. publicly derived from the blaze::Proxy class template). In case the type is a proxy, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsReduceExpr< T >
 Compile time check whether the given type is a reduction expression template.This type trait class tests whether or not the given type Type is a reduction expression template. In order to qualify as a valid reduction expression template, the given type has to derive publicly from the ReduceExpr base class. In case the given type is a valid reduction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsResizable< T >
 Compile time check for resizable data types.This type trait tests whether the given data type is a resizable data type. In case the data type can be resized (via the resize() function), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsRestricted< T >
 Compile time check for data types with restricted data access.This type trait tests whether the given data type has a restricted data access. Examples are the LowerMatrix and UpperMatrix adaptors that don't allow write access to the elements in the upper or lower part of the matrix, respectively. In case the data type has a restricted data access, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsRow< T >
 Compile time check for rows.This type trait tests whether or not the given template parameter is a row (i.e. a view on a row of a dense or sparse matrix). In case the type is a row, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsRowMajorMatrix< T >
 Compile time check for row-major matrix types.This type trait tests whether or not the given template argument is a row-major dense or sparse matrix type (i.e., a matrix whose storage order is set to true). In case the type is a row-major matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsRows< T >
 Compile time check for row selections.This type trait tests whether or not the given template parameter is a row selection (i.e. a view on rows of a dense or sparse matrix). In case the type is a row selection, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsRowVector< T >
 Compile time check for row vector types.This type trait tests whether or not the given template argument is a row dense or sparse vector type (i.e. a vector whose transposition flag is set to blaze::rowVector). In case the type is a row vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSchurExpr< T >
 Compile time check whether the given type is a Schur product expression template.This type trait class tests whether or not the given type Type is a Schur product expression template. In order to qualify as a valid Schur product expression template, the given type has to derive publicly from the SchurExpr base class. In case the given type is a valid Schur product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSerialExpr< T >
 Compile time check whether the given type is a serial evaluation expression template.This type trait class tests whether or not the given type Type is a serial evaluation expression template. In order to qualify as a valid serial evaluation expression template, the given type has to derive publicly from the SerialExpr base class. In case the given type is a valid serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsShrinkable< T >
 Compile time check for shrinkable data types.This type trait tests whether the given data type is a shrinkable data type. In case the data type can be shrunk (via the shrinkToFit() function), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsSIMDCombinable< T1, T2, Ts >
 Compile time check for data types.This type trait tests whether or not the given types can be combined in the context of SIMD operations. By default, all numeric data types are considered combinable to themselves. Also, different integral types of the same size can be combined. If the types are determined to be SIMD combinable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSIMDEnabled< T, Args >
 Compile time check for data types.This type trait tests whether or not the given data type T is a SIMD-enabled data type (i.e. provides the according SIMD-related member functions, such as load(), store(), etc). If the type is SIMD-enabled, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSIMDPack< T >
 Compile time check for SIMD data types.This type trait tests whether the given data type is a Blaze SIMD packed data type. The following types are considered valid SIMD packed types: More...
 
struct  blaze::IsSMPAssignable< T >
 Compile time check for data types.This type trait tests whether or not the given template parameter is an SMP-assignable data type (i.e. if it is a data type that can possibly and efficiently be assigned by several threads). In this context, built-in data types as well as complex numbers are non-SMP-assignable, whereas several vector and matrix types (as for instance DynamicVector and DynamicMatrix) can be SMP-assignable. If the type is SMP-assignable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSparseElement< T >
 Compile time check whether the given type is a sparse element type.This type trait class tests whether or not the given type Type is a Blaze sparse element type, i.e. if the type implements the sparse element concept by providing a value() and an index() member function. In order to qualify as a valid sparse element type, the given type has to derive (publicly or privately) from the SparseElement base class. In case the given type is a valid sparse element, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSparseMatrix< T >
 Compile time check for sparse matrix types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional matrix type. In case the type is a sparse matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSparseVector< T >
 Compile time check for sparse vector types.This type trait tests whether or not the given template parameter is a sparse, N-dimensional vector type. In case the type is a sparse vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSquare< T >
 Compile time check for square matrices.This type trait tests whether or not the given template parameter is a square matrix type (i.e. a matrix type that is guaranteed to be square at compile time). In case the type is a square matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsStatic< T >
 Compile time check for static data types.This type trait tests whether the given data type is a static data type, i.e. a vector or matrix with dimensions fixed at compile time. In case the data type a static data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. Examples: More...
 
struct  blaze::IsStrictlyLower< T >
 Compile time check for strictly lower triangular matrices.This type trait tests whether or not the given template parameter is a strictly lower triangular matrix type (i.e. a matrix type that is guaranteed to be strictly lower triangular at compile time). In case the type is a strictly lower triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsStrictlyTriangular< T >
 Compile time check for strictly triangular matrix types.This type trait tests whether or not the given template parameter is a strictly lower or upper triangular matrix type. In case the type is a triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsStrictlyUpper< T >
 Compile time check for strictly upper triangular matrices.This type trait tests whether or not the given template parameter is a strictly upper triangular matrix type (i.e. a matrix type that is guaranteed to be strictly upper triangular at compile time). In case the type is a strictly upper triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSubExpr< T >
 Compile time check whether the given type is a subtraction expression template.This type trait class tests whether or not the given type Type is a subtraction expression template (i.e. an expression representing a vector subtraction or a matrix subtraction). In order to qualify as a valid subtraction expression template, the given type has to derive publicly from the SubExpr base class. In case the given type is a valid subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSubmatrix< T >
 Compile time check for submatrices.This type trait tests whether or not the given template parameter is a submatrix (i.e. a view on the part of a dense or sparse matrix). In case the type is a submatrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSubvector< T >
 Compile time check for subvectors.This type trait tests whether or not the given template parameter is a subvector (i.e. a view on the part of a dense or sparse vector). In case the type is a subvector, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSymmetric< T >
 Compile time check for symmetric matrices.This type trait tests whether or not the given template parameter is a symmetric matrix type (i.e. a matrix type that is guaranteed to be symmetric at compile time). In case the type is a symmetric matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsTemporary< T >
 Compile time check whether the given type is a temporary vector or matrix type.This type trait class tests whether the given type is a temporary vector or matrix type, i.e. can be used for a temporary vector or matrix. In case the given type can be used as temporary, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsTransExpr< T >
 Compile time check whether the given type is a transposition expression template.This type trait class tests whether or not the given type Type is a transposition expression template (i.e. an expression representing a vector transposition or a matrix transposition). In order to qualify as a valid transposition expression template, the given type has to derive publicly from the TransExpr base class. In case the given type is a valid transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsTransformation< T >
 Compile time check whether the given type is a transformation expression template.This type trait class tests whether the given type Type is a transformation expression template (e.g. a transpose operation). In order to qualify as a valid transformation expression template, the given type has to derive (publicly or privately) from the Transformation base class. In case the given type is a valid transformation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsTriangular< T >
 Compile time check for triangular matrix types.This type trait tests whether or not the given template parameter is a lower or upper triangular matrix type. In case the type is a triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsTVecMatMultExpr< T >
 Compile time check whether the given type is a vector/matrix multiplication expression template.This type trait class tests whether or not the given type Type is a vector/matrix multiplication expression template. In order to qualify as a valid vector/matrix multiplication expression template, the given type has to derive publicly from the TVecMatMultExpr base class. In case the given type is a valid vector/matrix multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUnaryMapExpr< T >
 Compile time check whether the given type is a unary map expression template.This type trait class tests whether or not the given type Type is a unary map expression template. In order to qualify as a valid unary map expression template, the given type has to derive publicly from the UnaryMapExpr base class. In case the given type is a valid unary map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUniform< T >
 Compile time check for uniform vectors and matrices.This type trait tests whether or not the given template parameter is a uniform vector or matrix type (i.e. a data type that is guaranteed to be a uniform vector or matrix at compile time). In case the type is a uniform vector or matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUniLower< T >
 Compile time check for lower unitriangular matrices.This type trait tests whether or not the given template parameter is a lower unitriangular matrix type (i.e. a matrix type that is guaranteed to be lower unitriangular at compile time). In case the type is a lower unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUniTriangular< T >
 Compile time check for unitriangular matrix types.This type trait tests whether or not the given template parameter is a lower or upper unitriangular matrix type. In case the type is an unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise yes is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUniUpper< T >
 Compile time check for upper unitriangular matrices.This type trait tests whether or not the given template parameter is an upper unitriangular matrix type (i.e. a matrix type that is guaranteed to be upper unitriangular at compile time). In case the type is an upper unitriangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUpper< T >
 Compile time check for upper triangular matrices.This type trait tests whether or not the given template parameter is an upper triangular matrix type (i.e. a matrix type that is guaranteed to be upper triangular at compile time). This also includes upper unitriangular and strictly upper triangular matrices. In case the type is an upper triangular matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecEvalExpr< T >
 Compile time check whether the given type is a vector evaluation expression template.This type trait class tests whether or not the given type Type is a vector evaluation expression template. In order to qualify as a valid vector evaluation expression template, the given type has to derive publicly from the VecEvalExpr base class. In case the given type is a valid vector evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecExpandExpr< T >
 Compile time check whether the given type is a vector expansion expression template.This type trait class tests whether or not the given type Type is a vector expansion expression template. In order to qualify as a valid vector expansion expression template, the given type has to derive publicly from the VecExpandExpr base class. In case the given type is a valid expansion expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecMapExpr< T >
 Compile time check whether the given type is a unary vector map expression template.This type trait class tests whether or not the given type Type is a unary vector map expression template. In order to qualify as a valid unary vector map expression template, the given type has to derive publicly from the VecMapExpr base class. In case the given type is a valid unary vector map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecScalarDivExpr< T >
 Compile time check whether the given type is a vector/scalar division expression template.This type trait class tests whether or not the given type Type is a vector/scalar division expression template. In order to qualify as a valid vector/scalar division expression template, the given type has to derive publicly from the VecScalarDivExpr base class. In case the given type is a valid vector/scalar division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecScalarMultExpr< T >
 Compile time check whether the given type is a vector/scalar multiplication expression template.This type trait class tests whether or not the given type Type is a vector/scalar multiplication expression template. In order to qualify as a valid vector/scalar multiplication expression template, the given type has to derive publicly from the VecScalarMultExpr base class. In case the given type is a valid vector/scalar multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecSerialExpr< T >
 Compile time check whether the given type is a vector serial evaluation expression template.This type trait class tests whether or not the given type Type is a vector serial evaluation expression template. In order to qualify as a valid vector serial evaluation expression template, the given type has to derive publicly from the VecSerialExpr base class. In case the given type is a valid vector serial evaluation expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVector< T >
 Compile time check for vector types.This type trait tests whether or not the given template parameter is a N-dimensional dense or sparse vector type (i.e. whether T is derived from the Vector base class). In case the type is a vector type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecTransExpr< T >
 Compile time check whether the given type is a vector transposition expression template.This type trait class tests whether or not the given type Type is a vector transposition expression template. In order to qualify as a valid vector transposition expression template, the given type has to derive publicly from the VecTransExpr base class. In case the given type is a valid vector transposition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecTVecMultExpr< T >
 Compile time check whether the given type is an outer product expression template.This type trait class tests whether or not the given type Type is an outer product expression template (i.e. an expression representing the multiplication between a column vector and a row vector). In order to qualify as a valid outer product expression template, the given type has to derive publicly from the VecTVecMultExpr base class. In case the given type is a valid outer product expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecVecAddExpr< T >
 Compile time check whether the given type is a vector/vector addition expression template.This type trait class tests whether or not the given type Type is a vector/vector addition expression template. In order to qualify as a valid vector addition expression template, the given type has to derive publicly from the VecVecAddExpr base class. In case the given type is a valid vector addition expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecVecDivExpr< T >
 Compile time check whether the given type is a vector/vector division expression template.This type trait class tests whether or not the given type Type is a vector/vector division expression template. In order to qualify as a valid vector division expression template, the given type has to derive publicly from the VecVecDivExpr base class. In case the given type is a valid vector division expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecVecMapExpr< T >
 Compile time check whether the given type is a binary vector map expression template.This type trait class tests whether or not the given type Type is a binary vector map expression template. In order to qualify as a valid binary vector map expression template, the given type has to derive publicly from the VecVecMapExpr base class. In case the given type is a valid binary vector map expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecVecMultExpr< T >
 Compile time check whether the given type is a vector/vector multiplication expression template.This type trait class tests whether or not the given type Type is a vector/vector multiplication expression template. In order to qualify as a valid vector multiplication expression template, the given type has to derive publicly from the VecVecMultExpr base class. In case the given type is a valid vector multiplication expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVecVecSubExpr< T >
 Compile time check whether the given type is a vector/vector subtraction expression template.This type trait class tests whether or not the given type Type is a vector/vector subtraction expression template. In order to qualify as a valid vector subtraction expression template, the given type has to derive publicly from the VecVecSubExpr base class. In case the given type is a valid vector subtraction expression template, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsView< T >
 Compile time check for views.This type trait tests whether or not the given template parameter is a view (i.e. subvector, submatrix, row, column, ...). In case the type is a view, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsZero< T >
 Compile time check for zero vectors or matrices.This type trait tests whether or not the given template parameter is a zero vector or matrix type (i.e. a vector or matrix type that is guaranteed to be zero at compile time). In case the type is a zero vector or matrix type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::MaxSize< T, N >
 Compile time evaluation of the maximum size of vectors and matrices.The MaxSize type trait evaluates the maximum size of a particular dimension of the given vector or matrix type at compile time. In case the given type T is a vector or matrix type with a fixed maximum size (e.g. StaticVector, HybridVector, StaticMatrix, or HybridMatrix) and N is a valid dimension, the value member constant is set to the according size. In all other cases, value is set to -1. More...
 
struct  blaze::RemoveAdaptor< T >
 Removal of top level adaptor types.In case the given type is an adaptor type (SymmetricMatrix, LowerMatrix, UpperMatrix, ...), the RemoveAdaptor type trait removes the adaptor and extracts the contained general matrix type. Else the given type is returned as is. Note that cv-qualifiers are preserved. More...
 
struct  blaze::RequiresEvaluation< T >
 Compile time check to query the requirement to evaluate an expression.Via this type trait it is possible to determine whether a given vector or matrix expression type requires an intermediate evaluation in the context of a compound expression. In case the given type requires an evaluation, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Size< T, N >
 Compile time evaluation of the size of vectors and matrices.The Size type trait evaluates the size of a particular dimension of the given vector or matrix type at compile time. In case the given type T is a vector or matrix type with a fixed size (e.g. StaticVector or StaticMatrix) and N is a valid dimension, the value member constant is set to the according size. In all other cases, value is set to -1. More...
 
struct  blaze::StorageOrder< T >
 Evaluation of the storage order of a given matrix type.Via this type trait it is possible to evaluate the storage order of a given matrix type. In case the given type is a row-major matrix type the nested boolean value is set to rowMajor, in case it is a column-major matrix type it is set to columnMajor. If the given type is not a matrix type a compilation error is created. More...
 
struct  blaze::TransposeFlag< T >
 Evaluation of the transpose flag of a given matrix type.Via this type trait it is possible to evaluate the transpose flag of a given vector type. In case the given type is a row vector type the nested boolean value is set to rowVector, in case it is a column vector type it is set to columnVector. If the given type is not a vector type a compilation error is created. More...
 
struct  blaze::UnderlyingBuiltin< T >
 Evaluation of the underlying builtin element type of a given data type.Via this type trait it is possible to evaluate the underlying fundamental element type at the heart of a given data type. Examples: More...
 
struct  blaze::UnderlyingElement< T >
 Evaluation of the element type of a given data type.Via this type trait it is possible to evaluate the element type of a given data type. Examples: More...
 
struct  blaze::UnderlyingNumeric< T >
 Evaluation of the underlying numeric element type of a given data type.Via this type trait it is possible to evaluate the underlying numeric (fundamental or complex) element type at the heart of a given data type. Examples: More...
 
struct  blaze::YieldsDiagonal< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a diagonal matrix when applied to several matrices of types MT and MTs. In case the operation yields a diagonal matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsHermitian< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a Hermitian matrix when applied to several matrices of types MT and MTs. In case the operation yields a Hermitian matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsIdentity< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an identity matrix when applied to several matrices of types MT and MTs. In case the operation yields an identity matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsLower< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower matrix when applied to several matrices of types MT and MTs. In case the operation yields a lower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsStrictlyLower< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a strictly lower matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly lower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsStrictlyTriangular< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper strictly triangular matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly triangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsStrictlyUpper< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a strictly upper matrix when applied to several matrices of types MT and MTs. In case the operation yields a strictly upper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsSymmetric< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a symmetric matrix when applied to several matrices of types MT and MTs. In case the operation yields a symmetric matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsTriangular< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper triangular matrix when applied to several matrices of types MT and MTs. In case the operation yields a triangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsUniform< OP, T, Ts >
 Compile time check for operations on vectors and matrices.This type trait tests whether or not the given operation OP yields a uniform vector or matrix when applied to several vectors or matrices of types T and Ts. In case the operation yields a uniform vector or matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsUniLower< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an unilower matrix when applied to several matrices of types MT and MTs. In case the operation yields an unilower matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsUniTriangular< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields a lower or upper unitriangular matrix when applied to several matrices of types MT and MTs. In case the operation yields an unitriangular matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsUniUpper< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an uniupper matrix when applied to several matrices of types MT and MTs. In case the operation yields an uniupper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsUpper< OP, MT, MTs >
 Compile time check for operations on matrices.This type trait tests whether or not the given operation OP yields an upper matrix when applied to several matrices of types MT and MTs. In case the operation yields an upper matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::YieldsZero< OP, T, Ts >
 Compile time check for operations on vectors and matrices.This type trait tests whether or not the given operation OP yields a zero vector or zero matrix when applied to several vectors or matrices of types T and Ts. In case the operation yields a zero vector or matrix, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 

Macros

#define BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT(TYPE_TRAIT_NAME, MEMBER_NAME, FALLBACK_TYPE)
 Macro for the creation of a type trait to acquire member types.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine a specified member type of a given type. The first macro parameter TYPE_TRAIT_NAME specifies the resulting name of the type trait. The second parameter MEMBER_NAME specifies the name of the member type to be acquired and the third parameter FALLBACK_TYPE specifies the type to acquire in case the given type doesn't contain the specified member type. The following example demonstrates the use of the macro and the resulting type trait: More...
 
#define BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT(TYPE_TRAIT_NAME, MEMBER_NAME)
 Macro for the creation of a type trait for compile time checks for member data and functions.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine whether the specified element MEMBER_NAME is a data or function member of a given type. The following example demonstrates the use of the macro and the resulting type trait: More...
 
#define BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT(TYPE_TRAIT_NAME, MEMBER_NAME)
 Macro for the creation of a type trait for compile time checks for member types.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine whether the specified element MEMBER_NAME is a type member of a given type. The following example demonstrates the use of the macro and the resulting type trait: More...
 
#define BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT(TYPE_TRAIT_NAME, MEMBER_NAME)
 Macro for the creation of a type trait for compile time checks for members.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine whether the specified element MEMBER_NAME is a data, function, or type member of a given type. The following example demonstrates the use of the macro and the resulting type trait: More...
 

Typedefs

using blaze::DefaultMaxSize = PtrdiffT< DefaultMaxSize_v >
 Type representation of the default size of the MaxSize type trait.
 
using blaze::DefaultSize = PtrdiffT< DefaultSize_v >
 Type representation of the default size of the Size type trait.
 

Functions

 blaze::BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT (HasLoad, load)
 Compile time check for data types.This type trait provides the information whether the given data type T provides a load() operation (taking the cv-qualifiers into account). In case the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.
 

Variables

constexpr ptrdiff_t blaze::DefaultMaxSize_v = -1L
 Default size of the MaxSize type trait.
 
constexpr ptrdiff_t blaze::DefaultSize_v = -1L
 Default size of the Size type trait.
 

Detailed Description

Macro Definition Documentation

◆ BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT

#define BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT (   TYPE_TRAIT_NAME,
  MEMBER_NAME,
  FALLBACK_TYPE 
)
Value:
\
template< typename Type1233, typename = void > \
struct TYPE_TRAIT_NAME \
{ \
using Type = FALLBACK_TYPE; \
}; \
\
template< typename Type1233 > \
struct TYPE_TRAIT_NAME< Type1233, blaze::Void_t< typename Type1233::MEMBER_NAME > > \
{ \
using Type = typename Type1233::MEMBER_NAME; \
}; \
\
template< typename Type1233 > \
using TYPE_TRAIT_NAME##_t = typename TYPE_TRAIT_NAME<Type1233>::Type

Macro for the creation of a type trait to acquire member types.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine a specified member type of a given type. The first macro parameter TYPE_TRAIT_NAME specifies the resulting name of the type trait. The second parameter MEMBER_NAME specifies the name of the member type to be acquired and the third parameter FALLBACK_TYPE specifies the type to acquire in case the given type doesn't contain the specified member type. The following example demonstrates the use of the macro and the resulting type trait:

struct MyType1 {
using ElementType = float;
};
struct MyType2 {
using ElementType = double;
};
struct MyType3 {};
GetElementType<MyType1>::Type // Results in 'float'
GetElementType<MyType2>::Type // Results in 'double'
GetElementType<MyType3>::Type // Results in 'int'

The macro results in the definition of a new class with the specified name TYPE_TRAIT_NAME and an associated alias template called TYPE_TRAIT_NAME_t within the current namespace. This may cause name collisions with any other entity called TYPE_TRAIT_NAME in the same namespace. Therefore it is advisable to create the type trait as locally as possible to minimize the probability of name collisions. Note however that the macro cannot be used within function scope since a template declaration cannot appear at block scope.

◆ BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT

#define BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT (   TYPE_TRAIT_NAME,
  MEMBER_NAME 
)

Macro for the creation of a type trait for compile time checks for member data and functions.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine whether the specified element MEMBER_NAME is a data or function member of a given type. The following example demonstrates the use of the macro and the resulting type trait:

class MyType {
public:
void publicCompute();
private:
void privateCompute();
int value_;
};
BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT( HasPublicCompute , publicCompute );
BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT( HasPrivateCompute, privateCompute );
HasPublicCompute<MyType>::value // Evaluates to 'true'
HasPrivateCompute<MyType>::Type // Results in TrueType
HasValue<MyType> // Is derived from TrueType
HasEvaluate<MyType>::value // Evaluates to 'false'
HasDetermine<MyType>::Type // Results in FalseType
HasData<MyType> // Is derived from FalseType

The macro results in the definition of a new class with the specified name TYPE_TRAIT_NAME and an associated variable template called TYPE_TRAIT_NAME_v within the current namespace. This may cause name collisions with any other entity called TYPE_TRAIT_NAME in the same namespace. Therefore it is advisable to create the type trait as locally as possible to minimize the probability of name collisions. Note however that the macro cannot be used within function scope since a template declaration cannot appear at block scope.

◆ BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT

#define BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT (   TYPE_TRAIT_NAME,
  MEMBER_NAME 
)
Value:
\
template< typename Type1232 > \
struct TYPE_TRAIT_NAME##HELPER \
{ \
private: \
BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT( LOCAL_TYPE_TRAIT_1, MEMBER_NAME ); \
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( LOCAL_TYPE_TRAIT_2, MEMBER_NAME ); \
\
public: \
static constexpr bool value = ( LOCAL_TYPE_TRAIT_1<Type1232>::value || \
LOCAL_TYPE_TRAIT_2<Type1232>::value ); \
}; \
\
template< typename Type1232 > \
struct TYPE_TRAIT_NAME \
{}; \
\
template< typename Type1232 > \
static constexpr bool TYPE_TRAIT_NAME##_v = TYPE_TRAIT_NAME<Type1232>::value
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71

Macro for the creation of a type trait for compile time checks for members.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine whether the specified element MEMBER_NAME is a data, function, or type member of a given type. The following example demonstrates the use of the macro and the resulting type trait:

class MyType {
public:
void publicCompute();
protected:
using ProtectedType = float;
private:
int value_;
};
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasCompute , publicCompute );
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasProtectedType, ProtectedType );
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasPublicType, PublicType );
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasDetermine , determine );
HasCompute<MyType>::value // Evaluates to 'true'
HasProtectedType<MyType>::Type // Results in TrueType
HasValue<MyType> // Is derived from TrueType
HasPublicType<MyType>::value // Evaluates to 'false'
HasDetermine<MyType>::Type // Results in FalseType
HasData<MyType> // Is derived from FalseType

The macro results in the definition of a new class with the specified name TYPE_TRAIT_NAME and an associated variable template called TYPE_TRAIT_NAME_v within the current namespace. This may cause name collisions with any other entity called TYPE_TRAIT_NAME in the same namespace. Therefore it is advisable to create the type trait as locally as possible to minimize the probability of name collisions. Note however that the macro cannot be used within function scope since a template declaration cannot appear at block scope.

◆ BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT

#define BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT (   TYPE_TRAIT_NAME,
  MEMBER_NAME 
)
Value:
\
template < typename TYPE1231 > \
struct TYPE_TRAIT_NAME##HELPER \
{ \
private: \
struct Fallback { using MEMBER_NAME = int; }; \
\
struct Derived \
, Fallback \
{}; \
\
template < class U > \
static blaze::FalseType test( typename U::MEMBER_NAME* ); \
\
template < typename U > \
static blaze::TrueType test( U* ); \
\
public: \
using Type = decltype( test<Derived>( nullptr ) ); \
}; \
\
template< typename TYPE1231 > \
struct TYPE_TRAIT_NAME \
: public TYPE_TRAIT_NAME##HELPER<TYPE1231>::Type \
{}; \
\
template< typename TYPE1231 > \
static constexpr bool TYPE_TRAIT_NAME##_v = TYPE_TRAIT_NAME<TYPE1231>::value
Compile time type selection.The If class template selects one of the two given types T1 and T2 depend...
Definition: If.h:59
Generic wrapper for a compile time constant integral value.The IntegralConstant class template repres...
Definition: IntegralConstant.h:71
Empty data type for utility purposes.
Definition: EmptyType.h:45

Macro for the creation of a type trait for compile time checks for member types.This macro creates the definition of a type trait TYPE_TRAIT_NAME that can determine whether the specified element MEMBER_NAME is a type member of a given type. The following example demonstrates the use of the macro and the resulting type trait:

class MyType {
public:
using PublicType = int;
protected:
using ProtectedType = float;
private:
using PrivateType = double;
};
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasPublicType , PublicType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasProtectedType, ProtectedType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasPrivateType , PrivateType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasValueType , ValueType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasElementType, ElementTypeType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasDataType , DataType );
HasPublicType<MyType>::value // Evaluates to 'true'
HasProtectedType<MyType>::Type // Results in TrueType
HasPrivateType<MyType> // Is derived from TrueType
HasValueType<MyType>::value // Evaluates to 'false'
HasElementType<MyType>::Type // Results in FalseType
HasDataType<MyType> // Is derived from FalseType

The macro results in the definition of a new class with the specified name TYPE_TRAIT_NAME and an associated variable template called TYPE_TRAIT_NAME_v within the current namespace. This may cause name collisions with any other entity called TYPE_TRAIT_NAME in the same namespace. Therefore it is advisable to create the type trait as locally as possible to minimize the probability of name collisions. Note however that the macro cannot be used within function scope since a template declaration cannot appear at block scope.