Blaze 3.9
Classes | Macros | Typedefs | Functions | Variables
Type traits

Classes

struct  blaze::CustomOppositeType< T >
 Evaluation of the custom opposite type. More...
 
struct  blaze::CustomTransposeType< T >
 Evaluation of the custom transpose type. More...
 
struct  blaze::DynamicAllocator< A1, As >
 Deduction of an allocator type for dynamic vectors and matrices. More...
 
struct  blaze::HasAbs< T, typename >
 Availability of the abs() operation for the given data types. More...
 
struct  blaze::HasAcos< T, typename >
 Availability of the acos() operation for the given data types. More...
 
struct  blaze::HasAcosh< T, typename >
 Availability of the acosh() operation for the given data types. More...
 
struct  blaze::HasAdd< T1, T2, typename >
 Availability of an addition operator for the given data types. More...
 
struct  blaze::HasAsin< T, typename >
 Availability of the asin() operation for the given data types. More...
 
struct  blaze::HasAsinh< T, typename >
 Availability of the asinh() operation for the given data types. More...
 
struct  blaze::HasAtan< T, typename >
 Availability of the atan() operation for the given data types. More...
 
struct  blaze::HasAtan2< T1, T2, typename >
 Availability of the atan2() operation for the given data types. More...
 
struct  blaze::HasAtanh< T, typename >
 Availability of the atanh() operation for the given data types. More...
 
struct  blaze::HasCbrt< T, typename >
 Availability of the cbrt() operation for the given data types. More...
 
struct  blaze::HasCeil< T, typename >
 Availability of the ceil() operation for the given data types. More...
 
struct  blaze::HasClamp< T, typename >
 Availability of the clamp() operation for the given data types. More...
 
struct  blaze::HasConj< T, typename >
 Availability of the conj() operation for the given data types. More...
 
struct  blaze::HasConstDataAccess< T >
 Compile time check for low-level access to constant data. More...
 
struct  blaze::HasCos< T, typename >
 Availability of the cos() operation for the given data types. More...
 
struct  blaze::HasCosh< T, typename >
 Availability of the cosh() operation for the given data types. More...
 
struct  blaze::HasDiv< T1, T2, typename >
 Availability of a division operator for the given data types. More...
 
struct  blaze::HasErf< T, typename >
 Availability of the erf() operation for the given data types. More...
 
struct  blaze::HasErfc< T, typename >
 Availability of the erfc() operation for the given data types. More...
 
struct  blaze::HasExp< T, typename >
 Availability of the exp() operation for the given data types. More...
 
struct  blaze::HasExp10< T, typename >
 Availability of the exp10() operation for the given data types. More...
 
struct  blaze::HasExp2< T, typename >
 Availability of the exp2() operation for the given data types. More...
 
struct  blaze::HasFloor< T, typename >
 Availability of the floor() operation for the given data types. More...
 
struct  blaze::HasHypot< T1, T2, typename >
 Availability of the hypot() operation for the given data types. More...
 
struct  blaze::HasImag< T, typename >
 Availability of the imag() operation for the given data types. More...
 
struct  blaze::HasInvCbrt< T, typename >
 Availability of the invcbrt() operation for the given data types. More...
 
struct  blaze::HasInvSqrt< T, typename >
 Availability of the invsqrt() operation for the given data types. More...
 
struct  blaze::HasLGamma< T, typename >
 Availability of the lgamma() operation for the given data types. More...
 
struct  blaze::HasLog< T, typename >
 Availability of the log() operation for the given data types. More...
 
struct  blaze::HasLog10< T, typename >
 Availability of the log10() operation for the given data types. More...
 
struct  blaze::HasLog1p< T, typename >
 Availability of the log1p() operation for the given data types. More...
 
struct  blaze::HasLog2< T, typename >
 Availability of the log2() operation for the given data types. More...
 
struct  blaze::HasMax< T1, T2, typename >
 Availability of a max() operation for the given data types. More...
 
struct  blaze::HasMin< T1, T2, typename >
 Availability of a min() operation for the given data types. More...
 
struct  blaze::HasMult< T1, T2, typename >
 Availability of a multiplication operator for the given data types. More...
 
struct  blaze::HasMutableDataAccess< T >
 Compile time check for low-level access to mutable data. More...
 
struct  blaze::HasPow< T1, T2, typename >
 Availability of the pow() operation for the given data types. More...
 
struct  blaze::HasReal< T, typename >
 Availability of the real() operation for the given data types. More...
 
struct  blaze::HasRound< T, typename >
 Availability of the round() operation for the given data types. More...
 
struct  blaze::HasSign< T, typename >
 Availability of the sign() operation for the given data types. More...
 
struct  blaze::HasSIMDAbs< T >
 Availability of a SIMD absolute value operation for the given data type. More...
 
struct  blaze::HasSIMDAcos< T >
 Availability of a SIMD inverse cosine operation for the given data type. More...
 
struct  blaze::HasSIMDAcosh< T >
 Availability of a SIMD inverse hyperbolic cosine operation for the given data type. More...
 
struct  blaze::HasSIMDAdd< T1, T2, typename >
 Availability of a SIMD addition for the given data types. More...
 
struct  blaze::HasSIMDAsin< T >
 Availability of a SIMD inverse sine operation for the given data type. More...
 
struct  blaze::HasSIMDAsinh< T >
 Availability of a SIMD inverse hyperbolic sine operation for the given data type. More...
 
struct  blaze::HasSIMDAtan< T >
 Availability of a SIMD inverse tangent operation for the given data type. More...
 
struct  blaze::HasSIMDAtan2< T1, T2 >
 Availability of a SIMD inverse tangent operation for the given data types. More...
 
struct  blaze::HasSIMDAtanh< T >
 Availability of a SIMD inverse hyperbolic tangent operation for the given data type. More...
 
struct  blaze::HasSIMDBitand< T1, T2 >
 Availability of a SIMD bitwise AND ('&') for the given data types. More...
 
struct  blaze::HasSIMDBitor< T1, T2 >
 Availability of a SIMD bitwise OR ('|') for the given data types. More...
 
struct  blaze::HasSIMDBitxor< T1, T2 >
 Availability of a SIMD bitwise XOR ('^') for the given data types. More...
 
struct  blaze::HasSIMDCbrt< T >
 Availability of a SIMD cubic root operation for the given data type. More...
 
struct  blaze::HasSIMDCeil< T >
 Availability of a SIMD ceil operation for the given data type. More...
 
struct  blaze::HasSIMDConj< T >
 Availability of a SIMD conjugate operation for the given data type. More...
 
struct  blaze::HasSIMDCos< T >
 Availability of a SIMD cosine operation for the given data type. More...
 
struct  blaze::HasSIMDCosh< T >
 Availability of a SIMD hyperbolic cosine operation for the given data type. More...
 
struct  blaze::HasSIMDDiv< T1, T2, typename >
 Availability of a SIMD division for the given data types. More...
 
struct  blaze::HasSIMDEqual< T1, T2, typename >
 Availability of a SIMD equality comparison for the given data types. More...
 
struct  blaze::HasSIMDErf< T >
 Availability of a SIMD error function (erf) operation for the given data type. More...
 
struct  blaze::HasSIMDErfc< T >
 Availability of a SIMD complementary error function (erfc) operation for the given data type. More...
 
struct  blaze::HasSIMDExp< T >
 Availability of a SIMD exp() operation for the given data type. More...
 
struct  blaze::HasSIMDExp10< T >
 Availability of a SIMD exp10() operation for the given data type. More...
 
struct  blaze::HasSIMDExp2< T >
 Availability of a SIMD exp2() operation for the given data type. More...
 
struct  blaze::HasSIMDFloor< T >
 Availability of a SIMD floor operation for the given data type. More...
 
struct  blaze::HasSIMDHypot< T1, T2 >
 Availability of a SIMD hypotenous operation for the given data types. More...
 
struct  blaze::HasSIMDInvCbrt< T >
 Availability of a SIMD inverse cubic root operation for the given data type. More...
 
struct  blaze::HasSIMDInvSqrt< T >
 Availability of a SIMD inverse square root operation for the given data type. More...
 
struct  blaze::HasSIMDLGamma< T >
 Availability of a SIMD lgamma operation for the given data type. More...
 
struct  blaze::HasSIMDLog< T >
 Availability of a SIMD natural logarithm operation for the given data type. More...
 
struct  blaze::HasSIMDLog10< T >
 Availability of a SIMD common logarithm operation for the given data type. More...
 
struct  blaze::HasSIMDLog1p< T >
 Availability of a SIMD log1p operation for the given data type. More...
 
struct  blaze::HasSIMDLog2< T >
 Availability of a SIMD binary logarithm operation for the given data type. More...
 
struct  blaze::HasSIMDMax< T1, T2, typename >
 Availability of a SIMD max operation for the given data types. More...
 
struct  blaze::HasSIMDMin< T1, T2, typename >
 Availability of a SIMD min operation for the given data types. More...
 
struct  blaze::HasSIMDMult< T1, T2, typename >
 Availability of a SIMD multiplication for the given data types. More...
 
struct  blaze::HasSIMDPow< T1, T2 >
 Availability of a SIMD power operation for the given data type. More...
 
struct  blaze::HasSIMDRound< T >
 Availability of a SIMD round operation for the given data type. More...
 
struct  blaze::HasSIMDShiftLI< T >
 Availability of a SIMD uniform left-shift for the given data types. More...
 
struct  blaze::HasSIMDShiftLV< T1, T2 >
 Availability of an SIMD elementwise left-shift for the given data types. More...
 
struct  blaze::HasSIMDShiftRI< T >
 Availability of a SIMD uniform right-shift for the given data types. More...
 
struct  blaze::HasSIMDShiftRV< T1, T2 >
 Availability of a SIMD elementwise right-shift for the given data types. More...
 
struct  blaze::HasSIMDSign< T >
 Availability of a SIMD sign operation for the given data type. More...
 
struct  blaze::HasSIMDSin< T >
 Availability of a SIMD sine operation for the given data type. More...
 
struct  blaze::HasSIMDSinh< T >
 Availability of a SIMD hyperbolic sine operation for the given data type. More...
 
struct  blaze::HasSIMDSqrt< T >
 Availability of a SIMD square root operation for the given data type. More...
 
struct  blaze::HasSIMDSub< T1, T2, typename >
 Availability of a SIMD subtraction for the given data types. More...
 
struct  blaze::HasSIMDTan< T >
 Availability of a SIMD tangent operation for the given data type. More...
 
struct  blaze::HasSIMDTanh< T >
 Availability of a SIMD hyperbolic tangent operation for the given data type. More...
 
struct  blaze::HasSIMDTrunc< T >
 Availability of a SIMD trunc operation for the given data type. More...
 
struct  blaze::HasSin< T, typename >
 Availability of the sin() operation for the given data types. More...
 
struct  blaze::HasSinh< T, typename >
 Availability of the sinh() operation for the given data types. More...
 
struct  blaze::HasSqrt< T, typename >
 Availability of the sqrt() operation for the given data types. More...
 
struct  blaze::HasSub< T1, T2, typename >
 Availability of a subtraction operator for the given data types. More...
 
struct  blaze::HasTan< T, typename >
 Availability of the tan() operation for the given data types. More...
 
struct  blaze::HasTanh< T, typename >
 Availability of the tanh() operation for the given data types. More...
 
struct  blaze::HasTrunc< T, typename >
 Availability of the trunc() operation for the given data types. More...
 
struct  blaze::IsAdaptor< T >
 Compile time check for adaptors. More...
 
struct  blaze::IsAddExpr< T >
 Compile time check whether the given type is an addition expression template. More...
 
struct  blaze::IsAligned< T >
 Compile time check for the alignment of data types. More...
 
struct  blaze::IsBand< T >
 Compile time check for bands. More...
 
struct  blaze::IsBinaryMapExpr< T >
 Compile time check whether the given type is a binary map expression template. More...
 
struct  blaze::IsBLASCompatible< T >
 Compile time check for data types. More...
 
struct  blaze::IsClearable< T >
 Compile time check for clearable data types. More...
 
struct  blaze::IsColumn< T >
 Compile time check for columns. More...
 
struct  blaze::IsColumnMajorMatrix< T >
 Compile time check for column-major matrix types. More...
 
struct  blaze::IsColumns< T >
 Compile time check for column selections. More...
 
struct  blaze::IsColumnVector< T >
 Compile time check for column vector types. More...
 
struct  blaze::IsCommutative< T1, T2, typename >
 Compile time check for the commutativity of data types. More...
 
struct  blaze::IsComputation< T >
 Compile time check whether the given type is a computational expression template. More...
 
struct  blaze::IsContiguous< T >
 Compile time check for the memory layout of data types. More...
 
struct  blaze::IsCrossExpr< T >
 Compile time check whether the given type is a cross product expression template. More...
 
struct  blaze::IsCUDAAssignable< T >
 Compile time check for data types. More...
 
struct  blaze::IsCustom< T >
 Compile time check for custom data types. More...
 
struct  blaze::IsDeclaration< T >
 Compile time check whether the given type is a declaration expression template. More...
 
struct  blaze::IsDeclDiagExpr< T >
 Compile time check whether the given type is a decldiag expression template. More...
 
struct  blaze::IsDeclExpr< T >
 Compile time check whether the given type is a declaration expression template. More...
 
struct  blaze::IsDeclHermExpr< T >
 Compile time check whether the given type is a declherm expression template. More...
 
struct  blaze::IsDeclLowExpr< T >
 Compile time check whether the given type is a decllow expression template. More...
 
struct  blaze::IsDeclStrLowExpr< T >
 Compile time check whether the given type is a declstrlow expression template. More...
 
struct  blaze::IsDeclStrUppExpr< T >
 Compile time check whether the given type is a declstrupp expression template. More...
 
struct  blaze::IsDeclSymExpr< T >
 Compile time check whether the given type is a declsym expression template. More...
 
struct  blaze::IsDeclUniLowExpr< T >
 Compile time check whether the given type is a declunilow expression template. More...
 
struct  blaze::IsDeclUniUppExpr< T >
 Compile time check whether the given type is a decluniupp expression template. More...
 
struct  blaze::IsDeclUppExpr< T >
 Compile time check whether the given type is a declupp expression template. More...
 
struct  blaze::IsDenseMatrix< T >
 Compile time check for dense matrix types. More...
 
struct  blaze::IsDenseVector< T >
 Compile time check for dense vector types. More...
 
struct  blaze::IsDiagonal< T >
 Compile time check for diagonal matrices. More...
 
struct  blaze::IsDivExpr< T >
 Compile time check whether the given type is a division expression template. More...
 
struct  blaze::IsEigenExpr< T >
 Compile time check whether the given type is an eigenvalue expression template. More...
 
struct  blaze::IsElements< T >
 Compile time check for element selections. More...
 
struct  blaze::IsEvalExpr< T >
 Compile time check whether the given type is an evaluation expression template. More...
 
struct  blaze::IsExpandExpr< T >
 Compile time check whether the given type is an expansion expression template. More...
 
struct  blaze::IsExpression< T >
 Compile time check whether the given type is an expression template. More...
 
struct  blaze::IsGeneral< T >
 Compile time check for general matrices. More...
 
struct  blaze::IsGenExpr< T >
 Compile time check whether the given type is a generator expression template. More...
 
struct  blaze::IsHermitian< T >
 Compile time check for Hermitian matrices. More...
 
struct  blaze::IsIdentity< T >
 Compile time check for identity matrices. More...
 
struct  blaze::IsInitializer< T >
 Compile time check for custom data types. More...
 
struct  blaze::IsInvertible< T >
 Compile time check for data types. More...
 
struct  blaze::IsKronExpr< T >
 Compile time check whether the given type is a Kronecker product expression template. More...
 
struct  blaze::IsLower< T >
 Compile time check for lower triangular matrices. More...
 
struct  blaze::IsMatEvalExpr< T >
 Compile time check whether the given type is a matrix evaluation expression template. More...
 
struct  blaze::IsMatExpExpr< T >
 Compile time check whether the given type is a matrix exponential expression template. More...
 
struct  blaze::IsMatGenExpr< T >
 Compile time check whether the given type is a matrix generator expression template. More...
 
struct  blaze::IsMatInvExpr< T >
 Compile time check whether the given type is a matrix inversion expression template. More...
 
struct  blaze::IsMatMapExpr< T >
 Compile time check whether the given type is a unary matrix map expression template. More...
 
struct  blaze::IsMatMatAddExpr< T >
 Compile time check whether the given type is a matrix/matrix addition expression template. More...
 
struct  blaze::IsMatMatKronExpr< T >
 Compile time check whether the given type is a matrix/matrix Kronecker product expression template. More...
 
struct  blaze::IsMatMatMapExpr< T >
 Compile time check whether the given type is a binary matrix map expression template. More...
 
struct  blaze::IsMatMatMultExpr< T >
 Compile time check whether the given type is a matrix/matrix multiplication expression template. More...
 
struct  blaze::IsMatMatSolveExpr< T >
 Compile time check whether the given type is a multi LSE solver expression template. More...
 
struct  blaze::IsMatMatSubExpr< T >
 Compile time check whether the given type is a matrix/matrix subtraction expression template. More...
 
struct  blaze::IsMatNoAliasExpr< T >
 Compile time check whether the given type is a matrix no-alias expression template. More...
 
struct  blaze::IsMatNoSIMDExpr< T >
 Compile time check whether the given type is a matrix no-SIMD expression template. More...
 
struct  blaze::IsMatReduceExpr< T >
 Compile time check whether the given type is a reduction expression template. More...
 
struct  blaze::IsMatRepeatExpr< T >
 Compile time check whether the given type is a matrix repeater expression template. More...
 
struct  blaze::IsMatrix< T >
 Compile time check for matrix types. More...
 
struct  blaze::IsMatScalarDivExpr< T >
 Compile time check whether the given type is a matrix/scalar division expression template. More...
 
struct  blaze::IsMatScalarMultExpr< T >
 Compile time check whether the given type is a matrix/scalar multiplication expression template. More...
 
struct  blaze::IsMatSerialExpr< T >
 Compile time check whether the given type is a matrix serial evaluation expression template. More...
 
struct  blaze::IsMatTransExpr< T >
 Compile time check whether the given type is a matrix transposition expression template. More...
 
struct  blaze::IsMatVecMultExpr< T >
 Compile time check whether the given type is a matrix/vector multiplication expression template. More...
 
struct  blaze::IsMatVecSolveExpr< T >
 Compile time check whether the given type is a single LSE solver expression template. More...
 
struct  blaze::IsModification< T >
 Compile time check whether the given type is a modification expression template. More...
 
struct  blaze::IsMultExpr< T >
 Compile time check whether the given type is a multiplication expression template. More...
 
struct  blaze::IsNoAliasExpr< T >
 Compile time check whether the given type is a no-alias expression template. More...
 
struct  blaze::IsNoSIMDExpr< T >
 Compile time check whether the given type is a no-SIMD expression template. More...
 
struct  blaze::IsOperation< T >
 Compile time check whether the given type is an operational expression template. More...
 
struct  blaze::IsOpposedView< T >
 Compile time check for resizable data types. More...
 
struct  blaze::IsPadded< T >
 Compile time check for data types with padding. More...
 
struct  blaze::IsPaddingEnabled< T >
 Compile time check for data types. More...
 
struct  blaze::IsProxy< T >
 Compile time check for proxy types. More...
 
struct  blaze::IsReduceExpr< T >
 Compile time check whether the given type is a reduction expression template. More...
 
struct  blaze::IsRepeatExpr< T >
 Compile time check whether the given type is a repeater expression template. More...
 
struct  blaze::IsResizable< T >
 Compile time check for resizable data types. More...
 
struct  blaze::IsRestricted< T >
 Compile time check for data types with restricted data access. More...
 
struct  blaze::IsRow< T >
 Compile time check for rows. More...
 
struct  blaze::IsRowMajorMatrix< T >
 Compile time check for row-major matrix types. More...
 
struct  blaze::IsRows< T >
 Compile time check for row selections. More...
 
struct  blaze::IsRowVector< T >
 Compile time check for row vector types. More...
 
struct  blaze::IsScalar< T >
 Compile time check for scalar types. More...
 
struct  blaze::IsSchurExpr< T >
 Compile time check whether the given type is a Schur product expression template. More...
 
struct  blaze::IsSerialExpr< T >
 Compile time check whether the given type is a serial evaluation expression template. More...
 
struct  blaze::IsShrinkable< T >
 Compile time check for shrinkable data types. More...
 
struct  blaze::IsSIMDCombinable< T1, T2, Ts >
 Compile time check for data types. More...
 
struct  blaze::IsSIMDEnabled< T, Args >
 Compile time check for data types. More...
 
struct  blaze::IsSIMDPack< T >
 Compile time check for SIMD data types. More...
 
struct  blaze::IsSMPAssignable< T >
 Compile time check for data types. More...
 
struct  blaze::IsSolveExpr< T >
 Compile time check whether the given type is a solver expression template. More...
 
struct  blaze::IsSparseElement< T >
 Compile time check whether the given type is a sparse element type. More...
 
struct  blaze::IsSparseMatrix< T >
 Compile time check for sparse matrix types. More...
 
struct  blaze::IsSparseVector< T >
 Compile time check for sparse vector types. More...
 
struct  blaze::IsSquare< T >
 Compile time check for square matrices. More...
 
struct  blaze::IsStatic< T >
 Compile time check for static data types. More...
 
struct  blaze::IsStrictlyLower< T >
 Compile time check for strictly lower triangular matrices. More...
 
struct  blaze::IsStrictlyTriangular< T >
 Compile time check for strictly triangular matrix types. More...
 
struct  blaze::IsStrictlyUpper< T >
 Compile time check for strictly upper triangular matrices. More...
 
struct  blaze::IsSubExpr< T >
 Compile time check whether the given type is a subtraction expression template. More...
 
struct  blaze::IsSubmatrix< T >
 Compile time check for submatrices. More...
 
struct  blaze::IsSubvector< T >
 Compile time check for subvectors. More...
 
struct  blaze::IsSVDExpr< T >
 Compile time check whether the given type is a singular value expression template. More...
 
struct  blaze::IsSymmetric< T >
 Compile time check for symmetric matrices. More...
 
struct  blaze::IsTemporary< T >
 Compile time check whether the given type is a temporary vector or matrix type. More...
 
struct  blaze::IsTransExpr< T >
 Compile time check whether the given type is a transposition expression template. More...
 
struct  blaze::IsTransformation< T >
 Compile time check whether the given type is a transformation expression template. More...
 
struct  blaze::IsTriangular< T >
 Compile time check for triangular matrix types. More...
 
struct  blaze::IsTVecMatMultExpr< T >
 Compile time check whether the given type is a vector/matrix multiplication expression template. More...
 
struct  blaze::IsUnaryMapExpr< T >
 Compile time check whether the given type is a unary map expression template. More...
 
struct  blaze::IsUniform< T >
 Compile time check for uniform vectors and matrices. More...
 
struct  blaze::IsUniLower< T >
 Compile time check for lower unitriangular matrices. More...
 
struct  blaze::IsUniTriangular< T >
 Compile time check for unitriangular matrix types. More...
 
struct  blaze::IsUniUpper< T >
 Compile time check for upper unitriangular matrices. More...
 
struct  blaze::IsUpper< T >
 Compile time check for upper triangular matrices. More...
 
struct  blaze::IsVecEvalExpr< T >
 Compile time check whether the given type is a vector evaluation expression template. More...
 
struct  blaze::IsVecExpandExpr< T >
 Compile time check whether the given type is a vector expansion expression template. More...
 
struct  blaze::IsVecGenExpr< T >
 Compile time check whether the given type is a vector generator expression template. More...
 
struct  blaze::IsVecMapExpr< T >
 Compile time check whether the given type is a unary vector map expression template. More...
 
struct  blaze::IsVecNoAliasExpr< T >
 Compile time check whether the given type is a vector no-alias expression template. More...
 
struct  blaze::IsVecNoSIMDExpr< T >
 Compile time check whether the given type is a vector no-SIMD expression template. More...
 
struct  blaze::IsVecRepeatExpr< T >
 Compile time check whether the given type is a vector repeater expression template. More...
 
struct  blaze::IsVecScalarDivExpr< T >
 Compile time check whether the given type is a vector/scalar division expression template. More...
 
struct  blaze::IsVecScalarMultExpr< T >
 Compile time check whether the given type is a vector/scalar multiplication expression template. More...
 
struct  blaze::IsVecSerialExpr< T >
 Compile time check whether the given type is a vector serial evaluation expression template. More...
 
struct  blaze::IsVector< T >
 Compile time check for vector types. More...
 
struct  blaze::IsVecTransExpr< T >
 Compile time check whether the given type is a vector transposition expression template. More...
 
struct  blaze::IsVecTVecMapExpr< T >
 Compile time check whether the given type is an outer map expression template. More...
 
struct  blaze::IsVecTVecMultExpr< T >
 Compile time check whether the given type is an outer product expression template. More...
 
struct  blaze::IsVecVecAddExpr< T >
 Compile time check whether the given type is a vector/vector addition expression template. More...
 
struct  blaze::IsVecVecDivExpr< T >
 Compile time check whether the given type is a vector/vector division expression template. More...
 
struct  blaze::IsVecVecKronExpr< T >
 Compile time check whether the given type is a vector/vector Kronecker product expression template. More...
 
struct  blaze::IsVecVecMapExpr< T >
 Compile time check whether the given type is a binary vector map expression template. More...
 
struct  blaze::IsVecVecMultExpr< T >
 Compile time check whether the given type is a vector/vector multiplication expression template. More...
 
struct  blaze::IsVecVecSubExpr< T >
 Compile time check whether the given type is a vector/vector subtraction expression template. More...
 
struct  blaze::IsView< T >
 Compile time check for views. More...
 
struct  blaze::IsZero< T >
 Compile time check for zero vectors or matrices. More...
 
struct  blaze::MaxSize< T, N >
 Compile time evaluation of the maximum size of vectors and matrices. More...
 
struct  blaze::RemoveAdaptor< T >
 Removal of top level adaptor types. More...
 
struct  blaze::RequiresEvaluation< T >
 Compile time check to query the requirement to evaluate an expression. More...
 
struct  blaze::Size< T, N >
 Compile time evaluation of the size of vectors and matrices. More...
 
struct  blaze::StorageOrder< T >
 Evaluation of the storage order of a given matrix type. More...
 
struct  blaze::TransposeFlag< T >
 Evaluation of the transpose flag of a given matrix type. More...
 
struct  blaze::UnderlyingBuiltin< T >
 Evaluation of the underlying builtin element type of a given data type. More...
 
struct  blaze::UnderlyingElement< T >
 Evaluation of the element type of a given data type. More...
 
struct  blaze::UnderlyingNumeric< T >
 Evaluation of the underlying scalar element type of a given data type. More...
 
struct  blaze::UnderlyingScalar< T >
 Evaluation of the underlying scalar element type of a given data type. More...
 
struct  blaze::YieldsDiagonal< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsHermitian< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsIdentity< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsLower< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsStrictlyLower< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsStrictlyTriangular< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsStrictlyUpper< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsSymmetric< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsTriangular< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsUniform< OP, T, Ts >
 Compile time check for operations on vectors and matrices. More...
 
struct  blaze::YieldsUniLower< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsUniTriangular< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsUniUpper< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsUpper< OP, MT, MTs >
 Compile time check for operations on matrices. More...
 
struct  blaze::YieldsZero< OP, T, Ts >
 Compile time check for operations on vectors and matrices. 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. 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. 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. 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. More...
 

Typedefs

template<typename T >
using blaze::CustomOppositeType_t = typename CustomOppositeType< T >::Type
 Auxiliary alias declaration for the CustomOppositeType type trait. More...
 
template<typename T >
using blaze::CustomTransposeType_t = typename CustomTransposeType< T >::Type
 Auxiliary alias declaration for the CustomTransposeType type trait. More...
 
template<typename T , typename... As>
using blaze::DynamicAllocator_t = typename DynamicAllocator< As... >::template Type< T >
 Auxiliary alias declaration for the DynamicAllocator type trait. More...
 
template<typename T >
using blaze::GetAllocator = DetectedOr< NullAllocator< UnderlyingElement_t< T > >, AllocatorType_t, T >
 Determines the type of allocator of the given type. More...
 
template<typename T >
using blaze::GetAllocator_t = typename GetAllocator< T >::Type
 Auxiliary alias declaration for the GetAllocator type trait. More...
 
template<typename T >
using blaze::HasCompositeType = IsDetected< CompositeType_t, T >
 Compile time check for a public nested type alias CompositeType. More...
 
template<typename T >
using blaze::HasResultType = IsDetected< ResultType_t, T >
 Compile time check for a public nested type alias ResultType. More...
 
template<typename T1 , typename T2 >
using blaze::HighType_t = typename HighType< T1, T2 >::Type
 Auxiliary alias declaration for the HighType type trait. More...
 
template<typename T1 , typename T2 >
using blaze::LowType_t = typename LowType< T1, T2 >::Type
 Auxiliary alias declaration for the LowType type trait. 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. 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. More...
 
template<typename T >
using blaze::UnderlyingElement_t = typename UnderlyingElement< T >::Type
 Auxiliary alias declaration for the UnderlyingElement type trait. More...
 
template<typename T >
using blaze::UnderlyingNumeric_t = typename UnderlyingNumeric< T >::Type
 Auxiliary alias declaration for the UnderlyingNumeric type trait. More...
 
template<typename T >
using blaze::UnderlyingScalar_t = typename UnderlyingScalar< T >::Type
 Auxiliary alias declaration for the UnderlyingScalar type trait. More...
 

Functions

 blaze::BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT (HasLoad, load)
 Compile time check for data types. More...
 

Variables

template<typename T >
constexpr bool blaze::HasAbs_v = HasAbs<T>::value
 Auxiliary variable template for the HasAbs type trait. More...
 
template<typename T >
constexpr bool blaze::HasAcos_v = HasAcos<T>::value
 Auxiliary variable template for the HasAcos type trait. More...
 
template<typename T >
constexpr bool blaze::HasAcosh_v = HasAcosh<T>::value
 Auxiliary variable template for the HasAcosh type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasAdd_v = HasAdd<T1,T2>::value
 Auxiliary variable template for the HasAdd type trait. More...
 
template<typename T >
constexpr bool blaze::HasAsin_v = HasAsin<T>::value
 Auxiliary variable template for the HasAsin type trait. More...
 
template<typename T >
constexpr bool blaze::HasAsinh_v = HasAsinh<T>::value
 Auxiliary variable template for the HasAsinh type trait. More...
 
template<typename T >
constexpr bool blaze::HasAtan_v = HasAtan<T>::value
 Auxiliary variable template for the HasAtan type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasAtan2_v = HasAtan2<T1,T2>::value
 Auxiliary variable template for the HasAtan2 type trait. More...
 
template<typename T >
constexpr bool blaze::HasAtanh_v = HasAtanh<T>::value
 Auxiliary variable template for the HasAtanh type trait. More...
 
template<typename T >
constexpr bool blaze::HasCbrt_v = HasCbrt<T>::value
 Auxiliary variable template for the HasCbrt type trait. More...
 
template<typename T >
constexpr bool blaze::HasCeil_v = HasCeil<T>::value
 Auxiliary variable template for the HasCeil type trait. More...
 
template<typename T >
constexpr bool blaze::HasClamp_v = HasClamp<T>::value
 Auxiliary variable template for the HasClamp type trait. More...
 
template<typename T >
constexpr bool blaze::HasCompositeType_v = HasCompositeType<T>::value
 Auxiliary variable template for the HasCompositeType type trait. More...
 
template<typename T >
constexpr bool blaze::HasConj_v = HasConj<T>::value
 Auxiliary variable template for the HasConj type trait. More...
 
template<typename T >
constexpr bool blaze::HasConstDataAccess_v = HasConstDataAccess<T>::value
 Auxiliary variable template for the HasConstDataAccess type trait. More...
 
template<typename T >
constexpr bool blaze::HasCos_v = HasCos<T>::value
 Auxiliary variable template for the HasCos type trait. More...
 
template<typename T >
constexpr bool blaze::HasCosh_v = HasCosh<T>::value
 Auxiliary variable template for the HasCosh type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasDiv_v = HasDiv<T1,T2>::value
 Auxiliary variable template for the HasDiv type trait. More...
 
template<typename T >
constexpr bool blaze::HasErf_v = HasErf<T>::value
 Auxiliary variable template for the HasErf type trait. More...
 
template<typename T >
constexpr bool blaze::HasErfc_v = HasErfc<T>::value
 Auxiliary variable template for the HasErfc type trait. More...
 
template<typename T >
constexpr bool blaze::HasExp_v = HasExp<T>::value
 Auxiliary variable template for the HasExp type trait. More...
 
template<typename T >
constexpr bool blaze::HasExp10_v = HasExp10<T>::value
 Auxiliary variable template for the HasExp10 type trait. More...
 
template<typename T >
constexpr bool blaze::HasExp2_v = HasExp2<T>::value
 Auxiliary variable template for the HasExp2 type trait. More...
 
template<typename T >
constexpr bool blaze::HasFloor_v = HasFloor<T>::value
 Auxiliary variable template for the HasFloor type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasHypot_v = HasHypot<T1,T2>::value
 Auxiliary variable template for the HasHypot type trait. More...
 
template<typename T >
constexpr bool blaze::HasImag_v = HasImag<T>::value
 Auxiliary variable template for the HasImag type trait. More...
 
template<typename T >
constexpr bool blaze::HasInvCbrt_v = HasInvCbrt<T>::value
 Auxiliary variable template for the HasInvCbrt type trait. More...
 
template<typename T >
constexpr bool blaze::HasInvSqrt_v = HasInvSqrt<T>::value
 Auxiliary variable template for the HasInvSqrt type trait. More...
 
template<typename T >
constexpr bool blaze::HasLGamma_v = HasLGamma<T>::value
 Auxiliary variable template for the HasLGamma type trait. More...
 
template<typename T >
constexpr bool blaze::HasLog_v = HasLog<T>::value
 Auxiliary variable template for the HasLog type trait. More...
 
template<typename T >
constexpr bool blaze::HasLog10_v = HasLog10<T>::value
 Auxiliary variable template for the HasLog10 type trait. More...
 
template<typename T >
constexpr bool blaze::HasLog1p_v = HasLog1p<T>::value
 Auxiliary variable template for the HasLog1p type trait. More...
 
template<typename T >
constexpr bool blaze::HasLog2_v = HasLog2<T>::value
 Auxiliary variable template for the HasLog2 type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasMax_v = HasMax<T1,T2>::value
 Auxiliary variable template for the HasMax type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasMin_v = HasMin<T1,T2>::value
 Auxiliary variable template for the HasMin type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasMult_v = HasMult<T1,T2>::value
 Auxiliary variable template for the HasMult type trait. More...
 
template<typename T >
constexpr bool blaze::HasMutableDataAccess_v = HasMutableDataAccess<T>::value
 Auxiliary variable template for the HasMutableDataAccess type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasPow_v = HasPow<T1,T2>::value
 Auxiliary variable template for the HasPow type trait. More...
 
template<typename T >
constexpr bool blaze::HasReal_v = HasReal<T>::value
 Auxiliary variable template for the HasReal type trait. More...
 
template<typename T >
constexpr bool blaze::HasResultType_v = HasResultType<T>::value
 Auxiliary variable template for the HasResultType type trait. More...
 
template<typename T >
constexpr bool blaze::HasRound_v = HasRound<T>::value
 Auxiliary variable template for the HasRound type trait. More...
 
template<typename T >
constexpr bool blaze::HasSign_v = HasSign<T>::value
 Auxiliary variable template for the HasSign type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDAbs_v = HasSIMDAbs<T>::value
 Auxiliary variable template for the HasSIMDAbs type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDAcos_v = HasSIMDAcos<T>::value
 Auxiliary variable template for the HasSIMDAcos type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDAcosh_v = HasSIMDAcosh<T>::value
 Auxiliary variable template for the HasSIMDAcosh type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDAdd_v = HasSIMDAdd<T1,T2>::value
 Auxiliary variable template for the HasSIMDAdd type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDAsin_v = HasSIMDAsin<T>::value
 Auxiliary variable template for the HasSIMDAsin type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDAsinh_v = HasSIMDAsinh<T>::value
 Auxiliary variable template for the HasSIMDAsinh type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDAtan_v = HasSIMDAtan<T>::value
 Auxiliary variable template for the HasSIMDAtan type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDAtan2_v = HasSIMDAtan2<T1,T2>::value
 Auxiliary variable template for the HasSIMDAtan2 type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDAtanh_v = HasSIMDAtanh<T>::value
 Auxiliary variable template for the HasSIMDAtanh type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDBitand_v = HasSIMDBitand<T1,T2>::value
 Auxiliary variable template for the HasSIMDBitand type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDBitor_v = HasSIMDBitor<T1,T2>::value
 Auxiliary variable template for the HasSIMDBitor type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDBitxor_v = HasSIMDBitxor<T1,T2>::value
 Auxiliary variable template for the HasSIMDBitxor type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDCbrt_v = HasSIMDCbrt<T>::value
 Auxiliary variable template for the HasSIMDCbrt type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDCeil_v = HasSIMDCeil<T>::value
 Auxiliary variable template for the HasSIMDCeil type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDConj_v = HasSIMDConj<T>::value
 Auxiliary variable template for the HasSIMDConj type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDCos_v = HasSIMDCos<T>::value
 Auxiliary variable template for the HasSIMDCos type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDCosh_v = HasSIMDCosh<T>::value
 Auxiliary variable template for the HasSIMDCosh type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDDiv_v = HasSIMDDiv<T1,T2>::value
 Auxiliary variable template for the HasSIMDDiv type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDEqual_v = HasSIMDEqual<T1,T2>::value
 Auxiliary variable template for the HasSIMDEqual type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDErf_v = HasSIMDErf<T>::value
 Auxiliary variable template for the HasSIMDErf type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDErfc_v = HasSIMDErfc<T>::value
 Auxiliary variable template for the HasSIMDErfc type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDExp_v = HasSIMDExp<T>::value
 Auxiliary variable template for the HasSIMDExp type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDExp10_v = HasSIMDExp10<T>::value
 Auxiliary variable template for the HasSIMDExp10 type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDExp2_v = HasSIMDExp2<T>::value
 Auxiliary variable template for the HasSIMDExp2 type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDFloor_v = HasSIMDFloor<T>::value
 Auxiliary variable template for the HasSIMDFloor type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDHypot_v = HasSIMDHypot<T1,T2>::value
 Auxiliary variable template for the HasSIMDHypot type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDInvCbrt_v = HasSIMDInvCbrt<T>::value
 Auxiliary variable template for the HasSIMDInvCbrt type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDInvSqrt_v = HasSIMDInvSqrt<T>::value
 Auxiliary variable template for the HasSIMDInvSqrt type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDLGamma_v = HasSIMDLGamma<T>::value
 Auxiliary variable template for the HasSIMDLGamma type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDLog_v = HasSIMDLog<T>::value
 Auxiliary variable template for the HasSIMDLog type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDLog10_v = HasSIMDLog10<T>::value
 Auxiliary variable template for the HasSIMDLog10 type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDLog1p_v = HasSIMDLog1p<T>::value
 Auxiliary variable template for the HasSIMDLog1p type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDLog2_v = HasSIMDLog2<T>::value
 Auxiliary variable template for the HasSIMDLog2 type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMax_v = HasSIMDMax<T1,T2>::value
 Auxiliary variable template for the HasSIMDMax type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMin_v = HasSIMDMin<T1,T2>::value
 Auxiliary variable template for the HasSIMDMin type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMult_v = HasSIMDMult<T1,T2>::value
 Auxiliary variable template for the HasSIMDMult type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDPow_v = HasSIMDPow<T1,T2>::value
 Auxiliary variable template for the HasSIMDPow type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDRound_v = HasSIMDRound<T>::value
 Auxiliary variable template for the HasSIMDRound type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDShiftLI_v = HasSIMDShiftLI<T>::value
 Auxiliary variable template for the HasSIMDShiftLI type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDShiftLV_v = HasSIMDShiftLV<T1,T2>::value
 Auxiliary variable template for the HasSIMDShiftLV type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDShiftRI_v = HasSIMDShiftRI<T>::value
 Auxiliary variable template for the HasSIMDShiftRI type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDShiftRV_v = HasSIMDShiftRV<T1,T2>::value
 Auxiliary variable template for the HasSIMDShiftRV type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDSign_v = HasSIMDSign<T>::value
 Auxiliary variable template for the HasSIMDSign type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDSin_v = HasSIMDSin<T>::value
 Auxiliary variable template for the HasSIMDSin type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDSinh_v = HasSIMDSinh<T>::value
 Auxiliary variable template for the HasSIMDSinh type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDSqrt_v = HasSIMDSqrt<T>::value
 Auxiliary variable template for the HasSIMDSqrt type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDSub_v = HasSIMDSub<T1,T2>::value
 Auxiliary variable template for the HasSIMDSub type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDTan_v = HasSIMDTan<T>::value
 Auxiliary variable template for the HasSIMDTan type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDTanh_v = HasSIMDTanh<T>::value
 Auxiliary variable template for the HasSIMDTanh type trait. More...
 
template<typename T >
constexpr bool blaze::HasSIMDTrunc_v = HasSIMDTrunc<T>::value
 Auxiliary variable template for the HasSIMDTrunc type trait. More...
 
