![]() |
Blaze
3.6
|
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::HasSIMDBitand< T1, T2 > |
Availability of a SIMD bitwise AND ('&') 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 bitwise AND ('&') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise AND 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 AVX2 is available: More... | |
struct | blaze::HasSIMDBitor< T1, T2 > |
Availability of a SIMD bitwise OR ('|') 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 bitwise OR ('|') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise OR 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 AVX2 is available: More... | |
struct | blaze::HasSIMDBitxor< T1, T2 > |
Availability of a SIMD bitwise XOR ('^') 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 bitwise XOR ('^') operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD bitwise XOR 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 AVX2 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::HasSIMDShiftLI< T > |
Availability of a SIMD uniform left-shift 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 uniform left-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD uniform left-shift 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 AVX2 is available: More... | |
struct | blaze::HasSIMDShiftLV< T1, T2 > |
Availability of an SIMD elementwise left-shift 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 an SIMD elementwise left-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD elementwise left-shift 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 AVX2 is available: More... | |
struct | blaze::HasSIMDShiftRI< T > |
Availability of a SIMD uniform right-shift 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 uniform right-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD uniform right-shift 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 AVX2 is available: More... | |
struct | blaze::HasSIMDShiftRV< T1, T2 > |
Availability of a SIMD elementwise right-shift 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 an SIMD elementwise right-shift operation exists for the two given data types T1 and T2 (ignoring the cv-qualifiers). In case the SIMD elementwise right-shift 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 AVX2 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::IsCUDAAssignable< T > |
Compile time check for data types.This type trait tests whether or not the given template parameter is an CUDA-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 not considered CUDA-assignable, whereas several vector and matrix types (as for instance DynamicVector and DynamicMatrix) can be CUDA-assignable. If the type is CUDA-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::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::IsKronExpr< T > |
Compile time check whether the given type is a Kronecker product expression template.This type trait class tests whether or not the given type Type is a Kronecker product expression template. In order to qualify as a valid Kronecker product expression template, the given type has to derive publicly from the KronExpr base class. In case the given type is a valid Kronecker 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::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::IsMatMatKronExpr< T > |
Compile time check whether the given type is a matrix/matrix Kronecker product expression template.This type trait class tests whether or not the given type Type is a matrix/matrix Kronecker product expression template. In order to qualify as a valid matrix Kronecker product expression template, the given type has to derive publicly from the MatMatKronExpr base class. In case the given type is a valid matrix Kronecker 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::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::IsVecVecKronExpr< T > |
Compile time check whether the given type is a vector/vector Kronecker product expression template.This type trait class tests whether or not the given type Type is a vector/vector Kronecker product expression template. In order to qualify as a valid vector Kronecker product expression template, the given type has to derive publicly from the VecVecKronExpr base class. In case the given type is a valid vector Kronecker 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::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.This type trait evaluates the underlying fundamental element type at the heart of the given data type T. For this purpose either a nested ElementType or a nested value_type will be used. Examples: More... | |
struct | blaze::UnderlyingElement< T > |
Evaluation of the element type of a given data type.This type trait evaluates the underlying element type of the given data type T. If the given type provides a nested type ElementType, this type is reported as underlying element type type via the nested type Type. Else if the type provides a nested value_type, this type is reported as underlying element type. Else the given type itself reported as the underlying element type. Examples: More... | |
struct | blaze::UnderlyingNumeric< T > |
Evaluation of the underlying numeric element type of a given data type.This type trait evaluates the underlying numeric (fundamental or complex) element type at the heart of the given data type T. For this purpose either a nested ElementType or a nested value_type will be used. 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 | |
template<typename T1 , typename T2 > | |
using | blaze::HighType_t = typename HighType< T1, T2 >::Type |
Auxiliary alias declaration for the HighType type trait.The HighType_t alias declaration provides a convenient shortcut to access the nested Type of the HighType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
template<typename T1 , typename T2 > | |
using | blaze::LowType_t = typename LowType< T1, T2 >::Type |
Auxiliary alias declaration for the LowType type trait.The LowType_t alias declaration provides a convenient shortcut to access the nested Type of the LowType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More... | |
using | blaze::DefaultMaxSize = Ptrdiff_t< DefaultMaxSize_v > |
Type representation of the default size of the MaxSize type trait. | |
template<typename T > | |
using | blaze::RemoveAdaptor_t = typename RemoveAdaptor< T >::Type |
Auxiliary alias declaration for the RemoveAdaptor type trait.The RemoveAdaptor_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveAdaptor class template. For instance, given the type T the following two type definitions are identical: More... | |
using | blaze::DefaultSize = Ptrdiff_t< DefaultSize_v > |
Type representation of the default size of the Size type trait. | |
template<typename T > | |
using | blaze::UnderlyingBuiltin_t = typename UnderlyingBuiltin< T >::Type |
Auxiliary alias declaration for the UnderlyingBuiltin type trait.The UnderlyingBuiltin_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingBuiltin class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | blaze::UnderlyingElement_t = typename UnderlyingElement< T >::Type |
Auxiliary alias declaration for the UnderlyingElement type trait.The UnderlyingElement_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingElement class template. For instance, given the type T the following two type definitions are identical: More... | |
template<typename T > | |
using | blaze::UnderlyingNumeric_t = typename UnderlyingNumeric< T >::Type |
Auxiliary alias declaration for the UnderlyingNumeric type trait.The UnderlyingNumeric_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingNumeric class template. For instance, given the type T the following two type definitions are identical: More... | |
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 | |
template<typename T > | |
constexpr bool | blaze::HasAbs_v = HasAbs<T>::value |
Auxiliary variable template for the HasAbs type trait.The HasAbs_v variable template provides a convenient shortcut to access the nested value of the HasAbs class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasAcos_v = HasAcos<T>::value |
Auxiliary variable template for the HasAcos type trait.The HasAcos_v variable template provides a convenient shortcut to access the nested value of the HasAcos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasAcosh_v = HasAcosh<T>::value |
Auxiliary variable template for the HasAcosh type trait.The HasAcosh_v variable template provides a convenient shortcut to access the nested value of the HasAcosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasAdd_v = HasAdd<T1,T2>::value |
Auxiliary variable template for the HasAdd type trait.The HasAdd_v variable template provides a convenient shortcut to access the nested value of the HasAdd class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasAsin_v = HasAsin<T>::value |
Auxiliary variable template for the HasAsin type trait.The HasAsin_v variable template provides a convenient shortcut to access the nested value of the HasAsin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasAsinh_v = HasAsinh<T>::value |
Auxiliary variable template for the HasAsinh type trait.The HasAsinh_v variable template provides a convenient shortcut to access the nested value of the HasAsinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasAtan_v = HasAtan<T>::value |
Auxiliary variable template for the HasAtan type trait.The HasAtan_v variable template provides a convenient shortcut to access the nested value of the HasAtan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasAtan2_v = HasAtan2<T1,T2>::value |
Auxiliary variable template for the HasAtan2 type trait.The HasAtan2_v variable template provides a convenient shortcut to access the nested value of the HasAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasAtanh_v = HasAtanh<T>::value |
Auxiliary variable template for the HasAtanh type trait.The HasAtanh_v variable template provides a convenient shortcut to access the nested value of the HasAtanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasCbrt_v = HasCbrt<T>::value |
Auxiliary variable template for the HasCbrt type trait.The HasCbrt_v variable template provides a convenient shortcut to access the nested value of the HasCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasCeil_v = HasCeil<T>::value |
Auxiliary variable template for the HasCeil type trait.The HasCeil_v variable template provides a convenient shortcut to access the nested value of the HasCeil class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasClamp_v = HasClamp<T>::value |
Auxiliary variable template for the HasClamp type trait.The HasClamp_v variable template provides a convenient shortcut to access the nested value of the HasClamp class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasConj_v = HasConj<T>::value |
Auxiliary variable template for the HasConj type trait.The HasConj_v variable template provides a convenient shortcut to access the nested value of the HasConj class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasConstDataAccess_v = HasConstDataAccess<T>::value |
Auxiliary variable template for the HasConstDataAccess type trait.The HasConstDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasConstDataAccess class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasCos_v = HasCos<T>::value |
Auxiliary variable template for the HasCos type trait.The HasCos_v variable template provides a convenient shortcut to access the nested value of the HasCos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasCosh_v = HasCosh<T>::value |
Auxiliary variable template for the HasCosh type trait.The HasCosh_v variable template provides a convenient shortcut to access the nested value of the HasCosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasDiv_v = HasDiv<T1,T2>::value |
Auxiliary variable template for the HasDiv type trait.The HasDiv_v variable template provides a convenient shortcut to access the nested value of the HasDiv class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasErf_v = HasErf<T>::value |
Auxiliary variable template for the HasErf type trait.The HasErf_v variable template provides a convenient shortcut to access the nested value of the HasErf class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasErfc_v = HasErfc<T>::value |
Auxiliary variable template for the HasErfc type trait.The HasErfc_v variable template provides a convenient shortcut to access the nested value of the HasErfc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasExp_v = HasExp<T>::value |
Auxiliary variable template for the HasExp type trait.The HasExp_v variable template provides a convenient shortcut to access the nested value of the HasExp class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasExp10_v = HasExp10<T>::value |
Auxiliary variable template for the HasExp10 type trait.The HasExp10_v variable template provides a convenient shortcut to access the nested value of the HasExp10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasExp2_v = HasExp2<T>::value |
Auxiliary variable template for the HasExp2 type trait.The HasExp2_v variable template provides a convenient shortcut to access the nested value of the HasExp2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasFloor_v = HasFloor<T>::value |
Auxiliary variable template for the HasFloor type trait.The HasFloor_v variable template provides a convenient shortcut to access the nested value of the HasFloor class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasHypot_v = HasHypot<T1,T2>::value |
Auxiliary variable template for the HasHypot type trait.The HasHypot_v variable template provides a convenient shortcut to access the nested value of the HasHypot class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasImag_v = HasImag<T>::value |
Auxiliary variable template for the HasImag type trait.The HasImag_v variable template provides a convenient shortcut to access the nested value of the HasImag class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasInvCbrt_v = HasInvCbrt<T>::value |
Auxiliary variable template for the HasInvCbrt type trait.The HasInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasInvCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasInvSqrt_v = HasInvSqrt<T>::value |
Auxiliary variable template for the HasInvSqrt type trait.The HasInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasInvSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasLog_v = HasLog<T>::value |
Auxiliary variable template for the HasLog type trait.The HasLog_v variable template provides a convenient shortcut to access the nested value of the HasLog class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasLog10_v = HasLog10<T>::value |
Auxiliary variable template for the HasLog10 type trait.The HasLog10_v variable template provides a convenient shortcut to access the nested value of the HasLog10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasLog2_v = HasLog2<T>::value |
Auxiliary variable template for the HasLog2 type trait.The HasLog2_v variable template provides a convenient shortcut to access the nested value of the HasLog2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasMax_v = HasMax<T1,T2>::value |
Auxiliary variable template for the HasMax type trait.The HasMax_v variable template provides a convenient shortcut to access the nested value of the HasMax class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasMin_v = HasMin<T1,T2>::value |
Auxiliary variable template for the HasMin type trait.The HasMin_v variable template provides a convenient shortcut to access the nested value of the HasMin class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasMult_v = HasMult<T1,T2>::value |
Auxiliary variable template for the HasMult type trait.The HasMult_v variable template provides a convenient shortcut to access the nested value of the HasMult class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasMutableDataAccess_v = HasMutableDataAccess<T>::value |
Auxiliary variable template for the HasMutableDataAccess type trait.The HasMutableDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasMutableDataAccess class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasPow_v = HasPow<T1,T2>::value |
Auxiliary variable template for the HasPow type trait.The HasPow_v variable template provides a convenient shortcut to access the nested value of the HasPow class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasReal_v = HasReal<T>::value |
Auxiliary variable template for the HasReal type trait.The HasReal_v variable template provides a convenient shortcut to access the nested value of the HasReal class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasRound_v = HasRound<T>::value |
Auxiliary variable template for the HasRound type trait.The HasRound_v variable template provides a convenient shortcut to access the nested value of the HasRound class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSign_v = HasSign<T>::value |
Auxiliary variable template for the HasSign type trait.The HasSign_v variable template provides a convenient shortcut to access the nested value of the HasSign class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDAbs_v = HasSIMDAbs<T>::value |
Auxiliary variable template for the HasSIMDAbs type trait.The HasSIMDAbs_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAbs class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDAcos_v = HasSIMDAcos<T>::value |
Auxiliary variable template for the HasSIMDAcos type trait.The HasSIMDAcos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDAcosh_v = HasSIMDAcosh<T>::value |
Auxiliary variable template for the HasSIMDAcosh type trait.The HasSIMDAcosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDAdd_v = HasSIMDAdd<T1,T2>::value |
Auxiliary variable template for the HasSIMDAdd type trait.The HasSIMDAdd_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAdd class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDAsin_v = HasSIMDAsin<T>::value |
Auxiliary variable template for the HasSIMDAsin type trait.The HasSIMDAsin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDAsinh_v = HasSIMDAsinh<T>::value |
Auxiliary variable template for the HasSIMDAsinh type trait.The HasSIMDAsinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDAtan_v = HasSIMDAtan<T>::value |
Auxiliary variable template for the HasSIMDAtan type trait.The HasSIMDAtan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDAtan2_v = HasSIMDAtan2<T1,T2>::value |
Auxiliary variable template for the HasSIMDAtan2 type trait.The HasSIMDAtan2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDAtanh_v = HasSIMDAtanh<T>::value |
Auxiliary variable template for the HasSIMDAtanh type trait.The HasSIMDAtanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDBitand_v = HasSIMDBitand<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitand type trait.The HasSIMDBitand_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitand class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDBitor_v = HasSIMDBitor<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitor type trait.The HasSIMDBitor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitor class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDBitxor_v = HasSIMDBitxor<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitxor type trait.The HasSIMDBitxor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitxor class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDCbrt_v = HasSIMDCbrt<T>::value |
Auxiliary variable template for the HasSIMDCbrt type trait.The HasSIMDCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDCeil_v = HasSIMDCeil<T>::value |
Auxiliary variable template for the HasSIMDCeil type trait.The HasSIMDCeil_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCeil class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDConj_v = HasSIMDConj<T>::value |
Auxiliary variable template for the HasSIMDConj type trait.The HasSIMDConj_v variable template provides a convenient shortcut to access the nested value of the HasSIMDConj class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDCos_v = HasSIMDCos<T>::value |
Auxiliary variable template for the HasSIMDCos type trait.The HasSIMDCos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCos class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDCosh_v = HasSIMDCosh<T>::value |
Auxiliary variable template for the HasSIMDCosh type trait.The HasSIMDCosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCosh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDDiv_v = HasSIMDDiv<T1,T2>::value |
Auxiliary variable template for the HasSIMDDiv type trait.The HasSIMDDiv_v variable template provides a convenient shortcut to access the nested value of the HasSIMDDiv class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDEqual_v = HasSIMDEqual<T1,T2>::value |
Auxiliary variable template for the HasSIMDEqual type trait.The HasSIMDEqual_v variable template provides a convenient shortcut to access the nested value of the HasSIMDEqual class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDErf_v = HasSIMDErf<T>::value |
Auxiliary variable template for the HasSIMDErf type trait.The HasSIMDErf_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErf class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDErfc_v = HasSIMDErfc<T>::value |
Auxiliary variable template for the HasSIMDErfc type trait.The HasSIMDErfc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErfc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDExp_v = HasSIMDExp<T>::value |
Auxiliary variable template for the HasSIMDExp type trait.The HasSIMDExp_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDExp10_v = HasSIMDExp10<T>::value |
Auxiliary variable template for the HasSIMDExp10 type trait.The HasSIMDExp10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDExp2_v = HasSIMDExp2<T>::value |
Auxiliary variable template for the HasSIMDExp2 type trait.The HasSIMDExp2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDFloor_v = HasSIMDFloor<T>::value |
Auxiliary variable template for the HasSIMDFloor type trait.The HasSIMDFloor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDFloor class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDHypot_v = HasSIMDHypot<T1,T2>::value |
Auxiliary variable template for the HasSIMDHypot type trait.The HasSIMDHypot_v variable template provides a convenient shortcut to access the nested value of the HasSIMDHypot class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDInvCbrt_v = HasSIMDInvCbrt<T>::value |
Auxiliary variable template for the HasSIMDInvCbrt type trait.The HasSIMDInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvCbrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDInvSqrt_v = HasSIMDInvSqrt<T>::value |
Auxiliary variable template for the HasSIMDInvSqrt type trait.The HasSIMDInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDLog_v = HasSIMDLog<T>::value |
Auxiliary variable template for the HasSIMDLog type trait.The HasSIMDLog_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDLog10_v = HasSIMDLog10<T>::value |
Auxiliary variable template for the HasSIMDLog10 type trait.The HasSIMDLog10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog10 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDLog2_v = HasSIMDLog2<T>::value |
Auxiliary variable template for the HasSIMDLog2 type trait.The HasSIMDLog2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog2 class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDMax_v = HasSIMDMax<T1,T2>::value |
Auxiliary variable template for the HasSIMDMax type trait.The HasSIMDMax_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMax class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDMin_v = HasSIMDMin<T1,T2>::value |
Auxiliary variable template for the HasSIMDMin type trait.The HasSIMDMin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMin class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDMult_v = HasSIMDMult<T1,T2>::value |
Auxiliary variable template for the HasSIMDMult type trait.The HasSIMDMult_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMult class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDPow_v = HasSIMDPow<T1,T2>::value |
Auxiliary variable template for the HasSIMDPow type trait.The HasSIMDPow_v variable template provides a convenient shortcut to access the nested value of the HasSIMDPow class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDRound_v = HasSIMDRound<T>::value |
Auxiliary variable template for the HasSIMDRound type trait.The HasSIMDRound_v variable template provides a convenient shortcut to access the nested value of the HasSIMDRound class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDShiftLI_v = HasSIMDShiftLI<T>::value |
Auxiliary variable template for the HasSIMDShiftLI type trait.The HasSIMDShiftLI_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftLI class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDShiftLV_v = HasSIMDShiftLV<T1,T2>::value |
Auxiliary variable template for the HasSIMDShiftLV type trait.The HasSIMDShiftLV_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftLV class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDShiftRI_v = HasSIMDShiftRI<T>::value |
Auxiliary variable template for the HasSIMDShiftRI type trait.The HasSIMDShiftRI_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftRI class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDShiftRV_v = HasSIMDShiftRV<T1,T2>::value |
Auxiliary variable template for the HasSIMDShiftRV type trait.The HasSIMDShiftRV_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftRV class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDSign_v = HasSIMDSign<T>::value |
Auxiliary variable template for the HasSIMDSign type trait.The HasSIMDSign_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSign class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDSin_v = HasSIMDSin<T>::value |
Auxiliary variable template for the HasSIMDSin type trait.The HasSIMDSin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDSinh_v = HasSIMDSinh<T>::value |
Auxiliary variable template for the HasSIMDSinh type trait.The HasSIMDSinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDSqrt_v = HasSIMDSqrt<T>::value |
Auxiliary variable template for the HasSIMDSqrt type trait.The HasSIMDSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSIMDSub_v = HasSIMDSub<T1,T2>::value |
Auxiliary variable template for the HasSIMDSub type trait.The HasSIMDSub_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSub class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDTan_v = HasSIMDTan<T>::value |
Auxiliary variable template for the HasSIMDTan type trait.The HasSIMDTan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDTanh_v = HasSIMDTanh<T>::value |
Auxiliary variable template for the HasSIMDTanh type trait.The HasSIMDTanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSIMDTrunc_v = HasSIMDTrunc<T>::value |
Auxiliary variable template for the HasSIMDTrunc type trait.The HasSIMDTrunc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTrunc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSin_v = HasSin<T>::value |
Auxiliary variable template for the HasSin type trait.The HasSin_v variable template provides a convenient shortcut to access the nested value of the HasSin class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSinh_v = HasSinh<T>::value |
Auxiliary variable template for the HasSinh type trait.The HasSinh_v variable template provides a convenient shortcut to access the nested value of the HasSinh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasSqrt_v = HasSqrt<T>::value |
Auxiliary variable template for the HasSqrt type trait.The HasSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSqrt class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::HasSub_v = HasSub<T1,T2>::value |
Auxiliary variable template for the HasSub type trait.The HasSub_v variable template provides a convenient shortcut to access the nested value of the HasSub class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasTan_v = HasTan<T>::value |
Auxiliary variable template for the HasTan type trait.The HasTan_v variable template provides a convenient shortcut to access the nested value of the HasTan class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasTanh_v = HasTanh<T>::value |
Auxiliary variable template for the HasTanh type trait.The HasTanh_v variable template provides a convenient shortcut to access the nested value of the HasTanh class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::HasTrunc_v = HasTrunc<T>::value |
Auxiliary variable template for the HasTrunc type trait.The HasTrunc_v variable template provides a convenient shortcut to access the nested value of the HasTrunc class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsAdaptor_v = IsAdaptor<T>::value |
Auxiliary variable template for the IsAdaptor type trait.The IsAdaptor_v variable template provides a convenient shortcut to access the nested value of the IsAdaptor class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsAddExpr_v = IsAddExpr<T>::value |
Auxiliary variable template for the IsAddExpr type trait.The IsAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsAddExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsAligned_v = IsAligned<T>::value |
Auxiliary variable template for the IsAligned type trait.The IsAligned_v variable template provides a convenient shortcut to access the nested value of the IsAligned class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsBand_v = IsBand<T>::value |
Auxiliary variable template for the IsBand type trait.The IsBand_v variable template provides a convenient shortcut to access the nested value of the IsBand class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsBinaryMapExpr_v = IsBinaryMapExpr<T>::value |
Auxiliary variable template for the IsBinaryMapExpr type trait.The IsBinaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsBinaryMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsBLASCompatible_v = IsBLASCompatible<T>::value |
Auxiliary variable template for the IsBLASCompatible type trait.The IsBLASCompatible_v variable template provides a convenient shortcut to access the nested value of the IsBLASCompatible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsColumn_v = IsColumn<T>::value |
Auxiliary variable template for the IsColumn type trait.The IsColumn_v variable template provides a convenient shortcut to access the nested value of the IsColumn class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsColumnMajorMatrix_v = IsColumnMajorMatrix<T>::value |
Auxiliary variable template for the IsColumnMajorMatrix type trait.The IsColumnMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsColumnMajorMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsColumns_v = IsColumns<T>::value |
Auxiliary variable template for the IsColumns type trait.The IsColumns_v variable template provides a convenient shortcut to access the nested value of the IsColumns class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsColumnVector_v = IsColumnVector<T>::value |
Auxiliary variable template for the IsColumnVector type trait.The IsColumnVector_v variable template provides a convenient shortcut to access the nested value of the IsColumnVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 > | |
constexpr bool | blaze::IsCommutative_v = IsCommutative<T1,T2>::value |
Auxiliary variable template for the IsCommutative type trait.The IsCommutative_v variable template provides a convenient shortcut to access the nested value of the IsCommutative class template. For instance, given the type1 T1 and T2 the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsComputation_v = IsComputation<T>::value |
Auxiliary variable template for the IsComputation type trait.The IsComputation_v variable template provides a convenient shortcut to access the nested value of the IsComputation class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsContiguous_v = IsContiguous<T>::value |
Auxiliary variable template for the IsContiguous type trait.The IsContiguous_v variable template provides a convenient shortcut to access the nested value of the IsContiguous class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsCrossExpr_v = IsCrossExpr<T>::value |
Auxiliary variable template for the IsCrossExpr type trait.The IsCrossExpr_v variable template provides a convenient shortcut to access the nested value of the IsCrossExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsCustom_v = IsCustom<T>::value |
Auxiliary variable template for the IsCustom type trait.The IsCustom_v variable template provides a convenient shortcut to access the nested value of the IsCustom class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDeclaration_v = IsDeclaration<T>::value |
Auxiliary variable template for the IsDeclaration type trait.The IsDeclaration_v variable template provides a convenient shortcut to access the nested value of the IsDeclaration class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDeclDiagExpr_v = IsDeclDiagExpr<T>::value |
Auxiliary variable template for the IsDeclDiagExpr type trait.The IsDeclDiagExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclDiagExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDeclExpr_v = IsDeclExpr<T>::value |
Auxiliary variable template for the IsDeclExpr type trait.The IsDeclExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDeclHermExpr_v = IsDeclHermExpr<T>::value |
Auxiliary variable template for the IsDeclHermExpr type trait.The IsDeclHermExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclHermExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDeclLowExpr_v = IsDeclLowExpr<T>::value |
Auxiliary variable template for the IsDeclLowExpr type trait.The IsDeclLowExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclLowExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDeclSymExpr_v = IsDeclSymExpr<T>::value |
Auxiliary variable template for the IsDeclSymExpr type trait.The IsDeclSymExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclSymExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDeclUppExpr_v = IsDeclUppExpr<T>::value |
Auxiliary variable template for the IsDeclUppExpr type trait.The IsDeclUppExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclUppExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDenseMatrix_v = IsDenseMatrix<T>::value |
Auxiliary variable template for the IsDenseMatrix type trait.The IsDenseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsDenseMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDenseVector_v = IsDenseVector<T>::value |
Auxiliary variable template for the IsDenseVector type trait.The IsDenseVector_v variable template provides a convenient shortcut to access the nested value of the IsDenseVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDiagonal_v = IsDiagonal<T>::value |
Auxiliary variable template for the IsDiagonal type trait.The IsDiagonal_v variable template provides a convenient shortcut to access the nested value of the IsDiagonal class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsDivExpr_v = IsDivExpr<T>::value |
Auxiliary variable template for the IsDivExpr type trait.The IsDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsElements_v = IsElements<T>::value |
Auxiliary variable template for the IsElements type trait.The IsElements_v variable template provides a convenient shortcut to access the nested value of the IsElements class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsEvalExpr_v = IsEvalExpr<T>::value |
Auxiliary variable template for the IsEvalExpr type trait.The IsEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsEvalExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsExpandExpr_v = IsExpandExpr<T>::value |
Auxiliary variable template for the IsExpandExpr type trait.The IsExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsExpandExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsExpression_v = IsExpression<T>::value |
Auxiliary variable template for the IsExpression type trait.The IsExpression_v variable template provides a convenient shortcut to access the nested value of the IsExpression class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsGeneral_v = IsGeneral<T>::value |
Auxiliary variable template for the IsGeneral type trait.The IsGeneral_v variable template provides a convenient shortcut to access the nested value of the IsGeneral class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsHermitian_v = IsHermitian<T>::value |
Auxiliary variable template for the IsHermitian type trait.The IsHermitian_v variable template provides a convenient shortcut to access the nested value of the IsHermitian class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsIdentity_v = IsIdentity<T>::value |
Auxiliary variable template for the IsIdentity type trait.The IsIdentity_v variable template provides a convenient shortcut to access the nested value of the IsIdentity class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsInitializer_v = IsInitializer<T>::value |
Auxiliary variable template for the IsInitializer type trait.The IsInitializer_v variable template provides a convenient shortcut to access the nested value of the IsInitializer class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsInvertible_v = IsInvertible<T>::value |
Auxiliary variable template for the IsInvertible type trait.The IsInvertible_v variable template provides a convenient shortcut to access the nested value of the IsInvertible class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsKronExpr_v = IsKronExpr<T>::value |
Auxiliary variable template for the IsKronExpr type trait.The IsKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsKronExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsLower_v = IsLower<T>::value |
Auxiliary variable template for the IsLower type trait.The IsLower_v variable template provides a convenient shortcut to access the nested value of the IsLower class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatEvalExpr_v = IsMatEvalExpr<T>::value |
Auxiliary variable template for the IsMatEvalExpr type trait.The IsMatEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatEvalExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatInvExpr_v = IsMatInvExpr<T>::value |
Auxiliary variable template for the IsMatInvExpr type trait.The IsMatInvExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatInvExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatMapExpr_v = IsMatMapExpr<T>::value |
Auxiliary variable template for the IsMatMapExpr type trait.The IsMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatMatAddExpr_v = IsMatMatAddExpr<T>::value |
Auxiliary variable template for the IsMatMatAddExpr type trait.The IsMatMatAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatAddExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatMatKronExpr_v = IsMatMatKronExpr<T>::value |
Auxiliary variable template for the IsMatMatKronExpr type trait.The IsMatMatKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatKronExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatMatMapExpr_v = IsMatMatMapExpr<T>::value |
Auxiliary variable template for the IsMatMatMapExpr type trait.The IsMatMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatMatMultExpr_v = IsMatMatMultExpr<T>::value |
Auxiliary variable template for the IsMatMatMultExpr type trait.The IsMatMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatMatSubExpr_v = IsMatMatSubExpr<T>::value |
Auxiliary variable template for the IsMatMatSubExpr type trait.The IsMatMatSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatSubExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatReduceExpr_v = IsMatReduceExpr<T>::value |
Auxiliary variable template for the IsMatReduceExpr type trait.The IsMatReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatReduceExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatrix_v = IsMatrix<T>::value |
Auxiliary variable template for the IsMatrix type trait.The IsMatrix_v variable template provides a convenient shortcut to access the nested value of the IsMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatScalarDivExpr_v = IsMatScalarDivExpr<T>::value |
Auxiliary variable template for the IsMatScalarDivExpr type trait.The IsMatScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatScalarMultExpr_v = IsMatScalarMultExpr<T>::value |
Auxiliary variable template for the IsMatScalarMultExpr type trait.The IsMatScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatSerialExpr_v = IsMatSerialExpr<T>::value |
Auxiliary variable template for the IsMatSerialExpr type trait.The IsMatSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatSerialExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatTransExpr_v = IsMatTransExpr<T>::value |
Auxiliary variable template for the IsMatTransExpr type trait.The IsMatTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatTransExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMatVecMultExpr_v = IsMatVecMultExpr<T>::value |
Auxiliary variable template for the IsMatVecMultExpr type trait.The IsMatVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatVecMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsMultExpr_v = IsMultExpr<T>::value |
Auxiliary variable template for the IsMultExpr type trait.The IsMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsNumericMatrix_v = IsNumericMatrix<T>::value |
Auxiliary variable template for the IsNumericMatrix type trait.The IsNumericMatrix_v variable template provides a convenient shortcut to access the nested value of the IsNumericMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsNumericVector_v = IsNumericVector<T>::value |
Auxiliary variable template for the IsNumericVector type trait.The IsNumericVector_v variable template provides a convenient shortcut to access the nested value of the IsNumericVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsOperation_v = IsOperation<T>::value |
Auxiliary variable template for the IsOperation type trait.The IsOperation_v variable template provides a convenient shortcut to access the nested value of the IsOperation class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsOpposedView_v = IsOpposedView<T>::value |
Auxiliary variable template for the IsOpposedView type trait.The IsOpposedView_v variable template provides a convenient shortcut to access the nested value of the IsOpposedView class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsPadded_v = IsPadded<T>::value |
Auxiliary variable template for the IsPadded type trait.The IsPadded_v variable template provides a convenient shortcut to access the nested value of the IsPadded class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsPaddingEnabled_v = IsPaddingEnabled<T>::value |
Auxiliary variable template for the IsPaddingEnabled type trait.The IsPaddingEnabled_v variable template provides a convenient shortcut to access the nested value of the IsPaddingEnabled class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsProxy_v = IsProxy<T>::value |
Auxiliary variable template for the IsProxy type trait.The IsProxy_v variable template provides a convenient shortcut to access the nested value of the IsProxy class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsReduceExpr_v = IsReduceExpr<T>::value |
Auxiliary variable template for the IsReduceExpr type trait.The IsReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsReduceExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsResizable_v = IsResizable<T>::value |
Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provides a convenient shortcut to access the nested value of the IsResizable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsRestricted_v = IsRestricted<T>::value |
Auxiliary variable template for the IsRestricted type trait.The IsRestricted_v variable template provides a convenient shortcut to access the nested value of the IsRestricted class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsRow_v = IsRow<T>::value |
Auxiliary variable template for the IsRow type trait.The IsRow_v variable template provides a convenient shortcut to access the nested value of the IsRow class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsRowMajorMatrix_v = IsRowMajorMatrix<T>::value |
Auxiliary variable template for the IsRowMajorMatrix type trait.The IsRowMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsRowMajorMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsRows_v = IsRows<T>::value |
Auxiliary variable template for the IsRows type trait.The IsRows_v variable template provides a convenient shortcut to access the nested value of the IsRows class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsRowVector_v = IsRowVector<T>::value |
Auxiliary variable template for the IsRowVector type trait.The IsRowVector_v variable template provides a convenient shortcut to access the nested value of the IsRowVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSchurExpr_v = IsSchurExpr<T>::value |
Auxiliary variable template for the IsSchurExpr type trait.The IsSchurExpr_v variable template provides a convenient shortcut to access the nested value of the IsSchurExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSerialExpr_v = IsSerialExpr<T>::value |
Auxiliary variable template for the IsSerialExpr type trait.The IsSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsSerialExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsShrinkable_v = IsShrinkable<T>::value |
Auxiliary variable template for the IsShrinkable type trait.The IsShrinkable_v variable template provides a convenient shortcut to access the nested value of the IsShrinkable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T1 , typename T2 , typename... Ts> | |
constexpr bool | blaze::IsSIMDCombinable_v = IsSIMDCombinable<T1,T2,Ts...>::value |
Auxiliary variable template for the IsSIMDCombinable type trait.The IsSIMDCombinable_v variable template provides a convenient shortcut to access the nested value of the IsSIMDCombinable class template. For instance, given the types T1 and T2 the following two statements are identical: More... | |
template<typename T , typename... Args> | |
constexpr bool | blaze::IsSIMDEnabled_v = IsSIMDEnabled<T,Args...>::value |
Auxiliary variable template for the IsSIMDEnabled type trait.The IsSIMDEnabled_v variable template provides a convenient shortcut to access the nested value of the IsSIMDEnabled class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSIMDPack_v = IsSIMDPack<T>::value |
Auxiliary variable template for the IsSIMDPack type trait.The IsSIMDPack_v variable template provides a convenient shortcut to access the nested value of the IsSIMDPack class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSMPAssignable_v = IsSMPAssignable<T>::value |
Auxiliary variable template for the IsSMPAssignable type trait.The IsSMPAssignable_v variable template provides a convenient shortcut to access the nested value of the IsSMPAssignable class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSparseElement_v = IsSparseElement<T>::value |
Auxiliary variable template for the IsSparseElement type trait.The IsSparseElement_v variable template provides a convenient shortcut to access the nested value of the IsSparseElement class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSparseMatrix_v = IsSparseMatrix<T>::value |
Auxiliary variable template for the IsSparseMatrix type trait.The IsSparseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsSparseMatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSparseVector_v = IsSparseVector<T>::value |
Auxiliary variable template for the IsSparseVector type trait.The IsSparseVector_v variable template provides a convenient shortcut to access the nested value of the IsSparseVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSquare_v = IsSquare<T>::value |
Auxiliary variable template for the IsSquare type trait.The IsSquare_v variable template provides a convenient shortcut to access the nested value of the IsSquare class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsStatic_v = IsStatic<T>::value |
Auxiliary variable template for the IsStatic type trait.The IsStatic_v variable template provides a convenient shortcut to access the nested value of the IsStatic class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsStrictlyLower_v = IsStrictlyLower<T>::value |
Auxiliary variable template for the IsStrictlyLower type trait.The IsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyLower class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsStrictlyTriangular_v = IsStrictlyTriangular<T>::value |
Auxiliary variable template for the IsStrictlyTriangular type trait.The IsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyTriangular class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsStrictlyUpper_v = IsStrictlyUpper<T>::value |
Auxiliary variable template for the IsStrictlyUpper type trait.The IsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyUpper class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSubExpr_v = IsSubExpr<T>::value |
Auxiliary variable template for the IsSubExpr type trait.The IsSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsSubExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSubmatrix_v = IsSubmatrix<T>::value |
Auxiliary variable template for the IsSubmatrix type trait.The IsSubmatrix_v variable template provides a convenient shortcut to access the nested value of the IsSubmatrix class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSubvector_v = IsSubvector<T>::value |
Auxiliary variable template for the IsSubvector type trait.The IsSubvector_v variable template provides a convenient shortcut to access the nested value of the IsSubvector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsSymmetric_v = IsSymmetric<T>::value |
Auxiliary variable template for the IsSymmetric type trait.The IsSymmetric_v variable template provides a convenient shortcut to access the nested value of the IsSymmetric class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsTemporary_v = IsTemporary<T>::value |
Auxiliary variable template for the IsTemporary type trait.The IsTemporary_v variable template provides a convenient shortcut to access the nested value of the IsTemporary class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsTransExpr_v = IsTransExpr<T>::value |
Auxiliary variable template for the IsTransExpr type trait.The IsTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsTransExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsTransformation_v = IsTransformation<T>::value |
Auxiliary variable template for the IsTransformation type trait.The IsTransformation_v variable template provides a convenient shortcut to access the nested value of the IsTransformation class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsTriangular_v = IsTriangular<T>::value |
Auxiliary variable template for the IsTriangular type trait.The IsTriangular_v variable template provides a convenient shortcut to access the nested value of the IsTriangular class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsTVecMatMultExpr_v = IsTVecMatMultExpr<T>::value |
Auxiliary variable template for the IsTVecMatMultExpr type trait.The IsTVecMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsTVecMatMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsUnaryMapExpr_v = IsUnaryMapExpr<T>::value |
Auxiliary variable template for the IsUnaryMapExpr type trait.The IsUnaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsUnaryMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsUniform_v = IsUniform<T>::value |
Auxiliary variable template for the IsUniform type trait.The IsUniform_v variable template provides a convenient shortcut to access the nested value of the IsUniform class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsUniLower_v = IsUniLower<T>::value |
Auxiliary variable template for the IsUniLower type trait.The IsUniLower_v variable template provides a convenient shortcut to access the nested value of the IsUniLower class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsUniTriangular_v = IsUniTriangular<T>::value |
Auxiliary variable template for the IsUniTriangular type trait.The IsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the IsUniTriangular class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsUniUpper_v = IsUniUpper<T>::value |
Auxiliary variable template for the IsUniUpper type trait.The IsUniUpper_v variable template provides a convenient shortcut to access the nested value of the IsUniUpper class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsUpper_v = IsUpper<T>::value |
Auxiliary variable template for the IsUpper type trait.The IsUpper_v variable template provides a convenient shortcut to access the nested value of the IsUpper class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecEvalExpr_v = IsVecEvalExpr<T>::value |
Auxiliary variable template for the IsVecEvalExpr type trait.The IsVecEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecEvalExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecExpandExpr_v = IsVecExpandExpr<T>::value |
Auxiliary variable template for the IsVecExpandExpr type trait.The IsVecExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecExpandExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecMapExpr_v = IsVecMapExpr<T>::value |
Auxiliary variable template for the IsVecMapExpr type trait.The IsVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecScalarDivExpr_v = IsVecScalarDivExpr<T>::value |
Auxiliary variable template for the IsVecScalarDivExpr type trait.The IsVecScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecScalarMultExpr_v = IsVecScalarMultExpr<T>::value |
Auxiliary variable template for the IsVecScalarMultExpr type trait.The IsVecScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecSerialExpr_v = IsVecSerialExpr<T>::value |
Auxiliary variable template for the IsVecSerialExpr type trait.The IsVecSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecSerialExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVector_v = IsVector<T>::value |
Auxiliary variable template for the IsVector type trait.The IsVector_v variable template provides a convenient shortcut to access the nested value of the IsVector class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecTransExpr_v = IsVecTransExpr<T>::value |
Auxiliary variable template for the IsVecTransExpr type trait.The IsVecTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTransExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecTVecMultExpr_v = IsVecTVecMultExpr<T>::value |
Auxiliary variable template for the IsVecTVecMultExpr type trait.The IsVecTVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTVecMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecVecAddExpr_v = IsVecVecAddExpr<T>::value |
Auxiliary variable template for the IsVecVecAddExpr type trait.The IsVecVecAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecAddExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecVecDivExpr_v = IsVecVecDivExpr<T>::value |
Auxiliary variable template for the IsVecVecDivExpr type trait.The IsVecVecDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecDivExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecVecKronExpr_v = IsVecVecKronExpr<T>::value |
Auxiliary variable template for the IsVecVecKronExpr type trait.The IsVecVecKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecKronExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecVecMapExpr_v = IsVecVecMapExpr<T>::value |
Auxiliary variable template for the IsVecVecMapExpr type trait.The IsVecVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMapExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecVecMultExpr_v = IsVecVecMultExpr<T>::value |
Auxiliary variable template for the IsVecVecMultExpr type trait.The IsVecVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMultExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsVecVecSubExpr_v = IsVecVecSubExpr<T>::value |
Auxiliary variable template for the IsVecVecSubExpr type trait.The IsVecVecSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecSubExpr class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsView_v = IsView<T>::value |
Auxiliary variable template for the IsView type trait.The IsView_v variable template provides a convenient shortcut to access the nested value of the IsView class template. For instance, given the type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::IsZero_v = IsZero<T>::value |
Auxiliary variable template for the IsZero type trait.The IsZero_v variable template provides a convenient shortcut to access the nested value of the IsZero class template. For instance, given the type T the following two statements are identical: More... | |
constexpr ptrdiff_t | blaze::DefaultMaxSize_v = -1L |
Default size of the MaxSize type trait. | |
template<typename T , size_t N> | |
constexpr ptrdiff_t | blaze::MaxSize_v = MaxSize<T,N>::value |
Auxiliary variable template for the MaxSize type trait.The MaxSize_v variable template provides a convenient shortcut to access the nested value of the MaxSize class template. For instance, given the type T and the dimension N the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::RequiresEvaluation_v = RequiresEvaluation<T>::value |
Auxiliary variable template for the RequiresEvaluation type trait.The RequiresEvaluation_v variable template provides a convenient shortcut to access the nested value of the RequiresEvaluation class template. For instance, given the type T the following two statements are identical: More... | |
constexpr ptrdiff_t | blaze::DefaultSize_v = -1L |
Default size of the Size type trait. | |
template<typename T , size_t N> | |
constexpr ptrdiff_t | blaze::Size_v = Size<T,N>::value |
Auxiliary variable template for the Size type trait.The Size_v variable template provides a convenient shortcut to access the nested value of the Size class template. For instance, given the type T and the dimension N the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::StorageOrder_v = T::storageOrder |
Auxiliary variable template for the StorageOrder type trait.The StorageOrder_v variable template provides a convenient shortcut to access the nested value of the StorageOrder class template. For instance, given the matrix type T the following two statements are identical: More... | |
template<typename T > | |
constexpr bool | blaze::TransposeFlag_v = T::transposeFlag |
Auxiliary variable template for the TransposeFlag type trait.The TransposeFlag_v variable template provides a convenient shortcut to access the nested value of the TransposeFlag class template. For instance, given the vector type T the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsDiagonal_v = YieldsDiagonal<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsDiagonal type trait.The YieldsDiagonal_v variable template provides a convenient shortcut to access the nested value of the YieldsDiagonal class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsHermitian_v = YieldsHermitian<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsHermitian type trait.The YieldsHermitian_v variable template provides a convenient shortcut to access the nested value of the YieldsHermitian class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsIdentity_v = YieldsIdentity<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsIdentity type trait.The YieldsIdentity_v variable template provides a convenient shortcut to access the nested value of the YieldsIdentity class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsLower_v = YieldsLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsLower type trait.The YieldsLower_v variable template provides a convenient shortcut to access the nested value of the YieldsLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsStrictlyLower_v = YieldsStrictlyLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyLower type trait.The YieldsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsStrictlyTriangular_v = YieldsStrictlyTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyTriangular type trait.The YieldsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsStrictlyUpper_v = YieldsStrictlyUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyUpper type trait.The YieldsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsSymmetric_v = YieldsSymmetric<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsSymmetric type trait.The YieldsSymmetric_v variable template provides a convenient shortcut to access the nested value of the YieldsSymmetric class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsTriangular_v = YieldsTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsTriangular type trait.The YieldsTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename T , typename... Ts> | |
constexpr bool | blaze::YieldsUniform_v = YieldsUniform<OP,T,Ts...>::value |
Auxiliary variable template for the YieldsUniform type trait.The YieldsUniform_v variable template provides a convenient shortcut to access the nested value of the YieldsUniform class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsUniLower_v = YieldsUniLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniLower type trait.The YieldsUniLower_v variable template provides a convenient shortcut to access the nested value of the YieldsUniLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsUniTriangular_v = YieldsUniTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniTriangular type trait.The YieldsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsUniTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsUniUpper_v = YieldsUniUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniUpper type trait.The YieldsUniUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUniUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename MT , typename... MTs> | |
constexpr bool | blaze::YieldsUpper_v = YieldsUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUpper type trait.The YieldsUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More... | |
template<typename OP , typename T , typename... Ts> | |
constexpr bool | blaze::YieldsZero_v = YieldsZero<OP,T,Ts...>::value |
Auxiliary variable template for the YieldsZero type trait.The YieldsZero_v variable template provides a convenient shortcut to access the nested value of the YieldsZero class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical: More... | |
#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:
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.
#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:
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.
#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:
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.
#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:
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.
using blaze::HighType_t = typedef typename HighType<T1,T2>::Type |
Auxiliary alias declaration for the HighType type trait.The HighType_t alias declaration provides a convenient shortcut to access the nested Type of the HighType class template. For instance, given the types T1 and T2 the following two type definitions are identical:
using blaze::LowType_t = typedef typename LowType<T1,T2>::Type |
Auxiliary alias declaration for the LowType type trait.The LowType_t alias declaration provides a convenient shortcut to access the nested Type of the LowType class template. For instance, given the types T1 and T2 the following two type definitions are identical:
using blaze::RemoveAdaptor_t = typedef typename RemoveAdaptor<T>::Type |
Auxiliary alias declaration for the RemoveAdaptor type trait.The RemoveAdaptor_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveAdaptor class template. For instance, given the type T the following two type definitions are identical:
using blaze::UnderlyingBuiltin_t = typedef typename UnderlyingBuiltin<T>::Type |
Auxiliary alias declaration for the UnderlyingBuiltin type trait.The UnderlyingBuiltin_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingBuiltin class template. For instance, given the type T the following two type definitions are identical:
using blaze::UnderlyingElement_t = typedef typename UnderlyingElement<T>::Type |
Auxiliary alias declaration for the UnderlyingElement type trait.The UnderlyingElement_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingElement class template. For instance, given the type T the following two type definitions are identical:
using blaze::UnderlyingNumeric_t = typedef typename UnderlyingNumeric<T>::Type |
Auxiliary alias declaration for the UnderlyingNumeric type trait.The UnderlyingNumeric_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingNumeric class template. For instance, given the type T the following two type definitions are identical:
constexpr bool blaze::HasAbs_v = HasAbs<T>::value |
Auxiliary variable template for the HasAbs type trait.The HasAbs_v variable template provides a convenient shortcut to access the nested value of the HasAbs class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasAcos_v = HasAcos<T>::value |
Auxiliary variable template for the HasAcos type trait.The HasAcos_v variable template provides a convenient shortcut to access the nested value of the HasAcos class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasAcosh_v = HasAcosh<T>::value |
Auxiliary variable template for the HasAcosh type trait.The HasAcosh_v variable template provides a convenient shortcut to access the nested value of the HasAcosh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasAdd_v = HasAdd<T1,T2>::value |
Auxiliary variable template for the HasAdd type trait.The HasAdd_v variable template provides a convenient shortcut to access the nested value of the HasAdd class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasAsin_v = HasAsin<T>::value |
Auxiliary variable template for the HasAsin type trait.The HasAsin_v variable template provides a convenient shortcut to access the nested value of the HasAsin class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasAsinh_v = HasAsinh<T>::value |
Auxiliary variable template for the HasAsinh type trait.The HasAsinh_v variable template provides a convenient shortcut to access the nested value of the HasAsinh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasAtan2_v = HasAtan2<T1,T2>::value |
Auxiliary variable template for the HasAtan2 type trait.The HasAtan2_v variable template provides a convenient shortcut to access the nested value of the HasAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasAtan_v = HasAtan<T>::value |
Auxiliary variable template for the HasAtan type trait.The HasAtan_v variable template provides a convenient shortcut to access the nested value of the HasAtan class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasAtanh_v = HasAtanh<T>::value |
Auxiliary variable template for the HasAtanh type trait.The HasAtanh_v variable template provides a convenient shortcut to access the nested value of the HasAtanh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasCbrt_v = HasCbrt<T>::value |
Auxiliary variable template for the HasCbrt type trait.The HasCbrt_v variable template provides a convenient shortcut to access the nested value of the HasCbrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasCeil_v = HasCeil<T>::value |
Auxiliary variable template for the HasCeil type trait.The HasCeil_v variable template provides a convenient shortcut to access the nested value of the HasCeil class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasClamp_v = HasClamp<T>::value |
Auxiliary variable template for the HasClamp type trait.The HasClamp_v variable template provides a convenient shortcut to access the nested value of the HasClamp class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasConj_v = HasConj<T>::value |
Auxiliary variable template for the HasConj type trait.The HasConj_v variable template provides a convenient shortcut to access the nested value of the HasConj class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasConstDataAccess_v = HasConstDataAccess<T>::value |
Auxiliary variable template for the HasConstDataAccess type trait.The HasConstDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasConstDataAccess class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasCos_v = HasCos<T>::value |
Auxiliary variable template for the HasCos type trait.The HasCos_v variable template provides a convenient shortcut to access the nested value of the HasCos class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasCosh_v = HasCosh<T>::value |
Auxiliary variable template for the HasCosh type trait.The HasCosh_v variable template provides a convenient shortcut to access the nested value of the HasCosh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasDiv_v = HasDiv<T1,T2>::value |
Auxiliary variable template for the HasDiv type trait.The HasDiv_v variable template provides a convenient shortcut to access the nested value of the HasDiv class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasErf_v = HasErf<T>::value |
Auxiliary variable template for the HasErf type trait.The HasErf_v variable template provides a convenient shortcut to access the nested value of the HasErf class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasErfc_v = HasErfc<T>::value |
Auxiliary variable template for the HasErfc type trait.The HasErfc_v variable template provides a convenient shortcut to access the nested value of the HasErfc class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasExp10_v = HasExp10<T>::value |
Auxiliary variable template for the HasExp10 type trait.The HasExp10_v variable template provides a convenient shortcut to access the nested value of the HasExp10 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasExp2_v = HasExp2<T>::value |
Auxiliary variable template for the HasExp2 type trait.The HasExp2_v variable template provides a convenient shortcut to access the nested value of the HasExp2 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasExp_v = HasExp<T>::value |
Auxiliary variable template for the HasExp type trait.The HasExp_v variable template provides a convenient shortcut to access the nested value of the HasExp class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasFloor_v = HasFloor<T>::value |
Auxiliary variable template for the HasFloor type trait.The HasFloor_v variable template provides a convenient shortcut to access the nested value of the HasFloor class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasHypot_v = HasHypot<T1,T2>::value |
Auxiliary variable template for the HasHypot type trait.The HasHypot_v variable template provides a convenient shortcut to access the nested value of the HasHypot class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasImag_v = HasImag<T>::value |
Auxiliary variable template for the HasImag type trait.The HasImag_v variable template provides a convenient shortcut to access the nested value of the HasImag class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasInvCbrt_v = HasInvCbrt<T>::value |
Auxiliary variable template for the HasInvCbrt type trait.The HasInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasInvCbrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasInvSqrt_v = HasInvSqrt<T>::value |
Auxiliary variable template for the HasInvSqrt type trait.The HasInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasInvSqrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasLog10_v = HasLog10<T>::value |
Auxiliary variable template for the HasLog10 type trait.The HasLog10_v variable template provides a convenient shortcut to access the nested value of the HasLog10 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasLog2_v = HasLog2<T>::value |
Auxiliary variable template for the HasLog2 type trait.The HasLog2_v variable template provides a convenient shortcut to access the nested value of the HasLog2 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasLog_v = HasLog<T>::value |
Auxiliary variable template for the HasLog type trait.The HasLog_v variable template provides a convenient shortcut to access the nested value of the HasLog class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasMax_v = HasMax<T1,T2>::value |
Auxiliary variable template for the HasMax type trait.The HasMax_v variable template provides a convenient shortcut to access the nested value of the HasMax class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasMin_v = HasMin<T1,T2>::value |
Auxiliary variable template for the HasMin type trait.The HasMin_v variable template provides a convenient shortcut to access the nested value of the HasMin class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasMult_v = HasMult<T1,T2>::value |
Auxiliary variable template for the HasMult type trait.The HasMult_v variable template provides a convenient shortcut to access the nested value of the HasMult class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasMutableDataAccess_v = HasMutableDataAccess<T>::value |
Auxiliary variable template for the HasMutableDataAccess type trait.The HasMutableDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasMutableDataAccess class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasPow_v = HasPow<T1,T2>::value |
Auxiliary variable template for the HasPow type trait.The HasPow_v variable template provides a convenient shortcut to access the nested value of the HasPow class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasReal_v = HasReal<T>::value |
Auxiliary variable template for the HasReal type trait.The HasReal_v variable template provides a convenient shortcut to access the nested value of the HasReal class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasRound_v = HasRound<T>::value |
Auxiliary variable template for the HasRound type trait.The HasRound_v variable template provides a convenient shortcut to access the nested value of the HasRound class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSign_v = HasSign<T>::value |
Auxiliary variable template for the HasSign type trait.The HasSign_v variable template provides a convenient shortcut to access the nested value of the HasSign class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDAbs_v = HasSIMDAbs<T>::value |
Auxiliary variable template for the HasSIMDAbs type trait.The HasSIMDAbs_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAbs class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDAcos_v = HasSIMDAcos<T>::value |
Auxiliary variable template for the HasSIMDAcos type trait.The HasSIMDAcos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcos class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDAcosh_v = HasSIMDAcosh<T>::value |
Auxiliary variable template for the HasSIMDAcosh type trait.The HasSIMDAcosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcosh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDAdd_v = HasSIMDAdd<T1,T2>::value |
Auxiliary variable template for the HasSIMDAdd type trait.The HasSIMDAdd_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAdd class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDAsin_v = HasSIMDAsin<T>::value |
Auxiliary variable template for the HasSIMDAsin type trait.The HasSIMDAsin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsin class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDAsinh_v = HasSIMDAsinh<T>::value |
Auxiliary variable template for the HasSIMDAsinh type trait.The HasSIMDAsinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsinh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDAtan2_v = HasSIMDAtan2<T1,T2>::value |
Auxiliary variable template for the HasSIMDAtan2 type trait.The HasSIMDAtan2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDAtan_v = HasSIMDAtan<T>::value |
Auxiliary variable template for the HasSIMDAtan type trait.The HasSIMDAtan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDAtanh_v = HasSIMDAtanh<T>::value |
Auxiliary variable template for the HasSIMDAtanh type trait.The HasSIMDAtanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtanh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDBitand_v = HasSIMDBitand<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitand type trait.The HasSIMDBitand_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitand class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDBitor_v = HasSIMDBitor<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitor type trait.The HasSIMDBitor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitor class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDBitxor_v = HasSIMDBitxor<T1,T2>::value |
Auxiliary variable template for the HasSIMDBitxor type trait.The HasSIMDBitxor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDBitxor class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDCbrt_v = HasSIMDCbrt<T>::value |
Auxiliary variable template for the HasSIMDCbrt type trait.The HasSIMDCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCbrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDCeil_v = HasSIMDCeil<T>::value |
Auxiliary variable template for the HasSIMDCeil type trait.The HasSIMDCeil_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCeil class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDConj_v = HasSIMDConj<T>::value |
Auxiliary variable template for the HasSIMDConj type trait.The HasSIMDConj_v variable template provides a convenient shortcut to access the nested value of the HasSIMDConj class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDCos_v = HasSIMDCos<T>::value |
Auxiliary variable template for the HasSIMDCos type trait.The HasSIMDCos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCos class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDCosh_v = HasSIMDCosh<T>::value |
Auxiliary variable template for the HasSIMDCosh type trait.The HasSIMDCosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCosh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDDiv_v = HasSIMDDiv<T1,T2>::value |
Auxiliary variable template for the HasSIMDDiv type trait.The HasSIMDDiv_v variable template provides a convenient shortcut to access the nested value of the HasSIMDDiv class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDEqual_v = HasSIMDEqual<T1,T2>::value |
Auxiliary variable template for the HasSIMDEqual type trait.The HasSIMDEqual_v variable template provides a convenient shortcut to access the nested value of the HasSIMDEqual class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDErf_v = HasSIMDErf<T>::value |
Auxiliary variable template for the HasSIMDErf type trait.The HasSIMDErf_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErf class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDErfc_v = HasSIMDErfc<T>::value |
Auxiliary variable template for the HasSIMDErfc type trait.The HasSIMDErfc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErfc class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDExp10_v = HasSIMDExp10<T>::value |
Auxiliary variable template for the HasSIMDExp10 type trait.The HasSIMDExp10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp10 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDExp2_v = HasSIMDExp2<T>::value |
Auxiliary variable template for the HasSIMDExp2 type trait.The HasSIMDExp2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp2 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDExp_v = HasSIMDExp<T>::value |
Auxiliary variable template for the HasSIMDExp type trait.The HasSIMDExp_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDFloor_v = HasSIMDFloor<T>::value |
Auxiliary variable template for the HasSIMDFloor type trait.The HasSIMDFloor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDFloor class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDHypot_v = HasSIMDHypot<T1,T2>::value |
Auxiliary variable template for the HasSIMDHypot type trait.The HasSIMDHypot_v variable template provides a convenient shortcut to access the nested value of the HasSIMDHypot class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDInvCbrt_v = HasSIMDInvCbrt<T>::value |
Auxiliary variable template for the HasSIMDInvCbrt type trait.The HasSIMDInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvCbrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDInvSqrt_v = HasSIMDInvSqrt<T>::value |
Auxiliary variable template for the HasSIMDInvSqrt type trait.The HasSIMDInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvSqrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDLog10_v = HasSIMDLog10<T>::value |
Auxiliary variable template for the HasSIMDLog10 type trait.The HasSIMDLog10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog10 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDLog2_v = HasSIMDLog2<T>::value |
Auxiliary variable template for the HasSIMDLog2 type trait.The HasSIMDLog2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog2 class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDLog_v = HasSIMDLog<T>::value |
Auxiliary variable template for the HasSIMDLog type trait.The HasSIMDLog_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDMax_v = HasSIMDMax<T1,T2>::value |
Auxiliary variable template for the HasSIMDMax type trait.The HasSIMDMax_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMax class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDMin_v = HasSIMDMin<T1,T2>::value |
Auxiliary variable template for the HasSIMDMin type trait.The HasSIMDMin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMin class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDMult_v = HasSIMDMult<T1,T2>::value |
Auxiliary variable template for the HasSIMDMult type trait.The HasSIMDMult_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMult class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDPow_v = HasSIMDPow<T1,T2>::value |
Auxiliary variable template for the HasSIMDPow type trait.The HasSIMDPow_v variable template provides a convenient shortcut to access the nested value of the HasSIMDPow class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDRound_v = HasSIMDRound<T>::value |
Auxiliary variable template for the HasSIMDRound type trait.The HasSIMDRound_v variable template provides a convenient shortcut to access the nested value of the HasSIMDRound class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDShiftLI_v = HasSIMDShiftLI<T>::value |
Auxiliary variable template for the HasSIMDShiftLI type trait.The HasSIMDShiftLI_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftLI class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDShiftLV_v = HasSIMDShiftLV<T1,T2>::value |
Auxiliary variable template for the HasSIMDShiftLV type trait.The HasSIMDShiftLV_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftLV class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDShiftRI_v = HasSIMDShiftRI<T>::value |
Auxiliary variable template for the HasSIMDShiftRI type trait.The HasSIMDShiftRI_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftRI class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDShiftRV_v = HasSIMDShiftRV<T1,T2>::value |
Auxiliary variable template for the HasSIMDShiftRV type trait.The HasSIMDShiftRV_v variable template provides a convenient shortcut to access the nested value of the HasSIMDShiftRV class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDSign_v = HasSIMDSign<T>::value |
Auxiliary variable template for the HasSIMDSign type trait.The HasSIMDSign_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSign class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDSin_v = HasSIMDSin<T>::value |
Auxiliary variable template for the HasSIMDSin type trait.The HasSIMDSin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSin class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDSinh_v = HasSIMDSinh<T>::value |
Auxiliary variable template for the HasSIMDSinh type trait.The HasSIMDSinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSinh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDSqrt_v = HasSIMDSqrt<T>::value |
Auxiliary variable template for the HasSIMDSqrt type trait.The HasSIMDSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSqrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDSub_v = HasSIMDSub<T1,T2>::value |
Auxiliary variable template for the HasSIMDSub type trait.The HasSIMDSub_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSub class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasSIMDTan_v = HasSIMDTan<T>::value |
Auxiliary variable template for the HasSIMDTan type trait.The HasSIMDTan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTan class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDTanh_v = HasSIMDTanh<T>::value |
Auxiliary variable template for the HasSIMDTanh type trait.The HasSIMDTanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTanh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSIMDTrunc_v = HasSIMDTrunc<T>::value |
Auxiliary variable template for the HasSIMDTrunc type trait.The HasSIMDTrunc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTrunc class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSin_v = HasSin<T>::value |
Auxiliary variable template for the HasSin type trait.The HasSin_v variable template provides a convenient shortcut to access the nested value of the HasSin class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSinh_v = HasSinh<T>::value |
Auxiliary variable template for the HasSinh type trait.The HasSinh_v variable template provides a convenient shortcut to access the nested value of the HasSinh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSqrt_v = HasSqrt<T>::value |
Auxiliary variable template for the HasSqrt type trait.The HasSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSqrt class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasSub_v = HasSub<T1,T2>::value |
Auxiliary variable template for the HasSub type trait.The HasSub_v variable template provides a convenient shortcut to access the nested value of the HasSub class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::HasTan_v = HasTan<T>::value |
Auxiliary variable template for the HasTan type trait.The HasTan_v variable template provides a convenient shortcut to access the nested value of the HasTan class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasTanh_v = HasTanh<T>::value |
Auxiliary variable template for the HasTanh type trait.The HasTanh_v variable template provides a convenient shortcut to access the nested value of the HasTanh class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::HasTrunc_v = HasTrunc<T>::value |
Auxiliary variable template for the HasTrunc type trait.The HasTrunc_v variable template provides a convenient shortcut to access the nested value of the HasTrunc class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsAdaptor_v = IsAdaptor<T>::value |
Auxiliary variable template for the IsAdaptor type trait.The IsAdaptor_v variable template provides a convenient shortcut to access the nested value of the IsAdaptor class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsAddExpr_v = IsAddExpr<T>::value |
Auxiliary variable template for the IsAddExpr type trait.The IsAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsAddExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsAligned_v = IsAligned<T>::value |
Auxiliary variable template for the IsAligned type trait.The IsAligned_v variable template provides a convenient shortcut to access the nested value of the IsAligned class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsBand_v = IsBand<T>::value |
Auxiliary variable template for the IsBand type trait.The IsBand_v variable template provides a convenient shortcut to access the nested value of the IsBand class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsBinaryMapExpr_v = IsBinaryMapExpr<T>::value |
Auxiliary variable template for the IsBinaryMapExpr type trait.The IsBinaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsBinaryMapExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsBLASCompatible_v = IsBLASCompatible<T>::value |
Auxiliary variable template for the IsBLASCompatible type trait.The IsBLASCompatible_v variable template provides a convenient shortcut to access the nested value of the IsBLASCompatible class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsColumn_v = IsColumn<T>::value |
Auxiliary variable template for the IsColumn type trait.The IsColumn_v variable template provides a convenient shortcut to access the nested value of the IsColumn class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsColumnMajorMatrix_v = IsColumnMajorMatrix<T>::value |
Auxiliary variable template for the IsColumnMajorMatrix type trait.The IsColumnMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsColumnMajorMatrix class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsColumns_v = IsColumns<T>::value |
Auxiliary variable template for the IsColumns type trait.The IsColumns_v variable template provides a convenient shortcut to access the nested value of the IsColumns class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsColumnVector_v = IsColumnVector<T>::value |
Auxiliary variable template for the IsColumnVector type trait.The IsColumnVector_v variable template provides a convenient shortcut to access the nested value of the IsColumnVector class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsCommutative_v = IsCommutative<T1,T2>::value |
Auxiliary variable template for the IsCommutative type trait.The IsCommutative_v variable template provides a convenient shortcut to access the nested value of the IsCommutative class template. For instance, given the type1 T1 and T2 the following two statements are identical:
constexpr bool blaze::IsComputation_v = IsComputation<T>::value |
Auxiliary variable template for the IsComputation type trait.The IsComputation_v variable template provides a convenient shortcut to access the nested value of the IsComputation class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsContiguous_v = IsContiguous<T>::value |
Auxiliary variable template for the IsContiguous type trait.The IsContiguous_v variable template provides a convenient shortcut to access the nested value of the IsContiguous class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsCrossExpr_v = IsCrossExpr<T>::value |
Auxiliary variable template for the IsCrossExpr type trait.The IsCrossExpr_v variable template provides a convenient shortcut to access the nested value of the IsCrossExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsCustom_v = IsCustom<T>::value |
Auxiliary variable template for the IsCustom type trait.The IsCustom_v variable template provides a convenient shortcut to access the nested value of the IsCustom class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDeclaration_v = IsDeclaration<T>::value |
Auxiliary variable template for the IsDeclaration type trait.The IsDeclaration_v variable template provides a convenient shortcut to access the nested value of the IsDeclaration class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDeclDiagExpr_v = IsDeclDiagExpr<T>::value |
Auxiliary variable template for the IsDeclDiagExpr type trait.The IsDeclDiagExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclDiagExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDeclExpr_v = IsDeclExpr<T>::value |
Auxiliary variable template for the IsDeclExpr type trait.The IsDeclExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDeclHermExpr_v = IsDeclHermExpr<T>::value |
Auxiliary variable template for the IsDeclHermExpr type trait.The IsDeclHermExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclHermExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDeclLowExpr_v = IsDeclLowExpr<T>::value |
Auxiliary variable template for the IsDeclLowExpr type trait.The IsDeclLowExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclLowExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDeclSymExpr_v = IsDeclSymExpr<T>::value |
Auxiliary variable template for the IsDeclSymExpr type trait.The IsDeclSymExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclSymExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDeclUppExpr_v = IsDeclUppExpr<T>::value |
Auxiliary variable template for the IsDeclUppExpr type trait.The IsDeclUppExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclUppExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDenseMatrix_v = IsDenseMatrix<T>::value |
Auxiliary variable template for the IsDenseMatrix type trait.The IsDenseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsDenseMatrix class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDenseVector_v = IsDenseVector<T>::value |
Auxiliary variable template for the IsDenseVector type trait.The IsDenseVector_v variable template provides a convenient shortcut to access the nested value of the IsDenseVector class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDiagonal_v = IsDiagonal<T>::value |
Auxiliary variable template for the IsDiagonal type trait.The IsDiagonal_v variable template provides a convenient shortcut to access the nested value of the IsDiagonal class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsDivExpr_v = IsDivExpr<T>::value |
Auxiliary variable template for the IsDivExpr type trait.The IsDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsDivExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsElements_v = IsElements<T>::value |
Auxiliary variable template for the IsElements type trait.The IsElements_v variable template provides a convenient shortcut to access the nested value of the IsElements class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsEvalExpr_v = IsEvalExpr<T>::value |
Auxiliary variable template for the IsEvalExpr type trait.The IsEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsEvalExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsExpandExpr_v = IsExpandExpr<T>::value |
Auxiliary variable template for the IsExpandExpr type trait.The IsExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsExpandExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsExpression_v = IsExpression<T>::value |
Auxiliary variable template for the IsExpression type trait.The IsExpression_v variable template provides a convenient shortcut to access the nested value of the IsExpression class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsGeneral_v = IsGeneral<T>::value |
Auxiliary variable template for the IsGeneral type trait.The IsGeneral_v variable template provides a convenient shortcut to access the nested value of the IsGeneral class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsHermitian_v = IsHermitian<T>::value |
Auxiliary variable template for the IsHermitian type trait.The IsHermitian_v variable template provides a convenient shortcut to access the nested value of the IsHermitian class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsIdentity_v = IsIdentity<T>::value |
Auxiliary variable template for the IsIdentity type trait.The IsIdentity_v variable template provides a convenient shortcut to access the nested value of the IsIdentity class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsInitializer_v = IsInitializer<T>::value |
Auxiliary variable template for the IsInitializer type trait.The IsInitializer_v variable template provides a convenient shortcut to access the nested value of the IsInitializer class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsInvertible_v = IsInvertible<T>::value |
Auxiliary variable template for the IsInvertible type trait.The IsInvertible_v variable template provides a convenient shortcut to access the nested value of the IsInvertible class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsKronExpr_v = IsKronExpr<T>::value |
Auxiliary variable template for the IsKronExpr type trait.The IsKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsKronExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsLower_v = IsLower<T>::value |
Auxiliary variable template for the IsLower type trait.The IsLower_v variable template provides a convenient shortcut to access the nested value of the IsLower class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatEvalExpr_v = IsMatEvalExpr<T>::value |
Auxiliary variable template for the IsMatEvalExpr type trait.The IsMatEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatEvalExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatInvExpr_v = IsMatInvExpr<T>::value |
Auxiliary variable template for the IsMatInvExpr type trait.The IsMatInvExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatInvExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatMapExpr_v = IsMatMapExpr<T>::value |
Auxiliary variable template for the IsMatMapExpr type trait.The IsMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMapExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatMatAddExpr_v = IsMatMatAddExpr<T>::value |
Auxiliary variable template for the IsMatMatAddExpr type trait.The IsMatMatAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatAddExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatMatKronExpr_v = IsMatMatKronExpr<T>::value |
Auxiliary variable template for the IsMatMatKronExpr type trait.The IsMatMatKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatKronExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatMatMapExpr_v = IsMatMatMapExpr<T>::value |
Auxiliary variable template for the IsMatMatMapExpr type trait.The IsMatMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMapExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatMatMultExpr_v = IsMatMatMultExpr<T>::value |
Auxiliary variable template for the IsMatMatMultExpr type trait.The IsMatMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatMatSubExpr_v = IsMatMatSubExpr<T>::value |
Auxiliary variable template for the IsMatMatSubExpr type trait.The IsMatMatSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatSubExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatReduceExpr_v = IsMatReduceExpr<T>::value |
Auxiliary variable template for the IsMatReduceExpr type trait.The IsMatReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatReduceExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatrix_v = IsMatrix<T>::value |
Auxiliary variable template for the IsMatrix type trait.The IsMatrix_v variable template provides a convenient shortcut to access the nested value of the IsMatrix class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatScalarDivExpr_v = IsMatScalarDivExpr<T>::value |
Auxiliary variable template for the IsMatScalarDivExpr type trait.The IsMatScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarDivExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatScalarMultExpr_v = IsMatScalarMultExpr<T>::value |
Auxiliary variable template for the IsMatScalarMultExpr type trait.The IsMatScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatSerialExpr_v = IsMatSerialExpr<T>::value |
Auxiliary variable template for the IsMatSerialExpr type trait.The IsMatSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatSerialExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatTransExpr_v = IsMatTransExpr<T>::value |
Auxiliary variable template for the IsMatTransExpr type trait.The IsMatTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatTransExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMatVecMultExpr_v = IsMatVecMultExpr<T>::value |
Auxiliary variable template for the IsMatVecMultExpr type trait.The IsMatVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatVecMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsMultExpr_v = IsMultExpr<T>::value |
Auxiliary variable template for the IsMultExpr type trait.The IsMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsNumericMatrix_v = IsNumericMatrix<T>::value |
Auxiliary variable template for the IsNumericMatrix type trait.The IsNumericMatrix_v variable template provides a convenient shortcut to access the nested value of the IsNumericMatrix class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsNumericVector_v = IsNumericVector<T>::value |
Auxiliary variable template for the IsNumericVector type trait.The IsNumericVector_v variable template provides a convenient shortcut to access the nested value of the IsNumericVector class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsOperation_v = IsOperation<T>::value |
Auxiliary variable template for the IsOperation type trait.The IsOperation_v variable template provides a convenient shortcut to access the nested value of the IsOperation class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsOpposedView_v = IsOpposedView<T>::value |
Auxiliary variable template for the IsOpposedView type trait.The IsOpposedView_v variable template provides a convenient shortcut to access the nested value of the IsOpposedView class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsPadded_v = IsPadded<T>::value |
Auxiliary variable template for the IsPadded type trait.The IsPadded_v variable template provides a convenient shortcut to access the nested value of the IsPadded class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsPaddingEnabled_v = IsPaddingEnabled<T>::value |
Auxiliary variable template for the IsPaddingEnabled type trait.The IsPaddingEnabled_v variable template provides a convenient shortcut to access the nested value of the IsPaddingEnabled class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsProxy_v = IsProxy<T>::value |
Auxiliary variable template for the IsProxy type trait.The IsProxy_v variable template provides a convenient shortcut to access the nested value of the IsProxy class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsReduceExpr_v = IsReduceExpr<T>::value |
Auxiliary variable template for the IsReduceExpr type trait.The IsReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsReduceExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsResizable_v = IsResizable<T>::value |
Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provides a convenient shortcut to access the nested value of the IsResizable class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsRestricted_v = IsRestricted<T>::value |
Auxiliary variable template for the IsRestricted type trait.The IsRestricted_v variable template provides a convenient shortcut to access the nested value of the IsRestricted class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsRow_v = IsRow<T>::value |
Auxiliary variable template for the IsRow type trait.The IsRow_v variable template provides a convenient shortcut to access the nested value of the IsRow class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsRowMajorMatrix_v = IsRowMajorMatrix<T>::value |
Auxiliary variable template for the IsRowMajorMatrix type trait.The IsRowMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsRowMajorMatrix class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsRows_v = IsRows<T>::value |
Auxiliary variable template for the IsRows type trait.The IsRows_v variable template provides a convenient shortcut to access the nested value of the IsRows class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsRowVector_v = IsRowVector<T>::value |
Auxiliary variable template for the IsRowVector type trait.The IsRowVector_v variable template provides a convenient shortcut to access the nested value of the IsRowVector class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSchurExpr_v = IsSchurExpr<T>::value |
Auxiliary variable template for the IsSchurExpr type trait.The IsSchurExpr_v variable template provides a convenient shortcut to access the nested value of the IsSchurExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSerialExpr_v = IsSerialExpr<T>::value |
Auxiliary variable template for the IsSerialExpr type trait.The IsSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsSerialExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsShrinkable_v = IsShrinkable<T>::value |
Auxiliary variable template for the IsShrinkable type trait.The IsShrinkable_v variable template provides a convenient shortcut to access the nested value of the IsShrinkable class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSIMDCombinable_v = IsSIMDCombinable<T1,T2,Ts...>::value |
Auxiliary variable template for the IsSIMDCombinable type trait.The IsSIMDCombinable_v variable template provides a convenient shortcut to access the nested value of the IsSIMDCombinable class template. For instance, given the types T1 and T2 the following two statements are identical:
constexpr bool blaze::IsSIMDEnabled_v = IsSIMDEnabled<T,Args...>::value |
Auxiliary variable template for the IsSIMDEnabled type trait.The IsSIMDEnabled_v variable template provides a convenient shortcut to access the nested value of the IsSIMDEnabled class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSIMDPack_v = IsSIMDPack<T>::value |
Auxiliary variable template for the IsSIMDPack type trait.The IsSIMDPack_v variable template provides a convenient shortcut to access the nested value of the IsSIMDPack class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSMPAssignable_v = IsSMPAssignable<T>::value |
Auxiliary variable template for the IsSMPAssignable type trait.The IsSMPAssignable_v variable template provides a convenient shortcut to access the nested value of the IsSMPAssignable class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSparseElement_v = IsSparseElement<T>::value |
Auxiliary variable template for the IsSparseElement type trait.The IsSparseElement_v variable template provides a convenient shortcut to access the nested value of the IsSparseElement class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSparseMatrix_v = IsSparseMatrix<T>::value |
Auxiliary variable template for the IsSparseMatrix type trait.The IsSparseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsSparseMatrix class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSparseVector_v = IsSparseVector<T>::value |
Auxiliary variable template for the IsSparseVector type trait.The IsSparseVector_v variable template provides a convenient shortcut to access the nested value of the IsSparseVector class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSquare_v = IsSquare<T>::value |
Auxiliary variable template for the IsSquare type trait.The IsSquare_v variable template provides a convenient shortcut to access the nested value of the IsSquare class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsStatic_v = IsStatic<T>::value |
Auxiliary variable template for the IsStatic type trait.The IsStatic_v variable template provides a convenient shortcut to access the nested value of the IsStatic class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsStrictlyLower_v = IsStrictlyLower<T>::value |
Auxiliary variable template for the IsStrictlyLower type trait.The IsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyLower class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsStrictlyTriangular_v = IsStrictlyTriangular<T>::value |
Auxiliary variable template for the IsStrictlyTriangular type trait.The IsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyTriangular class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsStrictlyUpper_v = IsStrictlyUpper<T>::value |
Auxiliary variable template for the IsStrictlyUpper type trait.The IsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyUpper class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSubExpr_v = IsSubExpr<T>::value |
Auxiliary variable template for the IsSubExpr type trait.The IsSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsSubExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSubmatrix_v = IsSubmatrix<T>::value |
Auxiliary variable template for the IsSubmatrix type trait.The IsSubmatrix_v variable template provides a convenient shortcut to access the nested value of the IsSubmatrix class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSubvector_v = IsSubvector<T>::value |
Auxiliary variable template for the IsSubvector type trait.The IsSubvector_v variable template provides a convenient shortcut to access the nested value of the IsSubvector class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsSymmetric_v = IsSymmetric<T>::value |
Auxiliary variable template for the IsSymmetric type trait.The IsSymmetric_v variable template provides a convenient shortcut to access the nested value of the IsSymmetric class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsTemporary_v = IsTemporary<T>::value |
Auxiliary variable template for the IsTemporary type trait.The IsTemporary_v variable template provides a convenient shortcut to access the nested value of the IsTemporary class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsTransExpr_v = IsTransExpr<T>::value |
Auxiliary variable template for the IsTransExpr type trait.The IsTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsTransExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsTransformation_v = IsTransformation<T>::value |
Auxiliary variable template for the IsTransformation type trait.The IsTransformation_v variable template provides a convenient shortcut to access the nested value of the IsTransformation class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsTriangular_v = IsTriangular<T>::value |
Auxiliary variable template for the IsTriangular type trait.The IsTriangular_v variable template provides a convenient shortcut to access the nested value of the IsTriangular class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsTVecMatMultExpr_v = IsTVecMatMultExpr<T>::value |
Auxiliary variable template for the IsTVecMatMultExpr type trait.The IsTVecMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsTVecMatMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsUnaryMapExpr_v = IsUnaryMapExpr<T>::value |
Auxiliary variable template for the IsUnaryMapExpr type trait.The IsUnaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsUnaryMapExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsUniform_v = IsUniform<T>::value |
Auxiliary variable template for the IsUniform type trait.The IsUniform_v variable template provides a convenient shortcut to access the nested value of the IsUniform class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsUniLower_v = IsUniLower<T>::value |
Auxiliary variable template for the IsUniLower type trait.The IsUniLower_v variable template provides a convenient shortcut to access the nested value of the IsUniLower class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsUniTriangular_v = IsUniTriangular<T>::value |
Auxiliary variable template for the IsUniTriangular type trait.The IsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the IsUniTriangular class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsUniUpper_v = IsUniUpper<T>::value |
Auxiliary variable template for the IsUniUpper type trait.The IsUniUpper_v variable template provides a convenient shortcut to access the nested value of the IsUniUpper class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsUpper_v = IsUpper<T>::value |
Auxiliary variable template for the IsUpper type trait.The IsUpper_v variable template provides a convenient shortcut to access the nested value of the IsUpper class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecEvalExpr_v = IsVecEvalExpr<T>::value |
Auxiliary variable template for the IsVecEvalExpr type trait.The IsVecEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecEvalExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecExpandExpr_v = IsVecExpandExpr<T>::value |
Auxiliary variable template for the IsVecExpandExpr type trait.The IsVecExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecExpandExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecMapExpr_v = IsVecMapExpr<T>::value |
Auxiliary variable template for the IsVecMapExpr type trait.The IsVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecMapExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecScalarDivExpr_v = IsVecScalarDivExpr<T>::value |
Auxiliary variable template for the IsVecScalarDivExpr type trait.The IsVecScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarDivExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecScalarMultExpr_v = IsVecScalarMultExpr<T>::value |
Auxiliary variable template for the IsVecScalarMultExpr type trait.The IsVecScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecSerialExpr_v = IsVecSerialExpr<T>::value |
Auxiliary variable template for the IsVecSerialExpr type trait.The IsVecSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecSerialExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVector_v = IsVector<T>::value |
Auxiliary variable template for the IsVector type trait.The IsVector_v variable template provides a convenient shortcut to access the nested value of the IsVector class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecTransExpr_v = IsVecTransExpr<T>::value |
Auxiliary variable template for the IsVecTransExpr type trait.The IsVecTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTransExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecTVecMultExpr_v = IsVecTVecMultExpr<T>::value |
Auxiliary variable template for the IsVecTVecMultExpr type trait.The IsVecTVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTVecMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecVecAddExpr_v = IsVecVecAddExpr<T>::value |
Auxiliary variable template for the IsVecVecAddExpr type trait.The IsVecVecAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecAddExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecVecDivExpr_v = IsVecVecDivExpr<T>::value |
Auxiliary variable template for the IsVecVecDivExpr type trait.The IsVecVecDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecDivExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecVecKronExpr_v = IsVecVecKronExpr<T>::value |
Auxiliary variable template for the IsVecVecKronExpr type trait.The IsVecVecKronExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecKronExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecVecMapExpr_v = IsVecVecMapExpr<T>::value |
Auxiliary variable template for the IsVecVecMapExpr type trait.The IsVecVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMapExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecVecMultExpr_v = IsVecVecMultExpr<T>::value |
Auxiliary variable template for the IsVecVecMultExpr type trait.The IsVecVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMultExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsVecVecSubExpr_v = IsVecVecSubExpr<T>::value |
Auxiliary variable template for the IsVecVecSubExpr type trait.The IsVecVecSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecSubExpr class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsView_v = IsView<T>::value |
Auxiliary variable template for the IsView type trait.The IsView_v variable template provides a convenient shortcut to access the nested value of the IsView class template. For instance, given the type T the following two statements are identical:
constexpr bool blaze::IsZero_v = IsZero<T>::value |
Auxiliary variable template for the IsZero type trait.The IsZero_v variable template provides a convenient shortcut to access the nested value of the IsZero class template. For instance, given the type T the following two statements are identical:
Auxiliary variable template for the MaxSize type trait.The MaxSize_v variable template provides a convenient shortcut to access the nested value of the MaxSize class template. For instance, given the type T and the dimension N the following two statements are identical:
constexpr bool blaze::RequiresEvaluation_v = RequiresEvaluation<T>::value |
Auxiliary variable template for the RequiresEvaluation type trait.The RequiresEvaluation_v variable template provides a convenient shortcut to access the nested value of the RequiresEvaluation class template. For instance, given the type T the following two statements are identical:
Auxiliary variable template for the Size type trait.The Size_v variable template provides a convenient shortcut to access the nested value of the Size class template. For instance, given the type T and the dimension N the following two statements are identical:
constexpr bool blaze::StorageOrder_v = T::storageOrder |
Auxiliary variable template for the StorageOrder type trait.The StorageOrder_v variable template provides a convenient shortcut to access the nested value of the StorageOrder class template. For instance, given the matrix type T the following two statements are identical:
constexpr bool blaze::TransposeFlag_v = T::transposeFlag |
Auxiliary variable template for the TransposeFlag type trait.The TransposeFlag_v variable template provides a convenient shortcut to access the nested value of the TransposeFlag class template. For instance, given the vector type T the following two statements are identical:
constexpr bool blaze::YieldsDiagonal_v = YieldsDiagonal<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsDiagonal type trait.The YieldsDiagonal_v variable template provides a convenient shortcut to access the nested value of the YieldsDiagonal class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsHermitian_v = YieldsHermitian<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsHermitian type trait.The YieldsHermitian_v variable template provides a convenient shortcut to access the nested value of the YieldsHermitian class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsIdentity_v = YieldsIdentity<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsIdentity type trait.The YieldsIdentity_v variable template provides a convenient shortcut to access the nested value of the YieldsIdentity class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsLower_v = YieldsLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsLower type trait.The YieldsLower_v variable template provides a convenient shortcut to access the nested value of the YieldsLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsStrictlyLower_v = YieldsStrictlyLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyLower type trait.The YieldsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsStrictlyTriangular_v = YieldsStrictlyTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyTriangular type trait.The YieldsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsStrictlyUpper_v = YieldsStrictlyUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsStrictlyUpper type trait.The YieldsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsSymmetric_v = YieldsSymmetric<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsSymmetric type trait.The YieldsSymmetric_v variable template provides a convenient shortcut to access the nested value of the YieldsSymmetric class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsTriangular_v = YieldsTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsTriangular type trait.The YieldsTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsUniform_v = YieldsUniform<OP,T,Ts...>::value |
Auxiliary variable template for the YieldsUniform type trait.The YieldsUniform_v variable template provides a convenient shortcut to access the nested value of the YieldsUniform class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical:
constexpr bool blaze::YieldsUniLower_v = YieldsUniLower<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniLower type trait.The YieldsUniLower_v variable template provides a convenient shortcut to access the nested value of the YieldsUniLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsUniTriangular_v = YieldsUniTriangular<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniTriangular type trait.The YieldsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsUniTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsUniUpper_v = YieldsUniUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUniUpper type trait.The YieldsUniUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUniUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsUpper_v = YieldsUpper<OP,MT,MTs...>::value |
Auxiliary variable template for the YieldsUpper type trait.The YieldsUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:
constexpr bool blaze::YieldsZero_v = YieldsZero<OP,T,Ts...>::value |
Auxiliary variable template for the YieldsZero type trait.The YieldsZero_v variable template provides a convenient shortcut to access the nested value of the YieldsZero class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical: