Blaze 3.9
Loading...
Searching...
No Matches
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.
#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.
#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.
#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.

Typedefs

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

Functions

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

Variables

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

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 \
: public blaze::BoolConstant< TYPE_TRAIT_NAME##HELPER<Type1232>::value > \
{}; \
\
template< typename Type1232 > \
static constexpr bool TYPE_TRAIT_NAME##_v = TYPE_TRAIT_NAME<Type1232>::value
IntegralConstant< bool, B > BoolConstant
Generic wrapper for a compile time constant boolean value.
Definition IntegralConstant.h:110

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 \
: blaze::If_t< blaze::IsBuiltin_v<TYPE1231>, blaze::EmptyType, TYPE1231 > \
, 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
BoolConstant< false > FalseType
Type/value traits base class.
Definition IntegralConstant.h:121
BoolConstant< true > TrueType
Type traits base class.
Definition IntegralConstant.h:132
typename If< Condition >::template Type< T1, T2 > If_t
Auxiliary alias template for the If class template.
Definition If.h:108

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 = 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 = 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 = 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:

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

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>'
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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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>
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>;
constexpr bool HasAbs_v
Auxiliary variable template for the HasAbs type trait.
Definition HasAbs.h:153
Availability of the abs() operation for the given data types.
Definition HasAbs.h:109

◆ HasAcos_v

template<typename T>
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>;
constexpr bool HasAcos_v
Auxiliary variable template for the HasAcos type trait.
Definition HasAcos.h:153
Availability of the acos() operation for the given data types.
Definition HasAcos.h:109

◆ HasAcosh_v

template<typename T>
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>;
constexpr bool HasAcosh_v
Auxiliary variable template for the HasAcosh type trait.
Definition HasAcosh.h:153
Availability of the acosh() operation for the given data types.
Definition HasAcosh.h:109

◆ HasAdd_v

template<typename T1, typename T2>
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>;
constexpr bool HasAdd_v
Auxiliary variable template for the HasAdd type trait.
Definition HasAdd.h:151
Availability of an addition operator for the given data types.
Definition HasAdd.h:107

◆ HasAsin_v

template<typename T>
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>;
constexpr bool HasAsin_v
Auxiliary variable template for the HasAsin type trait.
Definition HasAsin.h:153
Availability of the asin() operation for the given data types.
Definition HasAsin.h:109

◆ HasAsinh_v

template<typename T>
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>;
constexpr bool HasAsinh_v
Auxiliary variable template for the HasAsinh type trait.
Definition HasAsinh.h:153
Availability of the asinh() operation for the given data types.
Definition HasAsinh.h:109

◆ HasAtan2_v

template<typename T1, typename T2>
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>;
constexpr bool HasAtan2_v
Auxiliary variable template for the HasAtan2 type trait.
Definition HasAtan2.h:151
Availability of the atan2() operation for the given data types.
Definition HasAtan2.h:107

◆ HasAtan_v

template<typename T>
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>;
constexpr bool HasAtan_v
Auxiliary variable template for the HasAtan type trait.
Definition HasAtan.h:153
Availability of the atan() operation for the given data types.
Definition HasAtan.h:109

◆ HasAtanh_v

template<typename T>
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>;
constexpr bool HasAtanh_v
Auxiliary variable template for the HasAtanh type trait.
Definition HasAtanh.h:153
Availability of the atanh() operation for the given data types.
Definition HasAtanh.h:109

◆ HasCbrt_v

template<typename T>
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>;
constexpr bool HasCbrt_v
Auxiliary variable template for the HasCbrt type trait.
Definition HasCbrt.h:153
Availability of the cbrt() operation for the given data types.
Definition HasCbrt.h:109

◆ HasCeil_v

template<typename T>
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>;
constexpr bool HasCeil_v
Auxiliary variable template for the HasCeil type trait.
Definition HasCeil.h:153
Availability of the ceil() operation for the given data types.
Definition HasCeil.h:109

◆ HasClamp_v

template<typename T>
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>;
constexpr bool HasClamp_v
Auxiliary variable template for the HasClamp type trait.
Definition HasClamp.h:153
Availability of the clamp() operation for the given data types.
Definition HasClamp.h:109

◆ HasCompositeType_v

template<typename T>
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>;
constexpr bool HasCompositeType_v
Auxiliary variable template for the HasCompositeType type trait.
Definition HasCompositeType.h:92

◆ HasConj_v

template<typename T>
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>;
constexpr bool HasConj_v
Auxiliary variable template for the HasConj type trait.
Definition HasConj.h:153
Availability of the conj() operation for the given data types.
Definition HasConj.h:109

◆ HasConstDataAccess_v

template<typename T>
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>;
constexpr bool HasConstDataAccess_v
Auxiliary variable template for the HasConstDataAccess type trait.
Definition HasConstDataAccess.h:133
Compile time check for low-level access to constant data.
Definition HasConstDataAccess.h:76

◆ HasCos_v

template<typename T>
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>;
constexpr bool HasCos_v
Auxiliary variable template for the HasCos type trait.
Definition HasCos.h:153
Availability of the cos() operation for the given data types.
Definition HasCos.h:109

◆ HasCosh_v

template<typename T>
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>;
constexpr bool HasCosh_v
Auxiliary variable template for the HasCosh type trait.
Definition HasCosh.h:153
Availability of the cosh() operation for the given data types.
Definition HasCosh.h:109

◆ HasDiv_v

template<typename T1, typename T2>
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>;
constexpr bool HasDiv_v
Auxiliary variable template for the HasDiv type trait.
Definition HasDiv.h:138
Availability of a division operator for the given data types.
Definition HasDiv.h:107

◆ HasErf_v

template<typename T>
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>;
constexpr bool HasErf_v
Auxiliary variable template for the HasErf type trait.
Definition HasErf.h:153
Availability of the erf() operation for the given data types.
Definition HasErf.h:109

◆ HasErfc_v

template<typename T>
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>;
constexpr bool HasErfc_v
Auxiliary variable template for the HasErfc type trait.
Definition HasErfc.h:153
Availability of the erfc() operation for the given data types.
Definition HasErfc.h:109

◆ HasExp10_v

template<typename T>
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>;
constexpr bool HasExp10_v
Auxiliary variable template for the HasExp10 type trait.
Definition HasExp10.h:153
Availability of the exp10() operation for the given data types.
Definition HasExp10.h:109

◆ HasExp2_v

template<typename T>
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>;
constexpr bool HasExp2_v
Auxiliary variable template for the HasExp2 type trait.
Definition HasExp2.h:153
Availability of the exp2() operation for the given data types.
Definition HasExp2.h:109

◆ HasExp_v

template<typename T>
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>;
constexpr bool HasExp_v
Auxiliary variable template for the HasExp type trait.
Definition HasExp.h:153
Availability of the exp() operation for the given data types.
Definition HasExp.h:109

◆ HasFloor_v

template<typename T>
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>;
constexpr bool HasFloor_v
Auxiliary variable template for the HasFloor type trait.
Definition HasFloor.h:153
Availability of the floor() operation for the given data types.
Definition HasFloor.h:109

◆ HasHypot_v

template<typename T1, typename T2>
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>;
constexpr bool HasHypot_v
Auxiliary variable template for the HasHypot type trait.
Definition HasHypot.h:151
Availability of the hypot() operation for the given data types.
Definition HasHypot.h:107

◆ HasImag_v

template<typename T>
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>;
constexpr bool HasImag_v
Auxiliary variable template for the HasImag type trait.
Definition HasImag.h:153
Availability of the imag() operation for the given data types.
Definition HasImag.h:109

◆ HasInvCbrt_v

template<typename T>
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>;
constexpr bool HasInvCbrt_v
Auxiliary variable template for the HasInvCbrt type trait.
Definition HasInvCbrt.h:154
Availability of the invcbrt() operation for the given data types.
Definition HasInvCbrt.h:110

◆ HasInvSqrt_v

template<typename T>
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>;
constexpr bool HasInvSqrt_v
Auxiliary variable template for the HasInvSqrt type trait.
Definition HasInvSqrt.h:154
Availability of the invsqrt() operation for the given data types.
Definition HasInvSqrt.h:110

◆ HasLGamma_v

template<typename T>
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>;
constexpr bool HasLGamma_v
Auxiliary variable template for the HasLGamma type trait.
Definition HasLGamma.h:153
Availability of the lgamma() operation for the given data types.
Definition HasLGamma.h:109

◆ HasLog10_v

template<typename T>
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>;
constexpr bool HasLog10_v
Auxiliary variable template for the HasLog10 type trait.
Definition HasLog10.h:153
Availability of the log10() operation for the given data types.
Definition HasLog10.h:109

◆ HasLog1p_v

template<typename T>
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>;
constexpr bool HasLog1p_v
Auxiliary variable template for the HasLog1p type trait.
Definition HasLog1p.h:153
Availability of the log1p() operation for the given data types.
Definition HasLog1p.h:109

◆ HasLog2_v

template<typename T>
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>;
constexpr bool HasLog2_v
Auxiliary variable template for the HasLog2 type trait.
Definition HasLog2.h:153
Availability of the log2() operation for the given data types.
Definition HasLog2.h:109

◆ HasLog_v

template<typename T>
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>;
constexpr bool HasLog_v
Auxiliary variable template for the HasLog type trait.
Definition HasLog.h:153
Availability of the log() operation for the given data types.
Definition HasLog.h:109

◆ HasMax_v

template<typename T1, typename T2>
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>;
constexpr bool HasMax_v
Auxiliary variable template for the HasMax type trait.
Definition HasMax.h:152
Availability of a max() operation for the given data types.
Definition HasMax.h:108

◆ HasMin_v

template<typename T1, typename T2>
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>;
constexpr bool HasMin_v
Auxiliary variable template for the HasMin type trait.
Definition HasMin.h:152
Availability of a min() operation for the given data types.
Definition HasMin.h:108

◆ HasMult_v

template<typename T1, typename T2>
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>;
constexpr bool HasMult_v
Auxiliary variable template for the HasMult type trait.
Definition HasMult.h:178
Availability of a multiplication operator for the given data types.
Definition HasMult.h:108

◆ HasMutableDataAccess_v

template<typename T>
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>;
constexpr bool HasMutableDataAccess_v
Auxiliary variable template for the HasMutableDataAccess type trait.
Definition HasMutableDataAccess.h:133
Compile time check for low-level access to mutable data.
Definition HasMutableDataAccess.h:76

◆ HasPow_v

template<typename T1, typename T2>
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>;
constexpr bool HasPow_v
Auxiliary variable template for the HasPow type trait.
Definition HasPow.h:151
Availability of the pow() operation for the given data types.
Definition HasPow.h:107

◆ HasReal_v

template<typename T>
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>;
constexpr bool HasReal_v
Auxiliary variable template for the HasReal type trait.
Definition HasReal.h:153
Availability of the real() operation for the given data types.
Definition HasReal.h:109

◆ HasResultType_v

template<typename T>
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>;
constexpr bool HasResultType_v
Auxiliary variable template for the HasResultType type trait.
Definition HasResultType.h:92

◆ HasRound_v

template<typename T>
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>;
constexpr bool HasRound_v
Auxiliary variable template for the HasRound type trait.
Definition HasRound.h:153
Availability of the round() operation for the given data types.
Definition HasRound.h:109

◆ HasSign_v

template<typename T>
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>;
constexpr bool HasSign_v
Auxiliary variable template for the HasSign type trait.
Definition HasSign.h:153
Availability of the sign() operation for the given data types.
Definition HasSign.h:109

◆ HasSIMDAbs_v

template<typename T>
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>;
constexpr bool HasSIMDAbs_v
Auxiliary variable template for the HasSIMDAbs type trait.
Definition HasSIMDAbs.h:132
Availability of a SIMD absolute value operation for the given data type.
Definition HasSIMDAbs.h:114

◆ HasSIMDAcos_v

template<typename T>
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>;
constexpr bool HasSIMDAcos_v
Auxiliary variable template for the HasSIMDAcos type trait.
Definition HasSIMDAcos.h:119
Availability of a SIMD inverse cosine operation for the given data type.
Definition HasSIMDAcos.h:101

◆ HasSIMDAcosh_v

template<typename T>
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>;
constexpr bool HasSIMDAcosh_v
Auxiliary variable template for the HasSIMDAcosh type trait.
Definition HasSIMDAcosh.h:119
Availability of a SIMD inverse hyperbolic cosine operation for the given data type.
Definition HasSIMDAcosh.h:101

◆ HasSIMDAdd_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDAdd_v
Auxiliary variable template for the HasSIMDAdd type trait.
Definition HasSIMDAdd.h:187
Availability of a SIMD addition for the given data types.
Definition HasSIMDAdd.h:168

◆ HasSIMDAsin_v

template<typename T>
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>;
constexpr bool HasSIMDAsin_v
Auxiliary variable template for the HasSIMDAsin type trait.
Definition HasSIMDAsin.h:119
Availability of a SIMD inverse sine operation for the given data type.
Definition HasSIMDAsin.h:101

◆ HasSIMDAsinh_v

template<typename T>
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>;
constexpr bool HasSIMDAsinh_v
Auxiliary variable template for the HasSIMDAsinh type trait.
Definition HasSIMDAsinh.h:119
Availability of a SIMD inverse hyperbolic sine operation for the given data type.
Definition HasSIMDAsinh.h:101

◆ HasSIMDAtan2_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDAtan2_v
Auxiliary variable template for the HasSIMDAtan2 type trait.
Definition HasSIMDAtan2.h:125
Availability of a SIMD inverse tangent operation for the given data types.
Definition HasSIMDAtan2.h:106

◆ HasSIMDAtan_v

template<typename T>
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>;
constexpr bool HasSIMDAtan_v
Auxiliary variable template for the HasSIMDAtan type trait.
Definition HasSIMDAtan.h:119
Availability of a SIMD inverse tangent operation for the given data type.
Definition HasSIMDAtan.h:101

◆ HasSIMDAtanh_v

template<typename T>
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>;
constexpr bool HasSIMDAtanh_v
Auxiliary variable template for the HasSIMDAtanh type trait.
Definition HasSIMDAtanh.h:119
Availability of a SIMD inverse hyperbolic tangent operation for the given data type.
Definition HasSIMDAtanh.h:101

◆ HasSIMDBitand_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDBitand_v
Auxiliary variable template for the HasSIMDBitand type trait.
Definition HasSIMDBitand.h:121
Availability of a SIMD bitwise AND ('&') for the given data types.
Definition HasSIMDBitand.h:102

◆ HasSIMDBitor_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDBitor_v
Auxiliary variable template for the HasSIMDBitor type trait.
Definition HasSIMDBitor.h:121
Availability of a SIMD bitwise OR ('|') for the given data types.
Definition HasSIMDBitor.h:102

◆ HasSIMDBitxor_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDBitxor_v
Auxiliary variable template for the HasSIMDBitxor type trait.
Definition HasSIMDBitxor.h:121
Availability of a SIMD bitwise XOR ('^') for the given data types.
Definition HasSIMDBitxor.h:102

◆ HasSIMDCbrt_v

template<typename T>
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>;
constexpr bool HasSIMDCbrt_v
Auxiliary variable template for the HasSIMDCbrt type trait.
Definition HasSIMDCbrt.h:119
Availability of a SIMD cubic root operation for the given data type.
Definition HasSIMDCbrt.h:101

◆ HasSIMDCeil_v

template<typename T>
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>;
constexpr bool HasSIMDCeil_v
Auxiliary variable template for the HasSIMDCeil type trait.
Definition HasSIMDCeil.h:115
Availability of a SIMD ceil operation for the given data type.
Definition HasSIMDCeil.h:97

◆ HasSIMDConj_v

template<typename T>
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>;
constexpr bool HasSIMDConj_v
Auxiliary variable template for the HasSIMDConj type trait.
Definition HasSIMDConj.h:130
Availability of a SIMD conjugate operation for the given data type.
Definition HasSIMDConj.h:112

◆ HasSIMDCos_v

template<typename T>
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>;
constexpr bool HasSIMDCos_v
Auxiliary variable template for the HasSIMDCos type trait.
Definition HasSIMDCos.h:119
Availability of a SIMD cosine operation for the given data type.
Definition HasSIMDCos.h:101

◆ HasSIMDCosh_v

template<typename T>
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>;
constexpr bool HasSIMDCosh_v
Auxiliary variable template for the HasSIMDCosh type trait.
Definition HasSIMDCosh.h:119
Availability of a SIMD hyperbolic cosine operation for the given data type.
Definition HasSIMDCosh.h:101

◆ HasSIMDDiv_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDDiv_v
Auxiliary variable template for the HasSIMDDiv type trait.
Definition HasSIMDDiv.h:173
Availability of a SIMD division for the given data types.
Definition HasSIMDDiv.h:154

◆ HasSIMDEqual_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDEqual_v
Auxiliary variable template for the HasSIMDEqual type trait.
Definition HasSIMDEqual.h:185
Availability of a SIMD equality comparison for the given data types.
Definition HasSIMDEqual.h:166

◆ HasSIMDErf_v

template<typename T>
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>;
constexpr bool HasSIMDErf_v
Auxiliary variable template for the HasSIMDErf type trait.
Definition HasSIMDErf.h:119
Availability of a SIMD error function (erf) operation for the given data type.
Definition HasSIMDErf.h:101

◆ HasSIMDErfc_v

template<typename T>
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>;
constexpr bool HasSIMDErfc_v
Auxiliary variable template for the HasSIMDErfc type trait.
Definition HasSIMDErfc.h:120
Availability of a SIMD complementary error function (erfc) operation for the given data type.
Definition HasSIMDErfc.h:102

◆ HasSIMDExp10_v

template<typename T>
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>;
constexpr bool HasSIMDExp10_v
Auxiliary variable template for the HasSIMDExp10 type trait.
Definition HasSIMDExp10.h:119
Availability of a SIMD exp10() operation for the given data type.
Definition HasSIMDExp10.h:101

◆ HasSIMDExp2_v

template<typename T>
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>;
constexpr bool HasSIMDExp2_v
Auxiliary variable template for the HasSIMDExp2 type trait.
Definition HasSIMDExp2.h:119
Availability of a SIMD exp2() operation for the given data type.
Definition HasSIMDExp2.h:101

◆ HasSIMDExp_v

template<typename T>
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>;
constexpr bool HasSIMDExp_v
Auxiliary variable template for the HasSIMDExp type trait.
Definition HasSIMDExp.h:119
Availability of a SIMD exp() operation for the given data type.
Definition HasSIMDExp.h:101

◆ HasSIMDFloor_v

template<typename T>
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>;
constexpr bool HasSIMDFloor_v
Auxiliary variable template for the HasSIMDFloor type trait.
Definition HasSIMDFloor.h:116
Availability of a SIMD floor operation for the given data type.
Definition HasSIMDFloor.h:98

◆ HasSIMDHypot_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDHypot_v
Auxiliary variable template for the HasSIMDHypot type trait.
Definition HasSIMDHypot.h:124
Availability of a SIMD hypotenous operation for the given data types.
Definition HasSIMDHypot.h:105

◆ HasSIMDInvCbrt_v

template<typename T>
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>;
constexpr bool HasSIMDInvCbrt_v
Auxiliary variable template for the HasSIMDInvCbrt type trait.
Definition HasSIMDInvCbrt.h:116
Availability of a SIMD inverse cubic root operation for the given data type.
Definition HasSIMDInvCbrt.h:98

◆ HasSIMDInvSqrt_v

template<typename T>
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>;
constexpr bool HasSIMDInvSqrt_v
Auxiliary variable template for the HasSIMDInvSqrt type trait.
Definition HasSIMDInvSqrt.h:117
Availability of a SIMD inverse square root operation for the given data type.
Definition HasSIMDInvSqrt.h:99

◆ HasSIMDLGamma_v

template<typename T>
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>;
constexpr bool HasSIMDLGamma_v
Auxiliary variable template for the HasSIMDLGamma type trait.
Definition HasSIMDLGamma.h:118
Availability of a SIMD lgamma operation for the given data type.
Definition HasSIMDLGamma.h:100

◆ HasSIMDLog10_v

template<typename T>
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>;
constexpr bool HasSIMDLog10_v
Auxiliary variable template for the HasSIMDLog10 type trait.
Definition HasSIMDLog10.h:119
Availability of a SIMD common logarithm operation for the given data type.
Definition HasSIMDLog10.h:101

◆ HasSIMDLog1p_v

template<typename T>
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>;
constexpr bool HasSIMDLog1p_v
Auxiliary variable template for the HasSIMDLog1p type trait.
Definition HasSIMDLog1p.h:118
Availability of a SIMD log1p operation for the given data type.
Definition HasSIMDLog1p.h:100

◆ HasSIMDLog2_v

template<typename T>
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>;
constexpr bool HasSIMDLog2_v
Auxiliary variable template for the HasSIMDLog2 type trait.
Definition HasSIMDLog2.h:119
Availability of a SIMD binary logarithm operation for the given data type.
Definition HasSIMDLog2.h:101

◆ HasSIMDLog_v

template<typename T>
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>;
constexpr bool HasSIMDLog_v
Auxiliary variable template for the HasSIMDLog type trait.
Definition HasSIMDLog.h:119
Availability of a SIMD natural logarithm operation for the given data type.
Definition HasSIMDLog.h:101

◆ HasSIMDMax_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDMax_v
Auxiliary variable template for the HasSIMDMax type trait.
Definition HasSIMDMax.h:188
Availability of a SIMD max operation for the given data types.
Definition HasSIMDMax.h:169

◆ HasSIMDMin_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDMin_v
Auxiliary variable template for the HasSIMDMin type trait.
Definition HasSIMDMin.h:188
Availability of a SIMD min operation for the given data types.
Definition HasSIMDMin.h:169

◆ HasSIMDMult_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDMult_v
Auxiliary variable template for the HasSIMDMult type trait.
Definition HasSIMDMult.h:188
Availability of a SIMD multiplication for the given data types.
Definition HasSIMDMult.h:169

◆ HasSIMDPow_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDPow_v
Auxiliary variable template for the HasSIMDPow type trait.
Definition HasSIMDPow.h:124
Availability of a SIMD power operation for the given data type.
Definition HasSIMDPow.h:105

◆ HasSIMDRound_v

template<typename T>
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>;
constexpr bool HasSIMDRound_v
Auxiliary variable template for the HasSIMDRound type trait.
Definition HasSIMDRound.h:120
Availability of a SIMD round operation for the given data type.
Definition HasSIMDRound.h:102

◆ HasSIMDShiftLI_v

template<typename T>
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>;
constexpr bool HasSIMDShiftLI_v
Auxiliary variable template for the HasSIMDShiftLI type trait.
Definition HasSIMDShiftLI.h:119
Availability of a SIMD uniform left-shift for the given data types.
Definition HasSIMDShiftLI.h:101

◆ HasSIMDShiftLV_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDShiftLV_v
Auxiliary variable template for the HasSIMDShiftLV type trait.
Definition HasSIMDShiftLV.h:121
Availability of an SIMD elementwise left-shift for the given data types.
Definition HasSIMDShiftLV.h:102

◆ HasSIMDShiftRI_v

template<typename T>
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>;
constexpr bool HasSIMDShiftRI_v
Auxiliary variable template for the HasSIMDShiftRI type trait.
Definition HasSIMDShiftRI.h:121
Availability of a SIMD uniform right-shift for the given data types.
Definition HasSIMDShiftRI.h:103

◆ HasSIMDShiftRV_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDShiftRV_v
Auxiliary variable template for the HasSIMDShiftRV type trait.
Definition HasSIMDShiftRV.h:123
Availability of a SIMD elementwise right-shift for the given data types.
Definition HasSIMDShiftRV.h:104

◆ HasSIMDSign_v

template<typename T>
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>;
constexpr bool HasSIMDSign_v
Auxiliary variable template for the HasSIMDSign type trait.
Definition HasSIMDSign.h:126
Availability of a SIMD sign operation for the given data type.
Definition HasSIMDSign.h:108

◆ HasSIMDSin_v

template<typename T>
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>;
constexpr bool HasSIMDSin_v
Auxiliary variable template for the HasSIMDSin type trait.
Definition HasSIMDSin.h:119
Availability of a SIMD sine operation for the given data type.
Definition HasSIMDSin.h:101

◆ HasSIMDSinh_v

template<typename T>
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>;
constexpr bool HasSIMDSinh_v
Auxiliary variable template for the HasSIMDSinh type trait.
Definition HasSIMDSinh.h:119
Availability of a SIMD hyperbolic sine operation for the given data type.
Definition HasSIMDSinh.h:101

◆ HasSIMDSqrt_v

template<typename T>
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>;
constexpr bool HasSIMDSqrt_v
Auxiliary variable template for the HasSIMDSqrt type trait.
Definition HasSIMDSqrt.h:119
Availability of a SIMD square root operation for the given data type.
Definition HasSIMDSqrt.h:101

◆ HasSIMDSub_v

template<typename T1, typename T2>
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>;
constexpr bool HasSIMDSub_v
Auxiliary variable template for the HasSIMDSub type trait.
Definition HasSIMDSub.h:187
Availability of a SIMD subtraction for the given data types.
Definition HasSIMDSub.h:168

◆ HasSIMDTan_v

template<typename T>
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>;
constexpr bool HasSIMDTan_v
Auxiliary variable template for the HasSIMDTan type trait.
Definition HasSIMDTan.h:119
Availability of a SIMD tangent operation for the given data type.
Definition HasSIMDTan.h:101

◆ HasSIMDTanh_v

template<typename T>
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>;
constexpr bool HasSIMDTanh_v
Auxiliary variable template for the HasSIMDTanh type trait.
Definition HasSIMDTanh.h:119
Availability of a SIMD hyperbolic tangent operation for the given data type.
Definition HasSIMDTanh.h:101

◆ HasSIMDTrunc_v

template<typename T>
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>;
constexpr bool HasSIMDTrunc_v
Auxiliary variable template for the HasSIMDTrunc type trait.
Definition HasSIMDTrunc.h:119
Availability of a SIMD trunc operation for the given data type.
Definition HasSIMDTrunc.h:101

◆ HasSin_v

template<typename T>
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>;
constexpr bool HasSin_v
Auxiliary variable template for the HasSin type trait.
Definition HasSin.h:153
Availability of the sin() operation for the given data types.
Definition HasSin.h:109

◆ HasSinh_v

template<typename T>
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>;
constexpr bool HasSinh_v
Auxiliary variable template for the HasSinh type trait.
Definition HasSinh.h:153
Availability of the sinh() operation for the given data types.
Definition HasSinh.h:109

◆ HasSqrt_v

template<typename T>
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>;
constexpr bool HasSqrt_v
Auxiliary variable template for the HasSqrt type trait.
Definition HasSqrt.h:153
Availability of the sqrt() operation for the given data types.
Definition HasSqrt.h:109

◆ HasSub_v

template<typename T1, typename T2>
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>;
constexpr bool HasSub_v
Auxiliary variable template for the HasSub type trait.
Definition HasSub.h:151
Availability of a subtraction operator for the given data types.
Definition HasSub.h:107

◆ HasTan_v

template<typename T>
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>;
constexpr bool HasTan_v
Auxiliary variable template for the HasTan type trait.
Definition HasTan.h:153
Availability of the tan() operation for the given data types.
Definition HasTan.h:109

◆ HasTanh_v

template<typename T>
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>;
constexpr bool HasTanh_v
Auxiliary variable template for the HasTanh type trait.
Definition HasTanh.h:153
Availability of the tanh() operation for the given data types.
Definition HasTanh.h:109

◆ HasTrunc_v

template<typename T>
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>;
constexpr bool HasTrunc_v
Auxiliary variable template for the HasTrunc type trait.
Definition HasTrunc.h:153
Availability of the trunc() operation for the given data types.
Definition HasTrunc.h:109

◆ IsAdaptor_v

template<typename T>
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>;
constexpr bool IsAdaptor_v
Auxiliary variable template for the IsAdaptor type trait.
Definition IsAdaptor.h:146
Compile time check for adaptors.
Definition IsAdaptor.h:89

◆ IsAddExpr_v

template<typename T>
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>;
constexpr bool IsAddExpr_v
Auxiliary variable template for the IsAddExpr type trait.
Definition IsAddExpr.h:115
Compile time check whether the given type is an addition expression template.
Definition IsAddExpr.h:84

◆ IsAligned_v

template<typename T>
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>;
constexpr bool IsAligned_v
Auxiliary variable template for the IsAligned type trait.
Definition IsAligned.h:145
Compile time check for the alignment of data types.
Definition IsAligned.h:88

◆ IsBand_v

template<typename T>
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>;
constexpr bool IsBand_v
Auxiliary variable template for the IsBand type trait.
Definition IsBand.h:162
Compile time check for bands.
Definition IsBand.h:92

◆ IsBinaryMapExpr_v

template<typename T>
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>;
constexpr bool IsBinaryMapExpr_v
Auxiliary variable template for the IsBinaryMapExpr type trait.
Definition IsBinaryMapExpr.h:114
Compile time check whether the given type is a binary map expression template.
Definition IsBinaryMapExpr.h:83

◆ IsBLASCompatible_v

template<typename T>
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>;
constexpr bool IsBLASCompatible_v
Auxiliary variable template for the IsBLASCompatible type trait.
Definition IsBLASCompatible.h:99
Compile time check for data types.
Definition IsBLASCompatible.h:81

◆ IsClearable_v

template<typename T>
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>;
constexpr bool IsClearable_v
Auxiliary variable template for the IsClearable type trait.
Definition IsClearable.h:121
Compile time check for clearable data types.
Definition IsClearable.h:90

◆ IsColumn_v

template<typename T>
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>;
constexpr bool IsColumn_v
Auxiliary variable template for the IsColumn type trait.
Definition IsColumn.h:161
Compile time check for columns.
Definition IsColumn.h:91

◆ IsColumnMajorMatrix_v

template<typename T>
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>;
constexpr bool IsColumnMajorMatrix_v
Auxiliary variable template for the IsColumnMajorMatrix type trait.
Definition IsColumnMajorMatrix.h:129
Compile time check for column-major matrix types.
Definition IsColumnMajorMatrix.h:98

◆ IsColumns_v

template<typename T>
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>;
constexpr bool IsColumns_v
Auxiliary variable template for the IsColumns type trait.
Definition IsColumns.h:161
Compile time check for column selections.
Definition IsColumns.h:91

◆ IsColumnVector_v

template<typename T>
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>;
constexpr bool IsColumnVector_v
Auxiliary variable template for the IsColumnVector type trait.
Definition IsColumnVector.h:126
Compile time check for column vector types.
Definition IsColumnVector.h:95

◆ IsCommutative_v

template<typename T1, typename T2>
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>;
constexpr bool IsCommutative_v
Auxiliary variable template for the IsCommutative type trait.
Definition IsCommutative.h:117
Compile time check for the commutativity of data types.
Definition IsCommutative.h:84

◆ IsComputation_v

template<typename T>
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>;
constexpr bool IsComputation_v
Auxiliary variable template for the IsComputation type trait.
Definition IsComputation.h:90
Compile time check whether the given type is a computational expression template.
Definition IsComputation.h:72

◆ IsContiguous_v

template<typename T>
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>;
constexpr bool IsContiguous_v
Auxiliary variable template for the IsContiguous type trait.
Definition IsContiguous.h:144
Compile time check for the memory layout of data types.
Definition IsContiguous.h:87

◆ IsCrossExpr_v

template<typename T>
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>;
constexpr bool IsCrossExpr_v
Auxiliary variable template for the IsCrossExpr type trait.
Definition IsCrossExpr.h:115
Compile time check whether the given type is a cross product expression template.
Definition IsCrossExpr.h:84

◆ IsCustom_v

template<typename T>
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>;
constexpr bool IsCustom_v
Auxiliary variable template for the IsCustom type trait.
Definition IsCustom.h:145
Compile time check for custom data types.
Definition IsCustom.h:88

◆ IsDeclaration_v

template<typename T>
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>;
constexpr bool IsDeclaration_v
Auxiliary variable template for the IsDeclaration type trait.
Definition IsDeclaration.h:114
Compile time check whether the given type is a declaration expression template.
Definition IsDeclaration.h:83

◆ IsDeclDiagExpr_v

template<typename T>
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>;
constexpr bool IsDeclDiagExpr_v
Auxiliary variable template for the IsDeclDiagExpr type trait.
Definition IsDeclDiagExpr.h:114
Compile time check whether the given type is a decldiag expression template.
Definition IsDeclDiagExpr.h:83

◆ IsDeclExpr_v

template<typename T>
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>;
constexpr bool IsDeclExpr_v
Auxiliary variable template for the IsDeclExpr type trait.
Definition IsDeclExpr.h:114
Compile time check whether the given type is a declaration expression template.
Definition IsDeclExpr.h:83

◆ IsDeclHermExpr_v

template<typename T>
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>;
constexpr bool IsDeclHermExpr_v
Auxiliary variable template for the IsDeclHermExpr type trait.
Definition IsDeclHermExpr.h:114
Compile time check whether the given type is a declherm expression template.
Definition IsDeclHermExpr.h:83

◆ IsDeclLowExpr_v

template<typename T>
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>;
constexpr bool IsDeclLowExpr_v
Auxiliary variable template for the IsDeclLowExpr type trait.
Definition IsDeclLowExpr.h:114
Compile time check whether the given type is a decllow expression template.
Definition IsDeclLowExpr.h:83

◆ IsDeclStrLowExpr_v

template<typename T>
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>;
constexpr bool IsDeclStrLowExpr_v
Auxiliary variable template for the IsDeclStrLowExpr type trait.
Definition IsDeclStrLowExpr.h:114
Compile time check whether the given type is a declstrlow expression template.
Definition IsDeclStrLowExpr.h:83

◆ IsDeclStrUppExpr_v

template<typename T>
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>;
constexpr bool IsDeclStrUppExpr_v
Auxiliary variable template for the IsDeclStrUppExpr type trait.
Definition IsDeclStrUppExpr.h:114
Compile time check whether the given type is a declstrupp expression template.
Definition IsDeclStrUppExpr.h:83

◆ IsDeclSymExpr_v

template<typename T>
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>;
constexpr bool IsDeclSymExpr_v
Auxiliary variable template for the IsDeclSymExpr type trait.
Definition IsDeclSymExpr.h:114
Compile time check whether the given type is a declsym expression template.
Definition IsDeclSymExpr.h:83

◆ IsDeclUniLowExpr_v

template<typename T>
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>;
constexpr bool IsDeclUniLowExpr_v
Auxiliary variable template for the IsDeclUniLowExpr type trait.
Definition IsDeclUniLowExpr.h:114
Compile time check whether the given type is a declunilow expression template.
Definition IsDeclUniLowExpr.h:83

◆ IsDeclUniUppExpr_v

template<typename T>
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>;
constexpr bool IsDeclUniUppExpr_v
Auxiliary variable template for the IsDeclUniUppExpr type trait.
Definition IsDeclUniUppExpr.h:114
Compile time check whether the given type is a decluniupp expression template.
Definition IsDeclUniUppExpr.h:83

◆ IsDeclUppExpr_v

template<typename T>
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>;
constexpr bool IsDeclUppExpr_v
Auxiliary variable template for the IsDeclUppExpr type trait.
Definition IsDeclUppExpr.h:114
Compile time check whether the given type is a declupp expression template.
Definition IsDeclUppExpr.h:83

◆ IsDenseMatrix_v

template<typename T>
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>;
constexpr bool IsDenseMatrix_v
Auxiliary variable template for the IsDenseMatrix type trait.
Definition IsDenseMatrix.h:124
Compile time check for dense matrix types.
Definition IsDenseMatrix.h:93

◆ IsDenseVector_v

template<typename T>
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>;
constexpr bool IsDenseVector_v
Auxiliary variable template for the IsDenseVector type trait.
Definition IsDenseVector.h:124
Compile time check for dense vector types.
Definition IsDenseVector.h:93

◆ IsDiagonal_v

template<typename T>
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>;
constexpr bool IsDiagonal_v
Auxiliary variable template for the IsDiagonal type trait.
Definition IsDiagonal.h:148
Compile time check for diagonal matrices.
Definition IsDiagonal.h:91

◆ IsDivExpr_v

template<typename T>
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>;
constexpr bool IsDivExpr_v
Auxiliary variable template for the IsDivExpr type trait.
Definition IsDivExpr.h:116
Compile time check whether the given type is a division expression template.
Definition IsDivExpr.h:85

◆ IsEigenExpr_v

template<typename T>
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>;
constexpr bool IsEigenExpr_v
Auxiliary variable template for the IsEigenExpr type trait.
Definition IsEigenExpr.h:114
Compile time check whether the given type is an eigenvalue expression template.
Definition IsEigenExpr.h:83

◆ IsElements_v

template<typename T>
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>;
constexpr bool IsElements_v
Auxiliary variable template for the IsElements type trait.
Definition IsElements.h:159
Compile time check for element selections.
Definition IsElements.h:89

◆ IsEvalExpr_v

template<typename T>
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>;
constexpr bool IsEvalExpr_v
Auxiliary variable template for the IsEvalExpr type trait.
Definition IsEvalExpr.h:114
Compile time check whether the given type is an evaluation expression template.
Definition IsEvalExpr.h:83

◆ IsExpandExpr_v

template<typename T>
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>;
constexpr bool IsExpandExpr_v
Auxiliary variable template for the IsExpandExpr type trait.
Definition IsExpandExpr.h:114
Compile time check whether the given type is an expansion expression template.
Definition IsExpandExpr.h:83

◆ IsExpression_v

template<typename T>
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>;
constexpr bool IsExpression_v
Auxiliary variable template for the IsExpression type trait.
Definition IsExpression.h:114
Compile time check whether the given type is an expression template.
Definition IsExpression.h:83

◆ IsGeneral_v

template<typename T>
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>;
constexpr bool IsGeneral_v
Auxiliary variable template for the IsGeneral type trait.
Definition IsGeneral.h:147
Compile time check for general matrices.
Definition IsGeneral.h:90

◆ IsGenExpr_v

template<typename T>
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>;
constexpr bool IsGenExpr_v
Auxiliary variable template for the IsGenExpr type trait.
Definition IsGenExpr.h:114
Compile time check whether the given type is a generator expression template.
Definition IsGenExpr.h:83

◆ IsHermitian_v

template<typename T>
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>;
constexpr bool IsHermitian_v
Auxiliary variable template for the IsHermitian type trait.
Definition IsHermitian.h:172
Compile time check for Hermitian matrices.
Definition IsHermitian.h:115

◆ IsIdentity_v

template<typename T>
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>;
constexpr bool IsIdentity_v
Auxiliary variable template for the IsIdentity type trait.
Definition IsIdentity.h:137
Compile time check for identity matrices.
Definition IsIdentity.h:80

◆ IsInitializer_v

template<typename T>
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>;
constexpr bool IsInitializer_v
Auxiliary variable template for the IsInitializer type trait.
Definition IsInitializer.h:140
Compile time check for custom data types.
Definition IsInitializer.h:83

◆ IsInvertible_v

template<typename T>
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>;
constexpr bool IsInvertible_v
Auxiliary variable template for the IsInvertible type trait.
Definition IsInvertible.h:103
Compile time check for data types.
Definition IsInvertible.h:85

◆ IsKronExpr_v

template<typename T>
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>;
constexpr bool IsKronExpr_v
Auxiliary variable template for the IsKronExpr type trait.
Definition IsKronExpr.h:115
Compile time check whether the given type is a Kronecker product expression template.
Definition IsKronExpr.h:84

◆ IsLower_v

template<typename T>
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>;
constexpr bool IsLower_v
Auxiliary variable template for the IsLower type trait.
Definition IsLower.h:175
Compile time check for lower triangular matrices.
Definition IsLower.h:118

◆ IsMatEvalExpr_v

template<typename T>
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>;
constexpr bool IsMatEvalExpr_v
Auxiliary variable template for the IsMatEvalExpr type trait.
Definition IsMatEvalExpr.h:115
Compile time check whether the given type is a matrix evaluation expression template.
Definition IsMatEvalExpr.h:84

◆ IsMatExpExpr_v

template<typename T>
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>;
constexpr bool IsMatExpExpr_v
Auxiliary variable template for the IsMatExpExpr type trait.
Definition IsMatExpExpr.h:115
Compile time check whether the given type is a matrix exponential expression template.
Definition IsMatExpExpr.h:84

◆ IsMatGenExpr_v

template<typename T>
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>;
constexpr bool IsMatGenExpr_v
Auxiliary variable template for the IsMatGenExpr type trait.
Definition IsMatGenExpr.h:115
Compile time check whether the given type is a matrix generator expression template.
Definition IsMatGenExpr.h:84

◆ IsMatInvExpr_v

template<typename T>
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>;
constexpr bool IsMatInvExpr_v
Auxiliary variable template for the IsMatInvExpr type trait.
Definition IsMatInvExpr.h:115
Compile time check whether the given type is a matrix inversion expression template.
Definition IsMatInvExpr.h:84

◆ IsMatMapExpr_v

template<typename T>
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>;
constexpr bool IsMatMapExpr_v
Auxiliary variable template for the IsMatMapExpr type trait.
Definition IsMatMapExpr.h:115
Compile time check whether the given type is a unary matrix map expression template.
Definition IsMatMapExpr.h:84

◆ IsMatMatAddExpr_v

template<typename T>
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>;
constexpr bool IsMatMatAddExpr_v
Auxiliary variable template for the IsMatMatAddExpr type trait.
Definition IsMatMatAddExpr.h:115
Compile time check whether the given type is a matrix/matrix addition expression template.
Definition IsMatMatAddExpr.h:84

◆ IsMatMatKronExpr_v

template<typename T>
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>;
constexpr bool IsMatMatKronExpr_v
Auxiliary variable template for the IsMatMatKronExpr type trait.
Definition IsMatMatKronExpr.h:116
Compile time check whether the given type is a matrix/matrix Kronecker product expression template.
Definition IsMatMatKronExpr.h:85

◆ IsMatMatMapExpr_v

template<typename T>
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>;
constexpr bool IsMatMatMapExpr_v
Auxiliary variable template for the IsMatMatMapExpr type trait.
Definition IsMatMatMapExpr.h:115
Compile time check whether the given type is a binary matrix map expression template.
Definition IsMatMatMapExpr.h:84

◆ IsMatMatMultExpr_v

template<typename T>
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>;
constexpr bool IsMatMatMultExpr_v
Auxiliary variable template for the IsMatMatMultExpr type trait.
Definition IsMatMatMultExpr.h:116
Compile time check whether the given type is a matrix/matrix multiplication expression template.
Definition IsMatMatMultExpr.h:85

◆ IsMatMatSolveExpr_v

template<typename T>
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>;
constexpr bool IsMatMatSolveExpr_v
Auxiliary variable template for the IsMatMatSolveExpr type trait.
Definition IsMatMatSolveExpr.h:115
Compile time check whether the given type is a multi LSE solver expression template.
Definition IsMatMatSolveExpr.h:84

◆ IsMatMatSubExpr_v

template<typename T>
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>;
constexpr bool IsMatMatSubExpr_v
Auxiliary variable template for the IsMatMatSubExpr type trait.
Definition IsMatMatSubExpr.h:115
Compile time check whether the given type is a matrix/matrix subtraction expression template.
Definition IsMatMatSubExpr.h:84

◆ IsMatNoAliasExpr_v

template<typename T>
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>;
constexpr bool IsMatNoAliasExpr_v
Auxiliary variable template for the IsMatNoAliasExpr type trait.
Definition IsMatNoAliasExpr.h:115
Compile time check whether the given type is a matrix no-alias expression template.
Definition IsMatNoAliasExpr.h:84

◆ IsMatNoSIMDExpr_v

template<typename T>
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>;
constexpr bool IsMatNoSIMDExpr_v
Auxiliary variable template for the IsMatNoSIMDExpr type trait.
Definition IsMatNoSIMDExpr.h:115
Compile time check whether the given type is a matrix no-SIMD expression template.
Definition IsMatNoSIMDExpr.h:84

◆ IsMatReduceExpr_v

template<typename T>
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>;
constexpr bool IsMatReduceExpr_v
Auxiliary variable template for the IsMatReduceExpr type trait.
Definition IsMatReduceExpr.h:115
Compile time check whether the given type is a reduction expression template.
Definition IsMatReduceExpr.h:84

◆ IsMatRepeatExpr_v

template<typename T>
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>;
constexpr bool IsMatRepeatExpr_v
Auxiliary variable template for the IsMatRepeatExpr type trait.
Definition IsMatRepeatExpr.h:115
Compile time check whether the given type is a matrix repeater expression template.
Definition IsMatRepeatExpr.h:84

◆ IsMatrix_v

template<typename T>
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>;
constexpr bool IsMatrix_v
Auxiliary variable template for the IsMatrix type trait.
Definition IsMatrix.h:124
Compile time check for matrix types.
Definition IsMatrix.h:93

◆ IsMatScalarDivExpr_v

template<typename T>
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>;
constexpr bool IsMatScalarDivExpr_v
Auxiliary variable template for the IsMatScalarDivExpr type trait.
Definition IsMatScalarDivExpr.h:116
Compile time check whether the given type is a matrix/scalar division expression template.
Definition IsMatScalarDivExpr.h:85

◆ IsMatScalarMultExpr_v

template<typename T>
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>;
constexpr bool IsMatScalarMultExpr_v
Auxiliary variable template for the IsMatScalarMultExpr type trait.
Definition IsMatScalarMultExpr.h:117
Compile time check whether the given type is a matrix/scalar multiplication expression template.
Definition IsMatScalarMultExpr.h:86

◆ IsMatSerialExpr_v

template<typename T>
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>;
constexpr bool IsMatSerialExpr_v
Auxiliary variable template for the IsMatSerialExpr type trait.
Definition IsMatSerialExpr.h:115
Compile time check whether the given type is a matrix serial evaluation expression template.
Definition IsMatSerialExpr.h:84

◆ IsMatTransExpr_v

template<typename T>
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>;
constexpr bool IsMatTransExpr_v
Auxiliary variable template for the IsMatTransExpr type trait.
Definition IsMatTransExpr.h:115
Compile time check whether the given type is a matrix transposition expression template.
Definition IsMatTransExpr.h:84

◆ IsMatVecMultExpr_v

template<typename T>
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>;
constexpr bool IsMatVecMultExpr_v
Auxiliary variable template for the IsMatVecMultExpr type trait.
Definition IsMatVecMultExpr.h:117
Compile time check whether the given type is a matrix/vector multiplication expression template.
Definition IsMatVecMultExpr.h:86

◆ IsMatVecSolveExpr_v

template<typename T>
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>;
constexpr bool IsMatVecSolveExpr_v
Auxiliary variable template for the IsMatVecSolveExpr type trait.
Definition IsMatVecSolveExpr.h:115
Compile time check whether the given type is a single LSE solver expression template.
Definition IsMatVecSolveExpr.h:84

◆ IsModification_v

template<typename T>
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>;
constexpr bool IsModification_v
Auxiliary variable template for the IsModification type trait.
Definition IsModification.h:114
Compile time check whether the given type is a modification expression template.
Definition IsModification.h:83

◆ IsMultExpr_v

template<typename T>
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>;
constexpr bool IsMultExpr_v
Auxiliary variable template for the IsMultExpr type trait.
Definition IsMultExpr.h:116
Compile time check whether the given type is a multiplication expression template.
Definition IsMultExpr.h:85

◆ IsNoAliasExpr_v

template<typename T>
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>;
constexpr bool IsNoAliasExpr_v
Auxiliary variable template for the IsNoAliasExpr type trait.
Definition IsNoAliasExpr.h:114
Compile time check whether the given type is a no-alias expression template.
Definition IsNoAliasExpr.h:83

◆ IsNoSIMDExpr_v

template<typename T>
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>;
constexpr bool IsNoSIMDExpr_v
Auxiliary variable template for the IsNoSIMDExpr type trait.
Definition IsNoSIMDExpr.h:114
Compile time check whether the given type is a no-SIMD expression template.
Definition IsNoSIMDExpr.h:83

◆ IsOperation_v

template<typename T>
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>;
constexpr bool IsOperation_v
Auxiliary variable template for the IsOperation type trait.
Definition IsOperation.h:89
Compile time check whether the given type is an operational expression template.
Definition IsOperation.h:71

◆ IsOpposedView_v

template<typename T>
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>;
constexpr bool IsOpposedView_v
Auxiliary variable template for the IsOpposedView type trait.
Definition IsOpposedView.h:139
Compile time check for resizable data types.
Definition IsOpposedView.h:82

◆ IsPadded_v

template<typename T>
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>;
constexpr bool IsPadded_v
Auxiliary variable template for the IsPadded type trait.
Definition IsPadded.h:134
Compile time check for data types with padding.
Definition IsPadded.h:77

◆ IsPaddingEnabled_v

template<typename T>
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>;
constexpr bool IsPaddingEnabled_v
Auxiliary variable template for the IsPaddingEnabled type trait.
Definition IsPaddingEnabled.h:131
Compile time check for data types.
Definition IsPaddingEnabled.h:113

◆ IsProxy_v

template<typename T>
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>;
constexpr bool IsProxy_v
Auxiliary variable template for the IsProxy type trait.
Definition IsProxy.h:127
Compile time check for proxy types.
Definition IsProxy.h:96

◆ IsReduceExpr_v

template<typename T>
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>;
constexpr bool IsReduceExpr_v
Auxiliary variable template for the IsReduceExpr type trait.
Definition IsReduceExpr.h:114
Compile time check whether the given type is a reduction expression template.
Definition IsReduceExpr.h:83

◆ IsRepeatExpr_v

template<typename T>
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>;
constexpr bool IsRepeatExpr_v
Auxiliary variable template for the IsRepeatExpr type trait.
Definition IsRepeatExpr.h:114
Compile time check whether the given type is a repeater expression template.
Definition IsRepeatExpr.h:83

◆ IsResizable_v

template<typename T>
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>;
constexpr bool IsResizable_v
Auxiliary variable template for the IsResizable type trait.
Definition IsResizable.h:136
Compile time check for resizable data types.
Definition IsResizable.h:105

◆ IsRestricted_v

template<typename T>
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>;
constexpr bool IsRestricted_v
Auxiliary variable template for the IsRestricted type trait.
Definition IsRestricted.h:140
Compile time check for data types with restricted data access.
Definition IsRestricted.h:83

◆ IsRow_v

template<typename T>
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>;
constexpr bool IsRow_v
Auxiliary variable template for the IsRow type trait.
Definition IsRow.h:161
Compile time check for rows.
Definition IsRow.h:91

◆ IsRowMajorMatrix_v

template<typename T>
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>;
constexpr bool IsRowMajorMatrix_v
Auxiliary variable template for the IsRowMajorMatrix type trait.
Definition IsRowMajorMatrix.h:129
Compile time check for row-major matrix types.
Definition IsRowMajorMatrix.h:98

◆ IsRows_v

template<typename T>
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>;
constexpr bool IsRows_v
Auxiliary variable template for the IsRows type trait.
Definition IsRows.h:161
Compile time check for row selections.
Definition IsRows.h:91

◆ IsRowVector_v

template<typename T>
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>;
constexpr bool IsRowVector_v
Auxiliary variable template for the IsRowVector type trait.
Definition IsRowVector.h:126
Compile time check for row vector types.
Definition IsRowVector.h:95

◆ IsScalar_v

template<typename T>
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>;
constexpr bool IsScalar_v
Auxiliary variable template for the IsScalar type trait.
Definition IsScalar.h:104
Compile time check for scalar types.
Definition IsScalar.h:86

◆ IsSchurExpr_v

template<typename T>
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>;
constexpr bool IsSchurExpr_v
Auxiliary variable template for the IsSchurExpr type trait.
Definition IsSchurExpr.h:115
Compile time check whether the given type is a Schur product expression template.
Definition IsSchurExpr.h:84

◆ IsSerialExpr_v

template<typename T>
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>;
constexpr bool IsSerialExpr_v
Auxiliary variable template for the IsSerialExpr type trait.
Definition IsSerialExpr.h:115
Compile time check whether the given type is a serial evaluation expression template.
Definition IsSerialExpr.h:84

◆ IsShrinkable_v

template<typename T>
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>;
constexpr bool IsShrinkable_v
Auxiliary variable template for the IsShrinkable type trait.
Definition IsShrinkable.h:121
Compile time check for shrinkable data types.
Definition IsShrinkable.h:90

◆ IsSIMDCombinable_v

template<typename T1, typename T2, typename... Ts>
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>;
constexpr bool IsSIMDCombinable_v
Auxiliary variable template for the IsSIMDCombinable type trait.
Definition IsSIMDCombinable.h:137
Compile time check for data types.
Definition IsSIMDCombinable.h:119

◆ IsSIMDEnabled_v

template<typename T, typename... Args>
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>;
constexpr bool IsSIMDEnabled_v
Auxiliary variable template for the IsSIMDEnabled type trait.
Definition IsSIMDEnabled.h:129
Compile time check for data types.
Definition IsSIMDEnabled.h:111

◆ IsSIMDPack_v

template<typename T>
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>;
constexpr bool IsSIMDPack_v
Auxiliary variable template for the IsSIMDPack type trait.
Definition IsSIMDPack.h:157
Compile time check for SIMD data types.
Definition IsSIMDPack.h:126

◆ IsSMPAssignable_v

template<typename T>
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>;
constexpr bool IsSMPAssignable_v
Auxiliary variable template for the IsSMPAssignable type trait.
Definition IsSMPAssignable.h:132
Compile time check for data types.
Definition IsSMPAssignable.h:114

◆ IsSolveExpr_v

template<typename T>
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>;
constexpr bool IsSolveExpr_v
Auxiliary variable template for the IsSolveExpr type trait.
Definition IsSolveExpr.h:115
Compile time check whether the given type is a solver expression template.
Definition IsSolveExpr.h:84

◆ IsSparseElement_v

template<typename T>
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>;
constexpr bool IsSparseElement_v
Auxiliary variable template for the IsSparseElement type trait.
Definition IsSparseElement.h:89
Compile time check whether the given type is a sparse element type.
Definition IsSparseElement.h:71

◆ IsSparseMatrix_v

template<typename T>
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>;
constexpr bool IsSparseMatrix_v
Auxiliary variable template for the IsSparseMatrix type trait.
Definition IsSparseMatrix.h:124
Compile time check for sparse matrix types.
Definition IsSparseMatrix.h:93