template<typename T >
constexpr bool blaze::HasSin_v = HasSin<T>::value
 Auxiliary variable template for the HasSin type trait. More...
 
template<typename T >
constexpr bool blaze::HasSinh_v = HasSinh<T>::value
 Auxiliary variable template for the HasSinh type trait. More...
 
template<typename T >
constexpr bool blaze::HasSqrt_v = HasSqrt<T>::value
 Auxiliary variable template for the HasSqrt type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSub_v = HasSub<T1,T2>::value
 Auxiliary variable template for the HasSub type trait. More...
 
template<typename T >
constexpr bool blaze::HasTan_v = HasTan<T>::value
 Auxiliary variable template for the HasTan type trait. More...
 
template<typename T >
constexpr bool blaze::HasTanh_v = HasTanh<T>::value
 Auxiliary variable template for the HasTanh type trait. More...
 
template<typename T >
constexpr bool blaze::HasTrunc_v = HasTrunc<T>::value
 Auxiliary variable template for the HasTrunc type trait. More...
 
template<typename T >
constexpr bool blaze::IsAdaptor_v = IsAdaptor<T>::value
 Auxiliary variable template for the IsAdaptor type trait. More...
 
template<typename T >
constexpr bool blaze::IsAddExpr_v = IsAddExpr<T>::value
 Auxiliary variable template for the IsAddExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsAligned_v = IsAligned<T>::value
 Auxiliary variable template for the IsAligned type trait. More...
 
template<typename T >
constexpr bool blaze::IsBand_v = IsBand<T>::value
 Auxiliary variable template for the IsBand type trait. More...
 
template<typename T >
constexpr bool blaze::IsBinaryMapExpr_v = IsBinaryMapExpr<T>::value
 Auxiliary variable template for the IsBinaryMapExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsBLASCompatible_v = IsBLASCompatible<T>::value
 Auxiliary variable template for the IsBLASCompatible type trait. More...
 
template<typename T >
constexpr bool blaze::IsClearable_v = IsClearable<T>::value
 Auxiliary variable template for the IsClearable type trait. More...
 
template<typename T >
constexpr bool blaze::IsColumn_v = IsColumn<T>::value
 Auxiliary variable template for the IsColumn type trait. More...
 
template<typename T >
constexpr bool blaze::IsColumnMajorMatrix_v = IsColumnMajorMatrix<T>::value
 Auxiliary variable template for the IsColumnMajorMatrix type trait. More...
 
template<typename T >
constexpr bool blaze::IsColumns_v = IsColumns<T>::value
 Auxiliary variable template for the IsColumns type trait. More...
 
template<typename T >
constexpr bool blaze::IsColumnVector_v = IsColumnVector<T>::value
 Auxiliary variable template for the IsColumnVector type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::IsCommutative_v = IsCommutative<T1,T2>::value
 Auxiliary variable template for the IsCommutative type trait. More...
 
template<typename T >
constexpr bool blaze::IsComputation_v = IsComputation<T>::value
 Auxiliary variable template for the IsComputation type trait. More...
 
template<typename T >
constexpr bool blaze::IsContiguous_v = IsContiguous<T>::value
 Auxiliary variable template for the IsContiguous type trait. More...
 
template<typename T >
constexpr bool blaze::IsCrossExpr_v = IsCrossExpr<T>::value
 Auxiliary variable template for the IsCrossExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsCustom_v = IsCustom<T>::value
 Auxiliary variable template for the IsCustom type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclaration_v = IsDeclaration<T>::value
 Auxiliary variable template for the IsDeclaration type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclDiagExpr_v = IsDeclDiagExpr<T>::value
 Auxiliary variable template for the IsDeclDiagExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclExpr_v = IsDeclExpr<T>::value
 Auxiliary variable template for the IsDeclExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclHermExpr_v = IsDeclHermExpr<T>::value
 Auxiliary variable template for the IsDeclHermExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclLowExpr_v = IsDeclLowExpr<T>::value
 Auxiliary variable template for the IsDeclLowExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclStrLowExpr_v = IsDeclStrLowExpr<T>::value
 Auxiliary variable template for the IsDeclStrLowExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclStrUppExpr_v = IsDeclStrUppExpr<T>::value
 Auxiliary variable template for the IsDeclStrUppExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclSymExpr_v = IsDeclSymExpr<T>::value
 Auxiliary variable template for the IsDeclSymExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclUniLowExpr_v = IsDeclUniLowExpr<T>::value
 Auxiliary variable template for the IsDeclUniLowExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclUniUppExpr_v = IsDeclUniUppExpr<T>::value
 Auxiliary variable template for the IsDeclUniUppExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDeclUppExpr_v = IsDeclUppExpr<T>::value
 Auxiliary variable template for the IsDeclUppExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsDenseMatrix_v = IsDenseMatrix<T>::value
 Auxiliary variable template for the IsDenseMatrix type trait. More...
 
template<typename T >
constexpr bool blaze::IsDenseVector_v = IsDenseVector<T>::value
 Auxiliary variable template for the IsDenseVector type trait. More...
 
template<typename T >
constexpr bool blaze::IsDiagonal_v = IsDiagonal<T>::value
 Auxiliary variable template for the IsDiagonal type trait. More...
 
template<typename T >
constexpr bool blaze::IsDivExpr_v = IsDivExpr<T>::value
 Auxiliary variable template for the IsDivExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsEigenExpr_v = IsEigenExpr<T>::value
 Auxiliary variable template for the IsEigenExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsElements_v = IsElements<T>::value
 Auxiliary variable template for the IsElements type trait. More...
 
template<typename T >
constexpr bool blaze::IsEvalExpr_v = IsEvalExpr<T>::value
 Auxiliary variable template for the IsEvalExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsExpandExpr_v = IsExpandExpr<T>::value
 Auxiliary variable template for the IsExpandExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsExpression_v = IsExpression<T>::value
 Auxiliary variable template for the IsExpression type trait. More...
 
template<typename T >
constexpr bool blaze::IsGeneral_v = IsGeneral<T>::value
 Auxiliary variable template for the IsGeneral type trait. More...
 
template<typename T >
constexpr bool blaze::IsGenExpr_v = IsGenExpr<T>::value
 Auxiliary variable template for the IsGenExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsHermitian_v = IsHermitian<T>::value
 Auxiliary variable template for the IsHermitian type trait. More...
 
template<typename T >
constexpr bool blaze::IsIdentity_v = IsIdentity<T>::value
 Auxiliary variable template for the IsIdentity type trait. More...
 
template<typename T >
constexpr bool blaze::IsInitializer_v = IsInitializer<T>::value
 Auxiliary variable template for the IsInitializer type trait. More...
 
template<typename T >
constexpr bool blaze::IsInvertible_v = IsInvertible<T>::value
 Auxiliary variable template for the IsInvertible type trait. More...
 
template<typename T >
constexpr bool blaze::IsKronExpr_v = IsKronExpr<T>::value
 Auxiliary variable template for the IsKronExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsLower_v = IsLower<T>::value
 Auxiliary variable template for the IsLower type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatEvalExpr_v = IsMatEvalExpr<T>::value
 Auxiliary variable template for the IsMatEvalExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatExpExpr_v = IsMatExpExpr<T>::value
 Auxiliary variable template for the IsMatExpExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatGenExpr_v = IsMatGenExpr<T>::value
 Auxiliary variable template for the IsMatGenExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatInvExpr_v = IsMatInvExpr<T>::value
 Auxiliary variable template for the IsMatInvExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatMapExpr_v = IsMatMapExpr<T>::value
 Auxiliary variable template for the IsMatMapExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatMatAddExpr_v = IsMatMatAddExpr<T>::value
 Auxiliary variable template for the IsMatMatAddExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatMatKronExpr_v = IsMatMatKronExpr<T>::value
 Auxiliary variable template for the IsMatMatKronExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatMatMapExpr_v = IsMatMatMapExpr<T>::value
 Auxiliary variable template for the IsMatMatMapExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatMatMultExpr_v = IsMatMatMultExpr<T>::value
 Auxiliary variable template for the IsMatMatMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatMatSolveExpr_v = IsMatMatSolveExpr<T>::value
 Auxiliary variable template for the IsMatMatSolveExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatMatSubExpr_v = IsMatMatSubExpr<T>::value
 Auxiliary variable template for the IsMatMatSubExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatNoAliasExpr_v = IsMatNoAliasExpr<T>::value
 Auxiliary variable template for the IsMatNoAliasExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatNoSIMDExpr_v = IsMatNoSIMDExpr<T>::value
 Auxiliary variable template for the IsMatNoSIMDExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatReduceExpr_v = IsMatReduceExpr<T>::value
 Auxiliary variable template for the IsMatReduceExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatRepeatExpr_v = IsMatRepeatExpr<T>::value
 Auxiliary variable template for the IsMatRepeatExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatrix_v = IsMatrix<T>::value
 Auxiliary variable template for the IsMatrix type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatScalarDivExpr_v = IsMatScalarDivExpr<T>::value
 Auxiliary variable template for the IsMatScalarDivExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatScalarMultExpr_v = IsMatScalarMultExpr<T>::value
 Auxiliary variable template for the IsMatScalarMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatSerialExpr_v = IsMatSerialExpr<T>::value
 Auxiliary variable template for the IsMatSerialExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatTransExpr_v = IsMatTransExpr<T>::value
 Auxiliary variable template for the IsMatTransExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatVecMultExpr_v = IsMatVecMultExpr<T>::value
 Auxiliary variable template for the IsMatVecMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsMatVecSolveExpr_v = IsMatVecSolveExpr<T>::value
 Auxiliary variable template for the IsMatVecSolveExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsModification_v = IsModification<T>::value
 Auxiliary variable template for the IsModification type trait. More...
 
template<typename T >
constexpr bool blaze::IsMultExpr_v = IsMultExpr<T>::value
 Auxiliary variable template for the IsMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsNoAliasExpr_v = IsNoAliasExpr<T>::value
 Auxiliary variable template for the IsNoAliasExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsNoSIMDExpr_v = IsNoSIMDExpr<T>::value
 Auxiliary variable template for the IsNoSIMDExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsOperation_v = IsOperation<T>::value
 Auxiliary variable template for the IsOperation type trait. More...
 
template<typename T >
constexpr bool blaze::IsOpposedView_v = IsOpposedView<T>::value
 Auxiliary variable template for the IsOpposedView type trait. More...
 
template<typename T >
constexpr bool blaze::IsPadded_v = IsPadded<T>::value
 Auxiliary variable template for the IsPadded type trait. More...
 
template<typename T >
constexpr bool blaze::IsPaddingEnabled_v = IsPaddingEnabled<T>::value
 Auxiliary variable template for the IsPaddingEnabled type trait. More...
 
template<typename T >
constexpr bool blaze::IsProxy_v = IsProxy<T>::value
 Auxiliary variable template for the IsProxy type trait. More...
 
template<typename T >
constexpr bool blaze::IsReduceExpr_v = IsReduceExpr<T>::value
 Auxiliary variable template for the IsReduceExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsRepeatExpr_v = IsRepeatExpr<T>::value
 Auxiliary variable template for the IsRepeatExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsResizable_v = IsResizable<T>::value
 Auxiliary variable template for the IsResizable type trait. More...
 
template<typename T >
constexpr bool blaze::IsRestricted_v = IsRestricted<T>::value
 Auxiliary variable template for the IsRestricted type trait. More...
 
template<typename T >
constexpr bool blaze::IsRow_v = IsRow<T>::value
 Auxiliary variable template for the IsRow type trait. More...
 
template<typename T >
constexpr bool blaze::IsRowMajorMatrix_v = IsRowMajorMatrix<T>::value
 Auxiliary variable template for the IsRowMajorMatrix type trait. More...
 
template<typename T >
constexpr bool blaze::IsRows_v = IsRows<T>::value
 Auxiliary variable template for the IsRows type trait. More...
 
template<typename T >
constexpr bool blaze::IsRowVector_v = IsRowVector<T>::value
 Auxiliary variable template for the IsRowVector type trait. More...
 
template<typename T >
constexpr bool blaze::IsScalar_v = IsScalar<T>::value
 Auxiliary variable template for the IsScalar type trait. More...
 
template<typename T >
constexpr bool blaze::IsSchurExpr_v = IsSchurExpr<T>::value
 Auxiliary variable template for the IsSchurExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsSerialExpr_v = IsSerialExpr<T>::value
 Auxiliary variable template for the IsSerialExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsShrinkable_v = IsShrinkable<T>::value
 Auxiliary variable template for the IsShrinkable type trait. 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. More...
 
template<typename T , typename... Args>
constexpr bool blaze::IsSIMDEnabled_v = IsSIMDEnabled<T,Args...>::value
 Auxiliary variable template for the IsSIMDEnabled type trait. More...
 
template<typename T >
constexpr bool blaze::IsSIMDPack_v = IsSIMDPack<T>::value
 Auxiliary variable template for the IsSIMDPack type trait. More...
 
template<typename T >
constexpr bool blaze::IsSMPAssignable_v = IsSMPAssignable<T>::value
 Auxiliary variable template for the IsSMPAssignable type trait. More...
 
template<typename T >
constexpr bool blaze::IsSolveExpr_v = IsSolveExpr<T>::value
 Auxiliary variable template for the IsSolveExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsSparseElement_v = IsSparseElement<T>::value
 Auxiliary variable template for the IsSparseElement type trait. More...
 
template<typename T >
constexpr bool blaze::IsSparseMatrix_v = IsSparseMatrix<T>::value
 Auxiliary variable template for the IsSparseMatrix type trait. More...
 
template<typename T >
constexpr bool blaze::IsSparseVector_v = IsSparseVector<T>::value
 Auxiliary variable template for the IsSparseVector type trait. More...
 
template<typename T >
constexpr bool blaze::IsSquare_v = IsSquare<T>::value
 Auxiliary variable template for the IsSquare type trait. More...
 
template<typename T >
constexpr bool blaze::IsStatic_v = IsStatic<T>::value
 Auxiliary variable template for the IsStatic type trait. More...
 
template<typename T >
constexpr bool blaze::IsStrictlyLower_v = IsStrictlyLower<T>::value
 Auxiliary variable template for the IsStrictlyLower type trait. More...
 
template<typename T >
constexpr bool blaze::IsStrictlyTriangular_v = IsStrictlyTriangular<T>::value
 Auxiliary variable template for the IsStrictlyTriangular type trait. More...
 
template<typename T >
constexpr bool blaze::IsStrictlyUpper_v = IsStrictlyUpper<T>::value
 Auxiliary variable template for the IsStrictlyUpper type trait. More...
 
template<typename T >
constexpr bool blaze::IsSubExpr_v = IsSubExpr<T>::value
 Auxiliary variable template for the IsSubExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsSubmatrix_v = IsSubmatrix<T>::value
 Auxiliary variable template for the IsSubmatrix type trait. More...
 
template<typename T >
constexpr bool blaze::IsSubvector_v = IsSubvector<T>::value
 Auxiliary variable template for the IsSubvector type trait. More...
 
template<typename T >
constexpr bool blaze::IsSVDExpr_v = IsSVDExpr<T>::value
 Auxiliary variable template for the IsSVDExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsSymmetric_v = IsSymmetric<T>::value
 Auxiliary variable template for the IsSymmetric type trait. More...
 
template<typename T >
constexpr bool blaze::IsTemporary_v = IsTemporary<T>::value
 Auxiliary variable template for the IsTemporary type trait. More...
 
template<typename T >
constexpr bool blaze::IsTransExpr_v = IsTransExpr<T>::value
 Auxiliary variable template for the IsTransExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsTransformation_v = IsTransformation<T>::value
 Auxiliary variable template for the IsTransformation type trait. More...
 
template<typename T >
constexpr bool blaze::IsTriangular_v = IsTriangular<T>::value
 Auxiliary variable template for the IsTriangular type trait. More...
 
template<typename T >
constexpr bool blaze::IsTVecMatMultExpr_v = IsTVecMatMultExpr<T>::value
 Auxiliary variable template for the IsTVecMatMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsUnaryMapExpr_v = IsUnaryMapExpr<T>::value
 Auxiliary variable template for the IsUnaryMapExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsUniform_v = IsUniform<T>::value
 Auxiliary variable template for the IsUniform type trait. More...
 
template<typename T >
constexpr bool blaze::IsUniLower_v = IsUniLower<T>::value
 Auxiliary variable template for the IsUniLower type trait. More...
 
template<typename T >
constexpr bool blaze::IsUniTriangular_v = IsUniTriangular<T>::value
 Auxiliary variable template for the IsUniTriangular type trait. More...
 
template<typename T >
constexpr bool blaze::IsUniUpper_v = IsUniUpper<T>::value
 Auxiliary variable template for the IsUniUpper type trait. More...
 
template<typename T >
constexpr bool blaze::IsUpper_v = IsUpper<T>::value
 Auxiliary variable template for the IsUpper type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecEvalExpr_v = IsVecEvalExpr<T>::value
 Auxiliary variable template for the IsVecEvalExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecExpandExpr_v = IsVecExpandExpr<T>::value
 Auxiliary variable template for the IsVecExpandExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecGenExpr_v = IsVecGenExpr<T>::value
 Auxiliary variable template for the IsVecGenExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecMapExpr_v = IsVecMapExpr<T>::value
 Auxiliary variable template for the IsVecMapExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecNoAliasExpr_v = IsVecNoAliasExpr<T>::value
 Auxiliary variable template for the IsVecNoAliasExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecNoSIMDExpr_v = IsVecNoSIMDExpr<T>::value
 Auxiliary variable template for the IsVecNoSIMDExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecRepeatExpr_v = IsVecRepeatExpr<T>::value
 Auxiliary variable template for the IsVecRepeatExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecScalarDivExpr_v = IsVecScalarDivExpr<T>::value
 Auxiliary variable template for the IsVecScalarDivExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecScalarMultExpr_v = IsVecScalarMultExpr<T>::value
 Auxiliary variable template for the IsVecScalarMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecSerialExpr_v = IsVecSerialExpr<T>::value
 Auxiliary variable template for the IsVecSerialExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVector_v = IsVector<T>::value
 Auxiliary variable template for the IsVector type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecTransExpr_v = IsVecTransExpr<T>::value
 Auxiliary variable template for the IsVecTransExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecTVecMapExpr_v = IsVecTVecMapExpr<T>::value
 Auxiliary variable template for the IsVecTVecMapExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecTVecMultExpr_v = IsVecTVecMultExpr<T>::value
 Auxiliary variable template for the IsVecTVecMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecVecAddExpr_v = IsVecVecAddExpr<T>::value
 Auxiliary variable template for the IsVecVecAddExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecVecDivExpr_v = IsVecVecDivExpr<T>::value
 Auxiliary variable template for the IsVecVecDivExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecVecKronExpr_v = IsVecVecKronExpr<T>::value
 Auxiliary variable template for the IsVecVecKronExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecVecMapExpr_v = IsVecVecMapExpr<T>::value
 Auxiliary variable template for the IsVecVecMapExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecVecMultExpr_v = IsVecVecMultExpr<T>::value
 Auxiliary variable template for the IsVecVecMultExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsVecVecSubExpr_v = IsVecVecSubExpr<T>::value
 Auxiliary variable template for the IsVecVecSubExpr type trait. More...
 
template<typename T >
constexpr bool blaze::IsView_v = IsView<T>::value
 Auxiliary variable template for the IsView type trait. More...
 
template<typename T >
constexpr bool blaze::IsZero_v = IsZero<T>::value
 Auxiliary variable template for the IsZero type trait. 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. More...
 
template<typename T >
constexpr bool blaze::RequiresEvaluation_v = RequiresEvaluation<T>::value
 Auxiliary variable template for the RequiresEvaluation type trait. 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. More...
 
template<typename T >
constexpr bool blaze::StorageOrder_v = T::storageOrder
 Auxiliary variable template for the StorageOrder type trait. More...
 
template<typename T >
constexpr bool blaze::TransposeFlag_v = T::transposeFlag
 Auxiliary variable template for the TransposeFlag type trait. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. More...
 

Detailed Description

Macro Definition Documentation

◆ BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT

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

Macro for the creation of a type trait to acquire member types.

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

struct MyType1 {
using ElementType = float;
};
struct MyType2 {
using ElementType = double;
};
struct MyType3 {};
BLAZE_CREATE_GET_TYPE_MEMBER_TYPE_TRAIT( GetElementType, ElementType, int );
GetElementType<MyType1>::Type // Results in 'float'
GetElementType<MyType2>::Type // Results in 'double'
GetElementType<MyType3>::Type // Results in 'int'
#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.
Definition: GetMemberType.h:90

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

◆ BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT

#define BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT (   TYPE_TRAIT_NAME,
  MEMBER_NAME 
)

Macro for the creation of a type trait for compile time checks for member data and functions.

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

class MyType {
public:
void publicCompute();
private:
void privateCompute();
int value_;
};
BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT( HasPublicCompute , publicCompute );
BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT( HasPrivateCompute, privateCompute );
HasPublicCompute<MyType>::value // Evaluates to 'true'
HasPrivateCompute<MyType>::Type // Results in TrueType
HasValue<MyType> // Is derived from TrueType
HasEvaluate<MyType>::value // Evaluates to 'false'
HasDetermine<MyType>::Type // Results in FalseType
HasData<MyType> // Is derived from FalseType
#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.
Definition: HasMember.h:99

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

◆ BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT

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

Macro for the creation of a type trait for compile time checks for members.

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

class MyType {
public:
void publicCompute();
protected:
using ProtectedType = float;
private:
int value_;
};
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasCompute , publicCompute );
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasProtectedType, ProtectedType );
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasPublicType, PublicType );
BLAZE_CREATE_HAS_MEMBER_TYPE_TRAIT( HasDetermine , determine );
HasCompute<MyType>::value // Evaluates to 'true'
HasProtectedType<MyType>::Type // Results in TrueType
HasValue<MyType> // Is derived from TrueType
HasPublicType<MyType>::value // Evaluates to 'false'
HasDetermine<MyType>::Type // Results in FalseType
HasData<MyType> // Is derived from FalseType
#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.
Definition: HasMember.h:253

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

◆ BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT

#define BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT (   TYPE_TRAIT_NAME,
  MEMBER_NAME 
)
Value:
\
template < typename TYPE1231 > \
struct TYPE_TRAIT_NAME##HELPER \
{ \
private: \
struct Fallback { using MEMBER_NAME = int; }; \
\
struct Derived \
, Fallback \
{}; \
\
template < class U > \
static blaze::FalseType test( typename U::MEMBER_NAME* ); \
\
template < typename U > \
static blaze::TrueType test( U* ); \
\
public: \
using Type = decltype( test<Derived>( nullptr ) ); \
}; \
\
template< typename TYPE1231 > \
struct TYPE_TRAIT_NAME \
: public TYPE_TRAIT_NAME##HELPER<TYPE1231>::Type \
{}; \
\
template< typename TYPE1231 > \
static constexpr bool TYPE_TRAIT_NAME##_v = TYPE_TRAIT_NAME<TYPE1231>::value
typename If< Condition >::template Type< T1, T2 > If_t
Auxiliary alias template for the If class template.
Definition: If.h:108
Empty data type for utility purposes.
Definition: EmptyType.h:46

Macro for the creation of a type trait for compile time checks for member types.

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

class MyType {
public:
using PublicType = int;
protected:
using ProtectedType = float;
private:
using PrivateType = double;
};
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasPublicType , PublicType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasProtectedType, ProtectedType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasPrivateType , PrivateType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasValueType , ValueType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasElementType, ElementTypeType );
BLAZE_CREATE_HAS_TYPE_MEMBER_TYPE_TRAIT( HasDataType , DataType );
HasPublicType<MyType>::value // Evaluates to 'true'
HasProtectedType<MyType>::Type // Results in TrueType
HasPrivateType<MyType> // Is derived from TrueType
HasValueType<MyType>::value // Evaluates to 'false'
HasElementType<MyType>::Type // Results in FalseType
HasDataType<MyType> // Is derived from FalseType
#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.
Definition: HasMember.h:177

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.

Typedef Documentation

◆ CustomOppositeType_t

template<typename T >
using blaze::CustomOppositeType_t = typedef typename CustomOppositeType<T>::Type

Auxiliary alias declaration for the CustomOppositeType type trait.

The CustomOppositeType_t alias declaration provides a convenient shortcut to access the nested Type of the CustomOppositeType class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename blaze::CustomOppositeType<T>::Type;
typename CustomOppositeType< T >::Type CustomOppositeType_t
Auxiliary alias declaration for the CustomOppositeType type trait.
Definition: CustomOppositeType.h:83
Evaluation of the custom opposite type.
Definition: CustomOppositeType.h:58

◆ CustomTransposeType_t

template<typename T >
using blaze::CustomTransposeType_t = typedef typename CustomTransposeType<T>::Type

Auxiliary alias declaration for the CustomTransposeType type trait.

The CustomTransposeType_t alias declaration provides a convenient shortcut to access the nested Type of the CustomTransposeType class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename blaze::CustomTransposeType<T>::Type;
typename CustomTransposeType< T >::Type CustomTransposeType_t
Auxiliary alias declaration for the CustomTransposeType type trait.
Definition: CustomTransposeType.h:83
Evaluation of the custom transpose type.
Definition: CustomTransposeType.h:58

◆ DynamicAllocator_t

template<typename T , typename... As>
using blaze::DynamicAllocator_t = typedef typename DynamicAllocator<As...>::template Type<T>

Auxiliary alias declaration for the DynamicAllocator type trait.

The DynamicAllocator_t alias declaration provides a convenient shortcut to access the nested Type of the DynamicAllocator class template. For instance, given the types A1 and A2 the following two type definitions are identical:

using Type1 = typename blaze::DynamicAllocator<A1,A2>::template Type<T>;
typename DynamicAllocator< As... >::template Type< T > DynamicAllocator_t
Auxiliary alias declaration for the DynamicAllocator type trait.
Definition: DynamicAllocator.h:211
Deduction of an allocator type for dynamic vectors and matrices.
Definition: DynamicAllocator.h:95

◆ GetAllocator

template<typename T >
using blaze::GetAllocator = typedef DetectedOr< NullAllocator< UnderlyingElement_t<T> >, AllocatorType_t, T >

Determines the type of allocator of the given type.

This type trait determines the type of allocator of the given type T. In case the type T exposes this allocator via a nested type AllocatorType, the nested type Type is set to the type of allocator. Otherwise the nested type Type is set to NullAllocator.

blaze::GetAllocator< DynamicVector<int> >::Type // Results in 'AlignedAllocator<int>'
blaze::GetAllocator< const DynamicVector<double> >::Type // Results in 'AlignedAllocator<double>'
blaze::GetAllocator< volatile DynamicMatrix<int> >::Type // Results in 'AlignedAllocator<int>'
blaze::GetAllocator< int >::Type // Results in 'NullAllocator<int>'
blaze::GetAllocator< const StaticVector<float,3UL> >::Type // Results in 'NullAllocator<float>'
blaze::GetAllocator< volatile CompressedMatrix<int> >::Type // Results in 'NullAllocator<int>'
Efficient implementation of a compressed matrix.
Definition: CompressedMatrix.h:239
Efficient implementation of a dynamic matrix.
Definition: DynamicMatrix.h:242
Efficient implementation of an arbitrary sized vector.
Definition: DynamicVector.h:223
Efficient implementation of a fixed-sized vector.
Definition: StaticVector.h:230
DetectedOr< NullAllocator< UnderlyingElement_t< T > >, AllocatorType_t, T > GetAllocator
Determines the type of allocator of the given type.
Definition: GetAllocator.h:80

◆ GetAllocator_t

template<typename T >
using blaze::GetAllocator_t = typedef typename GetAllocator<T>::Type

Auxiliary alias declaration for the GetAllocator type trait.

The GetAllocator_t alias declaration provides a convenient shortcut to access the nested Type of the GetAllocator class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename blaze::GetAllocator<T>::Type;
typename GetAllocator< T >::Type GetAllocator_t
Auxiliary alias declaration for the GetAllocator type trait.
Definition: GetAllocator.h:98

◆ HasCompositeType

template<typename T >
using blaze::HasCompositeType = typedef IsDetected< CompositeType_t, T >

Compile time check for a public nested type alias CompositeType.

This type trait tests whether the given data type T provides a public nested type alias named CompositeType. If it does, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.

IsDetected< CompositeType_t, T > HasCompositeType
Compile time check for a public nested type alias CompositeType.
Definition: HasCompositeType.h:74

◆ HasResultType

template<typename T >
using blaze::HasResultType = typedef IsDetected< ResultType_t, T >

Compile time check for a public nested type alias ResultType.

This type trait tests whether the given data type T provides a public nested type alias named ResultType. If it does, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.

blaze::HasResultType< volatile complex<float> > // Is derived from FalseType
IsDetected< ResultType_t, T > HasResultType
Compile time check for a public nested type alias ResultType.
Definition: HasResultType.h:74

◆ HighType_t

template<typename T1 , typename T2 >
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 Type1 = typename blaze::HighType<T1,T2>::Type;
typename HighType< T1, T2 >::Type HighType_t
Auxiliary alias declaration for the HighType type trait.
Definition: HighType.h:348
Base template for the HighType type trait.
Definition: HighType.h:322

◆ LowType_t

template<typename T1 , typename T2 >
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 Type1 = typename blaze::LowType<T1,T2>::Type;
typename LowType< T1, T2 >::Type LowType_t
Auxiliary alias declaration for the LowType type trait.
Definition: LowType.h:348
Base template for the LowType type trait.
Definition: LowType.h:322

◆ RemoveAdaptor_t

template<typename T >
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 Type1 = typename blaze::RemoveAdaptor<T>::Type;
typename RemoveAdaptor< T >::Type RemoveAdaptor_t
Auxiliary alias declaration for the RemoveAdaptor type trait.
Definition: RemoveAdaptor.h:153
Removal of top level adaptor types.
Definition: RemoveAdaptor.h:77

◆ UnderlyingBuiltin_t

template<typename T >
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 Type1 = typename blaze::UnderlyingBuiltin<T>::Type;
typename UnderlyingBuiltin< T >::Type UnderlyingBuiltin_t
Auxiliary alias declaration for the UnderlyingBuiltin type trait.
Definition: UnderlyingBuiltin.h:117
Evaluation of the underlying builtin element type of a given data type.
Definition: UnderlyingBuiltin.h:92

◆ UnderlyingElement_t

template<typename T >
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 Type1 = typename blaze::UnderlyingElement<T>::Type;
typename UnderlyingElement< T >::Type UnderlyingElement_t
Auxiliary alias declaration for the UnderlyingElement type trait.
Definition: UnderlyingElement.h:119
Evaluation of the element type of a given data type.
Definition: UnderlyingElement.h:94

◆ UnderlyingNumeric_t

template<typename T >
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:

using Type1 = typename blaze::UnderlyingNumeric<T>::Type;
typename UnderlyingNumeric< T >::Type UnderlyingNumeric_t
Auxiliary alias declaration for the UnderlyingNumeric type trait.
Definition: UnderlyingNumeric.h:118
Evaluation of the underlying scalar element type of a given data type.
Definition: UnderlyingNumeric.h:93

◆ UnderlyingScalar_t

template<typename T >
using blaze::UnderlyingScalar_t = typedef typename UnderlyingScalar<T>::Type

Auxiliary alias declaration for the UnderlyingScalar type trait.

The UnderlyingScalar_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingScalar class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename blaze::UnderlyingScalar<T>::Type;
typename UnderlyingScalar< T >::Type UnderlyingScalar_t
Auxiliary alias declaration for the UnderlyingScalar type trait.
Definition: UnderlyingScalar.h:116
Evaluation of the underlying scalar element type of a given data type.
Definition: UnderlyingScalar.h:91

Function Documentation

◆ BLAZE_CREATE_HAS_DATA_OR_FUNCTION_MEMBER_TYPE_TRAIT()

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.

Variable Documentation

◆ HasAbs_v

template<typename T >
constexpr bool blaze::HasAbs_v = HasAbs<T>::value
constexpr

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 value1 = blaze::HasAbs<T>::value;
constexpr bool value2 = blaze::HasAbs_v<T>;
Availability of the abs() operation for the given data types.
Definition: HasAbs.h:109

◆ HasAcos_v

template<typename T >
constexpr bool blaze::HasAcos_v = HasAcos<T>::value
constexpr

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 value1 = blaze::HasAcos<T>::value;
constexpr bool value2 = blaze::HasAcos_v<T>;
Availability of the acos() operation for the given data types.
Definition: HasAcos.h:109

◆ HasAcosh_v

template<typename T >
constexpr bool blaze::HasAcosh_v = HasAcosh<T>::value
constexpr

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 value1 = blaze::HasAcosh<T>::value;
constexpr bool value2 = blaze::HasAcosh_v<T>;
Availability of the acosh() operation for the given data types.
Definition: HasAcosh.h:109

◆ HasAdd_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasAdd_v = HasAdd<T1,T2>::value
constexpr

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 value1 = blaze::HasAdd<T1,T2>::value;
constexpr bool value2 = blaze::HasAdd_v<T1,T2>;
Availability of an addition operator for the given data types.
Definition: HasAdd.h:107

◆ HasAsin_v

template<typename T >
constexpr bool blaze::HasAsin_v = HasAsin<T>::value
constexpr

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 value1 = blaze::HasAsin<T>::value;
constexpr bool value2 = blaze::HasAsin_v<T>;
Availability of the asin() operation for the given data types.
Definition: HasAsin.h:109

◆ HasAsinh_v

template<typename T >
constexpr bool blaze::HasAsinh_v = HasAsinh<T>::value
constexpr

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 value1 = blaze::HasAsinh<T>::value;
constexpr bool value2 = blaze::HasAsinh_v<T>;
Availability of the asinh() operation for the given data types.
Definition: HasAsinh.h:109

◆ HasAtan2_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasAtan2_v = HasAtan2<T1,T2>::value
constexpr

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 value1 = blaze::HasAtan2<T1,T2>::value;
constexpr bool value2 = blaze::HasAtan2_v<T1,T2>;
Availability of the atan2() operation for the given data types.
Definition: HasAtan2.h:107

◆ HasAtan_v

template<typename T >
constexpr bool blaze::HasAtan_v = HasAtan<T>::value
constexpr

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 value1 = blaze::HasAtan<T>::value;
constexpr bool value2 = blaze::HasAtan_v<T>;
Availability of the atan() operation for the given data types.
Definition: HasAtan.h:109

◆ HasAtanh_v

template<typename T >
constexpr bool blaze::HasAtanh_v = HasAtanh<T>::value
constexpr

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 value1 = blaze::HasAtanh<T>::value;
constexpr bool value2 = blaze::HasAtanh_v<T>;
Availability of the atanh() operation for the given data types.
Definition: HasAtanh.h:109

◆ HasCbrt_v

template<typename T >
constexpr bool blaze::HasCbrt_v = HasCbrt<T>::value
constexpr

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 value1 = blaze::HasCbrt<T>::value;
constexpr bool value2 = blaze::HasCbrt_v<T>;
Availability of the cbrt() operation for the given data types.
Definition: HasCbrt.h:109

◆ HasCeil_v

template<typename T >
constexpr bool blaze::HasCeil_v = HasCeil<T>::value
constexpr

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 value1 = blaze::HasCeil<T>::value;
constexpr bool value2 = blaze::HasCeil_v<T>;
Availability of the ceil() operation for the given data types.
Definition: HasCeil.h:109

◆ HasClamp_v

template<typename T >
constexpr bool blaze::HasClamp_v = HasClamp<T>::value
constexpr

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 value1 = blaze::HasClamp<T>::value;
constexpr bool value2 = blaze::HasClamp_v<T>;
Availability of the clamp() operation for the given data types.
Definition: HasClamp.h:109

◆ HasCompositeType_v

template<typename T >
constexpr bool blaze::HasCompositeType_v = HasCompositeType<T>::value
constexpr

Auxiliary variable template for the HasCompositeType type trait.

The HasCompositeType_v variable template provides a convenient shortcut to access the nested value of the HasCompositeType class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasCompositeType<T>::value;
constexpr bool value2 = blaze::HasCompositeType_v<T>;

◆ HasConj_v

template<typename T >
constexpr bool blaze::HasConj_v = HasConj<T>::value
constexpr

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 value1 = blaze::HasConj<T>::value;
constexpr bool value2 = blaze::HasConj_v<T>;
Availability of the conj() operation for the given data types.
Definition: HasConj.h:109

◆ HasConstDataAccess_v

template<typename T >
constexpr bool blaze::HasConstDataAccess_v = HasConstDataAccess<T>::value
constexpr

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 value1 = blaze::HasConstDataAccess<T>::value;
constexpr bool value2 = blaze::HasConstDataAccess_v<T>;
Compile time check for low-level access to constant data.
Definition: HasConstDataAccess.h:76

◆ HasCos_v

template<typename T >
constexpr bool blaze::HasCos_v = HasCos<T>::value
constexpr

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 value1 = blaze::HasCos<T>::value;
constexpr bool value2 = blaze::HasCos_v<T>;
Availability of the cos() operation for the given data types.
Definition: HasCos.h:109

◆ HasCosh_v

template<typename T >
constexpr bool blaze::HasCosh_v = HasCosh<T>::value
constexpr

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 value1 = blaze::HasCosh<T>::value;
constexpr bool value2 = blaze::HasCosh_v<T>;
Availability of the cosh() operation for the given data types.
Definition: HasCosh.h:109

◆ HasDiv_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasDiv_v = HasDiv<T1,T2>::value
constexpr

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 value1 = blaze::HasDiv<T1,T2>::value;
constexpr bool value2 = blaze::HasDiv_v<T1,T2>;
Availability of a division operator for the given data types.
Definition: HasDiv.h:107

◆ HasErf_v

template<typename T >
constexpr bool blaze::HasErf_v = HasErf<T>::value
constexpr

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 value1 = blaze::HasErf<T>::value;
constexpr bool value2 = blaze::HasErf_v<T>;
Availability of the erf() operation for the given data types.
Definition: HasErf.h:109

◆ HasErfc_v

template<typename T >
constexpr bool blaze::HasErfc_v = HasErfc<T>::value
constexpr

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 value1 = blaze::HasErfc<T>::value;
constexpr bool value2 = blaze::HasErfc_v<T>;
Availability of the erfc() operation for the given data types.
Definition: HasErfc.h:109

◆ HasExp10_v

template<typename T >
constexpr bool blaze::HasExp10_v = HasExp10<T>::value
constexpr

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 value1 = blaze::HasExp10<T>::value;
constexpr bool value2 = blaze::HasExp10_v<T>;
Availability of the exp10() operation for the given data types.
Definition: HasExp10.h:109

◆ HasExp2_v

template<typename T >
constexpr bool blaze::HasExp2_v = HasExp2<T>::value
constexpr

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 value1 = blaze::HasExp2<T>::value;
constexpr bool value2 = blaze::HasExp2_v<T>;
Availability of the exp2() operation for the given data types.
Definition: HasExp2.h:109

◆ HasExp_v

template<typename T >
constexpr bool blaze::HasExp_v = HasExp<T>::value
constexpr

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 value1 = blaze::HasExp<T>::value;
constexpr bool value2 = blaze::HasExp_v<T>;
Availability of the exp() operation for the given data types.
Definition: HasExp.h:109

◆ HasFloor_v

template<typename T >
constexpr bool blaze::HasFloor_v = HasFloor<T>::value
constexpr

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 value1 = blaze::HasFloor<T>::value;
constexpr bool value2 = blaze::HasFloor_v<T>;
Availability of the floor() operation for the given data types.
Definition: HasFloor.h:109

◆ HasHypot_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasHypot_v = HasHypot<T1,T2>::value
constexpr

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 value1 = blaze::HasHypot<T1,T2>::value;
constexpr bool value2 = blaze::HasHypot_v<T1,T2>;
Availability of the hypot() operation for the given data types.
Definition: HasHypot.h:107

◆ HasImag_v

template<typename T >
constexpr bool blaze::HasImag_v = HasImag<T>::value
constexpr

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 value1 = blaze::HasImag<T>::value;
constexpr bool value2 = blaze::HasImag_v<T>;
Availability of the imag() operation for the given data types.
Definition: HasImag.h:109

◆ HasInvCbrt_v

template<typename T >
constexpr bool blaze::HasInvCbrt_v = HasInvCbrt<T>::value
constexpr

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 value1 = blaze::HasInvCbrt<T>::value;
constexpr bool value2 = blaze::HasInvCbrt_v<T>;
Availability of the invcbrt() operation for the given data types.
Definition: HasInvCbrt.h:110

◆ HasInvSqrt_v

template<typename T >
constexpr bool blaze::HasInvSqrt_v = HasInvSqrt<T>::value
constexpr

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 value1 = blaze::HasInvSqrt<T>::value;
constexpr bool value2 = blaze::HasInvSqrt_v<T>;
Availability of the invsqrt() operation for the given data types.
Definition: HasInvSqrt.h:110

◆ HasLGamma_v

template<typename T >
constexpr bool blaze::HasLGamma_v = HasLGamma<T>::value
constexpr