◆ IsSparseVector_v

template<typename T>
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>;
constexpr bool IsSparseVector_v
Auxiliary variable template for the IsSparseVector type trait.
Definition IsSparseVector.h:124
Compile time check for sparse vector types.
Definition IsSparseVector.h:93

◆ IsSquare_v

template<typename T>
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>;
constexpr bool IsSquare_v
Auxiliary variable template for the IsSquare type trait.
Definition IsSquare.h:146
Compile time check for square matrices.
Definition IsSquare.h:89

◆ IsStatic_v

template<typename T>
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>;
constexpr bool IsStatic_v
Auxiliary variable template for the IsStatic type trait.
Definition IsStatic.h:109
Compile time check for static data types.
Definition IsStatic.h:91

◆ IsStrictlyLower_v

template<typename T>
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>;
constexpr bool IsStrictlyLower_v
Auxiliary variable template for the IsStrictlyLower type trait.
Definition IsStrictlyLower.h:173
Compile time check for strictly lower triangular matrices.
Definition IsStrictlyLower.h:116

◆ IsStrictlyTriangular_v

template<typename T>
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>;
constexpr bool IsStrictlyTriangular_v
Auxiliary variable template for the IsStrictlyTriangular type trait.
Definition IsStrictlyTriangular.h:106
Compile time check for strictly triangular matrix types.
Definition IsStrictlyTriangular.h:88

◆ IsStrictlyUpper_v

template<typename T>
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>;
constexpr bool IsStrictlyUpper_v
Auxiliary variable template for the IsStrictlyUpper type trait.
Definition IsStrictlyUpper.h:173
Compile time check for strictly upper triangular matrices.
Definition IsStrictlyUpper.h:116

◆ IsSubExpr_v

template<typename T>
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>;
constexpr bool IsSubExpr_v
Auxiliary variable template for the IsSubExpr type trait.
Definition IsSubExpr.h:115
Compile time check whether the given type is a subtraction expression template.
Definition IsSubExpr.h:84

◆ IsSubmatrix_v

template<typename T>
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>;
constexpr bool IsSubmatrix_v
Auxiliary variable template for the IsSubmatrix type trait.
Definition IsSubmatrix.h:161
Compile time check for submatrices.
Definition IsSubmatrix.h:91

◆ IsSubvector_v

template<typename T>
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>;
constexpr bool IsSubvector_v
Auxiliary variable template for the IsSubvector type trait.
Definition IsSubvector.h:161
Compile time check for subvectors.
Definition IsSubvector.h:91

◆ IsSVDExpr_v

template<typename T>
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>;
constexpr bool IsSVDExpr_v
Auxiliary variable template for the IsSVDExpr type trait.
Definition IsSVDExpr.h:114
Compile time check whether the given type is a singular value expression template.
Definition IsSVDExpr.h:83

◆ IsSymmetric_v

template<typename T>
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>;
constexpr bool IsSymmetric_v
Auxiliary variable template for the IsSymmetric type trait.
Definition IsSymmetric.h:172
Compile time check for symmetric matrices.
Definition IsSymmetric.h:115

◆ IsTemporary_v

template<typename T>
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>;
constexpr bool IsTemporary_v
Auxiliary variable template for the IsTemporary type trait.
Definition IsTemporary.h:88
Compile time check whether the given type is a temporary vector or matrix type.
Definition IsTemporary.h:70

◆ IsTransExpr_v

template<typename T>
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>;
constexpr bool IsTransExpr_v
Auxiliary variable template for the IsTransExpr type trait.
Definition IsTransExpr.h:115
Compile time check whether the given type is a transposition expression template.
Definition IsTransExpr.h:84

◆ IsTransformation_v

template<typename T>
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>;
constexpr bool IsTransformation_v
Auxiliary variable template for the IsTransformation type trait.
Definition IsTransformation.h:89
Compile time check whether the given type is a transformation expression template.
Definition IsTransformation.h:71

◆ IsTriangular_v

template<typename T>
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>;
constexpr bool IsTriangular_v
Auxiliary variable template for the IsTriangular type trait.
Definition IsTriangular.h:106
Compile time check for triangular matrix types.
Definition IsTriangular.h:88

◆ IsTVecMatMultExpr_v

template<typename T>
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>;
constexpr bool IsTVecMatMultExpr_v
Auxiliary variable template for the IsTVecMatMultExpr type trait.
Definition IsTVecMatMultExpr.h:117
Compile time check whether the given type is a vector/matrix multiplication expression template.
Definition IsTVecMatMultExpr.h:86

◆ IsUnaryMapExpr_v

template<typename T>
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>;
constexpr bool IsUnaryMapExpr_v
Auxiliary variable template for the IsUnaryMapExpr type trait.
Definition IsUnaryMapExpr.h:114
Compile time check whether the given type is a unary map expression template.
Definition IsUnaryMapExpr.h:83

◆ IsUniform_v

template<typename T>
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>;
constexpr bool IsUniform_v
Auxiliary variable template for the IsUniform type trait.
Definition IsUniform.h:164
Compile time check for uniform vectors and matrices.
Definition IsUniform.h:107

◆ IsUniLower_v

template<typename T>
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>;
constexpr bool IsUniLower_v
Auxiliary variable template for the IsUniLower type trait.
Definition IsUniLower.h:173
Compile time check for lower unitriangular matrices.
Definition IsUniLower.h:116

◆ IsUniTriangular_v

template<typename T>
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>;
constexpr bool IsUniTriangular_v
Auxiliary variable template for the IsUniTriangular type trait.
Definition IsUniTriangular.h:106
Compile time check for unitriangular matrix types.
Definition IsUniTriangular.h:88

◆ IsUniUpper_v

template<typename T>
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>;
constexpr bool IsUniUpper_v
Auxiliary variable template for the IsUniUpper type trait.
Definition IsUniUpper.h:173
Compile time check for upper unitriangular matrices.
Definition IsUniUpper.h:116

◆ IsUpper_v

template<typename T>
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>;
constexpr bool IsUpper_v
Auxiliary variable template for the IsUpper type trait.
Definition IsUpper.h:175
Compile time check for upper triangular matrices.
Definition IsUpper.h:118

◆ IsVecEvalExpr_v

template<typename T>
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>;
constexpr bool IsVecEvalExpr_v
Auxiliary variable template for the IsVecEvalExpr type trait.
Definition IsVecEvalExpr.h:115
Compile time check whether the given type is a vector evaluation expression template.
Definition IsVecEvalExpr.h:84

◆ IsVecExpandExpr_v

template<typename T>
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>;
constexpr bool IsVecExpandExpr_v
Auxiliary variable template for the IsVecExpandExpr type trait.
Definition IsVecExpandExpr.h:115
Compile time check whether the given type is a vector expansion expression template.
Definition IsVecExpandExpr.h:84

◆ IsVecGenExpr_v

template<typename T>
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>;
constexpr bool IsVecGenExpr_v
Auxiliary variable template for the IsVecGenExpr type trait.
Definition IsVecGenExpr.h:115
Compile time check whether the given type is a vector generator expression template.
Definition IsVecGenExpr.h:84

◆ IsVecMapExpr_v

template<typename T>
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>;
constexpr bool IsVecMapExpr_v
Auxiliary variable template for the IsVecMapExpr type trait.
Definition IsVecMapExpr.h:115
Compile time check whether the given type is a unary vector map expression template.
Definition IsVecMapExpr.h:84

◆ IsVecNoAliasExpr_v

template<typename T>
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>;
constexpr bool IsVecNoAliasExpr_v
Auxiliary variable template for the IsVecNoAliasExpr type trait.
Definition IsVecNoAliasExpr.h:115
Compile time check whether the given type is a vector no-alias expression template.
Definition IsVecNoAliasExpr.h:84

◆ IsVecNoSIMDExpr_v

template<typename T>
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>;
constexpr bool IsVecNoSIMDExpr_v
Auxiliary variable template for the IsVecNoSIMDExpr type trait.
Definition IsVecNoSIMDExpr.h:115
Compile time check whether the given type is a vector no-SIMD expression template.
Definition IsVecNoSIMDExpr.h:84

◆ IsVecRepeatExpr_v

template<typename T>
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>;
constexpr bool IsVecRepeatExpr_v
Auxiliary variable template for the IsVecRepeatExpr type trait.
Definition IsVecRepeatExpr.h:115
Compile time check whether the given type is a vector repeater expression template.
Definition IsVecRepeatExpr.h:84

◆ IsVecScalarDivExpr_v

template<typename T>
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>;
constexpr bool IsVecScalarDivExpr_v
Auxiliary variable template for the IsVecScalarDivExpr type trait.
Definition IsVecScalarDivExpr.h:116
Compile time check whether the given type is a vector/scalar division expression template.
Definition IsVecScalarDivExpr.h:85

◆ IsVecScalarMultExpr_v

template<typename T>
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>;
constexpr bool IsVecScalarMultExpr_v
Auxiliary variable template for the IsVecScalarMultExpr type trait.
Definition IsVecScalarMultExpr.h:117
Compile time check whether the given type is a vector/scalar multiplication expression template.
Definition IsVecScalarMultExpr.h:86

◆ IsVecSerialExpr_v