Auxiliary variable template for the HasLGamma type trait.

The HasLGamma_v variable template provides a convenient shortcut to access the nested value of the HasLGamma class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasLGamma<T>::value;
constexpr bool value2 = blaze::HasLGamma_v<T>;
Availability of the lgamma() operation for the given data types.
Definition: HasLGamma.h:109

◆ HasLog10_v

template<typename T >
constexpr bool blaze::HasLog10_v = HasLog10<T>::value
constexpr

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 value1 = blaze::HasLog10<T>::value;
constexpr bool value2 = blaze::HasLog10_v<T>;
Availability of the log10() operation for the given data types.
Definition: HasLog10.h:109

◆ HasLog1p_v

template<typename T >
constexpr bool blaze::HasLog1p_v = HasLog1p<T>::value
constexpr

Auxiliary variable template for the HasLog1p type trait.

The HasLog1p_v variable template provides a convenient shortcut to access the nested value of the HasLog1p class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasLog1p<T>::value;
constexpr bool value2 = blaze::HasLog1p_v<T>;
Availability of the log1p() operation for the given data types.
Definition: HasLog1p.h:109

◆ HasLog2_v

template<typename T >
constexpr bool blaze::HasLog2_v = HasLog2<T>::value
constexpr

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 value1 = blaze::HasLog2<T>::value;
constexpr bool value2 = blaze::HasLog2_v<T>;
Availability of the log2() operation for the given data types.
Definition: HasLog2.h:109

◆ HasLog_v

template<typename T >
constexpr bool blaze::HasLog_v = HasLog<T>::value
constexpr

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 value1 = blaze::HasLog<T>::value;
constexpr bool value2 = blaze::HasLog_v<T>;
Availability of the log() operation for the given data types.
Definition: HasLog.h:109

◆ HasMax_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasMax_v = HasMax<T1,T2>::value
constexpr

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 value1 = blaze::HasMax<T1,T2>::value;
constexpr bool value2 = blaze::HasMax_v<T1,T2>;
Availability of a max() operation for the given data types.
Definition: HasMax.h:108

◆ HasMin_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasMin_v = HasMin<T1,T2>::value
constexpr

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 value1 = blaze::HasMin<T1,T2>::value;
constexpr bool value2 = blaze::HasMin_v<T1,T2>;
Availability of a min() operation for the given data types.
Definition: HasMin.h:108

◆ HasMult_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasMult_v = HasMult<T1,T2>::value
constexpr

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 value1 = blaze::HasMult<T1,T2>::value;
constexpr bool value2 = blaze::HasMult_v<T1,T2>;
Availability of a multiplication operator for the given data types.
Definition: HasMult.h:108

◆ HasMutableDataAccess_v

template<typename T >
constexpr bool blaze::HasMutableDataAccess_v = HasMutableDataAccess<T>::value
constexpr

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 value1 = blaze::HasMutableDataAccess<T>::value;
constexpr bool value2 = blaze::HasMutableDataAccess_v<T>;
Compile time check for low-level access to mutable data.
Definition: HasMutableDataAccess.h:76

◆ HasPow_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasPow_v = HasPow<T1,T2>::value
constexpr

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 value1 = blaze::HasPow<T1,T2>::value;
constexpr bool value2 = blaze::HasPow_v<T1,T2>;
Availability of the pow() operation for the given data types.
Definition: HasPow.h:107

◆ HasReal_v

template<typename T >
constexpr bool blaze::HasReal_v = HasReal<T>::value
constexpr

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 value1 = blaze::HasReal<T>::value;
constexpr bool value2 = blaze::HasReal_v<T>;
Availability of the real() operation for the given data types.
Definition: HasReal.h:109

◆ HasResultType_v

template<typename T >
constexpr bool blaze::HasResultType_v = HasResultType<T>::value
constexpr

Auxiliary variable template for the HasResultType type trait.

The HasResultType_v variable template provides a convenient shortcut to access the nested value of the HasResultType class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasResultType<T>::value;
constexpr bool value2 = blaze::HasResultType_v<T>;

◆ HasRound_v

template<typename T >
constexpr bool blaze::HasRound_v = HasRound<T>::value
constexpr

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 value1 = blaze::HasRound<T>::value;
constexpr bool value2 = blaze::HasRound_v<T>;
Availability of the round() operation for the given data types.
Definition: HasRound.h:109

◆ HasSign_v

template<typename T >
constexpr bool blaze::HasSign_v = HasSign<T>::value
constexpr

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 value1 = blaze::HasSign<T>::value;
constexpr bool value2 = blaze::HasSign_v<T>;
Availability of the sign() operation for the given data types.
Definition: HasSign.h:109

◆ HasSIMDAbs_v

template<typename T >
constexpr bool blaze::HasSIMDAbs_v = HasSIMDAbs<T>::value
constexpr

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 value1 = blaze::HasSIMDAbs<T>::value;
constexpr bool value2 = blaze::HasSIMDAbs_v<T>;
Availability of a SIMD absolute value operation for the given data type.
Definition: HasSIMDAbs.h:114

◆ HasSIMDAcos_v

template<typename T >
constexpr bool blaze::HasSIMDAcos_v = HasSIMDAcos<T>::value
constexpr

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 value1 = blaze::HasSIMDAcos<T>::value;
constexpr bool value2 = blaze::HasSIMDAcos_v<T>;
Availability of a SIMD inverse cosine operation for the given data type.
Definition: HasSIMDAcos.h:101

◆ HasSIMDAcosh_v

template<typename T >
constexpr bool blaze::HasSIMDAcosh_v = HasSIMDAcosh<T>::value
constexpr

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 value1 = blaze::HasSIMDAcosh<T>::value;
constexpr bool value2 = blaze::HasSIMDAcosh_v<T>;
Availability of a SIMD inverse hyperbolic cosine operation for the given data type.
Definition: HasSIMDAcosh.h:101

◆ HasSIMDAdd_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDAdd_v = HasSIMDAdd<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDAdd<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDAdd_v<T1,T2>;
Availability of a SIMD addition for the given data types.
Definition: HasSIMDAdd.h:168

◆ HasSIMDAsin_v

template<typename T >
constexpr bool blaze::HasSIMDAsin_v = HasSIMDAsin<T>::value
constexpr

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 value1 = blaze::HasSIMDAsin<T>::value;
constexpr bool value2 = blaze::HasSIMDAsin_v<T>;
Availability of a SIMD inverse sine operation for the given data type.
Definition: HasSIMDAsin.h:101

◆ HasSIMDAsinh_v

template<typename T >
constexpr bool blaze::HasSIMDAsinh_v = HasSIMDAsinh<T>::value
constexpr

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 value1 = blaze::HasSIMDAsinh<T>::value;
constexpr bool value2 = blaze::HasSIMDAsinh_v<T>;
Availability of a SIMD inverse hyperbolic sine operation for the given data type.
Definition: HasSIMDAsinh.h:101

◆ HasSIMDAtan2_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDAtan2_v = HasSIMDAtan2<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDAtan2<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDAtan2_v<T1,T2>;
Availability of a SIMD inverse tangent operation for the given data types.
Definition: HasSIMDAtan2.h:106

◆ HasSIMDAtan_v

template<typename T >
constexpr bool blaze::HasSIMDAtan_v = HasSIMDAtan<T>::value
constexpr

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 value1 = blaze::HasSIMDAtan<T>::value;
constexpr bool value2 = blaze::HasSIMDAtan_v<T>;
Availability of a SIMD inverse tangent operation for the given data type.
Definition: HasSIMDAtan.h:101

◆ HasSIMDAtanh_v

template<typename T >
constexpr bool blaze::HasSIMDAtanh_v = HasSIMDAtanh<T>::value
constexpr

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 value1 = blaze::HasSIMDAtanh<T>::value;
constexpr bool value2 = blaze::HasSIMDAtanh_v<T>;
Availability of a SIMD inverse hyperbolic tangent operation for the given data type.
Definition: HasSIMDAtanh.h:101

◆ HasSIMDBitand_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDBitand_v = HasSIMDBitand<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDBitand<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDBitand_v<T1,T2>;
Availability of a SIMD bitwise AND ('&') for the given data types.
Definition: HasSIMDBitand.h:102

◆ HasSIMDBitor_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDBitor_v = HasSIMDBitor<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDBitor<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDBitor_v<T1,T2>;
Availability of a SIMD bitwise OR ('|') for the given data types.
Definition: HasSIMDBitor.h:102

◆ HasSIMDBitxor_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDBitxor_v = HasSIMDBitxor<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDBitxor<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDBitxor_v<T1,T2>;
Availability of a SIMD bitwise XOR ('^') for the given data types.
Definition: HasSIMDBitxor.h:102

◆ HasSIMDCbrt_v

template<typename T >
constexpr bool blaze::HasSIMDCbrt_v = HasSIMDCbrt<T>::value
constexpr

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 value1 = blaze::HasSIMDCbrt<T>::value;
constexpr bool value2 = blaze::HasSIMDCbrt_v<T>;
Availability of a SIMD cubic root operation for the given data type.
Definition: HasSIMDCbrt.h:101

◆ HasSIMDCeil_v

template<typename T >
constexpr bool blaze::HasSIMDCeil_v = HasSIMDCeil<T>::value
constexpr

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 value1 = blaze::HasSIMDCeil<T>::value;
constexpr bool value2 = blaze::HasSIMDCeil_v<T>;
Availability of a SIMD ceil operation for the given data type.
Definition: HasSIMDCeil.h:97

◆ HasSIMDConj_v

template<typename T >
constexpr bool blaze::HasSIMDConj_v = HasSIMDConj<T>::value
constexpr

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 value1 = blaze::HasSIMDConj<T>::value;
constexpr bool value2 = blaze::HasSIMDConj_v<T>;
Availability of a SIMD conjugate operation for the given data type.
Definition: HasSIMDConj.h:112

◆ HasSIMDCos_v

template<typename T >
constexpr bool blaze::HasSIMDCos_v = HasSIMDCos<T>::value
constexpr

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 value1 = blaze::HasSIMDCos<T>::value;
constexpr bool value2 = blaze::HasSIMDCos_v<T>;
Availability of a SIMD cosine operation for the given data type.
Definition: HasSIMDCos.h:101

◆ HasSIMDCosh_v

template<typename T >
constexpr bool blaze::HasSIMDCosh_v = HasSIMDCosh<T>::value
constexpr

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 value1 = blaze::HasSIMDCosh<T>::value;
constexpr bool value2 = blaze::HasSIMDCosh_v<T>;
Availability of a SIMD hyperbolic cosine operation for the given data type.
Definition: HasSIMDCosh.h:101

◆ HasSIMDDiv_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDDiv_v = HasSIMDDiv<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDDiv<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDDiv_v<T1,T2>;
Availability of a SIMD division for the given data types.
Definition: HasSIMDDiv.h:154

◆ HasSIMDEqual_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDEqual_v = HasSIMDEqual<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDEqual<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDEqual_v<T1,T2>;
Availability of a SIMD equality comparison for the given data types.
Definition: HasSIMDEqual.h:166

◆ HasSIMDErf_v

template<typename T >
constexpr bool blaze::HasSIMDErf_v = HasSIMDErf<T>::value
constexpr

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 value1 = blaze::HasSIMDErf<T>::value;
constexpr bool value2 = blaze::HasSIMDErf_v<T>;
Availability of a SIMD error function (erf) operation for the given data type.
Definition: HasSIMDErf.h:101

◆ HasSIMDErfc_v

template<typename T >
constexpr bool blaze::HasSIMDErfc_v = HasSIMDErfc<T>::value
constexpr

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 value1 = blaze::HasSIMDErfc<T>::value;
constexpr bool value2 = blaze::HasSIMDErfc_v<T>;
Availability of a SIMD complementary error function (erfc) operation for the given data type.
Definition: HasSIMDErfc.h:102

◆ HasSIMDExp10_v

template<typename T >
constexpr bool blaze::HasSIMDExp10_v = HasSIMDExp10<T>::value
constexpr

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 value1 = blaze::HasSIMDExp10<T>::value;
constexpr bool value2 = blaze::HasSIMDExp10_v<T>;
Availability of a SIMD exp10() operation for the given data type.
Definition: HasSIMDExp10.h:101

◆ HasSIMDExp2_v

template<typename T >
constexpr bool blaze::HasSIMDExp2_v = HasSIMDExp2<T>::value
constexpr

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 value1 = blaze::HasSIMDExp2<T>::value;
constexpr bool value2 = blaze::HasSIMDExp2_v<T>;
Availability of a SIMD exp2() operation for the given data type.
Definition: HasSIMDExp2.h:101

◆ HasSIMDExp_v

template<typename T >
constexpr bool blaze::HasSIMDExp_v = HasSIMDExp<T>::value
constexpr

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 value1 = blaze::HasSIMDExp<T>::value;
constexpr bool value2 = blaze::HasSIMDExp_v<T>;
Availability of a SIMD exp() operation for the given data type.
Definition: HasSIMDExp.h:101

◆ HasSIMDFloor_v

template<typename T >
constexpr bool blaze::HasSIMDFloor_v = HasSIMDFloor<T>::value
constexpr

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 value1 = blaze::HasSIMDFloor<T>::value;
constexpr bool value2 = blaze::HasSIMDFloor_v<T>;
Availability of a SIMD floor operation for the given data type.
Definition: HasSIMDFloor.h:98

◆ HasSIMDHypot_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDHypot_v = HasSIMDHypot<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDHypot<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDHypot_v<T1,T2>;
Availability of a SIMD hypotenous operation for the given data types.
Definition: HasSIMDHypot.h:105

◆ HasSIMDInvCbrt_v

template<typename T >
constexpr bool blaze::HasSIMDInvCbrt_v = HasSIMDInvCbrt<T>::value
constexpr

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 value1 = blaze::HasSIMDInvCbrt<T>::value;
constexpr bool value2 = blaze::HasSIMDInvCbrt_v<T>;
Availability of a SIMD inverse cubic root operation for the given data type.
Definition: HasSIMDInvCbrt.h:98

◆ HasSIMDInvSqrt_v

template<typename T >
constexpr bool blaze::HasSIMDInvSqrt_v = HasSIMDInvSqrt<T>::value
constexpr

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 value1 = blaze::HasSIMDInvSqrt<T>::value;
constexpr bool value2 = blaze::HasSIMDInvSqrt_v<T>;
Availability of a SIMD inverse square root operation for the given data type.
Definition: HasSIMDInvSqrt.h:99

◆ HasSIMDLGamma_v

template<typename T >
constexpr bool blaze::HasSIMDLGamma_v = HasSIMDLGamma<T>::value
constexpr

Auxiliary variable template for the HasSIMDLGamma type trait.

The HasSIMDLGamma_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLGamma class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDLGamma<T>::value;
constexpr bool value2 = blaze::HasSIMDLGamma_v<T>;
Availability of a SIMD lgamma operation for the given data type.
Definition: HasSIMDLGamma.h:100

◆ HasSIMDLog10_v

template<typename T >
constexpr bool blaze::HasSIMDLog10_v = HasSIMDLog10<T>::value
constexpr

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 value1 = blaze::HasSIMDLog10<T>::value;
constexpr bool value2 = blaze::HasSIMDLog10_v<T>;
Availability of a SIMD common logarithm operation for the given data type.
Definition: HasSIMDLog10.h:101

◆ HasSIMDLog1p_v

template<typename T >
constexpr bool blaze::HasSIMDLog1p_v = HasSIMDLog1p<T>::value
constexpr

Auxiliary variable template for the HasSIMDLog1p type trait.

The HasSIMDLog1p_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog1p class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDLog1p<T>::value;
constexpr bool value2 = blaze::HasSIMDLog1p_v<T>;
Availability of a SIMD log1p operation for the given data type.
Definition: HasSIMDLog1p.h:100

◆ HasSIMDLog2_v

template<typename T >
constexpr bool blaze::HasSIMDLog2_v = HasSIMDLog2<T>::value
constexpr

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 value1 = blaze::HasSIMDLog2<T>::value;
constexpr bool value2 = blaze::HasSIMDLog2_v<T>;
Availability of a SIMD binary logarithm operation for the given data type.
Definition: HasSIMDLog2.h:101

◆ HasSIMDLog_v

template<typename T >
constexpr bool blaze::HasSIMDLog_v = HasSIMDLog<T>::value
constexpr

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 value1 = blaze::HasSIMDLog<T>::value;
constexpr bool value2 = blaze::HasSIMDLog_v<T>;
Availability of a SIMD natural logarithm operation for the given data type.
Definition: HasSIMDLog.h:101

◆ HasSIMDMax_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMax_v = HasSIMDMax<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDMax<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDMax_v<T1,T2>;
Availability of a SIMD max operation for the given data types.
Definition: HasSIMDMax.h:169

◆ HasSIMDMin_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMin_v = HasSIMDMin<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDMin<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDMin_v<T1,T2>;
Availability of a SIMD min operation for the given data types.
Definition: HasSIMDMin.h:169

◆ HasSIMDMult_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMult_v = HasSIMDMult<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDMult<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDMult_v<T1,T2>;
Availability of a SIMD multiplication for the given data types.
Definition: HasSIMDMult.h:169

◆ HasSIMDPow_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDPow_v = HasSIMDPow<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDPow<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDPow_v<T1,T2>;
Availability of a SIMD power operation for the given data type.
Definition: HasSIMDPow.h:105

◆ HasSIMDRound_v

template<typename T >
constexpr bool blaze::HasSIMDRound_v = HasSIMDRound<T>::value
constexpr

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 value1 = blaze::HasSIMDRound<T>::value;
constexpr bool value2 = blaze::HasSIMDRound_v<T>;
Availability of a SIMD round operation for the given data type.
Definition: HasSIMDRound.h:102

◆ HasSIMDShiftLI_v

template<typename T >
constexpr bool blaze::HasSIMDShiftLI_v = HasSIMDShiftLI<T>::value
constexpr

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 value1 = blaze::HasSIMDShiftLI<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDShiftLI_v<T1,T2>;
Availability of a SIMD uniform left-shift for the given data types.
Definition: HasSIMDShiftLI.h:101

◆ HasSIMDShiftLV_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDShiftLV_v = HasSIMDShiftLV<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDShiftLV<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDShiftLV_v<T1,T2>;
Availability of an SIMD elementwise left-shift for the given data types.
Definition: HasSIMDShiftLV.h:102

◆ HasSIMDShiftRI_v

template<typename T >
constexpr bool blaze::HasSIMDShiftRI_v = HasSIMDShiftRI<T>::value
constexpr

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 value1 = blaze::HasSIMDShiftRI<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDShiftRI_v<T1,T2>;
Availability of a SIMD uniform right-shift for the given data types.
Definition: HasSIMDShiftRI.h:103

◆ HasSIMDShiftRV_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDShiftRV_v = HasSIMDShiftRV<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDShiftRV<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDShiftRV_v<T1,T2>;
Availability of a SIMD elementwise right-shift for the given data types.
Definition: HasSIMDShiftRV.h:104

◆ HasSIMDSign_v

template<typename T >
constexpr bool blaze::HasSIMDSign_v = HasSIMDSign<T>::value
constexpr

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 value1 = blaze::HasSIMDSign<T>::value;
constexpr bool value2 = blaze::HasSIMDSign_v<T>;
Availability of a SIMD sign operation for the given data type.
Definition: HasSIMDSign.h:108

◆ HasSIMDSin_v

template<typename T >
constexpr bool blaze::HasSIMDSin_v = HasSIMDSin<T>::value
constexpr

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 value1 = blaze::HasSIMDSin<T>::value;
constexpr bool value2 = blaze::HasSIMDSin_v<T>;
Availability of a SIMD sine operation for the given data type.
Definition: HasSIMDSin.h:101

◆ HasSIMDSinh_v

template<typename T >
constexpr bool blaze::HasSIMDSinh_v = HasSIMDSinh<T>::value
constexpr

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 value1 = blaze::HasSIMDSinh<T>::value;
constexpr bool value2 = blaze::HasSIMDSinh_v<T>;
Availability of a SIMD hyperbolic sine operation for the given data type.
Definition: HasSIMDSinh.h:101

◆ HasSIMDSqrt_v

template<typename T >
constexpr bool blaze::HasSIMDSqrt_v = HasSIMDSqrt<T>::value
constexpr

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 value1 = blaze::HasSIMDSqrt<T>::value;
constexpr bool value2 = blaze::HasSIMDSqrt_v<T>;
Availability of a SIMD square root operation for the given data type.
Definition: HasSIMDSqrt.h:101

◆ HasSIMDSub_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDSub_v = HasSIMDSub<T1,T2>::value
constexpr

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 value1 = blaze::HasSIMDSub<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDSub_v<T1,T2>;
Availability of a SIMD subtraction for the given data types.
Definition: HasSIMDSub.h:168

◆ HasSIMDTan_v

template<typename T >
constexpr bool blaze::HasSIMDTan_v = HasSIMDTan<T>::value
constexpr

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 value1 = blaze::HasSIMDTan<T>::value;
constexpr bool value2 = blaze::HasSIMDTan_v<T>;
Availability of a SIMD tangent operation for the given data type.
Definition: HasSIMDTan.h:101

◆ HasSIMDTanh_v

template<typename T >
constexpr bool blaze::HasSIMDTanh_v = HasSIMDTanh<T>::value
constexpr

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 value1 = blaze::HasSIMDTanh<T>::value;
constexpr bool value2 = blaze::HasSIMDTanh_v<T>;
Availability of a SIMD hyperbolic tangent operation for the given data type.
Definition: HasSIMDTanh.h:101

◆ HasSIMDTrunc_v

template<typename T >
constexpr bool blaze::HasSIMDTrunc_v = HasSIMDTrunc<T>::value
constexpr

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 value1 = blaze::HasSIMDTrunc<T>::value;
constexpr bool value2 = blaze::HasSIMDTrunc_v<T>;
Availability of a SIMD trunc operation for the given data type.
Definition: HasSIMDTrunc.h:101

◆ HasSin_v

template<typename T >
constexpr bool blaze::HasSin_v = HasSin<T>::value
constexpr

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 value1 = blaze::HasSin<T>::value;
constexpr bool value2 = blaze::HasSin_v<T>;
Availability of the sin() operation for the given data types.
Definition: HasSin.h:109

◆ HasSinh_v

template<typename T >
constexpr bool blaze::HasSinh_v = HasSinh<T>::value
constexpr

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 value1 = blaze::HasSinh<T>::value;
constexpr bool value2 = blaze::HasSinh_v<T>;
Availability of the sinh() operation for the given data types.
Definition: HasSinh.h:109

◆ HasSqrt_v

template<typename T >
constexpr bool blaze::HasSqrt_v = HasSqrt<T>::value
constexpr

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 value1 = blaze::HasSqrt<T>::value;
constexpr bool value2 = blaze::HasSqrt_v<T>;
Availability of the sqrt() operation for the given data types.
Definition: HasSqrt.h:109

◆ HasSub_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasSub_v = HasSub<T1,T2>::value
constexpr

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 value1 = blaze::HasSub<T1,T2>::value;
constexpr bool value2 = blaze::HasSub_v<T1,T2>;
Availability of a subtraction operator for the given data types.
Definition: HasSub.h:107

◆ HasTan_v

template<typename T >
constexpr bool blaze::HasTan_v = HasTan<T>::value
constexpr

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 value1 = blaze::HasTan<T>::value;
constexpr bool value2 = blaze::HasTan_v<T>;
Availability of the tan() operation for the given data types.
Definition: HasTan.h:109

◆ HasTanh_v

template<typename T >
constexpr bool blaze::HasTanh_v = HasTanh<T>::value
constexpr

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 value1 = blaze::HasTanh<T>::value;
constexpr bool value2 = blaze::HasTanh_v<T>;
Availability of the tanh() operation for the given data types.
Definition: HasTanh.h:109

◆ HasTrunc_v

template<typename T >
constexpr bool blaze::HasTrunc_v = HasTrunc<T>::value
constexpr

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 value1 = blaze::HasTrunc<T>::value;
constexpr bool value2 = blaze::HasTrunc_v<T>;
Availability of the trunc() operation for the given data types.
Definition: HasTrunc.h:109

◆ IsAdaptor_v

template<typename T >
constexpr bool blaze::IsAdaptor_v = IsAdaptor<T>::value
constexpr

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 value1 = blaze::IsAdaptor<T>::value;
constexpr bool value2 = blaze::IsAdaptor_v<T>;
Compile time check for adaptors.
Definition: IsAdaptor.h:89

◆ IsAddExpr_v

template<typename T >
constexpr bool blaze::IsAddExpr_v = IsAddExpr<T>::value
constexpr

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 value1 = blaze::IsAddExpr<T>::value;
constexpr bool value2 = blaze::IsAddExpr_v<T>;
Compile time check whether the given type is an addition expression template.
Definition: IsAddExpr.h:84

◆ IsAligned_v

template<typename T >
constexpr bool blaze::IsAligned_v = IsAligned<T>::value
constexpr

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 value1 = blaze::IsAligned<T>::value;
constexpr bool value2 = blaze::IsAligned_v<T>;
Compile time check for the alignment of data types.
Definition: IsAligned.h:88

◆ IsBand_v

template<typename T >
constexpr bool blaze::IsBand_v = IsBand<T>::value
constexpr

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 value1 = blaze::IsBand<T>::value;
constexpr bool value2 = blaze::IsBand_v<T>;
Compile time check for bands.
Definition: IsBand.h:92

◆ IsBinaryMapExpr_v

template<typename T >
constexpr bool blaze::IsBinaryMapExpr_v = IsBinaryMapExpr<T>::value
constexpr

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 value1 = blaze::IsBinaryMapExpr<T>::value;
constexpr bool value2 = blaze::IsBinaryMapExpr_v<T>;
Compile time check whether the given type is a binary map expression template.
Definition: IsBinaryMapExpr.h:83

◆ IsBLASCompatible_v

template<typename T >
constexpr bool blaze::IsBLASCompatible_v = IsBLASCompatible<T>::value
constexpr

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 value1 = blaze::IsBLASCompatible<T>::value;
constexpr bool value2 = blaze::IsBLASCompatible_v<T>;
Compile time check for data types.
Definition: IsBLASCompatible.h:81

◆ IsClearable_v

template<typename T >
constexpr bool blaze::IsClearable_v = IsClearable<T>::value
constexpr

Auxiliary variable template for the IsClearable type trait.

The IsClearable_v variable template provides a convenient shortcut to access the nested value of the IsClearable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsClearable<T>::value;
constexpr bool value2 = blaze::IsClearable_v<T>;
Compile time check for clearable data types.
Definition: IsClearable.h:90

◆ IsColumn_v

template<typename T >
constexpr bool blaze::IsColumn_v = IsColumn<T>::value
constexpr

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 value1 = blaze::IsColumn<T>::value;
constexpr bool value2 = blaze::IsColumn_v<T>;
Compile time check for columns.
Definition: IsColumn.h:91

◆ IsColumnMajorMatrix_v

template<typename T >
constexpr bool blaze::IsColumnMajorMatrix_v = IsColumnMajorMatrix<T>::value
constexpr

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 value1 = blaze::IsColumnMajorMatrix<T>::value;
constexpr bool value2 = blaze::IsColumnMajorMatrix_v<T>;
Compile time check for column-major matrix types.
Definition: IsColumnMajorMatrix.h:98

◆ IsColumns_v

template<typename T >
constexpr bool blaze::IsColumns_v = IsColumns<T>::value
constexpr

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 value1 = blaze::IsColumns<T>::value;
constexpr bool value2 = blaze::IsColumns_v<T>;
Compile time check for column selections.
Definition: IsColumns.h:91

◆ IsColumnVector_v

template<typename T >
constexpr bool blaze::IsColumnVector_v = IsColumnVector<T>::value
constexpr

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 value1 = blaze::IsColumnVector<T>::value;
constexpr bool value2 = blaze::IsColumnVector_v<T>;
Compile time check for column vector types.
Definition: IsColumnVector.h:95

◆ IsCommutative_v

template<typename T1 , typename T2 >
constexpr bool blaze::IsCommutative_v = IsCommutative<T1,T2>::value
constexpr

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 value1 = blaze::IsCommutative<T1,T2>::value;
constexpr bool value2 = blaze::IsCommutative_v<T1,T2>;
Compile time check for the commutativity of data types.
Definition: IsCommutative.h:84

◆ IsComputation_v

template<typename T >
constexpr bool blaze::IsComputation_v = IsComputation<T>::value
constexpr

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 value1 = blaze::IsComputation<T>::value;
constexpr bool value2 = blaze::IsComputation_v<T>;
Compile time check whether the given type is a computational expression template.
Definition: IsComputation.h:72

◆ IsContiguous_v

template<typename T >
constexpr bool blaze::IsContiguous_v = IsContiguous<T>::value
constexpr

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 value1 = blaze::IsContiguous<T>::value;
constexpr bool value2 = blaze::IsContiguous_v<T>;
Compile time check for the memory layout of data types.
Definition: IsContiguous.h:87

◆ IsCrossExpr_v

template<typename T >
constexpr bool blaze::IsCrossExpr_v = IsCrossExpr<T>::value
constexpr

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 value1 = blaze::IsCrossExpr<T>::value;
constexpr bool value2 = blaze::IsCrossExpr_v<T>;
Compile time check whether the given type is a cross product expression template.
Definition: IsCrossExpr.h:84

◆ IsCustom_v

template<typename T >
constexpr bool blaze::IsCustom_v = IsCustom<T>::value
constexpr

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 value1 = blaze::IsCustom<T>::value;
constexpr bool value2 = blaze::IsCustom_v<T>;
Compile time check for custom data types.
Definition: IsCustom.h:88

◆ IsDeclaration_v

template<typename T >
constexpr bool blaze::IsDeclaration_v = IsDeclaration<T>::value
constexpr

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 value1 = blaze::IsDeclaration<T>::value;
constexpr bool value2 = blaze::IsDeclaration_v<T>;
Compile time check whether the given type is a declaration expression template.
Definition: IsDeclaration.h:83

◆ IsDeclDiagExpr_v

template<typename T >
constexpr bool blaze::IsDeclDiagExpr_v = IsDeclDiagExpr<T>::value
constexpr

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 value1 = blaze::IsDeclDiagExpr<T>::value;
constexpr bool value2 = blaze::IsDeclDiagExpr_v<T>;
Compile time check whether the given type is a decldiag expression template.
Definition: IsDeclDiagExpr.h:83

◆ IsDeclExpr_v

template<typename T >
constexpr bool blaze::IsDeclExpr_v = IsDeclExpr<T>::value
constexpr

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 value1 = blaze::IsDeclExpr<T>::value;
constexpr bool value2 = blaze::IsDeclExpr_v<T>;
Compile time check whether the given type is a declaration expression template.
Definition: IsDeclExpr.h:83

◆ IsDeclHermExpr_v

template<typename T >
constexpr bool blaze::IsDeclHermExpr_v = IsDeclHermExpr<T>::value
constexpr

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 value1 = blaze::IsDeclHermExpr<T>::value;
constexpr bool value2 = blaze::IsDeclHermExpr_v<T>;
Compile time check whether the given type is a declherm expression template.
Definition: IsDeclHermExpr.h:83

◆ IsDeclLowExpr_v

template<typename T >
constexpr bool blaze::IsDeclLowExpr_v = IsDeclLowExpr<T>::value
constexpr

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 value1 = blaze::IsDeclLowExpr<T>::value;
constexpr bool value2 = blaze::IsDeclLowExpr_v<T>;
Compile time check whether the given type is a decllow expression template.
Definition: IsDeclLowExpr.h:83

◆ IsDeclStrLowExpr_v

template<typename T >
constexpr bool blaze::IsDeclStrLowExpr_v = IsDeclStrLowExpr<T>::value
constexpr

Auxiliary variable template for the IsDeclStrLowExpr type trait.

The IsDeclStrLowExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclStrLowExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclStrLowExpr<T>::value;
constexpr bool value2 = blaze::IsDeclStrLowExpr_v<T>;
Compile time check whether the given type is a declstrlow expression template.
Definition: IsDeclStrLowExpr.h:83

◆ IsDeclStrUppExpr_v

template<typename T >
constexpr bool blaze::IsDeclStrUppExpr_v = IsDeclStrUppExpr<T>::value
constexpr

Auxiliary variable template for the IsDeclStrUppExpr type trait.

The IsDeclStrUppExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclStrUppExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclStrUppExpr<T>::value;
constexpr bool value2 = blaze::IsDeclStrUppExpr_v<T>;
Compile time check whether the given type is a declstrupp expression template.
Definition: IsDeclStrUppExpr.h:83

◆ IsDeclSymExpr_v

template<typename T >
constexpr bool blaze::IsDeclSymExpr_v = IsDeclSymExpr<T>::value
constexpr

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 value1 = blaze::IsDeclSymExpr<T>::value;
constexpr bool value2 = blaze::IsDeclSymExpr_v<T>;
Compile time check whether the given type is a declsym expression template.
Definition: IsDeclSymExpr.h:83

◆ IsDeclUniLowExpr_v

template<typename T >
constexpr bool blaze::IsDeclUniLowExpr_v = IsDeclUniLowExpr<T>::value
constexpr

Auxiliary variable template for the IsDeclUniLowExpr type trait.

The IsDeclUniLowExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclUniLowExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclUniLowExpr<T>::value;
constexpr bool value2 = blaze::IsDeclUniLowExpr_v<T>;
Compile time check whether the given type is a declunilow expression template.
Definition: IsDeclUniLowExpr.h:83

◆ IsDeclUniUppExpr_v

template<typename T >
constexpr bool blaze::IsDeclUniUppExpr_v = IsDeclUniUppExpr<T>::value
constexpr

Auxiliary variable template for the IsDeclUniUppExpr type trait.

The IsDeclUniUppExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclUniUppExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclUniUppExpr<T>::value;
constexpr bool value2 = blaze::IsDeclUniUppExpr_v<T>;
Compile time check whether the given type is a decluniupp expression template.
Definition: IsDeclUniUppExpr.h:83

◆ IsDeclUppExpr_v

template<typename T >
constexpr bool blaze::IsDeclUppExpr_v = IsDeclUppExpr<T>::value
constexpr

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 value1 = blaze::IsDeclUppExpr<T>::value;
constexpr bool value2 = blaze::IsDeclUppExpr_v<T>;
Compile time check whether the given type is a declupp expression template.
Definition: IsDeclUppExpr.h:83

◆ IsDenseMatrix_v

template<typename T >
constexpr bool blaze::IsDenseMatrix_v = IsDenseMatrix<T>::value
constexpr

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 value1 = blaze::IsDenseMatrix<T>::value;
constexpr bool value2 = blaze::IsDenseMatrix_v<T>;
Compile time check for dense matrix types.
Definition: IsDenseMatrix.h:93

◆ IsDenseVector_v

template<typename T >
constexpr bool blaze::IsDenseVector_v = IsDenseVector<T>::value
constexpr

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 value1 = blaze::IsDenseVector<T>::value;
constexpr bool value2 = blaze::IsDenseVector_v<T>;
Compile time check for dense vector types.
Definition: IsDenseVector.h:93

◆ IsDiagonal_v

template<typename T >
constexpr bool blaze::IsDiagonal_v = IsDiagonal<T>::value
constexpr

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 value1 = blaze::IsDiagonal<T>::value;
constexpr bool value2 = blaze::IsDiagonal_v<T>;
Compile time check for diagonal matrices.
Definition: IsDiagonal.h:91

◆ IsDivExpr_v

template<typename T >
constexpr bool blaze::IsDivExpr_v = IsDivExpr<T>::value
constexpr

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 value1 = blaze::IsDivExpr<T>::value;
constexpr bool value2 = blaze::IsDivExpr_v<T>;
Compile time check whether the given type is a division expression template.
Definition: IsDivExpr.h:85

◆ IsEigenExpr_v

template<typename T >
constexpr bool blaze::IsEigenExpr_v = IsEigenExpr<T>::value
constexpr

Auxiliary variable template for the IsEigenExpr type trait.

The IsEigenExpr_v variable template provides a convenient shortcut to access the nested value of the IsEigenExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsEigenExpr<T>::value;
constexpr bool value2 = blaze::IsEigenExpr_v<T>;
Compile time check whether the given type is an eigenvalue expression template.
Definition: IsEigenExpr.h:83

◆ IsElements_v

template<typename T >
constexpr bool blaze::IsElements_v = IsElements<T>::value
constexpr

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 value1 = blaze::IsElements<T>::value;
constexpr bool value2 = blaze::IsElements_v<T>;
Compile time check for element selections.
Definition: IsElements.h:89

◆ IsEvalExpr_v

template<typename T >
constexpr bool blaze::IsEvalExpr_v = IsEvalExpr<T>::value
constexpr

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 value1 = blaze::IsEvalExpr<T>::value;
constexpr bool value2 = blaze::IsEvalExpr_v<T>;
Compile time check whether the given type is an evaluation expression template.
Definition: IsEvalExpr.h:83

◆ IsExpandExpr_v

template<typename T >
constexpr bool blaze::IsExpandExpr_v = IsExpandExpr<T>::value
constexpr

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 value1 = blaze::IsExpandExpr<T>::value;
constexpr bool value2 = blaze::IsExpandExpr_v<T>;
Compile time check whether the given type is an expansion expression template.
Definition: IsExpandExpr.h:83

◆ IsExpression_v

template<typename T >
constexpr bool blaze::IsExpression_v = IsExpression<T>::value
constexpr

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 value1 = blaze::IsExpression<T>::value;
constexpr bool value2 = blaze::IsExpression_v<T>;
Compile time check whether the given type is an expression template.
Definition: IsExpression.h:83

◆ IsGeneral_v

template<typename T >
constexpr bool blaze::IsGeneral_v = IsGeneral<T>::value
constexpr

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 value1 = blaze::IsGeneral<T>::value;
constexpr bool value2 = blaze::IsGeneral_v<T>;
Compile time check for general matrices.
Definition: IsGeneral.h:90

◆ IsGenExpr_v

template<typename T >
constexpr bool blaze::IsGenExpr_v = IsGenExpr<T>::value
constexpr

Auxiliary variable template for the IsGenExpr type trait.

The IsGenExpr_v variable template provides a convenient shortcut to access the nested value of the IsGenExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsGenExpr<T>::value;
constexpr bool value2 = blaze::IsGenExpr_v<T>;
Compile time check whether the given type is a generator expression template.
Definition: IsGenExpr.h:83

◆ IsHermitian_v

template<typename T >
constexpr bool blaze::IsHermitian_v = IsHermitian<T>::value
constexpr

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 value1 = blaze::IsHermitian<T>::value;
constexpr bool value2 = blaze::IsHermitian_v<T>;
Compile time check for Hermitian matrices.
Definition: IsHermitian.h:115

◆ IsIdentity_v

template<typename T >
constexpr bool blaze::IsIdentity_v = IsIdentity<T>::value
constexpr

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 value1 = blaze::IsIdentity<T>::value;
constexpr bool value2 = blaze::IsIdentity_v<T>;
Compile time check for identity matrices.
Definition: IsIdentity.h:80

◆ IsInitializer_v

template<typename T >
constexpr bool blaze::IsInitializer_v = IsInitializer<T>::value
constexpr

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 value1 = blaze::IsInitializer<T>::value;
constexpr bool value2 = blaze::IsInitializer_v<T>;
Compile time check for custom data types.
Definition: IsInitializer.h:83

◆ IsInvertible_v

template<typename T >
constexpr bool blaze::IsInvertible_v = IsInvertible<T>::value
constexpr

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 value1 = blaze::IsInvertible<T>::value;
constexpr bool value2 = blaze::IsInvertible_v<T>;
Compile time check for data types.
Definition: IsInvertible.h:85

◆ IsKronExpr_v

template<typename T >
constexpr bool blaze::IsKronExpr_v = IsKronExpr<T>::value
constexpr

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 value1 = blaze::IsKronExpr<T>::value;
constexpr bool value2 = blaze::IsKronExpr_v<T>;
Compile time check whether the given type is a Kronecker product expression template.
Definition: IsKronExpr.h:84

◆ IsLower_v

template<typename T >
constexpr bool blaze::IsLower_v = IsLower<T>::value
constexpr

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 value1 = blaze::IsLower<T>::value;
constexpr bool value2 = blaze::IsLower_v<T>;
Compile time check for lower triangular matrices.
Definition: IsLower.h:118

◆ IsMatEvalExpr_v

template<typename T >
constexpr bool blaze::IsMatEvalExpr_v = IsMatEvalExpr<T>::value
constexpr

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 value1 = blaze::IsMatEvalExpr<T>::value;
constexpr bool value2 = blaze::IsMatEvalExpr_v<T>;
Compile time check whether the given type is a matrix evaluation expression template.
Definition: IsMatEvalExpr.h:84

◆ IsMatExpExpr_v

template<typename T >
constexpr bool blaze::IsMatExpExpr_v = IsMatExpExpr<T>::value
constexpr

Auxiliary variable template for the IsMatExpExpr type trait.

The IsMatExpExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatExpExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatExpExpr<T>::value;
constexpr bool value2 = blaze::IsMatExpExpr_v<T>;
Compile time check whether the given type is a matrix exponential expression template.
Definition: IsMatExpExpr.h:84

◆ IsMatGenExpr_v