template<typename T>
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>;
constexpr bool IsVecSerialExpr_v
Auxiliary variable template for the IsVecSerialExpr type trait.
Definition IsVecSerialExpr.h:115
Compile time check whether the given type is a vector serial evaluation expression template.
Definition IsVecSerialExpr.h:84

◆ IsVector_v

template<typename T>
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>;
constexpr bool IsVector_v
Auxiliary variable template for the IsVector type trait.
Definition IsVector.h:125
Compile time check for vector types.
Definition IsVector.h:94

◆ IsVecTransExpr_v

template<typename T>
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>;
constexpr bool IsVecTransExpr_v
Auxiliary variable template for the IsVecTransExpr type trait.
Definition IsVecTransExpr.h:115
Compile time check whether the given type is a vector transposition expression template.
Definition IsVecTransExpr.h:84

◆ IsVecTVecMapExpr_v

template<typename T>
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>;
constexpr bool IsVecTVecMapExpr_v
Auxiliary variable template for the IsVecTVecMapExpr type trait.
Definition IsVecTVecMapExpr.h:115
Compile time check whether the given type is an outer map expression template.
Definition IsVecTVecMapExpr.h:84

◆ IsVecTVecMultExpr_v

template<typename T>
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>;
constexpr bool IsVecTVecMultExpr_v
Auxiliary variable template for the IsVecTVecMultExpr type trait.
Definition IsVecTVecMultExpr.h:116
Compile time check whether the given type is an outer product expression template.
Definition IsVecTVecMultExpr.h:85

◆ IsVecVecAddExpr_v

template<typename T>
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>;
constexpr bool IsVecVecAddExpr_v
Auxiliary variable template for the IsVecVecAddExpr type trait.
Definition IsVecVecAddExpr.h:115
Compile time check whether the given type is a vector/vector addition expression template.
Definition IsVecVecAddExpr.h:84

◆ IsVecVecDivExpr_v

template<typename T>
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>;
constexpr bool IsVecVecDivExpr_v
Auxiliary variable template for the IsVecVecDivExpr type trait.
Definition IsVecVecDivExpr.h:116
Compile time check whether the given type is a vector/vector division expression template.
Definition IsVecVecDivExpr.h:85

◆ IsVecVecKronExpr_v

template<typename T>
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>;
constexpr bool IsVecVecKronExpr_v
Auxiliary variable template for the IsVecVecKronExpr type trait.
Definition IsVecVecKronExpr.h:116
Compile time check whether the given type is a vector/vector Kronecker product expression template.
Definition IsVecVecKronExpr.h:85

◆ IsVecVecMapExpr_v

template<typename T>
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>;
constexpr bool IsVecVecMapExpr_v
Auxiliary variable template for the IsVecVecMapExpr type trait.
Definition IsVecVecMapExpr.h:115
Compile time check whether the given type is a binary vector map expression template.
Definition IsVecVecMapExpr.h:84

◆ IsVecVecMultExpr_v

template<typename T>
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>;
constexpr bool IsVecVecMultExpr_v
Auxiliary variable template for the IsVecVecMultExpr type trait.
Definition IsVecVecMultExpr.h:116
Compile time check whether the given type is a vector/vector multiplication expression template.
Definition IsVecVecMultExpr.h:85

◆ IsVecVecSubExpr_v

template<typename T>
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>;
constexpr bool IsVecVecSubExpr_v
Auxiliary variable template for the IsVecVecSubExpr type trait.
Definition IsVecVecSubExpr.h:116
Compile time check whether the given type is a vector/vector subtraction expression template.
Definition IsVecVecSubExpr.h:85

◆ IsView_v

template<typename T>
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>;
constexpr bool IsView_v
Auxiliary variable template for the IsView type trait.
Definition IsView.h:134
Compile time check for views.
Definition IsView.h:103

◆ IsZero_v

template<typename T>
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>;
constexpr bool IsZero_v
Auxiliary variable template for the IsZero type trait.
Definition IsZero.h:166
Compile time check for zero vectors or matrices.
Definition IsZero.h:109

◆ MaxSize_v

template<typename T, size_t N>
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>;
constexpr ptrdiff_t MaxSize_v
Auxiliary variable template for the MaxSize type trait.
Definition MaxSize.h:175
Compile time evaluation of the maximum size of vectors and matrices.
Definition MaxSize.h:118

◆ RequiresEvaluation_v

template<typename T>
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>;
constexpr bool RequiresEvaluation_v
Auxiliary variable template for the RequiresEvaluation type trait.
Definition RequiresEvaluation.h:91
Compile time check to query the requirement to evaluate an expression.
Definition RequiresEvaluation.h:73

◆ Size_v

template<typename T, size_t N>
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>;
constexpr ptrdiff_t Size_v
Auxiliary variable template for the Size type trait.
Definition Size.h:176
Compile time evaluation of the size of vectors and matrices.
Definition Size.h:119

◆ StorageOrder_v

template<typename T>
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>;
constexpr bool StorageOrder_v
Auxiliary variable template for the StorageOrder type trait.
Definition StorageOrder.h:93
Evaluation of the storage order of a given matrix type.
Definition StorageOrder.h:75

◆ TransposeFlag_v

template<typename T>
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>;
constexpr bool TransposeFlag_v
Auxiliary variable template for the TransposeFlag type trait.
Definition TransposeFlag.h:93
Evaluation of the transpose flag of a given matrix type.
Definition TransposeFlag.h:75

◆ YieldsDiagonal_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsDiagonal_v
Auxiliary variable template for the YieldsDiagonal type trait.
Definition YieldsDiagonal.h:126
Compile time check for operations on matrices.
Definition YieldsDiagonal.h:69

◆ YieldsHermitian_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsHermitian_v
Auxiliary variable template for the YieldsHermitian type trait.
Definition YieldsHermitian.h:124
Compile time check for operations on matrices.
Definition YieldsHermitian.h:67

◆ YieldsIdentity_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsIdentity_v
Auxiliary variable template for the YieldsIdentity type trait.
Definition YieldsIdentity.h:126
Compile time check for operations on matrices.
Definition YieldsIdentity.h:69

◆ YieldsLower_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsLower_v
Auxiliary variable template for the YieldsLower type trait.
Definition YieldsLower.h:126
Compile time check for operations on matrices.
Definition YieldsLower.h:69

◆ YieldsStrictlyLower_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsStrictlyLower_v
Auxiliary variable template for the YieldsStrictlyLower type trait.
Definition YieldsStrictlyLower.h:124
Compile time check for operations on matrices.
Definition YieldsStrictlyLower.h:67

◆ YieldsStrictlyTriangular_v

template<typename OP, typename MT, typename... MTs>
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 YieldsStrictlyTriangular_v
Auxiliary variable template for the YieldsStrictlyTriangular type trait.
Definition YieldsStrictlyTriangular.h:127
Compile time check for operations on matrices.
Definition YieldsStrictlyTriangular.h:70

◆ YieldsStrictlyUpper_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsStrictlyUpper_v
Auxiliary variable template for the YieldsStrictlyUpper type trait.
Definition YieldsStrictlyUpper.h:124
Compile time check for operations on matrices.
Definition YieldsStrictlyUpper.h:67

◆ YieldsSymmetric_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsSymmetric_v
Auxiliary variable template for the YieldsSymmetric type trait.
Definition YieldsSymmetric.h:124
Compile time check for operations on matrices.
Definition YieldsSymmetric.h:67

◆ YieldsTriangular_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsTriangular_v
Auxiliary variable template for the YieldsTriangular type trait.
Definition YieldsTriangular.h:127
Compile time check for operations on matrices.
Definition YieldsTriangular.h:70

◆ YieldsUniform_v

template<typename OP, typename T, typename... Ts>
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>;
constexpr bool YieldsUniform_v
Auxiliary variable template for the YieldsUniform type trait.
Definition YieldsUniform.h:125
Compile time check for operations on vectors and matrices.
Definition YieldsUniform.h:68

◆ YieldsUniLower_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsUniLower_v
Auxiliary variable template for the YieldsUniLower type trait.
Definition YieldsUniLower.h:124
Compile time check for operations on matrices.
Definition YieldsUniLower.h:67

◆ YieldsUniTriangular_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsUniTriangular_v
Auxiliary variable template for the YieldsUniTriangular type trait.
Definition YieldsUniTriangular.h:127
Compile time check for operations on matrices.
Definition YieldsUniTriangular.h:70

◆ YieldsUniUpper_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsUniUpper_v
Auxiliary variable template for the YieldsUniUpper type trait.
Definition YieldsUniUpper.h:124
Compile time check for operations on matrices.
Definition YieldsUniUpper.h:67

◆ YieldsUpper_v

template<typename OP, typename MT, typename... MTs>
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>;
constexpr bool YieldsUpper_v
Auxiliary variable template for the YieldsUpper type trait.
Definition YieldsUpper.h:126
Compile time check for operations on matrices.
Definition YieldsUpper.h:69

◆ YieldsZero_v

template<typename OP, typename T, typename... Ts>
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>;
constexpr bool YieldsZero_v
Auxiliary variable template for the YieldsZero type trait.
Definition YieldsZero.h:125
Compile time check for operations on vectors and matrices.
Definition YieldsZero.h:68