template<typename T >
constexpr bool blaze::IsMatGenExpr_v = IsMatGenExpr<T>::value
constexpr

Auxiliary variable template for the IsMatGenExpr type trait.

The IsMatGenExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatGenExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatGenExpr<T>::value;
constexpr bool value2 = blaze::IsMatGenExpr_v<T>;
Compile time check whether the given type is a matrix generator expression template.
Definition: IsMatGenExpr.h:84

◆ IsMatInvExpr_v

template<typename T >
constexpr bool blaze::IsMatInvExpr_v = IsMatInvExpr<T>::value
constexpr

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 value1 = blaze::IsMatInvExpr<T>::value;
constexpr bool value2 = blaze::IsMatInvExpr_v<T>;
Compile time check whether the given type is a matrix inversion expression template.
Definition: IsMatInvExpr.h:84

◆ IsMatMapExpr_v

template<typename T >
constexpr bool blaze::IsMatMapExpr_v = IsMatMapExpr<T>::value
constexpr

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 value1 = blaze::IsMatMapExpr<T>::value;
constexpr bool value2 = blaze::IsMatMapExpr_v<T>;
Compile time check whether the given type is a unary matrix map expression template.
Definition: IsMatMapExpr.h:84

◆ IsMatMatAddExpr_v

template<typename T >
constexpr bool blaze::IsMatMatAddExpr_v = IsMatMatAddExpr<T>::value
constexpr

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 value1 = blaze::IsMatMatAddExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatAddExpr_v<T>;
Compile time check whether the given type is a matrix/matrix addition expression template.
Definition: IsMatMatAddExpr.h:84

◆ IsMatMatKronExpr_v

template<typename T >
constexpr bool blaze::IsMatMatKronExpr_v = IsMatMatKronExpr<T>::value
constexpr

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 value1 = blaze::IsMatMatKronExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatKronExpr_v<T>;
Compile time check whether the given type is a matrix/matrix Kronecker product expression template.
Definition: IsMatMatKronExpr.h:85

◆ IsMatMatMapExpr_v

template<typename T >
constexpr bool blaze::IsMatMatMapExpr_v = IsMatMatMapExpr<T>::value
constexpr

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 value1 = blaze::IsMatMatMapExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatMapExpr_v<T>;
Compile time check whether the given type is a binary matrix map expression template.
Definition: IsMatMatMapExpr.h:84

◆ IsMatMatMultExpr_v

template<typename T >
constexpr bool blaze::IsMatMatMultExpr_v = IsMatMatMultExpr<T>::value
constexpr

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 value1 = blaze::IsMatMatMultExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatMultExpr_v<T>;
Compile time check whether the given type is a matrix/matrix multiplication expression template.
Definition: IsMatMatMultExpr.h:85

◆ IsMatMatSolveExpr_v

template<typename T >
constexpr bool blaze::IsMatMatSolveExpr_v = IsMatMatSolveExpr<T>::value
constexpr

Auxiliary variable template for the IsMatMatSolveExpr type trait.

The IsMatMatSolveExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatSolveExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatMatSolveExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatSolveExpr_v<T>;
Compile time check whether the given type is a multi LSE solver expression template.
Definition: IsMatMatSolveExpr.h:84

◆ IsMatMatSubExpr_v

template<typename T >
constexpr bool blaze::IsMatMatSubExpr_v = IsMatMatSubExpr<T>::value
constexpr

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 value1 = blaze::IsMatMatSubExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatSubExpr_v<T>;
Compile time check whether the given type is a matrix/matrix subtraction expression template.
Definition: IsMatMatSubExpr.h:84

◆ IsMatNoAliasExpr_v

template<typename T >
constexpr bool blaze::IsMatNoAliasExpr_v = IsMatNoAliasExpr<T>::value
constexpr

Auxiliary variable template for the IsMatNoAliasExpr type trait.

The IsMatNoAliasExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatNoAliasExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatNoAliasExpr<T>::value;
constexpr bool value2 = blaze::IsMatNoAliasExpr_v<T>;
Compile time check whether the given type is a matrix no-alias expression template.
Definition: IsMatNoAliasExpr.h:84

◆ IsMatNoSIMDExpr_v

template<typename T >
constexpr bool blaze::IsMatNoSIMDExpr_v = IsMatNoSIMDExpr<T>::value
constexpr

Auxiliary variable template for the IsMatNoSIMDExpr type trait.

The IsMatNoSIMDExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatNoSIMDExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatNoSIMDExpr<T>::value;
constexpr bool value2 = blaze::IsMatNoSIMDExpr_v<T>;
Compile time check whether the given type is a matrix no-SIMD expression template.
Definition: IsMatNoSIMDExpr.h:84

◆ IsMatReduceExpr_v

template<typename T >
constexpr bool blaze::IsMatReduceExpr_v = IsMatReduceExpr<T>::value
constexpr

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 value1 = blaze::IsMatReduceExpr<T>::value;
constexpr bool value2 = blaze::IsMatReduceExpr_v<T>;
Compile time check whether the given type is a reduction expression template.
Definition: IsMatReduceExpr.h:84

◆ IsMatRepeatExpr_v

template<typename T >
constexpr bool blaze::IsMatRepeatExpr_v = IsMatRepeatExpr<T>::value
constexpr

Auxiliary variable template for the IsMatRepeatExpr type trait.

The IsMatRepeatExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatRepeatExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatRepeatExpr<T>::value;
constexpr bool value2 = blaze::IsMatRepeatExpr_v<T>;
Compile time check whether the given type is a matrix repeater expression template.
Definition: IsMatRepeatExpr.h:84

◆ IsMatrix_v

template<typename T >
constexpr bool blaze::IsMatrix_v = IsMatrix<T>::value
constexpr

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 value1 = blaze::IsMatrix<T>::value;
constexpr bool value2 = blaze::IsMatrix_v<T>;
Compile time check for matrix types.
Definition: IsMatrix.h:93

◆ IsMatScalarDivExpr_v

template<typename T >
constexpr bool blaze::IsMatScalarDivExpr_v = IsMatScalarDivExpr<T>::value
constexpr

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 value1 = blaze::IsMatScalarDivExpr<T>::value;
constexpr bool value2 = blaze::IsMatScalarDivExpr_v<T>;
Compile time check whether the given type is a matrix/scalar division expression template.
Definition: IsMatScalarDivExpr.h:85

◆ IsMatScalarMultExpr_v

template<typename T >
constexpr bool blaze::IsMatScalarMultExpr_v = IsMatScalarMultExpr<T>::value
constexpr

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 value1 = blaze::IsMatScalarMultExpr<T>::value;
constexpr bool value2 = blaze::IsMatScalarMultExpr_v<T>;
Compile time check whether the given type is a matrix/scalar multiplication expression template.
Definition: IsMatScalarMultExpr.h:86

◆ IsMatSerialExpr_v

template<typename T >
constexpr bool blaze::IsMatSerialExpr_v = IsMatSerialExpr<T>::value
constexpr

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 value1 = blaze::IsMatSerialExpr<T>::value;
constexpr bool value2 = blaze::IsMatSerialExpr_v<T>;
Compile time check whether the given type is a matrix serial evaluation expression template.
Definition: IsMatSerialExpr.h:84

◆ IsMatTransExpr_v

template<typename T >
constexpr bool blaze::IsMatTransExpr_v = IsMatTransExpr<T>::value
constexpr

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 value1 = blaze::IsMatTransExpr<T>::value;
constexpr bool value2 = blaze::IsMatTransExpr_v<T>;
Compile time check whether the given type is a matrix transposition expression template.
Definition: IsMatTransExpr.h:84

◆ IsMatVecMultExpr_v

template<typename T >
constexpr bool blaze::IsMatVecMultExpr_v = IsMatVecMultExpr<T>::value
constexpr

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 value1 = blaze::IsMatVecMultExpr<T>::value;
constexpr bool value2 = blaze::IsMatVecMultExpr_v<T>;
Compile time check whether the given type is a matrix/vector multiplication expression template.
Definition: IsMatVecMultExpr.h:86

◆ IsMatVecSolveExpr_v

template<typename T >
constexpr bool blaze::IsMatVecSolveExpr_v = IsMatVecSolveExpr<T>::value
constexpr

Auxiliary variable template for the IsMatVecSolveExpr type trait.

The IsMatVecSolveExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatVecSolveExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatVecSolveExpr<T>::value;
constexpr bool value2 = blaze::IsMatVecSolveExpr_v<T>;
Compile time check whether the given type is a single LSE solver expression template.
Definition: IsMatVecSolveExpr.h:84

◆ IsModification_v

template<typename T >
constexpr bool blaze::IsModification_v = IsModification<T>::value
constexpr

Auxiliary variable template for the IsModification type trait.

The IsModification_v variable template provides a convenient shortcut to access the nested value of the IsModification class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsModification<T>::value;
constexpr bool value2 = blaze::IsModification_v<T>;
Compile time check whether the given type is a modification expression template.
Definition: IsModification.h:83

◆ IsMultExpr_v

template<typename T >
constexpr bool blaze::IsMultExpr_v = IsMultExpr<T>::value
constexpr

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 value1 = blaze::IsMultExpr<T>::value;
constexpr bool value2 = blaze::IsMultExpr_v<T>;
Compile time check whether the given type is a multiplication expression template.
Definition: IsMultExpr.h:85

◆ IsNoAliasExpr_v

template<typename T >
constexpr bool blaze::IsNoAliasExpr_v = IsNoAliasExpr<T>::value
constexpr

Auxiliary variable template for the IsNoAliasExpr type trait.

The IsNoAliasExpr_v variable template provides a convenient shortcut to access the nested value of the IsNoAliasExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsNoAliasExpr<T>::value;
constexpr bool value2 = blaze::IsNoAliasExpr_v<T>;
Compile time check whether the given type is a no-alias expression template.
Definition: IsNoAliasExpr.h:83

◆ IsNoSIMDExpr_v

template<typename T >
constexpr bool blaze::IsNoSIMDExpr_v = IsNoSIMDExpr<T>::value
constexpr

Auxiliary variable template for the IsNoSIMDExpr type trait.

The IsNoSIMDExpr_v variable template provides a convenient shortcut to access the nested value of the IsNoSIMDExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsNoSIMDExpr<T>::value;
constexpr bool value2 = blaze::IsNoSIMDExpr_v<T>;
Compile time check whether the given type is a no-SIMD expression template.
Definition: IsNoSIMDExpr.h:83

◆ IsOperation_v

template<typename T >
constexpr bool blaze::IsOperation_v = IsOperation<T>::value
constexpr

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 value1 = blaze::IsOperation<T>::value;
constexpr bool value2 = blaze::IsOperation_v<T>;
Compile time check whether the given type is an operational expression template.
Definition: IsOperation.h:71

◆ IsOpposedView_v

template<typename T >
constexpr bool blaze::IsOpposedView_v = IsOpposedView<T>::value
constexpr

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 value1 = blaze::IsOpposedView<T>::value;
constexpr bool value2 = blaze::IsOpposedView_v<T>;
Compile time check for resizable data types.
Definition: IsOpposedView.h:82

◆ IsPadded_v

template<typename T >
constexpr bool blaze::IsPadded_v = IsPadded<T>::value
constexpr

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 value1 = blaze::IsPadded<T>::value;
constexpr bool value2 = blaze::IsPadded_v<T>;
Compile time check for data types with padding.
Definition: IsPadded.h:77

◆ IsPaddingEnabled_v

template<typename T >
constexpr bool blaze::IsPaddingEnabled_v = IsPaddingEnabled<T>::value
constexpr

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 value1 = blaze::IsPaddingEnabled<T>::value;
constexpr bool value2 = blaze::IsPaddingEnabled_v<T>;
Compile time check for data types.
Definition: IsPaddingEnabled.h:113

◆ IsProxy_v

template<typename T >
constexpr bool blaze::IsProxy_v = IsProxy<T>::value
constexpr

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 value1 = blaze::IsProxy<T>::value;
constexpr bool value2 = blaze::IsProxy_v<T>;
Compile time check for proxy types.
Definition: IsProxy.h:96

◆ IsReduceExpr_v

template<typename T >
constexpr bool blaze::IsReduceExpr_v = IsReduceExpr<T>::value
constexpr

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 value1 = blaze::IsReduceExpr<T>::value;
constexpr bool value2 = blaze::IsReduceExpr_v<T>;
Compile time check whether the given type is a reduction expression template.
Definition: IsReduceExpr.h:83

◆ IsRepeatExpr_v

template<typename T >
constexpr bool blaze::IsRepeatExpr_v = IsRepeatExpr<T>::value
constexpr

Auxiliary variable template for the IsRepeatExpr type trait.

The IsRepeatExpr_v variable template provides a convenient shortcut to access the nested value of the IsRepeatExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRepeatExpr<T>::value;
constexpr bool value2 = blaze::IsRepeatExpr_v<T>;
Compile time check whether the given type is a repeater expression template.
Definition: IsRepeatExpr.h:83

◆ IsResizable_v

template<typename T >
constexpr bool blaze::IsResizable_v = IsResizable<T>::value
constexpr

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 value1 = blaze::IsResizable<T>::value;
constexpr bool value2 = blaze::IsResizable_v<T>;
Compile time check for resizable data types.
Definition: IsResizable.h:105

◆ IsRestricted_v

template<typename T >
constexpr bool blaze::IsRestricted_v = IsRestricted<T>::value
constexpr

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 value1 = blaze::IsRestricted<T>::value;
constexpr bool value2 = blaze::IsRestricted_v<T>;
Compile time check for data types with restricted data access.
Definition: IsRestricted.h:83

◆ IsRow_v

template<typename T >
constexpr bool blaze::IsRow_v = IsRow<T>::value
constexpr

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 value1 = blaze::IsRow<T>::value;
constexpr bool value2 = blaze::IsRow_v<T>;
Compile time check for rows.
Definition: IsRow.h:91

◆ IsRowMajorMatrix_v

template<typename T >
constexpr bool blaze::IsRowMajorMatrix_v = IsRowMajorMatrix<T>::value
constexpr

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 value1 = blaze::IsRowMajorMatrix<T>::value;
constexpr bool value2 = blaze::IsRowMajorMatrix_v<T>;
Compile time check for row-major matrix types.
Definition: IsRowMajorMatrix.h:98

◆ IsRows_v

template<typename T >
constexpr bool blaze::IsRows_v = IsRows<T>::value
constexpr

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 value1 = blaze::IsRows<T>::value;
constexpr bool value2 = blaze::IsRows_v<T>;
Compile time check for row selections.
Definition: IsRows.h:91

◆ IsRowVector_v

template<typename T >
constexpr bool blaze::IsRowVector_v = IsRowVector<T>::value
constexpr

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 value1 = blaze::IsRowVector<T>::value;
constexpr bool value2 = blaze::IsRowVector_v<T>;
Compile time check for row vector types.
Definition: IsRowVector.h:95

◆ IsScalar_v

template<typename T >
constexpr bool blaze::IsScalar_v = IsScalar<T>::value
constexpr

Auxiliary variable template for the IsScalar type trait.

The IsScalar_v variable template provides a convenient shortcut to access the nested value of the IsScalar class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsScalar<T>::value;
constexpr bool value2 = blaze::IsScalar_v<T>;
Compile time check for scalar types.
Definition: IsScalar.h:86

◆ IsSchurExpr_v

template<typename T >
constexpr bool blaze::IsSchurExpr_v = IsSchurExpr<T>::value
constexpr

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 value1 = blaze::IsSchurExpr<T>::value;
constexpr bool value2 = blaze::IsSchurExpr_v<T>;
Compile time check whether the given type is a Schur product expression template.
Definition: IsSchurExpr.h:84

◆ IsSerialExpr_v

template<typename T >
constexpr bool blaze::IsSerialExpr_v = IsSerialExpr<T>::value
constexpr

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 value1 = blaze::IsSerialExpr<T>::value;
constexpr bool value2 = blaze::IsSerialExpr_v<T>;
Compile time check whether the given type is a serial evaluation expression template.
Definition: IsSerialExpr.h:84

◆ IsShrinkable_v

template<typename T >
constexpr bool blaze::IsShrinkable_v = IsShrinkable<T>::value
constexpr

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 value1 = blaze::IsShrinkable<T>::value;
constexpr bool value2 = blaze::IsShrinkable_v<T>;
Compile time check for shrinkable data types.
Definition: IsShrinkable.h:90

◆ IsSIMDCombinable_v

template<typename T1 , typename T2 , typename... Ts>
constexpr bool blaze::IsSIMDCombinable_v = IsSIMDCombinable<T1,T2,Ts...>::value
constexpr

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 value1 = blaze::IsSIMDCombinable<T1,T2>::value;
constexpr bool value2 = blaze::IsSIMDCombinable_v<T1,T2>;
Compile time check for data types.
Definition: IsSIMDCombinable.h:119

◆ IsSIMDEnabled_v

template<typename T , typename... Args>
constexpr bool blaze::IsSIMDEnabled_v = IsSIMDEnabled<T,Args...>::value
constexpr

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 value1 = blaze::IsSIMDEnabled<T>::value;
constexpr bool value2 = blaze::IsSIMDEnabled_v<T>;
Compile time check for data types.
Definition: IsSIMDEnabled.h:111

◆ IsSIMDPack_v

template<typename T >
constexpr bool blaze::IsSIMDPack_v = IsSIMDPack<T>::value
constexpr

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 value1 = blaze::IsSIMDPack<T>::value;
constexpr bool value2 = blaze::IsSIMDPack_v<T>;
Compile time check for SIMD data types.
Definition: IsSIMDPack.h:126

◆ IsSMPAssignable_v

template<typename T >
constexpr bool blaze::IsSMPAssignable_v = IsSMPAssignable<T>::value
constexpr

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 value1 = blaze::IsSMPAssignable<T>::value;
constexpr bool value2 = blaze::IsSMPAssignable_v<T>;
Compile time check for data types.
Definition: IsSMPAssignable.h:114

◆ IsSolveExpr_v

template<typename T >
constexpr bool blaze::IsSolveExpr_v = IsSolveExpr<T>::value
constexpr

Auxiliary variable template for the IsSolveExpr type trait.

The IsSolveExpr_v variable template provides a convenient shortcut to access the nested value of the IsSolveExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSolveExpr<T>::value;
constexpr bool value2 = blaze::IsSolveExpr_v<T>;
Compile time check whether the given type is a solver expression template.
Definition: IsSolveExpr.h:84

◆ IsSparseElement_v

template<typename T >
constexpr bool blaze::IsSparseElement_v = IsSparseElement<T>::value
constexpr

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 value1 = blaze::IsSparseElement<T>::value;
constexpr bool value2 = blaze::IsSparseElement_v<T>;
Compile time check whether the given type is a sparse element type.
Definition: IsSparseElement.h:71

◆ IsSparseMatrix_v

template<typename T >
constexpr bool blaze::IsSparseMatrix_v = IsSparseMatrix<T>::value
constexpr

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 value1 = blaze::IsSparseMatrix<T>::value;
constexpr bool value2 = blaze::IsSparseMatrix_v<T>;
Compile time check for sparse matrix types.
Definition: IsSparseMatrix.h:93

◆ IsSparseVector_v

template<typename T >
constexpr bool blaze::IsSparseVector_v = IsSparseVector<T>::value
constexpr

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 value1 = blaze::IsSparseVector<T>::value;
constexpr bool value2 = blaze::IsSparseVector_v<T>;
Compile time check for sparse vector types.
Definition: IsSparseVector.h:93

◆ IsSquare_v

template<typename T >
constexpr bool blaze::IsSquare_v = IsSquare<T>::value
constexpr

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 value1 = blaze::IsSquare<T>::value;
constexpr bool value2 = blaze::IsSquare_v<T>;
Compile time check for square matrices.
Definition: IsSquare.h:89

◆ IsStatic_v

template<typename T >
constexpr bool blaze::IsStatic_v = IsStatic<T>::value
constexpr

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 value1 = blaze::IsStatic<T>::value;
constexpr bool value2 = blaze::IsStatic_v<T>;
Compile time check for static data types.
Definition: IsStatic.h:91

◆ IsStrictlyLower_v

template<typename T >
constexpr bool blaze::IsStrictlyLower_v = IsStrictlyLower<T>::value
constexpr

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 value1 = blaze::IsStrictlyLower<T>::value;
constexpr bool value2 = blaze::IsStrictlyLower_v<T>;
Compile time check for strictly lower triangular matrices.
Definition: IsStrictlyLower.h:116

◆ IsStrictlyTriangular_v

template<typename T >
constexpr bool blaze::IsStrictlyTriangular_v = IsStrictlyTriangular<T>::value
constexpr

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 value1 = blaze::IsStrictlyTriangular<T>::value;
constexpr bool value2 = blaze::IsStrictlyTriangular_v<T>;
Compile time check for strictly triangular matrix types.
Definition: IsStrictlyTriangular.h:88

◆ IsStrictlyUpper_v

template<typename T >
constexpr bool blaze::IsStrictlyUpper_v = IsStrictlyUpper<T>::value
constexpr

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 value1 = blaze::IsStrictlyUpper<T>::value;
constexpr bool value2 = blaze::IsStrictlyUpper_v<T>;
Compile time check for strictly upper triangular matrices.
Definition: IsStrictlyUpper.h:116

◆ IsSubExpr_v

template<typename T >
constexpr bool blaze::IsSubExpr_v = IsSubExpr<T>::value
constexpr

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 value1 = blaze::IsSubExpr<T>::value;
constexpr bool value2 = blaze::IsSubExpr_v<T>;
Compile time check whether the given type is a subtraction expression template.
Definition: IsSubExpr.h:84

◆ IsSubmatrix_v

template<typename T >
constexpr bool blaze::IsSubmatrix_v = IsSubmatrix<T>::value
constexpr

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 value1 = blaze::IsSubmatrix<T>::value;
constexpr bool value2 = blaze::IsSubmatrix_v<T>;
Compile time check for submatrices.
Definition: IsSubmatrix.h:91

◆ IsSubvector_v

template<typename T >
constexpr bool blaze::IsSubvector_v = IsSubvector<T>::value
constexpr

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 value1 = blaze::IsSubvector<T>::value;
constexpr bool value2 = blaze::IsSubvector_v<T>;
Compile time check for subvectors.
Definition: IsSubvector.h:91

◆ IsSVDExpr_v

template<typename T >
constexpr bool blaze::IsSVDExpr_v = IsSVDExpr<T>::value
constexpr

Auxiliary variable template for the IsSVDExpr type trait.

The IsSVDExpr_v variable template provides a convenient shortcut to access the nested value of the IsSVDExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSVDExpr<T>::value;
constexpr bool value2 = blaze::IsSVDExpr_v<T>;
Compile time check whether the given type is a singular value expression template.
Definition: IsSVDExpr.h:83

◆ IsSymmetric_v

template<typename T >
constexpr bool blaze::IsSymmetric_v = IsSymmetric<T>::value
constexpr

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 value1 = blaze::IsSymmetric<T>::value;
constexpr bool value2 = blaze::IsSymmetric_v<T>;
Compile time check for symmetric matrices.
Definition: IsSymmetric.h:115

◆ IsTemporary_v

template<typename T >
constexpr bool blaze::IsTemporary_v = IsTemporary<T>::value
constexpr

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 value1 = blaze::IsTemporary<T>::value;
constexpr bool value2 = blaze::IsTemporary_v<T>;
Compile time check whether the given type is a temporary vector or matrix type.
Definition: IsTemporary.h:70

◆ IsTransExpr_v

template<typename T >
constexpr bool blaze::IsTransExpr_v = IsTransExpr<T>::value
constexpr

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 value1 = blaze::IsTransExpr<T>::value;
constexpr bool value2 = blaze::IsTransExpr_v<T>;
Compile time check whether the given type is a transposition expression template.
Definition: IsTransExpr.h:84

◆ IsTransformation_v

template<typename T >
constexpr bool blaze::IsTransformation_v = IsTransformation<T>::value
constexpr

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 value1 = blaze::IsTransformation<T>::value;
constexpr bool value2 = blaze::IsTransformation_v<T>;
Compile time check whether the given type is a transformation expression template.
Definition: IsTransformation.h:71

◆ IsTriangular_v

template<typename T >
constexpr bool blaze::IsTriangular_v = IsTriangular<T>::value
constexpr

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 value1 = blaze::IsTriangular<T>::value;
constexpr bool value2 = blaze::IsTriangular_v<T>;
Compile time check for triangular matrix types.
Definition: IsTriangular.h:88

◆ IsTVecMatMultExpr_v

template<typename T >
constexpr bool blaze::IsTVecMatMultExpr_v = IsTVecMatMultExpr<T>::value
constexpr

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 value1 = blaze::IsTVecMatMultExpr<T>::value;
constexpr bool value2 = blaze::IsTVecMatMultExpr_v<T>;
Compile time check whether the given type is a vector/matrix multiplication expression template.
Definition: IsTVecMatMultExpr.h:86

◆ IsUnaryMapExpr_v

template<typename T >
constexpr bool blaze::IsUnaryMapExpr_v = IsUnaryMapExpr<T>::value
constexpr

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 value1 = blaze::IsUnaryMapExpr<T>::value;
constexpr bool value2 = blaze::IsUnaryMapExpr_v<T>;
Compile time check whether the given type is a unary map expression template.
Definition: IsUnaryMapExpr.h:83

◆ IsUniform_v

template<typename T >
constexpr bool blaze::IsUniform_v = IsUniform<T>::value
constexpr

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 value1 = blaze::IsUniform<T>::value;
constexpr bool value2 = blaze::IsUniform_v<T>;
Compile time check for uniform vectors and matrices.
Definition: IsUniform.h:107

◆ IsUniLower_v

template<typename T >
constexpr bool blaze::IsUniLower_v = IsUniLower<T>::value
constexpr

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 value1 = blaze::IsUniLower<T>::value;
constexpr bool value2 = blaze::IsUniLower_v<T>;
Compile time check for lower unitriangular matrices.
Definition: IsUniLower.h:116

◆ IsUniTriangular_v

template<typename T >
constexpr bool blaze::IsUniTriangular_v = IsUniTriangular<T>::value
constexpr

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 value1 = blaze::IsUniTriangular<T>::value;
constexpr bool value2 = blaze::IsUniTriangular_v<T>;
Compile time check for unitriangular matrix types.
Definition: IsUniTriangular.h:88

◆ IsUniUpper_v

template<typename T >
constexpr bool blaze::IsUniUpper_v = IsUniUpper<T>::value
constexpr

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 value1 = blaze::IsUniUpper<T>::value;
constexpr bool value2 = blaze::IsUniUpper_v<T>;
Compile time check for upper unitriangular matrices.
Definition: IsUniUpper.h:116

◆ IsUpper_v

template<typename T >
constexpr bool blaze::IsUpper_v = IsUpper<T>::value
constexpr

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 value1 = blaze::IsUpper<T>::value;
constexpr bool value2 = blaze::IsUpper_v<T>;
Compile time check for upper triangular matrices.
Definition: IsUpper.h:118

◆ IsVecEvalExpr_v

template<typename T >
constexpr bool blaze::IsVecEvalExpr_v = IsVecEvalExpr<T>::value
constexpr

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 value1 = blaze::IsVecEvalExpr<T>::value;
constexpr bool value2 = blaze::IsVecEvalExpr_v<T>;
Compile time check whether the given type is a vector evaluation expression template.
Definition: IsVecEvalExpr.h:84

◆ IsVecExpandExpr_v

template<typename T >
constexpr bool blaze::IsVecExpandExpr_v = IsVecExpandExpr<T>::value
constexpr

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 value1 = blaze::IsVecExpandExpr<T>::value;
constexpr bool value2 = blaze::IsVecExpandExpr_v<T>;
Compile time check whether the given type is a vector expansion expression template.
Definition: IsVecExpandExpr.h:84

◆ IsVecGenExpr_v

template<typename T >
constexpr bool blaze::IsVecGenExpr_v = IsVecGenExpr<T>::value
constexpr

Auxiliary variable template for the IsVecGenExpr type trait.

The IsVecGenExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecGenExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecGenExpr<T>::value;
constexpr bool value2 = blaze::IsVecGenExpr_v<T>;
Compile time check whether the given type is a vector generator expression template.
Definition: IsVecGenExpr.h:84

◆ IsVecMapExpr_v

template<typename T >
constexpr bool blaze::IsVecMapExpr_v = IsVecMapExpr<T>::value
constexpr

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 value1 = blaze::IsVecMapExpr<T>::value;
constexpr bool value2 = blaze::IsVecMapExpr_v<T>;
Compile time check whether the given type is a unary vector map expression template.
Definition: IsVecMapExpr.h:84

◆ IsVecNoAliasExpr_v

template<typename T >
constexpr bool blaze::IsVecNoAliasExpr_v = IsVecNoAliasExpr<T>::value
constexpr

Auxiliary variable template for the IsVecNoAliasExpr type trait.

The IsVecNoAliasExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecNoAliasExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecNoAliasExpr<T>::value;
constexpr bool value2 = blaze::IsVecNoAliasExpr_v<T>;
Compile time check whether the given type is a vector no-alias expression template.
Definition: IsVecNoAliasExpr.h:84

◆ IsVecNoSIMDExpr_v

template<typename T >
constexpr bool blaze::IsVecNoSIMDExpr_v = IsVecNoSIMDExpr<T>::value
constexpr

Auxiliary variable template for the IsVecNoSIMDExpr type trait.

The IsVecNoSIMDExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecNoSIMDExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecNoSIMDExpr<T>::value;
constexpr bool value2 = blaze::IsVecNoSIMDExpr_v<T>;
Compile time check whether the given type is a vector no-SIMD expression template.
Definition: IsVecNoSIMDExpr.h:84

◆ IsVecRepeatExpr_v

template<typename T >
constexpr bool blaze::IsVecRepeatExpr_v = IsVecRepeatExpr<T>::value
constexpr

Auxiliary variable template for the IsVecRepeatExpr type trait.

The IsVecRepeatExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecRepeatExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecRepeatExpr<T>::value;
constexpr bool value2 = blaze::IsVecRepeatExpr_v<T>;
Compile time check whether the given type is a vector repeater expression template.
Definition: IsVecRepeatExpr.h:84

◆ IsVecScalarDivExpr_v

template<typename T >
constexpr bool blaze::IsVecScalarDivExpr_v = IsVecScalarDivExpr<T>::value
constexpr

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 value1 = blaze::IsVecScalarDivExpr<T>::value;
constexpr bool value2 = blaze::IsVecScalarDivExpr_v<T>;
Compile time check whether the given type is a vector/scalar division expression template.
Definition: IsVecScalarDivExpr.h:85

◆ IsVecScalarMultExpr_v

template<typename T >
constexpr bool blaze::IsVecScalarMultExpr_v = IsVecScalarMultExpr<T>::value
constexpr

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 value1 = blaze::IsVecScalarMultExpr<T>::value;
constexpr bool value2 = blaze::IsVecScalarMultExpr_v<T>;
Compile time check whether the given type is a vector/scalar multiplication expression template.
Definition: IsVecScalarMultExpr.h:86

◆ IsVecSerialExpr_v

template<typename T >
constexpr bool blaze::IsVecSerialExpr_v = IsVecSerialExpr<T>::value
constexpr

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 value1 = blaze::IsVecSerialExpr<T>::value;
constexpr bool value2 = blaze::IsVecSerialExpr_v<T>;
Compile time check whether the given type is a vector serial evaluation expression template.
Definition: IsVecSerialExpr.h:84

◆ IsVector_v

template<typename T >
constexpr bool blaze::IsVector_v = IsVector<T>::value
constexpr

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 value1 = blaze::IsVector<T>::value;
constexpr bool value2 = blaze::IsVector_v<T>;
Compile time check for vector types.
Definition: IsVector.h:94

◆ IsVecTransExpr_v

template<typename T >
constexpr bool blaze::IsVecTransExpr_v = IsVecTransExpr<T>::value
constexpr

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 value1 = blaze::IsVecTransExpr<T>::value;
constexpr bool value2 = blaze::IsVecTransExpr_v<T>;
Compile time check whether the given type is a vector transposition expression template.
Definition: IsVecTransExpr.h:84

◆ IsVecTVecMapExpr_v

template<typename T >
constexpr bool blaze::IsVecTVecMapExpr_v = IsVecTVecMapExpr<T>::value
constexpr

Auxiliary variable template for the IsVecTVecMapExpr type trait.

The IsVecTVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTVecMapExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecTVecMapExpr<T>::value;
constexpr bool value2 = blaze::IsVecTVecMapExpr_v<T>;
Compile time check whether the given type is an outer map expression template.
Definition: IsVecTVecMapExpr.h:84

◆ IsVecTVecMultExpr_v

template<typename T >
constexpr bool blaze::IsVecTVecMultExpr_v = IsVecTVecMultExpr<T>::value
constexpr

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 value1 = blaze::IsVecTVecMultExpr<T>::value;
constexpr bool value2 = blaze::IsVecTVecMultExpr_v<T>;
Compile time check whether the given type is an outer product expression template.
Definition: IsVecTVecMultExpr.h:85

◆ IsVecVecAddExpr_v

template<typename T >
constexpr bool blaze::IsVecVecAddExpr_v = IsVecVecAddExpr<T>::value
constexpr

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 value1 = blaze::IsVecVecAddExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecAddExpr_v<T>;
Compile time check whether the given type is a vector/vector addition expression template.
Definition: IsVecVecAddExpr.h:84

◆ IsVecVecDivExpr_v

template<typename T >
constexpr bool blaze::IsVecVecDivExpr_v = IsVecVecDivExpr<T>::value
constexpr

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 value1 = blaze::IsVecVecDivExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecDivExpr_v<T>;
Compile time check whether the given type is a vector/vector division expression template.
Definition: IsVecVecDivExpr.h:85

◆ IsVecVecKronExpr_v

template<typename T >
constexpr bool blaze::IsVecVecKronExpr_v = IsVecVecKronExpr<T>::value
constexpr

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 value1 = blaze::IsVecVecKronExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecKronExpr_v<T>;
Compile time check whether the given type is a vector/vector Kronecker product expression template.
Definition: IsVecVecKronExpr.h:85

◆ IsVecVecMapExpr_v

template<typename T >
constexpr bool blaze::IsVecVecMapExpr_v = IsVecVecMapExpr<T>::value
constexpr

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 value1 = blaze::IsVecVecMapExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecMapExpr_v<T>;
Compile time check whether the given type is a binary vector map expression template.
Definition: IsVecVecMapExpr.h:84

◆ IsVecVecMultExpr_v

template<typename T >
constexpr bool blaze::IsVecVecMultExpr_v = IsVecVecMultExpr<T>::value
constexpr

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 value1 = blaze::IsVecVecMultExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecMultExpr_v<T>;
Compile time check whether the given type is a vector/vector multiplication expression template.
Definition: IsVecVecMultExpr.h:85

◆ IsVecVecSubExpr_v

template<typename T >
constexpr bool blaze::IsVecVecSubExpr_v = IsVecVecSubExpr<T>::value
constexpr

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 value1 = blaze::IsVecVecSubExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecSubExpr_v<T>;
Compile time check whether the given type is a vector/vector subtraction expression template.
Definition: IsVecVecSubExpr.h:85

◆ IsView_v

template<typename T >
constexpr bool blaze::IsView_v = IsView<T>::value
constexpr

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 value1 = blaze::IsView<T>::value;
constexpr bool value2 = blaze::IsView_v<T>;
Compile time check for views.
Definition: IsView.h:103

◆ IsZero_v

template<typename T >
constexpr bool blaze::IsZero_v = IsZero<T>::value
constexpr

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:

constexpr bool value1 = blaze::IsZero<T>::value;
constexpr bool value2 = blaze::IsZero_v<T>;
Compile time check for zero vectors or matrices.
Definition: IsZero.h:109

◆ MaxSize_v

template<typename T , size_t N>
constexpr ptrdiff_t blaze::MaxSize_v = MaxSize<T,N>::value
constexpr

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 size_t value1 = blaze::MaxSize<T,N>::value;
constexpr size_t value2 = blaze::MaxSize_v<T,N>;
Compile time evaluation of the maximum size of vectors and matrices.
Definition: MaxSize.h:118

◆ RequiresEvaluation_v

template<typename T >
constexpr bool blaze::RequiresEvaluation_v = RequiresEvaluation<T>::value
constexpr

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:

constexpr bool value1 = blaze::RequiresEvaluation<T>::value;
constexpr bool value2 = blaze::RequiresEvaluation_v<T>;
Compile time check to query the requirement to evaluate an expression.
Definition: RequiresEvaluation.h:73

◆ Size_v

template<typename T , size_t N>
constexpr ptrdiff_t blaze::Size_v = Size<T,N>::value
constexpr

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 size_t value1 = blaze::Size<T,N>::value;
constexpr size_t value2 = blaze::Size_v<T,N>;
Compile time evaluation of the size of vectors and matrices.
Definition: Size.h:119

◆ StorageOrder_v

template<typename T >
constexpr bool blaze::StorageOrder_v = T::storageOrder
constexpr

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 value1 = blaze::StorageOrder<T>::value;
constexpr bool value2 = blaze::StorageOrder_v<T>;
Evaluation of the storage order of a given matrix type.
Definition: StorageOrder.h:75

◆ TransposeFlag_v

template<typename T >
constexpr bool blaze::TransposeFlag_v = T::transposeFlag
constexpr

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 value1 = blaze::TransposeFlag<T>::value;
constexpr bool value2 = blaze::TransposeFlag_v<T>;
Evaluation of the transpose flag of a given matrix type.
Definition: TransposeFlag.h:75

◆ YieldsDiagonal_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsDiagonal_v = YieldsDiagonal<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsDiagonal<OP,MT>::value;
constexpr bool value2 = blaze::YieldsDiagonal_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsDiagonal.h:69

◆ YieldsHermitian_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsHermitian_v = YieldsHermitian<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsHermitian<OP,MT>::value;
constexpr bool value2 = blaze::YieldsHermitian_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsHermitian.h:67

◆ YieldsIdentity_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsIdentity_v = YieldsIdentity<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsIdentity<OP,MT>::value;
constexpr bool value2 = blaze::YieldsIdentity_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsIdentity.h:69

◆ YieldsLower_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsLower_v = YieldsLower<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsLower<OP,MT>::value;
constexpr bool value2 = blaze::YieldsLower_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsLower.h:69

◆ YieldsStrictlyLower_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsStrictlyLower_v = YieldsStrictlyLower<OP,MT,MTs...>::value
constexpr

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 value2 = blaze::YieldsStrictlyLower_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsStrictlyLower.h:67

◆ YieldsStrictlyTriangular_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsStrictlyTriangular_v = YieldsStrictlyTriangular<OP,MT,MTs...>::value
constexpr

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 value2 = blaze::YieldsStrictlyTriangular_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsStrictlyTriangular.h:70

◆ YieldsStrictlyUpper_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsStrictlyUpper_v = YieldsStrictlyUpper<OP,MT,MTs...>::value
constexpr

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 value2 = blaze::YieldsStrictlyUpper_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsStrictlyUpper.h:67

◆ YieldsSymmetric_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsSymmetric_v = YieldsSymmetric<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsSymmetric<OP,MT>::value;
constexpr bool value2 = blaze::YieldsSymmetric_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsSymmetric.h:67

◆ YieldsTriangular_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsTriangular_v = YieldsTriangular<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsTriangular<OP,MT>::value;
constexpr bool value2 = blaze::YieldsTriangular_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsTriangular.h:70

◆ YieldsUniform_v

template<typename OP , typename T , typename... Ts>
constexpr bool blaze::YieldsUniform_v = YieldsUniform<OP,T,Ts...>::value
constexpr

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 value1 = blaze::YieldsUniform<OP,T>::value;
constexpr bool value2 = blaze::YieldsUniform_v<OP,T>;
Compile time check for operations on vectors and matrices.
Definition: YieldsUniform.h:68

◆ YieldsUniLower_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUniLower_v = YieldsUniLower<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsUniLower<OP,MT>::value;
constexpr bool value2 = blaze::YieldsUniLower_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsUniLower.h:67

◆ YieldsUniTriangular_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUniTriangular_v = YieldsUniTriangular<OP,MT,MTs...>::value
constexpr

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 value2 = blaze::YieldsUniTriangular_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsUniTriangular.h:70

◆ YieldsUniUpper_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUniUpper_v = YieldsUniUpper<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsUniUpper<OP,MT>::value;
constexpr bool value2 = blaze::YieldsUniUpper_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsUniUpper.h:67

◆ YieldsUpper_v

template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUpper_v = YieldsUpper<OP,MT,MTs...>::value
constexpr

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 value1 = blaze::YieldsUpper<OP,MT>::value;
constexpr bool value2 = blaze::YieldsUpper_v<OP,MT>;
Compile time check for operations on matrices.
Definition: YieldsUpper.h:69

◆ YieldsZero_v

template<typename OP , typename T , typename... Ts>
constexpr bool blaze::YieldsZero_v = YieldsZero<OP,T,Ts...>::value
constexpr

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:

constexpr bool value1 = blaze::YieldsZero<OP,T>::value;
constexpr bool value2 = blaze::YieldsZero_v<OP,T>;
Compile time check for operations on vectors and matrices.
Definition: YieldsZero.h:68