Classes | Typedefs | Variables
Type traits

Classes

struct  blaze::AddConst< T >
 Addition of a top level 'const' qualifier.The AddConst type trait adds a top level 'const' qualifier to the given type T. More...
 
struct  blaze::AddCV< T >
 Addition of a top level 'const' and 'volatile' qualifier.The AddCV type trait adds both a top level 'const' and 'volatile' qualifier to the given type T. More...
 
struct  blaze::AddPointer< T >
 Addition of a top level pointer.The AddPointer type trait adds a top level pointer to the given type T. It has the same effect as blaze::RemovePointer<T>::Type*. More...
 
struct  blaze::AddReference< T >
 Addition of a top level reference.In case the given type T is not a reference type, the AddReference type trait adds a top level reference to the given type T. Else the resulting type Type is T. More...
 
struct  blaze::AddVolatile< T >
 Addition of a top level 'volatile' qualifier.The AddVolatile type trait adds a top level 'volatile' qualifier to the given type T. More...
 
struct  blaze::AlignmentOf< T >
 Evaluation of the required alignment of the given data type.The AlignmentOf type trait template evaluates the required alignment for the given data type. For instance, for fundamental data types that can be vectorized via SSE or AVX instructions, the proper alignment is 16 or 32 bytes, respectively. For all other data types, a multiple of the alignment chosen by the compiler is returned. The evaluated alignment can be queried via the nested value member. More...
 
struct  blaze::All< TypeTrait, T1, T2, Ts >
 Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for all given types Ts. If the expression. More...
 
struct  blaze::AlwaysFalse< T >
 Type dependent compile time false.This type trait represents a type dependent compile time false. For all possible types, the value member constant is set to false, the nested type definition Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::AlwaysTrue< T >
 Type dependent compile time true.This type trait represents a type dependent compile time true. For all possible types, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. More...
 
struct  blaze::Any< TypeTrait, T1, T2, Ts >
 Compile time type check.This type trait determines whether the given type trait TypeTrait evaluates to true for at least one of the given types Ts. If the expression. More...
 
struct  blaze::CommonType< T >
 Deduction of a type common to several types.The CommonType type trait deduces the result type of a mixed-mode arithmetic expression between all types T..., that is the type all T... can be implicitly converted to. Note that cv and reference qualifiers are generally ignored. More...
 
struct  blaze::Decay< T >
 Applies the type conversions for by-value function arguments.This type trait applies the type conversions that are used for by-value function arguments. This conversions include lvalue-to-rvalue, array-to-pointer, and function-to-pointer implicit conversions to the type T, and the removal of top level cv-qualifiers. More...
 
struct  blaze::Extent< T, N >
 Compile time check for the size of array bounds.Via this type trait it is possible to query at compile time for the size of a particular array extent. In case the given template argument is an array type with a rank greater than N, the value member constant is set to the number of elements of the N'th array dimension. In all other cases, and especially in case the N'th array dimension is incomplete, value is set to 0. More...
 
struct  blaze::HasSize< T, Size >
 Compile time size check.This class offers the possibility to test the size of a type at compile time. If the type T is exactly Size bytes large, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has1Byte< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly one byte. If the type T has one byte, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has2Bytes< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly two bytes. If the type T has two bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has4Bytes< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::Has8Bytes< T >
 Compile time size check.This type trait offers the possibility to test whether a given type has a size of exactly four bytes. If the type T has four bytes, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives fromTrueType. Otherwise value is set to false, Type is FalseType, and the classderives from FalseType. More...
 
class  blaze::HaveSameSize< T1, T2 >
 Compile time size check.This class offers the possibility to test the size of two types at compile time. If an object of type T1 has the same size as an object of type T2, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsArithmetic< T >
 Compile time check for arithmetic data types.This type trait tests whether or not the given template parameter is a (possibly cv-qualified) arithmetic (integral or floating point) data type. In case the type is an arithmetic type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More...
 
struct  blaze::IsArray< T >
 Compile time type check.The IsArray type trait tests whether or not the given template parameter is an array type. In case the given data type is an array type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More...
 
struct  blaze::IsAssignable< T, U >
 Compile time type check.The IsAssignable type trait tests whether the expression. More...
 
struct  blaze::IsNothrowAssignable< T, U >
 Compile time type check.The IsNothrowAssignable type trait tests whether the expression. More...
 
struct  blaze::IsCopyAssignable< T >
 Compile time type check.The IsCopyAssignable type trait tests whether the expression. More...
 
struct  blaze::IsNothrowCopyAssignable< T >
 Compile time type check.The IsNothrowCopyAssignable type trait tests whether the expression. More...
 
struct  blaze::IsMoveAssignable< T >
 Compile time type check.The IsMoveAssignable type trait tests whether the expression. More...
 
struct  blaze::IsNothrowMoveAssignable< T >
 Compile time type check.The IsNothrowMoveAssignable type trait tests whether the expression. More...
 
class  blaze::IsBaseOf< Base, Derived >
 Compile time analysis of an inheritance relationship.This type trait tests for an inheritance relationship between the two types Base and Derived. If Derived is a type derived from Base or the same type as Base the value member contant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsBoolean< T >
 Compile time check for boolean types.This type trait tests whether or not the given template parameter is of boolean type. In case the type is a boolean (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsBuiltin< T >
 Compile time check for built-in data types.This type trait tests whether or not the given template parameter is a built-in/fundamental data type. In case the type is a built-in type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsCharacter< T >
 Compile time check for character types.This type trait tests whether or not the given template parameter is a character type (i.e., either char, signed char, unsigned char, or wchar_t, possibly cv-qualified). In case the type is a character type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsClass< T >
 Compile time type check.The IsClass type trait tests whether or not the given template parameter is a (possibly cv-qualified) class type. In case the given data type is a class type, the value member constant is set to true, the nested type definition Type is set to TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType and the class derives from FalseType. More...
 
struct  blaze::IsComplex< T >
 Compile time check for complex types.This type trait tests whether or not the given template parameter is a complex data type. In case the type is a complex data type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsComplexDouble< T >
 Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<double>. In case the type is complex<double> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsComplexFloat< T >
 Compile time check for single precision complex types.This type trait tests whether or not the given template parameter is of type complex<float>. In case the type is complex<float> (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsConst< T >
 Compile time check for constant data types.The IsConst type trait tests whether or not the given template parameter is a (top level) const-qualified data type. In case the given data type is const-qualified, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsConstructible< T, Args >
 Compile time type check.The IsConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowConstructible< T, Args >
 Compile time type check.The IsNothrowConstructible type trait tests whether the expression. More...
 
struct  blaze::IsDefaultConstructible< T >
 Compile time type check.The IsDefaultConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowDefaultConstructible< T >
 Compile time type check.The IsNothrowDefaultConstructible type trait tests whether the expression. More...
 
struct  blaze::IsCopyConstructible< T >
 Compile time type check.The IsCopyConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowCopyConstructible< T >
 Compile time type check.The IsNothrowCopyConstructible type trait tests whether the expression. More...
 
struct  blaze::IsMoveConstructible< T >
 Compile time type check.The IsMoveConstructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowMoveConstructible< T >
 Compile time type check.The IsNothrowMoveConstructible type trait tests whether the expression. More...
 
struct  blaze::IsConvertible< From, To >
 Compile time pointer relationship constraint.This type traits tests whether the first given template argument can be converted to the second template argument via copy construction. If the first argument can be converted to the second argument, the value member constnt is set to true, the nested type definition type is TrueType, and the class derives from TrueType. Otherwise value is set to false, type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsDestructible< T >
 Compile time type check.The IsDestructible type trait tests whether the expression. More...
 
struct  blaze::IsNothrowDestructible< T >
 Compile time type check.The IsDestructible type trait tests whether the expression. More...
 
struct  blaze::IsDouble< T >
 Compile time check for double precision floating point types.This type trait tests whether or not the given template parameter is of double type. In case the type is double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsEmpty< T >
 Compile time type check.This class tests whether the given template parameter is an empty class type, i.e. a type without member data and virtual functions. If it is an empty class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsEnum< T >
 Compile time check for complete enumeration types.This type trait tests whether or not the given template parameter is an enumeration type. In case the type is an enumeration type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsFloat< T >
 Compile time check for single precision floating point types.This type trait tests whether or not the given template parameter is of float type. In case the type is float (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsFloatingPoint< T >
 Compile time check for floating point data types.This type trait tests whether or not the given template parameter is a floating point data type (ignoring the cv-qualifiers). In case the type is a floating point data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsInteger< T >
 Compile time check for integer types.This type trait tests whether or not the given template parameter is an integer type (i.e., either (signed) int or unsigned int, possibly cv-qualified). In case the type is an integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsIntegral< T >
 Compile time check for integral data types.This type trait tests whether or not the given template parameter is an integral data type. In case the type is an integral data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsLong< T >
 Compile time check for long integer types.This type trait tests whether or not the given template parameter is a long integer type (i.e., either (signed) long or unsigned long, possibly cv-qualified). In case the type is a long integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsLongDouble< T >
 Compile time check for extended precision floating point types.This type trait tests whether or not the given template parameter is of long double type. In case the type is long double (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsLValueReference< T >
 Compile time type check.This class tests whether the given template parameter T is an lvalue reference type. If it is an lvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsNumeric< T >
 Compile time check for numeric types.This type trait tests whether or not the given template parameter is a numeric data type. Blaze considers all integral (except bool), floating point, and complex data types as numeric data types. In case the type is a numeric type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsObject< T >
 Compile time type check.This class tests whether the given template parameter T is an object type. All types are considered object types except references, void, and function types. If T is an object type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsPod< T >
 Compile time check for pod data types.This type trait tests whether or not the given template parameter is a POD (Plain Old Data). In case the type is a POD, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsPointer< T >
 Compile time type check.This class tests whether the given template parameter is a pointer type (including function pointers, but excluding pointers to members) or not. If it is a pointer type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsReference< T >
 Compile time type check.This class tests whether the given template parameter T is a reference type (including references to functions). If it is a reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsRValueReference< T >
 Compile time type check.This class tests whether the given template parameter T is an rvalue reference type. If it is an rvalue reference type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsStrictlySame< A, B >
 Compile time type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are not ignored. If A and B are the same data type, then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSame< A, B >
 Type relationship analysis.This class tests if the two data types A and B are equal. For this type comparison, the cv-qualifiers of both data types are ignored. If A and B are the same data type (ignoring the cv-qualifiers), then the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsShort< T >
 Compile time check for short integer types.This type trait tests whether or not the given template parameter is a short integer type (i.e., either (signed) short or unsigned short, possibly cv-qualified). In case the type is a short integer type (ignoring the cv-qualifiers), the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsSigned< T >
 Compile time check for signed data types.This type trait tests whether or not the given template parameter is a signed integral or a floating point data type. In case the type is a signed (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUnion< T >
 Compile time check for union data types.This type trait tests whether or not the given template parameter is a union data type. In case the type is a union, the value member constant is set o true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsUnsigned< T >
 Compile time check for unsigned data types.This type trait tests whether or not the given template parameter is an unsigned, integral data type. In case the type is an unsigned (possibly cv-qualified) data type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsValid< T >
 Compile time type check.This class tests whether the given template parameter is a valid or invalid data type (i.e. if the type is the INVALID_TYPE). If T is not the INVALID_TYPE class type, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVectorizable< T >
 Compile time check for vectorizable types.Depending on the available instruction set (SSE, SSE2, SSE3, SSE4, AVX, AVX2, MIC, ...), this type trait tests whether or not the given template parameter is a vectorizable type, i.e. a type for which intrinsic vector operations and optimizations can be used. Currently, all built-in data types except bool and the according complex numbers are considered to be vectorizable types. In case the type is vectorizable, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVoid< T >
 Compile time check for the void data type.This type trait tests whether or not the given template parameter is of type void (ignoring the cv-qualifiers). In case the type is of type void, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::IsVolatile< T >
 Compile time check for volatile data types.The IsVolatile type trait tests whether or not the given template parameter is a (top level) volatile-qualified data type. In case the given data type is volatile, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType. More...
 
struct  blaze::MakeSigned< T >
 Compile time type conversion into a signed integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding signed integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created. More...
 
struct  blaze::MakeUnsigned< T >
 Compile time type conversion into an unsigned integral type.This type trait provides the feature to convert the given integral or constant type T to the corresponding unsigned integral data type with the same size and with the same cv-qualifiers. Note that in case T is bool or a non-integral data type, a compilation error is created. More...
 
struct  blaze::Rank< T >
 Compile time check for array ranks.This type trait determines the rank of the given template argument. In case the given type is an array type, the nested value member constant is set to the number of dimensions of T. Otherwise value is set to 0. More...
 
struct  blaze::RemoveAllExtents< T >
 Removal of all array extents.The RemoveAllExtents type trait removes all array extents from the given type T. More...
 
struct  blaze::RemoveConst< T >
 Removal of const-qualifiers.The RemoveConst type trait removes all top level 'const' qualifiers from the given type T. More...
 
struct  blaze::RemoveCV< T >
 Removal of top level cv-qualifiers.The RemoveCV type trait removes all top level cv-qualifiers from the given type T. More...
 
struct  blaze::RemoveExtent< T >
 Removal of the top level array extent.The RemoveExtent type trait removes the top level array extent from the given type T. More...
 
struct  blaze::RemovePointer< T >
 Removal of pointer modifiers.The RemovePointer type trait removes any pointer modifiers from the given type T. More...
 
struct  blaze::RemoveReference< T >
 Removal of reference modifiers.The RemoveReference type trait removes any reference modifiers from the given type T. More...
 
struct  blaze::RemoveVolatile< T >
 Removal of volatile-qualifiers.The RemoveVolatile type trait removes all top level 'volatile' qualifiers from the given type T. More...
 

Typedefs

template<typename T1 , typename T2 >
using blaze::HighType_t = typename HighType< T1, T2 >::Type
 Auxiliary alias declaration for the HighType type trait.The HighType_t alias declaration provides a convenient shortcut to access the nested Type of the HighType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T1 , typename T2 >
using blaze::LowType_t = typename LowType< T1, T2 >::Type
 Auxiliary alias declaration for the LowType type trait.The LowType_t alias declaration provides a convenient shortcut to access the nested Type of the LowType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveAdaptor_t = typename RemoveAdaptor< T >::Type
 Auxiliary alias declaration for the RemoveAdaptor type trait.The RemoveAdaptor_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveAdaptor class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::UnderlyingBuiltin_t = typename UnderlyingBuiltin< T >::Type
 Auxiliary alias declaration for the UnderlyingBuiltin type trait.The UnderlyingBuiltin_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingBuiltin class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::UnderlyingElement_t = typename UnderlyingElement< T >::Type
 Auxiliary alias declaration for the UnderlyingElement type trait.The UnderlyingElement_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingElement class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::UnderlyingNumeric_t = typename UnderlyingNumeric< T >::Type
 Auxiliary alias declaration for the UnderlyingNumeric type trait.The UnderlyingNumeric_t alias declaration provides a convenient shortcut to access the nested Type of the UnderlyingNumeric class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename TL , typename T >
using blaze::Append_t = typename Append< TL, T >::Type
 Auxiliary alias declaration for the Append class template.The Append_t alias declaration provides a convenient shortcut to access the nested Type of the Append class template. For instance, given the type list TL and the type T the following two type definitions are identical: More...
 
template<typename TL , typename T >
using blaze::Erase_t = typename Erase< TL, T >::Type
 Auxiliary alias declaration for the Erase class template.The Erase_t alias declaration provides a convenient shortcut to access the nested Type of the Erase class template. For instance, given the type list TL and the type T the following two type definitions are identical: More...
 
template<typename TL , typename T >
using blaze::EraseAll_t = typename EraseAll< TL, T >::Type
 Auxiliary alias declaration for the EraseAll class template.The EraseAll_t alias declaration provides a convenient shortcut to access the nested Type of the EraseAll class template. For instance, given the type list TL and the type T the following two type definitions are identical: More...
 
template<typename TL , size_t Index>
using blaze::TypeAt_t = typename TypeAt< TL, Index >::Type
 Auxiliary alias declaration for the TypeAt class template.The TypeAt_t alias declaration provides a convenient shortcut to access the nested Type of the TypeAt class template. For instance, given the type list TL and the index Index the following two type definitions are identical: More...
 
template<typename TL >
using blaze::Unique_t = typename Unique< TL >::Type
 Auxiliary alias declaration for the Unique class template.The Unique_t alias declaration provides a convenient shortcut to access the nested Type of the Unique class template. For instance, given the type list TL the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddConst_t = typename AddConst< T >::Type
 Auxiliary alias declaration for the AddConst type trait.The AddConst_t alias declaration provides a convenient shortcut to access the nested Type of the AddConst class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddCV_t = typename AddCV< T >::Type
 Auxiliary alias declaration for the AddCV type trait.The AddCV_t alias declaration provides a convenient shortcut to access the nested Type of the AddCV class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddPointer_t = typename AddPointer< T >::Type
 Auxiliary alias declaration for the AddPointer type trait.The AddPointer_t alias declaration provides a convenient shortcut to access the nested Type of the AddPointer class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddReference_t = typename AddReference< T >::Type
 Auxiliary alias declaration for the AddReference type trait.The AddReference_t alias declaration provides a convenient shortcut to access the nested Type of the AddReference class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::AddVolatile_t = typename AddVolatile< T >::Type
 Auxiliary alias declaration for the AddVolatile type trait.The AddVolatile_t alias declaration provides a convenient shortcut to access the nested Type of the AddVolatile class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename... T>
using blaze::CommonType_t = typename CommonType< T... >::Type
 Auxiliary alias declaration for the CommonType type trait.The CommonType_t alias declaration provides a convenient shortcut to access the nested Type of the CommonType class template. For instance, given the types T1 and T2 the following two type definitions are identical: More...
 
template<typename T >
using blaze::Decay_t = typename Decay< T >::Type
 Auxiliary alias declaration for the Decay type trait.The Decay_t alias declaration provides a convenient shortcut to access the nested Type of the Decay class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::MakeSigned_t = typename MakeSigned< T >::Type
 Auxiliary alias declaration for the MakeSigned type trait.The MakeSigned_t alias declaration provides a convenient shortcut to access the nested Type of the MakeSigned class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::MakeUnsigned_t = typename MakeUnsigned< T >::Type
 Auxiliary alias declaration for the MakeUnsigned type trait.The MakeUnsigned_t alias declaration provides a convenient shortcut to access the nested Type of the MakeUnsigned class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveAllExtents_t = typename RemoveAllExtents< T >::Type
 Auxiliary alias declaration for the RemoveAllExtents type trait.The RemoveAllExtents_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveAllExtents class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveConst_t = typename RemoveConst< T >::Type
 Auxiliary alias declaration for the RemoveConst type trait.The RemoveConst_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveConst class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveCV_t = typename RemoveCV< T >::Type
 Auxiliary alias declaration for the RemoveCV type trait.The RemoveCV_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveCV class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveExtent_t = typename RemoveExtent< T >::Type
 Auxiliary alias declaration for the RemoveExtent type trait.The RemoveExtent_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveExtent class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemovePointer_t = typename RemovePointer< T >::Type
 Auxiliary alias declaration for the RemovePointer type trait.The RemovePointer_t alias declaration provides a convenient shortcut to access the nested Type of the RemovePointer class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveReference_t = typename RemoveReference< T >::Type
 Auxiliary alias declaration for the RemoveReference type trait.The RemoveReference_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveReference class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename T >
using blaze::RemoveVolatile_t = typename RemoveVolatile< T >::Type
 Auxiliary alias declaration for the RemoveVolatile type trait.The RemoveVolatile_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveVolatile class template. For instance, given the type T the following two type definitions are identical: More...
 
template<typename... Ts>
using blaze::Void_t = void
 Compile time type check.This type trait maps an arbitrary sequence of types to the type void. It can for instance be used to determine the validity of an expression: More...
 

Variables

template<typename T >
constexpr bool blaze::HasAbs_v = HasAbs<T>::value
 Auxiliary variable template for the HasAbs type trait.The HasAbs_v variable template provides a convenient shortcut to access the nested value of the HasAbs class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasAcos_v = HasAcos<T>::value
 Auxiliary variable template for the HasAcos type trait.The HasAcos_v variable template provides a convenient shortcut to access the nested value of the HasAcos class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasAcosh_v = HasAcosh<T>::value
 Auxiliary variable template for the HasAcosh type trait.The HasAcosh_v variable template provides a convenient shortcut to access the nested value of the HasAcosh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasAdd_v = HasAdd<T1,T2>::value
 Auxiliary variable template for the HasAdd type trait.The HasAdd_v variable template provides a convenient shortcut to access the nested value of the HasAdd class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasAsin_v = HasAsin<T>::value
 Auxiliary variable template for the HasAsin type trait.The HasAsin_v variable template provides a convenient shortcut to access the nested value of the HasAsin class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasAsinh_v = HasAsinh<T>::value
 Auxiliary variable template for the HasAsinh type trait.The HasAsinh_v variable template provides a convenient shortcut to access the nested value of the HasAsinh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasAtan_v = HasAtan<T>::value
 Auxiliary variable template for the HasAtan type trait.The HasAtan_v variable template provides a convenient shortcut to access the nested value of the HasAtan class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasAtan2_v = HasAtan2<T1,T2>::value
 Auxiliary variable template for the HasAtan2 type trait.The HasAtan2_v variable template provides a convenient shortcut to access the nested value of the HasAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasAtanh_v = HasAtanh<T>::value
 Auxiliary variable template for the HasAtanh type trait.The HasAtanh_v variable template provides a convenient shortcut to access the nested value of the HasAtanh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasCbrt_v = HasCbrt<T>::value
 Auxiliary variable template for the HasCbrt type trait.The HasCbrt_v variable template provides a convenient shortcut to access the nested value of the HasCbrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasCeil_v = HasCeil<T>::value
 Auxiliary variable template for the HasCeil type trait.The HasCeil_v variable template provides a convenient shortcut to access the nested value of the HasCeil class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasClamp_v = HasClamp<T>::value
 Auxiliary variable template for the HasClamp type trait.The HasClamp_v variable template provides a convenient shortcut to access the nested value of the HasClamp class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasConj_v = HasConj<T>::value
 Auxiliary variable template for the HasConj type trait.The HasConj_v variable template provides a convenient shortcut to access the nested value of the HasConj class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasConstDataAccess_v = HasConstDataAccess<T>::value
 Auxiliary variable template for the HasConstDataAccess type trait.The HasConstDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasConstDataAccess class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasCos_v = HasCos<T>::value
 Auxiliary variable template for the HasCos type trait.The HasCos_v variable template provides a convenient shortcut to access the nested value of the HasCos class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasCosh_v = HasCosh<T>::value
 Auxiliary variable template for the HasCosh type trait.The HasCosh_v variable template provides a convenient shortcut to access the nested value of the HasCosh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasDiv_v = HasDiv<T1,T2>::value
 Auxiliary variable template for the HasDiv type trait.The HasDiv_v variable template provides a convenient shortcut to access the nested value of the HasDiv class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasErf_v = HasErf<T>::value
 Auxiliary variable template for the HasErf type trait.The HasErf_v variable template provides a convenient shortcut to access the nested value of the HasErf class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasErfc_v = HasErfc<T>::value
 Auxiliary variable template for the HasErfc type trait.The HasErfc_v variable template provides a convenient shortcut to access the nested value of the HasErfc class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasExp_v = HasExp<T>::value
 Auxiliary variable template for the HasExp type trait.The HasExp_v variable template provides a convenient shortcut to access the nested value of the HasExp class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasExp10_v = HasExp10<T>::value
 Auxiliary variable template for the HasExp10 type trait.The HasExp10_v variable template provides a convenient shortcut to access the nested value of the HasExp10 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasExp2_v = HasExp2<T>::value
 Auxiliary variable template for the HasExp2 type trait.The HasExp2_v variable template provides a convenient shortcut to access the nested value of the HasExp2 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasFloor_v = HasFloor<T>::value
 Auxiliary variable template for the HasFloor type trait.The HasFloor_v variable template provides a convenient shortcut to access the nested value of the HasFloor class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasHypot_v = HasHypot<T1,T2>::value
 Auxiliary variable template for the HasHypot type trait.The HasHypot_v variable template provides a convenient shortcut to access the nested value of the HasHypot class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasImag_v = HasImag<T>::value
 Auxiliary variable template for the HasImag type trait.The HasImag_v variable template provides a convenient shortcut to access the nested value of the HasImag class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasInvCbrt_v = HasInvCbrt<T>::value
 Auxiliary variable template for the HasInvCbrt type trait.The HasInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasInvCbrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasInvSqrt_v = HasInvSqrt<T>::value
 Auxiliary variable template for the HasInvSqrt type trait.The HasInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasInvSqrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasLog_v = HasLog<T>::value
 Auxiliary variable template for the HasLog type trait.The HasLog_v variable template provides a convenient shortcut to access the nested value of the HasLog class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasLog10_v = HasLog10<T>::value
 Auxiliary variable template for the HasLog10 type trait.The HasLog10_v variable template provides a convenient shortcut to access the nested value of the HasLog10 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasLog2_v = HasLog2<T>::value
 Auxiliary variable template for the HasLog2 type trait.The HasLog2_v variable template provides a convenient shortcut to access the nested value of the HasLog2 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasMax_v = HasMax<T1,T2>::value
 Auxiliary variable template for the HasMax type trait.The HasMax_v variable template provides a convenient shortcut to access the nested value of the HasMax class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasMin_v = HasMin<T1,T2>::value
 Auxiliary variable template for the HasMin type trait.The HasMin_v variable template provides a convenient shortcut to access the nested value of the HasMin class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasMult_v = HasMult<T1,T2>::value
 Auxiliary variable template for the HasMult type trait.The HasMult_v variable template provides a convenient shortcut to access the nested value of the HasMult class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasMutableDataAccess_v = HasMutableDataAccess<T>::value
 Auxiliary variable template for the HasMutableDataAccess type trait.The HasMutableDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasMutableDataAccess class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasPow_v = HasPow<T1,T2>::value
 Auxiliary variable template for the HasPow type trait.The HasPow_v variable template provides a convenient shortcut to access the nested value of the HasPow class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasReal_v = HasReal<T>::value
 Auxiliary variable template for the HasReal type trait.The HasReal_v variable template provides a convenient shortcut to access the nested value of the HasReal class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasRound_v = HasRound<T>::value
 Auxiliary variable template for the HasRound type trait.The HasRound_v variable template provides a convenient shortcut to access the nested value of the HasRound class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSign_v = HasSign<T>::value
 Auxiliary variable template for the HasSign type trait.The HasSign_v variable template provides a convenient shortcut to access the nested value of the HasSign class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDAbs_v = HasSIMDAbs<T>::value
 Auxiliary variable template for the HasSIMDAbs type trait.The HasSIMDAbs_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAbs class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDAcos_v = HasSIMDAcos<T>::value
 Auxiliary variable template for the HasSIMDAcos type trait.The HasSIMDAcos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcos class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDAcosh_v = HasSIMDAcosh<T>::value
 Auxiliary variable template for the HasSIMDAcosh type trait.The HasSIMDAcosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcosh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDAdd_v = HasSIMDAdd<T1,T2>::value
 Auxiliary variable template for the HasSIMDAdd type trait.The HasSIMDAdd_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAdd class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDAsin_v = HasSIMDAsin<T>::value
 Auxiliary variable template for the HasSIMDAsin type trait.The HasSIMDAsin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsin class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDAsinh_v = HasSIMDAsinh<T>::value
 Auxiliary variable template for the HasSIMDAsinh type trait.The HasSIMDAsinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsinh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDAtan_v = HasSIMDAtan<T>::value
 Auxiliary variable template for the HasSIMDAtan type trait.The HasSIMDAtan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDAtan2_v = HasSIMDAtan2<T1,T2>::value
 Auxiliary variable template for the HasSIMDAtan2 type trait.The HasSIMDAtan2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDAtanh_v = HasSIMDAtanh<T>::value
 Auxiliary variable template for the HasSIMDAtanh type trait.The HasSIMDAtanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtanh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDCbrt_v = HasSIMDCbrt<T>::value
 Auxiliary variable template for the HasSIMDCbrt type trait.The HasSIMDCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCbrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDCeil_v = HasSIMDCeil<T>::value
 Auxiliary variable template for the HasSIMDCeil type trait.The HasSIMDCeil_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCeil class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDConj_v = HasSIMDConj<T>::value
 Auxiliary variable template for the HasSIMDConj type trait.The HasSIMDConj_v variable template provides a convenient shortcut to access the nested value of the HasSIMDConj class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDCos_v = HasSIMDCos<T>::value
 Auxiliary variable template for the HasSIMDCos type trait.The HasSIMDCos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCos class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDCosh_v = HasSIMDCosh<T>::value
 Auxiliary variable template for the HasSIMDCosh type trait.The HasSIMDCosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCosh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDDiv_v = HasSIMDDiv<T1,T2>::value
 Auxiliary variable template for the HasSIMDDiv type trait.The HasSIMDDiv_v variable template provides a convenient shortcut to access the nested value of the HasSIMDDiv class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDEqual_v = HasSIMDEqual<T1,T2>::value
 Auxiliary variable template for the HasSIMDEqual type trait.The HasSIMDEqual_v variable template provides a convenient shortcut to access the nested value of the HasSIMDEqual class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDErf_v = HasSIMDErf<T>::value
 Auxiliary variable template for the HasSIMDErf type trait.The HasSIMDErf_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErf class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDErfc_v = HasSIMDErfc<T>::value
 Auxiliary variable template for the HasSIMDErfc type trait.The HasSIMDErfc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErfc class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDExp_v = HasSIMDExp<T>::value
 Auxiliary variable template for the HasSIMDExp type trait.The HasSIMDExp_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDExp10_v = HasSIMDExp10<T>::value
 Auxiliary variable template for the HasSIMDExp10 type trait.The HasSIMDExp10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp10 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDExp2_v = HasSIMDExp2<T>::value
 Auxiliary variable template for the HasSIMDExp2 type trait.The HasSIMDExp2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp2 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDFloor_v = HasSIMDFloor<T>::value
 Auxiliary variable template for the HasSIMDFloor type trait.The HasSIMDFloor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDFloor class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDHypot_v = HasSIMDHypot<T1,T2>::value
 Auxiliary variable template for the HasSIMDHypot type trait.The HasSIMDHypot_v variable template provides a convenient shortcut to access the nested value of the HasSIMDHypot class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDInvCbrt_v = HasSIMDInvCbrt<T>::value
 Auxiliary variable template for the HasSIMDInvCbrt type trait.The HasSIMDInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvCbrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDInvSqrt_v = HasSIMDInvSqrt<T>::value
 Auxiliary variable template for the HasSIMDInvSqrt type trait.The HasSIMDInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvSqrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDLog_v = HasSIMDLog<T>::value
 Auxiliary variable template for the HasSIMDLog type trait.The HasSIMDLog_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDLog10_v = HasSIMDLog10<T>::value
 Auxiliary variable template for the HasSIMDLog10 type trait.The HasSIMDLog10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog10 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDLog2_v = HasSIMDLog2<T>::value
 Auxiliary variable template for the HasSIMDLog2 type trait.The HasSIMDLog2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog2 class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMax_v = HasSIMDMax<T1,T2>::value
 Auxiliary variable template for the HasSIMDMax type trait.The HasSIMDMax_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMax class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMin_v = HasSIMDMin<T1,T2>::value
 Auxiliary variable template for the HasSIMDMin type trait.The HasSIMDMin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMin class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDMult_v = HasSIMDMult<T1,T2>::value
 Auxiliary variable template for the HasSIMDMult type trait.The HasSIMDMult_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMult class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDPow_v = HasSIMDPow<T1,T2>::value
 Auxiliary variable template for the HasSIMDPow type trait.The HasSIMDPow_v variable template provides a convenient shortcut to access the nested value of the HasSIMDPow class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDRound_v = HasSIMDRound<T>::value
 Auxiliary variable template for the HasSIMDRound type trait.The HasSIMDRound_v variable template provides a convenient shortcut to access the nested value of the HasSIMDRound class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDSign_v = HasSIMDSign<T>::value
 Auxiliary variable template for the HasSIMDSign type trait.The HasSIMDSign_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSign class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDSin_v = HasSIMDSin<T>::value
 Auxiliary variable template for the HasSIMDSin type trait.The HasSIMDSin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSin class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDSinh_v = HasSIMDSinh<T>::value
 Auxiliary variable template for the HasSIMDSinh type trait.The HasSIMDSinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSinh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDSqrt_v = HasSIMDSqrt<T>::value
 Auxiliary variable template for the HasSIMDSqrt type trait.The HasSIMDSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSqrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSIMDSub_v = HasSIMDSub<T1,T2>::value
 Auxiliary variable template for the HasSIMDSub type trait.The HasSIMDSub_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSub class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDTan_v = HasSIMDTan<T>::value
 Auxiliary variable template for the HasSIMDTan type trait.The HasSIMDTan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTan class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDTanh_v = HasSIMDTanh<T>::value
 Auxiliary variable template for the HasSIMDTanh type trait.The HasSIMDTanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTanh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSIMDTrunc_v = HasSIMDTrunc<T>::value
 Auxiliary variable template for the HasSIMDTrunc type trait.The HasSIMDTrunc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTrunc class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSin_v = HasSin<T>::value
 Auxiliary variable template for the HasSin type trait.The HasSin_v variable template provides a convenient shortcut to access the nested value of the HasSin class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSinh_v = HasSinh<T>::value
 Auxiliary variable template for the HasSinh type trait.The HasSinh_v variable template provides a convenient shortcut to access the nested value of the HasSinh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasSqrt_v = HasSqrt<T>::value
 Auxiliary variable template for the HasSqrt type trait.The HasSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSqrt class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasSub_v = HasSub<T1,T2>::value
 Auxiliary variable template for the HasSub type trait.The HasSub_v variable template provides a convenient shortcut to access the nested value of the HasSub class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasTan_v = HasTan<T>::value
 Auxiliary variable template for the HasTan type trait.The HasTan_v variable template provides a convenient shortcut to access the nested value of the HasTan class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasTanh_v = HasTanh<T>::value
 Auxiliary variable template for the HasTanh type trait.The HasTanh_v variable template provides a convenient shortcut to access the nested value of the HasTanh class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::HasTrunc_v = HasTrunc<T>::value
 Auxiliary variable template for the HasTrunc type trait.The HasTrunc_v variable template provides a convenient shortcut to access the nested value of the HasTrunc class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsAdaptor_v = IsAdaptor<T>::value
 Auxiliary variable template for the IsAdaptor type trait.The IsAdaptor_v variable template provides a convenient shortcut to access the nested value of the IsAdaptor class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsAddExpr_v = IsAddExpr<T>::value
 Auxiliary variable template for the IsAddExpr type trait.The IsAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsAddExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsAligned_v = IsAligned<T>::value
 Auxiliary variable template for the IsAligned type trait.The IsAligned_v variable template provides a convenient shortcut to access the nested value of the IsAligned class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsBand_v = IsBand<T>::value
 Auxiliary variable template for the IsBand type trait.The IsBand_v variable template provides a convenient shortcut to access the nested value of the IsBand class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsBinaryMapExpr_v = IsBinaryMapExpr<T>::value
 Auxiliary variable template for the IsBinaryMapExpr type trait.The IsBinaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsBinaryMapExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsBLASCompatible_v = IsBLASCompatible<T>::value
 Auxiliary variable template for the IsBLASCompatible type trait.The IsBLASCompatible_v variable template provides a convenient shortcut to access the nested value of the IsBLASCompatible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsColumn_v = IsColumn<T>::value
 Auxiliary variable template for the IsColumn type trait.The IsColumn_v variable template provides a convenient shortcut to access the nested value of the IsColumn class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsColumnMajorMatrix_v = IsColumnMajorMatrix<T>::value
 Auxiliary variable template for the IsColumnMajorMatrix type trait.The IsColumnMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsColumnMajorMatrix class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsColumns_v = IsColumns<T>::value
 Auxiliary variable template for the IsColumns type trait.The IsColumns_v variable template provides a convenient shortcut to access the nested value of the IsColumns class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsColumnVector_v = IsColumnVector<T>::value
 Auxiliary variable template for the IsColumnVector type trait.The IsColumnVector_v variable template provides a convenient shortcut to access the nested value of the IsColumnVector class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::IsCommutative_v = IsCommutative<T1,T2>::value
 Auxiliary variable template for the IsCommutative type trait.The IsCommutative_v variable template provides a convenient shortcut to access the nested value of the IsCommutative class template. For instance, given the type1 T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsComputation_v = IsComputation<T>::value
 Auxiliary variable template for the IsComputation type trait.The IsComputation_v variable template provides a convenient shortcut to access the nested value of the IsComputation class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsContiguous_v = IsContiguous<T>::value
 Auxiliary variable template for the IsContiguous type trait.The IsContiguous_v variable template provides a convenient shortcut to access the nested value of the IsContiguous class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsCrossExpr_v = IsCrossExpr<T>::value
 Auxiliary variable template for the IsCrossExpr type trait.The IsCrossExpr_v variable template provides a convenient shortcut to access the nested value of the IsCrossExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsCustom_v = IsCustom<T>::value
 Auxiliary variable template for the IsCustom type trait.The IsCustom_v variable template provides a convenient shortcut to access the nested value of the IsCustom class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDeclaration_v = IsDeclaration<T>::value
 Auxiliary variable template for the IsDeclaration type trait.The IsDeclaration_v variable template provides a convenient shortcut to access the nested value of the IsDeclaration class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDeclDiagExpr_v = IsDeclDiagExpr<T>::value
 Auxiliary variable template for the IsDeclDiagExpr type trait.The IsDeclDiagExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclDiagExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDeclExpr_v = IsDeclExpr<T>::value
 Auxiliary variable template for the IsDeclExpr type trait.The IsDeclExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDeclHermExpr_v = IsDeclHermExpr<T>::value
 Auxiliary variable template for the IsDeclHermExpr type trait.The IsDeclHermExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclHermExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDeclLowExpr_v = IsDeclLowExpr<T>::value
 Auxiliary variable template for the IsDeclLowExpr type trait.The IsDeclLowExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclLowExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDeclSymExpr_v = IsDeclSymExpr<T>::value
 Auxiliary variable template for the IsDeclSymExpr type trait.The IsDeclSymExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclSymExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDeclUppExpr_v = IsDeclUppExpr<T>::value
 Auxiliary variable template for the IsDeclUppExpr type trait.The IsDeclUppExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclUppExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDenseMatrix_v = IsDenseMatrix<T>::value
 Auxiliary variable template for the IsDenseMatrix type trait.The IsDenseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsDenseMatrix class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDenseVector_v = IsDenseVector<T>::value
 Auxiliary variable template for the IsDenseVector type trait.The IsDenseVector_v variable template provides a convenient shortcut to access the nested value of the IsDenseVector class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDiagonal_v = IsDiagonal<T>::value
 Auxiliary variable template for the IsDiagonal type trait.The IsDiagonal_v variable template provides a convenient shortcut to access the nested value of the IsDiagonal class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDivExpr_v = IsDivExpr<T>::value
 Auxiliary variable template for the IsDivExpr type trait.The IsDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsDivExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsElements_v = IsElements<T>::value
 Auxiliary variable template for the IsElements type trait.The IsElements_v variable template provides a convenient shortcut to access the nested value of the IsElements class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsEvalExpr_v = IsEvalExpr<T>::value
 Auxiliary variable template for the IsEvalExpr type trait.The IsEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsEvalExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsExpandExpr_v = IsExpandExpr<T>::value
 Auxiliary variable template for the IsExpandExpr type trait.The IsExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsExpandExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsExpression_v = IsExpression<T>::value
 Auxiliary variable template for the IsExpression type trait.The IsExpression_v variable template provides a convenient shortcut to access the nested value of the IsExpression class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsGeneral_v = IsGeneral<T>::value
 Auxiliary variable template for the IsGeneral type trait.The IsGeneral_v variable template provides a convenient shortcut to access the nested value of the IsGeneral class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsHermitian_v = IsHermitian<T>::value
 Auxiliary variable template for the IsHermitian type trait.The IsHermitian_v variable template provides a convenient shortcut to access the nested value of the IsHermitian class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsIdentity_v = IsIdentity<T>::value
 Auxiliary variable template for the IsIdentity type trait.The IsIdentity_v variable template provides a convenient shortcut to access the nested value of the IsIdentity class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsInitializer_v = IsInitializer<T>::value
 Auxiliary variable template for the IsInitializer type trait.The IsInitializer_v variable template provides a convenient shortcut to access the nested value of the IsInitializer class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsInvertible_v = IsInvertible<T>::value
 Auxiliary variable template for the IsInvertible type trait.The IsInvertible_v variable template provides a convenient shortcut to access the nested value of the IsInvertible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsLower_v = IsLower<T>::value
 Auxiliary variable template for the IsLower type trait.The IsLower_v variable template provides a convenient shortcut to access the nested value of the IsLower class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatEvalExpr_v = IsMatEvalExpr<T>::value
 Auxiliary variable template for the IsMatEvalExpr type trait.The IsMatEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatEvalExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatInvExpr_v = IsMatInvExpr<T>::value
 Auxiliary variable template for the IsMatInvExpr type trait.The IsMatInvExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatInvExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatMapExpr_v = IsMatMapExpr<T>::value
 Auxiliary variable template for the IsMatMapExpr type trait.The IsMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMapExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatMatAddExpr_v = IsMatMatAddExpr<T>::value
 Auxiliary variable template for the IsMatMatAddExpr type trait.The IsMatMatAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatAddExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatMatMapExpr_v = IsMatMatMapExpr<T>::value
 Auxiliary variable template for the IsMatMatMapExpr type trait.The IsMatMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMapExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatMatMultExpr_v = IsMatMatMultExpr<T>::value
 Auxiliary variable template for the IsMatMatMultExpr type trait.The IsMatMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatMatSubExpr_v = IsMatMatSubExpr<T>::value
 Auxiliary variable template for the IsMatMatSubExpr type trait.The IsMatMatSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatSubExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatReduceExpr_v = IsMatReduceExpr<T>::value
 Auxiliary variable template for the IsMatReduceExpr type trait.The IsMatReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatReduceExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatrix_v = IsMatrix<T>::value
 Auxiliary variable template for the IsMatrix type trait.The IsMatrix_v variable template provides a convenient shortcut to access the nested value of the IsMatrix class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatScalarDivExpr_v = IsMatScalarDivExpr<T>::value
 Auxiliary variable template for the IsMatScalarDivExpr type trait.The IsMatScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarDivExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatScalarMultExpr_v = IsMatScalarMultExpr<T>::value
 Auxiliary variable template for the IsMatScalarMultExpr type trait.The IsMatScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatSerialExpr_v = IsMatSerialExpr<T>::value
 Auxiliary variable template for the IsMatSerialExpr type trait.The IsMatSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatSerialExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatTransExpr_v = IsMatTransExpr<T>::value
 Auxiliary variable template for the IsMatTransExpr type trait.The IsMatTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatTransExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMatVecMultExpr_v = IsMatVecMultExpr<T>::value
 Auxiliary variable template for the IsMatVecMultExpr type trait.The IsMatVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatVecMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMultExpr_v = IsMultExpr<T>::value
 Auxiliary variable template for the IsMultExpr type trait.The IsMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNumericMatrix_v = IsNumericMatrix<T>::value
 Auxiliary variable template for the IsNumericMatrix type trait.The IsNumericMatrix_v variable template provides a convenient shortcut to access the nested value of the IsNumericMatrix class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNumericVector_v = IsNumericVector<T>::value
 Auxiliary variable template for the IsNumericVector type trait.The IsNumericVector_v variable template provides a convenient shortcut to access the nested value of the IsNumericVector class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsOperation_v = IsOperation<T>::value
 Auxiliary variable template for the IsOperation type trait.The IsOperation_v variable template provides a convenient shortcut to access the nested value of the IsOperation class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsOpposedView_v = IsOpposedView<T>::value
 Auxiliary variable template for the IsOpposedView type trait.The IsOpposedView_v variable template provides a convenient shortcut to access the nested value of the IsOpposedView class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsPadded_v = IsPadded<T>::value
 Auxiliary variable template for the IsPadded type trait.The IsPadded_v variable template provides a convenient shortcut to access the nested value of the IsPadded class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsPaddingEnabled_v = IsPaddingEnabled<T>::value
 Auxiliary variable template for the IsPaddingEnabled type trait.The IsPaddingEnabled_v variable template provides a convenient shortcut to access the nested value of the IsPaddingEnabled class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsProxy_v = IsProxy<T>::value
 Auxiliary variable template for the IsProxy type trait.The IsProxy_v variable template provides a convenient shortcut to access the nested value of the IsProxy class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsReduceExpr_v = IsReduceExpr<T>::value
 Auxiliary variable template for the IsReduceExpr type trait.The IsReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsReduceExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsResizable_v = IsResizable<T>::value
 Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provides a convenient shortcut to access the nested value of the IsResizable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsRestricted_v = IsRestricted<T>::value
 Auxiliary variable template for the IsRestricted type trait.The IsRestricted_v variable template provides a convenient shortcut to access the nested value of the IsRestricted class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsRow_v = IsRow<T>::value
 Auxiliary variable template for the IsRow type trait.The IsRow_v variable template provides a convenient shortcut to access the nested value of the IsRow class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsRowMajorMatrix_v = IsRowMajorMatrix<T>::value
 Auxiliary variable template for the IsRowMajorMatrix type trait.The IsRowMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsRowMajorMatrix class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsRows_v = IsRows<T>::value
 Auxiliary variable template for the IsRows type trait.The IsRows_v variable template provides a convenient shortcut to access the nested value of the IsRows class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsRowVector_v = IsRowVector<T>::value
 Auxiliary variable template for the IsRowVector type trait.The IsRowVector_v variable template provides a convenient shortcut to access the nested value of the IsRowVector class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSchurExpr_v = IsSchurExpr<T>::value
 Auxiliary variable template for the IsSchurExpr type trait.The IsSchurExpr_v variable template provides a convenient shortcut to access the nested value of the IsSchurExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSerialExpr_v = IsSerialExpr<T>::value
 Auxiliary variable template for the IsSerialExpr type trait.The IsSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsSerialExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsShrinkable_v = IsShrinkable<T>::value
 Auxiliary variable template for the IsShrinkable type trait.The IsShrinkable_v variable template provides a convenient shortcut to access the nested value of the IsShrinkable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 , typename... Ts>
constexpr bool blaze::IsSIMDCombinable_v = IsSIMDCombinable<T1,T2,Ts...>::value
 Auxiliary variable template for the IsSIMDCombinable type trait.The IsSIMDCombinable_v variable template provides a convenient shortcut to access the nested value of the IsSIMDCombinable class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T , typename... Args>
constexpr bool blaze::IsSIMDEnabled_v = IsSIMDEnabled<T,Args...>::value
 Auxiliary variable template for the IsSIMDEnabled type trait.The IsSIMDEnabled_v variable template provides a convenient shortcut to access the nested value of the IsSIMDEnabled class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSIMDPack_v = IsSIMDPack<T>::value
 Auxiliary variable template for the IsSIMDPack type trait.The IsSIMDPack_v variable template provides a convenient shortcut to access the nested value of the IsSIMDPack class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSMPAssignable_v = IsSMPAssignable<T>::value
 Auxiliary variable template for the IsSMPAssignable type trait.The IsSMPAssignable_v variable template provides a convenient shortcut to access the nested value of the IsSMPAssignable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSparseElement_v = IsSparseElement<T>::value
 Auxiliary variable template for the IsSparseElement type trait.The IsSparseElement_v variable template provides a convenient shortcut to access the nested value of the IsSparseElement class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSparseMatrix_v = IsSparseMatrix<T>::value
 Auxiliary variable template for the IsSparseMatrix type trait.The IsSparseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsSparseMatrix class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSparseVector_v = IsSparseVector<T>::value
 Auxiliary variable template for the IsSparseVector type trait.The IsSparseVector_v variable template provides a convenient shortcut to access the nested value of the IsSparseVector class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSquare_v = IsSquare<T>::value
 Auxiliary variable template for the IsSquare type trait.The IsSquare_v variable template provides a convenient shortcut to access the nested value of the IsSquare class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsStatic_v = IsStatic<T>::value
 Auxiliary variable template for the IsStatic type trait.The IsStatic_v variable template provides a convenient shortcut to access the nested value of the IsStatic class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsStrictlyLower_v = IsStrictlyLower<T>::value
 Auxiliary variable template for the IsStrictlyLower type trait.The IsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyLower class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsStrictlyTriangular_v = IsStrictlyTriangular<T>::value
 Auxiliary variable template for the IsStrictlyTriangular type trait.The IsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyTriangular class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsStrictlyUpper_v = IsStrictlyUpper<T>::value
 Auxiliary variable template for the IsStrictlyUpper type trait.The IsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyUpper class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSubExpr_v = IsSubExpr<T>::value
 Auxiliary variable template for the IsSubExpr type trait.The IsSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsSubExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSubmatrix_v = IsSubmatrix<T>::value
 Auxiliary variable template for the IsSubmatrix type trait.The IsSubmatrix_v variable template provides a convenient shortcut to access the nested value of the IsSubmatrix class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSubvector_v = IsSubvector<T>::value
 Auxiliary variable template for the IsSubvector type trait.The IsSubvector_v variable template provides a convenient shortcut to access the nested value of the IsSubvector class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSymmetric_v = IsSymmetric<T>::value
 Auxiliary variable template for the IsSymmetric type trait.The IsSymmetric_v variable template provides a convenient shortcut to access the nested value of the IsSymmetric class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsTemporary_v = IsTemporary<T>::value
 Auxiliary variable template for the IsTemporary type trait.The IsTemporary_v variable template provides a convenient shortcut to access the nested value of the IsTemporary class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsTransExpr_v = IsTransExpr<T>::value
 Auxiliary variable template for the IsTransExpr type trait.The IsTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsTransExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsTransformation_v = IsTransformation<T>::value
 Auxiliary variable template for the IsTransformation type trait.The IsTransformation_v variable template provides a convenient shortcut to access the nested value of the IsTransformation class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsTriangular_v = IsTriangular<T>::value
 Auxiliary variable template for the IsTriangular type trait.The IsTriangular_v variable template provides a convenient shortcut to access the nested value of the IsTriangular class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsTVecMatMultExpr_v = IsTVecMatMultExpr<T>::value
 Auxiliary variable template for the IsTVecMatMultExpr type trait.The IsTVecMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsTVecMatMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUnaryMapExpr_v = IsUnaryMapExpr<T>::value
 Auxiliary variable template for the IsUnaryMapExpr type trait.The IsUnaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsUnaryMapExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUniform_v = IsUniform<T>::value
 Auxiliary variable template for the IsUniform type trait.The IsUniform_v variable template provides a convenient shortcut to access the nested value of the IsUniform class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUniLower_v = IsUniLower<T>::value
 Auxiliary variable template for the IsUniLower type trait.The IsUniLower_v variable template provides a convenient shortcut to access the nested value of the IsUniLower class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUniTriangular_v = IsUniTriangular<T>::value
 Auxiliary variable template for the IsUniTriangular type trait.The IsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the IsUniTriangular class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUniUpper_v = IsUniUpper<T>::value
 Auxiliary variable template for the IsUniUpper type trait.The IsUniUpper_v variable template provides a convenient shortcut to access the nested value of the IsUniUpper class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUpper_v = IsUpper<T>::value
 Auxiliary variable template for the IsUpper type trait.The IsUpper_v variable template provides a convenient shortcut to access the nested value of the IsUpper class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecEvalExpr_v = IsVecEvalExpr<T>::value
 Auxiliary variable template for the IsVecEvalExpr type trait.The IsVecEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecEvalExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecExpandExpr_v = IsVecExpandExpr<T>::value
 Auxiliary variable template for the IsVecExpandExpr type trait.The IsVecExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecExpandExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecMapExpr_v = IsVecMapExpr<T>::value
 Auxiliary variable template for the IsVecMapExpr type trait.The IsVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecMapExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecScalarDivExpr_v = IsVecScalarDivExpr<T>::value
 Auxiliary variable template for the IsVecScalarDivExpr type trait.The IsVecScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarDivExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecScalarMultExpr_v = IsVecScalarMultExpr<T>::value
 Auxiliary variable template for the IsVecScalarMultExpr type trait.The IsVecScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecSerialExpr_v = IsVecSerialExpr<T>::value
 Auxiliary variable template for the IsVecSerialExpr type trait.The IsVecSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecSerialExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVector_v = IsVector<T>::value
 Auxiliary variable template for the IsVector type trait.The IsVector_v variable template provides a convenient shortcut to access the nested value of the IsVector class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecTransExpr_v = IsVecTransExpr<T>::value
 Auxiliary variable template for the IsVecTransExpr type trait.The IsVecTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTransExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecTVecMultExpr_v = IsVecTVecMultExpr<T>::value
 Auxiliary variable template for the IsVecTVecMultExpr type trait.The IsVecTVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTVecMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecVecAddExpr_v = IsVecVecAddExpr<T>::value
 Auxiliary variable template for the IsVecVecAddExpr type trait.The IsVecVecAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecAddExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecVecDivExpr_v = IsVecVecDivExpr<T>::value
 Auxiliary variable template for the IsVecVecDivExpr type trait.The IsVecVecDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecDivExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecVecMapExpr_v = IsVecVecMapExpr<T>::value
 Auxiliary variable template for the IsVecVecMapExpr type trait.The IsVecVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMapExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecVecMultExpr_v = IsVecVecMultExpr<T>::value
 Auxiliary variable template for the IsVecVecMultExpr type trait.The IsVecVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMultExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVecVecSubExpr_v = IsVecVecSubExpr<T>::value
 Auxiliary variable template for the IsVecVecSubExpr type trait.The IsVecVecSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecSubExpr class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsView_v = IsView<T>::value
 Auxiliary variable template for the IsView type trait.The IsView_v variable template provides a convenient shortcut to access the nested value of the IsView class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsZero_v = IsZero<T>::value
 Auxiliary variable template for the IsZero type trait.The IsZero_v variable template provides a convenient shortcut to access the nested value of the IsZero class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T , size_t N>
constexpr ptrdiff_t blaze::MaxSize_v = MaxSize<T,N>::value
 Auxiliary variable template for the MaxSize type trait.The MaxSize_v variable template provides a convenient shortcut to access the nested value of the MaxSize class template. For instance, given the type T and the dimension N the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::RequiresEvaluation_v = RequiresEvaluation<T>::value
 Auxiliary variable template for the RequiresEvaluation type trait.The RequiresEvaluation_v variable template provides a convenient shortcut to access the nested value of the RequiresEvaluation class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T , size_t N>
constexpr ptrdiff_t blaze::Size_v = Size<T,N>::value
 Auxiliary variable template for the Size type trait.The Size_v variable template provides a convenient shortcut to access the nested value of the Size class template. For instance, given the type T and the dimension N the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::StorageOrder_v = T::storageOrder
 Auxiliary variable template for the StorageOrder type trait.The StorageOrder_v variable template provides a convenient shortcut to access the nested value of the StorageOrder class template. For instance, given the matrix type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::TransposeFlag_v = T::transposeFlag
 Auxiliary variable template for the TransposeFlag type trait.The TransposeFlag_v variable template provides a convenient shortcut to access the nested value of the TransposeFlag class template. For instance, given the vector type T the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsDiagonal_v = YieldsDiagonal<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsDiagonal type trait.The YieldsDiagonal_v variable template provides a convenient shortcut to access the nested value of the YieldsDiagonal class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsHermitian_v = YieldsHermitian<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsHermitian type trait.The YieldsHermitian_v variable template provides a convenient shortcut to access the nested value of the YieldsHermitian class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsIdentity_v = YieldsIdentity<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsIdentity type trait.The YieldsIdentity_v variable template provides a convenient shortcut to access the nested value of the YieldsIdentity class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsLower_v = YieldsLower<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsLower type trait.The YieldsLower_v variable template provides a convenient shortcut to access the nested value of the YieldsLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsStrictlyLower_v = YieldsStrictlyLower<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsStrictlyLower type trait.The YieldsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsStrictlyTriangular_v = YieldsStrictlyTriangular<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsStrictlyTriangular type trait.The YieldsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsStrictlyUpper_v = YieldsStrictlyUpper<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsStrictlyUpper type trait.The YieldsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsSymmetric_v = YieldsSymmetric<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsSymmetric type trait.The YieldsSymmetric_v variable template provides a convenient shortcut to access the nested value of the YieldsSymmetric class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsTriangular_v = YieldsTriangular<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsTriangular type trait.The YieldsTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename T , typename... Ts>
constexpr bool blaze::YieldsUniform_v = YieldsUniform<OP,T,Ts...>::value
 Auxiliary variable template for the YieldsUniform type trait.The YieldsUniform_v variable template provides a convenient shortcut to access the nested value of the YieldsUniform class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUniLower_v = YieldsUniLower<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsUniLower type trait.The YieldsUniLower_v variable template provides a convenient shortcut to access the nested value of the YieldsUniLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUniTriangular_v = YieldsUniTriangular<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsUniTriangular type trait.The YieldsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsUniTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUniUpper_v = YieldsUniUpper<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsUniUpper type trait.The YieldsUniUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUniUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename MT , typename... MTs>
constexpr bool blaze::YieldsUpper_v = YieldsUpper<OP,MT,MTs...>::value
 Auxiliary variable template for the YieldsUpper type trait.The YieldsUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical: More...
 
template<typename OP , typename T , typename... Ts>
constexpr bool blaze::YieldsZero_v = YieldsZero<OP,T,Ts...>::value
 Auxiliary variable template for the YieldsZero type trait.The YieldsZero_v variable template provides a convenient shortcut to access the nested value of the YieldsZero class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical: More...
 
template<typename TL , typename T >
constexpr bool blaze::Contains_v = Contains<TL,T>::value
 Auxiliary variable template for the Contains type trait.The Contains_v variable template provides a convenient shortcut to access the nested value of the Contains class template. For instance, given the type list TL and the type T the following two statements are identical: More...
 
template<typename TL , typename T >
constexpr bool blaze::ContainsRelated_v = ContainsRelated<TL,T>::value
 Auxiliary variable template for the ContainsRelated type trait.The ContainsRelated_v variable template provides a convenient shortcut to access the nested value of the ContainsRelated class template. For instance, given the type list TL and the type T the following two statements are identical: More...
 
template<typename TL , typename T >
constexpr size_t blaze::IndexOf_v = IndexOf<TL,T>::value
 Auxiliary variable template for the IndexOf type trait.The IndexOf_v variable template provides a convenient shortcut to access the nested value of the IndexOf class template. For instance, given the type list TL and the type T the following two statements are identical: More...
 
template<typename TL >
constexpr size_t blaze::Length_v = Length<TL>::value
 Auxiliary variable template for the Length type trait.The Length_v variable template provides a convenient shortcut to access the nested value of the Length class template. For instance, given the type list TL the following two statements are identical: More...
 
template<typename T >
constexpr size_t blaze::AlignmentOf_v = AlignmentOf<T>::value
 Auxiliary variable template for the AlignmentOf type trait.The AlignmentOf_v variable template provides a convenient shortcut to access the nested value of the AlignmentOf class template. For instance, given the type T the following two statements are identical: More...
 
template<template< typename > class TypeTrait, typename T1 , typename T2 , typename... Ts>
constexpr bool blaze::All_v = All<TypeTrait,T1,T2,Ts...>::value
 Auxiliary variable template for the All type trait.The All_v variable template provides a convenient shortcut to access the nested value of the All class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::AlwaysFalse_v = false
 Auxiliary variable template for the AlwaysFalse type trait.The AlwaysFalse_v variable template provides a convenient shortcut to access the nested value of the AlwaysFalse class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::AlwaysTrue_v = true
 Auxiliary variable template for the AlwaysTrue type trait.The AlwaysTrue_v variable template provides a convenient shortcut to access the nested value of the AlwaysTrue class template. For instance, given the type T the following two statements are identical: More...
 
template<template< typename > class TypeTrait, typename T1 , typename T2 , typename... Ts>
constexpr bool blaze::Any_v = Any<TypeTrait,T1,T2,Ts...>::value
 Auxiliary variable template for the Any type trait.The Any_v variable template provides a convenient shortcut to access the nested value of the Any class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical: More...
 
template<typename T , size_t N>
constexpr size_t blaze::Extent_v = Extent<T,N>::value
 Auxiliary variable template for the Extent type trait.The Extent_v variable template provides a convenient shortcut to access the nested value of the Extent class template. For instance, given the type T and the compile time constant N the following two statements are identical: More...
 
template<typename T , size_t Size>
constexpr bool blaze::HasSize_v = HasSize<T,Size>::value
 Auxiliary variable template for the HasSize type trait.The HasSize_v variable template provides a convenient shortcut to access the nested value of the HasSize class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::Has1Byte_v = Has1Byte<T>::value
 Auxiliary variable template for the Has1Byte type trait.The Has1Byte_v variable template provides a convenient shortcut to access the nested value of the Has1Byte class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::Has2Bytes_v = Has2Bytes<T>::value
 Auxiliary variable template for the Has2Bytes type trait.The Has2Bytes_v variable template provides a convenient shortcut to access the nested value of the Has2Bytes class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::Has4Bytes_v = Has4Bytes<T>::value
 Auxiliary variable template for the Has4Bytes type trait.The Has4Bytes_v variable template provides a convenient shortcut to access the nested value of the Has4Bytes class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::Has8Bytes_v = Has8Bytes<T>::value
 Auxiliary variable template for the Has8Bytes type trait.The Has8Bytes_v variable template provides a convenient shortcut to access the nested value of the Has8Bytes class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HaveSameSize_v = HaveSameSize<T1,T2>::value
 Auxiliary variable template for the HaveSameSize type trait.The HaveSameSize_v variable template provides a convenient shortcut to access the nested value of the HaveSameSize class template. For instance, given the typew T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsArithmetic_v = IsArithmetic<T>::value
 Auxiliary variable template for the IsArithmetic type trait.The IsArithmetic_v variable template provides a convenient shortcut to access the nested value of the IsArithmetic class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsArray_v = IsArray<T>::value
 Auxiliary variable template for the IsArray type trait.The IsArray_v variable template provides a convenient shortcut to access the nested value of the IsArray class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T , typename U >
constexpr bool blaze::IsAssignable_v = IsAssignable<T,U>::value
 Auxiliary variable template for the IsAssignable type trait.The IsAssignable_v variable template provides a convenient shortcut to access the nested value of the IsAssignable class template. For instance, given the types T and U the following two statements are identical: More...
 
template<typename T , typename U >
constexpr bool blaze::IsNothrowAssignable_v = IsNothrowAssignable<T,U>::value
 Auxiliary variable template for the IsNothrowAssignable type trait.The IsNothrowAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowAssignable class template. For instance, given the types T and U the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsCopyAssignable_v = IsCopyAssignable<T>::value
 Auxiliary variable template for the IsCopyAssignable type trait.The IsCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsCopyAssignable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNothrowCopyAssignable_v = IsNothrowCopyAssignable<T>::value
 Auxiliary variable template for the IsNothrowCopyAssignable type trait.The IsNothrowCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyAssignable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMoveAssignable_v = IsMoveAssignable<T>::value
 Auxiliary variable template for the IsMoveAssignable type trait.The IsMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsMoveAssignable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNothrowMoveAssignable_v = IsNothrowMoveAssignable<T>::value
 Auxiliary variable template for the IsNothrowMoveAssignable type trait.The IsNothrowMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveAssignable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename Base , typename Derived >
constexpr bool blaze::IsBaseOf_v = IsBaseOf<Base,Derived>::value
 Auxiliary variable template for the IsBaseOf type trait.The IsBaseOf_v variable template provides a convenient shortcut to access the nested value of the IsBaseOf class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsBoolean_v = IsBoolean<T>::value
 Auxiliary variable template for the IsBoolean type trait.The IsBoolean_v variable template provides a convenient shortcut to access the nested value of the IsBoolean class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsBuiltin_v = IsBuiltin<T>::value
 Auxiliary variable template for the IsBuiltin type trait.The IsBuiltin_v variable template provides a convenient shortcut to access the nested value of the IsBuiltin class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsCharacter_v = IsCharacter<T>::value
 Auxiliary variable template for the IsCharacter type trait.The IsCharacter_v variable template provides a convenient shortcut to access the nested value of the IsCharacter class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsClass_v = IsClass<T>::value
 Auxiliary variable template for the IsClass type trait.The IsClass_v variable template provides a convenient shortcut to access the nested value of the IsClass class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsComplex_v = IsComplex<T>::value
 Auxiliary variable template for the IsComplex type trait.The IsComplex_v variable template provides a convenient shortcut to access the nested value of the IsComplex class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsComplexDouble_v = IsComplexDouble<T>::value
 Auxiliary variable template for the IsComplexDouble type trait.The IsComplexDouble_v variable template provides a convenient shortcut to access the nested value of the IsComplexDouble class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsComplexFloat_v = IsComplexFloat<T>::value
 Auxiliary variable template for the IsComplexFloat type trait.The IsComplexFloat_v variable template provides a convenient shortcut to access the nested value of the IsComplexFloat class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsConst_v = IsConst<T>::value
 Auxiliary variable template for the IsConst type trait.The IsConst_v variable template provides a convenient shortcut to access the nested value of the IsConst class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T , typename... Args>
constexpr bool blaze::IsConstructible_v = IsConstructible<T>::value
 Auxiliary variable template for the IsConstructible type trait.The IsConstructible_v variable template provides a convenient shortcut to access the nested value of the IsConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical: More...
 
template<typename T , typename... Args>
constexpr bool blaze::IsNothrowConstructible_v = IsNothrowConstructible<T>::value
 Auxiliary variable template for the IsNothrowConstructible type trait.The IsNothrowConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDefaultConstructible_v = IsDefaultConstructible<T>::value
 Auxiliary variable template for the IsDefaultConstructible type trait.The IsDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsDefaultConstructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible<T>::value
 Auxiliary variable template for the IsNothrowDefaultConstructible type trait.The IsNothrowDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDefaultConstructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsCopyConstructible_v = IsCopyConstructible<T>::value
 Auxiliary variable template for the IsCopyConstructible type trait.The IsCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsCopyConstructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNothrowCopyConstructible_v = IsNothrowCopyConstructible<T>::value
 Auxiliary variable template for the IsNothrowCopyConstructible type trait.The IsNothrowCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyConstructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsMoveConstructible_v = IsMoveConstructible<T>::value
 Auxiliary variable template for the IsMoveConstructible type trait.The IsMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsMoveConstructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNothrowMoveConstructible_v = IsNothrowMoveConstructible<T>::value
 Auxiliary variable template for the IsNothrowMoveConstructible type trait.The IsNothrowMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveConstructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename From , typename To >
constexpr bool blaze::IsConvertible_v = IsConvertible<From,To>::value
 Auxiliary variable template for the IsConvertible type trait.The IsConvertible_v variable template provides a convenient shortcut to access the nested value of the IsConvertible class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDestructible_v = IsDestructible<T>::value
 Auxiliary variable template for the IsDestructible type trait.The IsDestructible_v variable template provides a convenient shortcut to access the nested value of the IsDestructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNothrowDestructible_v = IsNothrowDestructible<T>::value
 Auxiliary variable template for the IsNothrowDestructible type trait.The IsNothrowDestructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDestructible class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsDouble_v = IsDouble<T>::value
 Auxiliary variable template for the IsDouble type trait.The IsDouble_v variable template provides a convenient shortcut to access the nested value of the IsDouble class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsEmpty_v = IsEmpty<T>::value
 Auxiliary variable template for the IsEmpty type trait.The IsEmpty_v variable template provides a convenient shortcut to access the nested value of the IsEmpty class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsEnum_v = IsEnum<T>::value
 Auxiliary variable template for the IsEnum type trait.The IsEnum_v variable template provides a convenient shortcut to access the nested value of the IsEnum class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsFloat_v = IsFloat<T>::value
 Auxiliary variable template for the IsFloat type trait.The IsFloat_v variable template provides a convenient shortcut to access the nested value of the IsFloat class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsFloatingPoint_v = IsFloatingPoint<T>::value
 Auxiliary variable template for the IsFloatingPoint type trait.The IsFloatingPoint_v variable template provides a convenient shortcut to access the nested value of the IsFloatingPoint class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsInteger_v = IsInteger<T>::value
 Auxiliary variable template for the IsInteger type trait.The IsInteger_v variable template provides a convenient shortcut to access the nested value of the IsInteger class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsIntegral_v = IsIntegral<T>::value
 Auxiliary variable template for the IsIntegral type trait.The IsIntegral_v variable template provides a convenient shortcut to access the nested value of the IsIntegral class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsLong_v = IsLong<T>::value
 Auxiliary variable template for the IsLong type trait.The IsLong_v variable template provides a convenient shortcut to access the nested value of the IsLong class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsLongDouble_v = IsLongDouble<T>::value
 Auxiliary variable template for the IsLongDouble type trait.The IsLongDouble_v variable template provides a convenient shortcut to access the nested value of the IsLongDouble class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsLValueReference_v = IsLValueReference<T>::value
 Auxiliary variable template for the IsLValueReference type trait.The IsLValueReference_v variable template provides a convenient shortcut to access the nested value of the IsLValueReference class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsNumeric_v = IsNumeric<T>::value
 Auxiliary variable template for the IsNumeric type trait.The IsNumeric_v variable template provides a convenient shortcut to access the nested value of the IsNumeric class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsObject_v = IsObject<T>::value
 Auxiliary variable template for the IsObject type trait.The IsObject_v variable template provides a convenient shortcut to access the nested value of the IsObject class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsPod_v = IsPod<T>::value
 Auxiliary variable template for the IsPod type trait.The IsPod_v variable template provides a convenient shortcut to access the nested value of the IsPod class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsPointer_v = IsPointer<T>::value
 Auxiliary variable template for the IsPointer type trait.The IsPointer_v variable template provides a convenient shortcut to access the nested value of the IsPointer class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsReference_v = IsReference<T>::value
 Auxiliary variable template for the IsReference type trait.The IsReference_v variable template provides a convenient shortcut to access the nested value of the IsReference class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsRValueReference_v = IsRValueReference<T>::value
 Auxiliary variable template for the IsRValueReference type trait.The IsRValueReference_v variable template provides a convenient shortcut to access the nested value of the IsRValueReference class template. For instance, given the type T the following two statements are identical: More...
 
template<typename A , typename B >
constexpr bool blaze::IsStrictlySame_v = IsStrictlySame<A,B>::value
 Auxiliary variable template for the IsStrictlySame type trait.The IsStrictlySame_v variable template provides a convenient shortcut to access the nested value of the IsStrictlySame class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename A , typename B >
constexpr bool blaze::IsSame_v = IsSame<A,B>::value
 Auxiliary variable template for the IsSame type trait.The IsSame_v variable template provides a convenient shortcut to access the nested value of the IsSame class template. For instance, given the types T1 and T2 the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsShort_v = IsShort<T>::value
 Auxiliary variable template for the IsShort type trait.The IsShort_v variable template provides a convenient shortcut to access the nested value of the IsShort class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsSigned_v = IsSigned<T>::value
 Auxiliary variable template for the IsSigned type trait.The IsSigned_v variable template provides a convenient shortcut to access the nested value of the IsSigned class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUnion_v = IsUnion<T>::value
 Auxiliary variable template for the IsUnion type trait.The IsUnion_v variable template provides a convenient shortcut to access the nested value of the IsUnion class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsUnsigned_v = IsUnsigned<T>::value
 Auxiliary variable template for the IsUnsigned type trait.The IsUnsigned_v variable template provides a convenient shortcut to access the nested value of the IsUnsigned class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsValid_v = IsValid<T>::value
 Auxiliary variable template for the IsValid type trait.The IsValid_v variable template provides a convenient shortcut to access the nested value of the IsValid class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVectorizable_v = IsVectorizable<T>::value
 Auxiliary variable template for the IsVectorizable type trait.The IsVectorizable_v variable template provides a convenient shortcut to access the nested value of the IsVectorizable class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVoid_v = IsVoid<T>::value
 Auxiliary variable template for the IsVoid type trait.The IsVoid_v variable template provides a convenient shortcut to access the nested value of the IsVoid class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr bool blaze::IsVolatile_v = IsVolatile<T>::value
 Auxiliary variable template for the IsVolatile type trait.The IsVolatile_v variable template provides a convenient shortcut to access the nested value of the IsVolatile class template. For instance, given the type T the following two statements are identical: More...
 
template<typename T >
constexpr size_t blaze::Rank_v = Rank<T>::value
 Auxiliary variable template for the Rank type trait.The Rank_v variable template provides a convenient shortcut to access the nested value of the Rank class template. For instance, given the type T the following two statements are identical: More...
 

Detailed Description

Typedef Documentation

◆ AddConst_t

template<typename T >
using blaze::AddConst_t = typedef typename AddConst<T>::Type

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

using Type1 = typename blaze::AddConst<T>::Type;
using Type2 = blaze::AddConst_t<T>;

◆ AddCV_t

template<typename T >
using blaze::AddCV_t = typedef typename AddCV<T>::Type

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

using Type1 = typename blaze::AddCV<T>::Type;
using Type2 = blaze::AddCV_t<T>;

◆ AddPointer_t

template<typename T >
using blaze::AddPointer_t = typedef typename AddPointer<T>::Type

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

using Type1 = typename blaze::AddPointer<T>::Type;
using Type2 = blaze::AddPointer_t<T>;

◆ AddReference_t

template<typename T >
using blaze::AddReference_t = typedef typename AddReference<T>::Type

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

using Type1 = typename blaze::AddReference<T>::Type;

◆ AddVolatile_t

template<typename T >
using blaze::AddVolatile_t = typedef typename AddVolatile<T>::Type

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

using Type1 = typename blaze::AddVolatile<T>::Type;

◆ Append_t

template<typename TL , typename T >
using blaze::Append_t = typedef typename Append<TL,T>::Type

Auxiliary alias declaration for the Append class template.The Append_t alias declaration provides a convenient shortcut to access the nested Type of the Append class template. For instance, given the type list TL and the type T the following two type definitions are identical:

using Type1 = typename Append<TL,T>::Type;
using Type2 = Append_t<TL,T>;

◆ CommonType_t

template<typename... T>
using blaze::CommonType_t = typedef typename CommonType<T...>::Type

Auxiliary alias declaration for the CommonType type trait.The CommonType_t alias declaration provides a convenient shortcut to access the nested Type of the CommonType class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename blaze::CommonType<T1,T2>::Type;

◆ Decay_t

template<typename T >
using blaze::Decay_t = typedef typename Decay<T>::Type

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

using Type1 = typename blaze::Decay<T>::Type;
using Type2 = blaze::Decay_t<T>;

◆ Erase_t

template<typename TL , typename T >
using blaze::Erase_t = typedef typename Erase<TL,T>::Type

Auxiliary alias declaration for the Erase class template.The Erase_t alias declaration provides a convenient shortcut to access the nested Type of the Erase class template. For instance, given the type list TL and the type T the following two type definitions are identical:

using Type1 = typename Erase<TL,T>::Type;
using Type2 = Erase_t<TL,T>;

◆ EraseAll_t

template<typename TL , typename T >
using blaze::EraseAll_t = typedef typename EraseAll<TL,T>::Type

Auxiliary alias declaration for the EraseAll class template.The EraseAll_t alias declaration provides a convenient shortcut to access the nested Type of the EraseAll class template. For instance, given the type list TL and the type T the following two type definitions are identical:

using Type1 = typename EraseAll<TL,T>::Type;
using Type2 = EraseAll_t<TL,T>;

◆ HighType_t

template<typename T1 , typename T2 >
using blaze::HighType_t = typedef typename HighType<T1,T2>::Type

Auxiliary alias declaration for the HighType type trait.The HighType_t alias declaration provides a convenient shortcut to access the nested Type of the HighType class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename blaze::HighType<T1,T2>::Type;

◆ LowType_t

template<typename T1 , typename T2 >
using blaze::LowType_t = typedef typename LowType<T1,T2>::Type

Auxiliary alias declaration for the LowType type trait.The LowType_t alias declaration provides a convenient shortcut to access the nested Type of the LowType class template. For instance, given the types T1 and T2 the following two type definitions are identical:

using Type1 = typename blaze::LowType<T1,T2>::Type;

◆ MakeSigned_t

template<typename T >
using blaze::MakeSigned_t = typedef typename MakeSigned<T>::Type

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

using Type1 = typename blaze::MakeSigned<T>::Type;
using Type2 = blaze::MakeSigned_t<T>;

◆ MakeUnsigned_t

template<typename T >
using blaze::MakeUnsigned_t = typedef typename MakeUnsigned<T>::Type

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

using Type1 = typename blaze::MakeUnsigned<T>::Type;

◆ RemoveAdaptor_t

template<typename T >
using blaze::RemoveAdaptor_t = typedef typename RemoveAdaptor<T>::Type

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

using Type1 = typename blaze::RemoveAdaptor<T>::Type;

◆ RemoveAllExtents_t

template<typename T >
using blaze::RemoveAllExtents_t = typedef typename RemoveAllExtents<T>::Type

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

◆ RemoveConst_t

template<typename T >
using blaze::RemoveConst_t = typedef typename RemoveConst<T>::Type

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

using Type1 = typename blaze::RemoveConst<T>::Type;

◆ RemoveCV_t

template<typename T >
using blaze::RemoveCV_t = typedef typename RemoveCV<T>::Type

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

using Type1 = typename blaze::RemoveCV<T>::Type;
using Type2 = blaze::RemoveCV_t<T>;

◆ RemoveExtent_t

template<typename T >
using blaze::RemoveExtent_t = typedef typename RemoveExtent<T>::Type

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

using Type1 = typename blaze::RemoveExtent<T>::Type;

◆ RemovePointer_t

template<typename T >
using blaze::RemovePointer_t = typedef typename RemovePointer<T>::Type

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

using Type1 = typename blaze::RemovePointer<T>::Type;

◆ RemoveReference_t

template<typename T >
using blaze::RemoveReference_t = typedef typename RemoveReference<T>::Type

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

using Type1 = typename blaze::RemoveReference<T>::Type;

◆ RemoveVolatile_t

template<typename T >
using blaze::RemoveVolatile_t = typedef typename RemoveVolatile<T>::Type

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

using Type1 = typename blaze::RemoveVolatile<T>::Type;

◆ TypeAt_t

template<typename TL , size_t Index>
using blaze::TypeAt_t = typedef typename TypeAt<TL,Index>::Type

Auxiliary alias declaration for the TypeAt class template.The TypeAt_t alias declaration provides a convenient shortcut to access the nested Type of the TypeAt class template. For instance, given the type list TL and the index Index the following two type definitions are identical:

using Type1 = typename TypeAt<TL,Index>::Type;
using Type2 = TypeAt_t<TL,Index>;

◆ UnderlyingBuiltin_t

template<typename T >
using blaze::UnderlyingBuiltin_t = typedef typename UnderlyingBuiltin<T>::Type

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

◆ UnderlyingElement_t

template<typename T >
using blaze::UnderlyingElement_t = typedef typename UnderlyingElement<T>::Type

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

◆ UnderlyingNumeric_t

template<typename T >
using blaze::UnderlyingNumeric_t = typedef typename UnderlyingNumeric<T>::Type

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

◆ Unique_t

template<typename TL >
using blaze::Unique_t = typedef typename Unique<TL>::Type

Auxiliary alias declaration for the Unique class template.The Unique_t alias declaration provides a convenient shortcut to access the nested Type of the Unique class template. For instance, given the type list TL the following two type definitions are identical:

using Type1 = typename Unique<TL>::Type;
using Type2 = Unique_t<TL>;

◆ Void_t

template<typename... Ts>
using blaze::Void_t = typedef void

Compile time type check.This type trait maps an arbitrary sequence of types to the type void. It can for instance be used to determine the validity of an expression:

template< typename T1, typename T2, typename = Void_t<> >
struct HasAdd : public FalseType {};
template< typename T1, typename T2
, Void_t< decltype( std::declval<T1>() + std::declval<T2>() ) >
struct HasAdd : public TrueType {};

Variable Documentation

◆ AlignmentOf_v

template<typename T >
constexpr size_t blaze::AlignmentOf_v = AlignmentOf<T>::value

Auxiliary variable template for the AlignmentOf type trait.The AlignmentOf_v variable template provides a convenient shortcut to access the nested value of the AlignmentOf class template. For instance, given the type T the following two statements are identical:

constexpr size_t value1 = blaze::AlignmentOf<T>::value;
constexpr size_t value2 = blaze::AlignmentOf_v<T>;

◆ All_v

template<template< typename > class TypeTrait, typename T1 , typename T2 , typename... Ts>
constexpr bool blaze::All_v = All<TypeTrait,T1,T2,Ts...>::value

Auxiliary variable template for the All type trait.The All_v variable template provides a convenient shortcut to access the nested value of the All class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::All<TypeTrait,T1,T2>::value;
constexpr bool value2 = blaze::All_v<TypeTrait,T1,T2>;

◆ AlwaysFalse_v

template<typename T >
constexpr bool blaze::AlwaysFalse_v = false

Auxiliary variable template for the AlwaysFalse type trait.The AlwaysFalse_v variable template provides a convenient shortcut to access the nested value of the AlwaysFalse class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::AlwaysFalse<T>::value;
constexpr bool value2 = blaze::AlwaysFalse_v<T>;

◆ AlwaysTrue_v

template<typename T >
constexpr bool blaze::AlwaysTrue_v = true

Auxiliary variable template for the AlwaysTrue type trait.The AlwaysTrue_v variable template provides a convenient shortcut to access the nested value of the AlwaysTrue class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::AlwaysTrue<T>::value;
constexpr bool value2 = blaze::AlwaysTrue_v<T>;

◆ Any_v

template<template< typename > class TypeTrait, typename T1 , typename T2 , typename... Ts>
constexpr bool blaze::Any_v = Any<TypeTrait,T1,T2,Ts...>::value

Auxiliary variable template for the Any type trait.The Any_v variable template provides a convenient shortcut to access the nested value of the Any class template. For instance, given the type trait TypeTrait and the two types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::Any<TypeTrait,T1,T2>::value;
constexpr bool value2 = blaze::Any_v<TypeTrait,T1,T2>;

◆ Contains_v

template<typename TL , typename T >
constexpr bool blaze::Contains_v = Contains<TL,T>::value

Auxiliary variable template for the Contains type trait.The Contains_v variable template provides a convenient shortcut to access the nested value of the Contains class template. For instance, given the type list TL and the type T the following two statements are identical:

constexpr bool value1 = Contains<TL,T>::value;
constexpr bool value2 = Contains_v<TL,T>;

◆ ContainsRelated_v

template<typename TL , typename T >
constexpr bool blaze::ContainsRelated_v = ContainsRelated<TL,T>::value

Auxiliary variable template for the ContainsRelated type trait.The ContainsRelated_v variable template provides a convenient shortcut to access the nested value of the ContainsRelated class template. For instance, given the type list TL and the type T the following two statements are identical:

constexpr bool value1 = ContainsRelated<TL,T>::value;
constexpr bool value2 = ContainsRelated_v<TL,T>;

◆ Extent_v

template<typename T , size_t N>
constexpr size_t blaze::Extent_v = Extent<T,N>::value

Auxiliary variable template for the Extent type trait.The Extent_v variable template provides a convenient shortcut to access the nested value of the Extent class template. For instance, given the type T and the compile time constant N the following two statements are identical:

constexpr size_t value1 = blaze::Extent<T,N>::value;
constexpr size_t value2 = blaze::Extent_v<T,N>;

◆ Has1Byte_v

template<typename T >
constexpr bool blaze::Has1Byte_v = Has1Byte<T>::value

Auxiliary variable template for the Has1Byte type trait.The Has1Byte_v variable template provides a convenient shortcut to access the nested value of the Has1Byte class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has1Byte<T>::value;
constexpr bool value2 = blaze::Has1Byte_v<T>;

◆ Has2Bytes_v

template<typename T >
constexpr bool blaze::Has2Bytes_v = Has2Bytes<T>::value

Auxiliary variable template for the Has2Bytes type trait.The Has2Bytes_v variable template provides a convenient shortcut to access the nested value of the Has2Bytes class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has2Bytes<T>::value;
constexpr bool value2 = blaze::Has2Bytes_v<T>;

◆ Has4Bytes_v

template<typename T >
constexpr bool blaze::Has4Bytes_v = Has4Bytes<T>::value

Auxiliary variable template for the Has4Bytes type trait.The Has4Bytes_v variable template provides a convenient shortcut to access the nested value of the Has4Bytes class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has4Bytes<T>::value;
constexpr bool value2 = blaze::Has4Bytes_v<T>;

◆ Has8Bytes_v

template<typename T >
constexpr bool blaze::Has8Bytes_v = Has8Bytes<T>::value

Auxiliary variable template for the Has8Bytes type trait.The Has8Bytes_v variable template provides a convenient shortcut to access the nested value of the Has8Bytes class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::Has8Bytes<T>::value;
constexpr bool value2 = blaze::Has8Bytes_v<T>;

◆ HasAbs_v

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

Auxiliary variable template for the HasAbs type trait.The HasAbs_v variable template provides a convenient shortcut to access the nested value of the HasAbs class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasAbs<T>::value;
constexpr bool value2 = blaze::HasAbs_v<T>;

◆ HasAcos_v

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

Auxiliary variable template for the HasAcos type trait.The HasAcos_v variable template provides a convenient shortcut to access the nested value of the HasAcos class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasAcos<T>::value;
constexpr bool value2 = blaze::HasAcos_v<T>;

◆ HasAcosh_v

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

Auxiliary variable template for the HasAcosh type trait.The HasAcosh_v variable template provides a convenient shortcut to access the nested value of the HasAcosh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasAcosh<T>::value;
constexpr bool value2 = blaze::HasAcosh_v<T>;

◆ HasAdd_v

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

Auxiliary variable template for the HasAdd type trait.The HasAdd_v variable template provides a convenient shortcut to access the nested value of the HasAdd class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasAdd<T1,T2>::value;
constexpr bool value2 = blaze::HasAdd_v<T1,T2>;

◆ HasAsin_v

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

Auxiliary variable template for the HasAsin type trait.The HasAsin_v variable template provides a convenient shortcut to access the nested value of the HasAsin class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasAsin<T>::value;
constexpr bool value2 = blaze::HasAsin_v<T>;

◆ HasAsinh_v

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

Auxiliary variable template for the HasAsinh type trait.The HasAsinh_v variable template provides a convenient shortcut to access the nested value of the HasAsinh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasAsinh<T>::value;
constexpr bool value2 = blaze::HasAsinh_v<T>;

◆ HasAtan2_v

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

Auxiliary variable template for the HasAtan2 type trait.The HasAtan2_v variable template provides a convenient shortcut to access the nested value of the HasAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasAtan2<T1,T2>::value;
constexpr bool value2 = blaze::HasAtan2_v<T1,T2>;

◆ HasAtan_v

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

Auxiliary variable template for the HasAtan type trait.The HasAtan_v variable template provides a convenient shortcut to access the nested value of the HasAtan class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasAtan<T>::value;
constexpr bool value2 = blaze::HasAtan_v<T>;

◆ HasAtanh_v

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

Auxiliary variable template for the HasAtanh type trait.The HasAtanh_v variable template provides a convenient shortcut to access the nested value of the HasAtanh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasAtanh<T>::value;
constexpr bool value2 = blaze::HasAtanh_v<T>;

◆ HasCbrt_v

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

Auxiliary variable template for the HasCbrt type trait.The HasCbrt_v variable template provides a convenient shortcut to access the nested value of the HasCbrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasCbrt<T>::value;
constexpr bool value2 = blaze::HasCbrt_v<T>;

◆ HasCeil_v

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

Auxiliary variable template for the HasCeil type trait.The HasCeil_v variable template provides a convenient shortcut to access the nested value of the HasCeil class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasCeil<T>::value;
constexpr bool value2 = blaze::HasCeil_v<T>;

◆ HasClamp_v

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

Auxiliary variable template for the HasClamp type trait.The HasClamp_v variable template provides a convenient shortcut to access the nested value of the HasClamp class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasClamp<T>::value;
constexpr bool value2 = blaze::HasClamp_v<T>;

◆ HasConj_v

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

Auxiliary variable template for the HasConj type trait.The HasConj_v variable template provides a convenient shortcut to access the nested value of the HasConj class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasConj<T>::value;
constexpr bool value2 = blaze::HasConj_v<T>;

◆ HasConstDataAccess_v

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

Auxiliary variable template for the HasConstDataAccess type trait.The HasConstDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasConstDataAccess class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasConstDataAccess<T>::value;
constexpr bool value2 = blaze::HasConstDataAccess_v<T>;

◆ HasCos_v

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

Auxiliary variable template for the HasCos type trait.The HasCos_v variable template provides a convenient shortcut to access the nested value of the HasCos class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasCos<T>::value;
constexpr bool value2 = blaze::HasCos_v<T>;

◆ HasCosh_v

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

Auxiliary variable template for the HasCosh type trait.The HasCosh_v variable template provides a convenient shortcut to access the nested value of the HasCosh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasCosh<T>::value;
constexpr bool value2 = blaze::HasCosh_v<T>;

◆ HasDiv_v

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

Auxiliary variable template for the HasDiv type trait.The HasDiv_v variable template provides a convenient shortcut to access the nested value of the HasDiv class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasDiv<T1,T2>::value;
constexpr bool value2 = blaze::HasDiv_v<T1,T2>;

◆ HasErf_v

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

Auxiliary variable template for the HasErf type trait.The HasErf_v variable template provides a convenient shortcut to access the nested value of the HasErf class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasErf<T>::value;
constexpr bool value2 = blaze::HasErf_v<T>;

◆ HasErfc_v

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

Auxiliary variable template for the HasErfc type trait.The HasErfc_v variable template provides a convenient shortcut to access the nested value of the HasErfc class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasErfc<T>::value;
constexpr bool value2 = blaze::HasErfc_v<T>;

◆ HasExp10_v

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

Auxiliary variable template for the HasExp10 type trait.The HasExp10_v variable template provides a convenient shortcut to access the nested value of the HasExp10 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasExp10<T>::value;
constexpr bool value2 = blaze::HasExp10_v<T>;

◆ HasExp2_v

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

Auxiliary variable template for the HasExp2 type trait.The HasExp2_v variable template provides a convenient shortcut to access the nested value of the HasExp2 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasExp2<T>::value;
constexpr bool value2 = blaze::HasExp2_v<T>;

◆ HasExp_v

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

Auxiliary variable template for the HasExp type trait.The HasExp_v variable template provides a convenient shortcut to access the nested value of the HasExp class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasExp<T>::value;
constexpr bool value2 = blaze::HasExp_v<T>;

◆ HasFloor_v

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

Auxiliary variable template for the HasFloor type trait.The HasFloor_v variable template provides a convenient shortcut to access the nested value of the HasFloor class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasFloor<T>::value;
constexpr bool value2 = blaze::HasFloor_v<T>;

◆ HasHypot_v

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

Auxiliary variable template for the HasHypot type trait.The HasHypot_v variable template provides a convenient shortcut to access the nested value of the HasHypot class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasHypot<T1,T2>::value;
constexpr bool value2 = blaze::HasHypot_v<T1,T2>;

◆ HasImag_v

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

Auxiliary variable template for the HasImag type trait.The HasImag_v variable template provides a convenient shortcut to access the nested value of the HasImag class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasImag<T>::value;
constexpr bool value2 = blaze::HasImag_v<T>;

◆ HasInvCbrt_v

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

Auxiliary variable template for the HasInvCbrt type trait.The HasInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasInvCbrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasInvCbrt<T>::value;
constexpr bool value2 = blaze::HasInvCbrt_v<T>;

◆ HasInvSqrt_v

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

Auxiliary variable template for the HasInvSqrt type trait.The HasInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasInvSqrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasInvSqrt<T>::value;
constexpr bool value2 = blaze::HasInvSqrt_v<T>;

◆ HasLog10_v

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

Auxiliary variable template for the HasLog10 type trait.The HasLog10_v variable template provides a convenient shortcut to access the nested value of the HasLog10 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasLog10<T>::value;
constexpr bool value2 = blaze::HasLog10_v<T>;

◆ HasLog2_v

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

Auxiliary variable template for the HasLog2 type trait.The HasLog2_v variable template provides a convenient shortcut to access the nested value of the HasLog2 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasLog2<T>::value;
constexpr bool value2 = blaze::HasLog2_v<T>;

◆ HasLog_v

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

Auxiliary variable template for the HasLog type trait.The HasLog_v variable template provides a convenient shortcut to access the nested value of the HasLog class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasLog<T>::value;
constexpr bool value2 = blaze::HasLog_v<T>;

◆ HasMax_v

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

Auxiliary variable template for the HasMax type trait.The HasMax_v variable template provides a convenient shortcut to access the nested value of the HasMax class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasMax<T1,T2>::value;
constexpr bool value2 = blaze::HasMax_v<T1,T2>;

◆ HasMin_v

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

Auxiliary variable template for the HasMin type trait.The HasMin_v variable template provides a convenient shortcut to access the nested value of the HasMin class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasMin<T1,T2>::value;
constexpr bool value2 = blaze::HasMin_v<T1,T2>;

◆ HasMult_v

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

Auxiliary variable template for the HasMult type trait.The HasMult_v variable template provides a convenient shortcut to access the nested value of the HasMult class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasMult<T1,T2>::value;
constexpr bool value2 = blaze::HasMult_v<T1,T2>;

◆ HasMutableDataAccess_v

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

Auxiliary variable template for the HasMutableDataAccess type trait.The HasMutableDataAccess_v variable template provides a convenient shortcut to access the nested value of the HasMutableDataAccess class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasMutableDataAccess<T>::value;
constexpr bool value2 = blaze::HasMutableDataAccess_v<T>;

◆ HasPow_v

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

Auxiliary variable template for the HasPow type trait.The HasPow_v variable template provides a convenient shortcut to access the nested value of the HasPow class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasPow<T1,T2>::value;
constexpr bool value2 = blaze::HasPow_v<T1,T2>;

◆ HasReal_v

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

Auxiliary variable template for the HasReal type trait.The HasReal_v variable template provides a convenient shortcut to access the nested value of the HasReal class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasReal<T>::value;
constexpr bool value2 = blaze::HasReal_v<T>;

◆ HasRound_v

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

Auxiliary variable template for the HasRound type trait.The HasRound_v variable template provides a convenient shortcut to access the nested value of the HasRound class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasRound<T>::value;
constexpr bool value2 = blaze::HasRound_v<T>;

◆ HasSign_v

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

Auxiliary variable template for the HasSign type trait.The HasSign_v variable template provides a convenient shortcut to access the nested value of the HasSign class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSign<T>::value;
constexpr bool value2 = blaze::HasSign_v<T>;

◆ HasSIMDAbs_v

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

Auxiliary variable template for the HasSIMDAbs type trait.The HasSIMDAbs_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAbs class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAbs<T>::value;
constexpr bool value2 = blaze::HasSIMDAbs_v<T>;

◆ HasSIMDAcos_v

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

Auxiliary variable template for the HasSIMDAcos type trait.The HasSIMDAcos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcos class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAcos<T>::value;
constexpr bool value2 = blaze::HasSIMDAcos_v<T>;

◆ HasSIMDAcosh_v

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

Auxiliary variable template for the HasSIMDAcosh type trait.The HasSIMDAcosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAcosh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAcosh<T>::value;
constexpr bool value2 = blaze::HasSIMDAcosh_v<T>;

◆ HasSIMDAdd_v

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

Auxiliary variable template for the HasSIMDAdd type trait.The HasSIMDAdd_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAdd class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAdd<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDAdd_v<T1,T2>;

◆ HasSIMDAsin_v

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

Auxiliary variable template for the HasSIMDAsin type trait.The HasSIMDAsin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsin class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAsin<T>::value;
constexpr bool value2 = blaze::HasSIMDAsin_v<T>;

◆ HasSIMDAsinh_v

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

Auxiliary variable template for the HasSIMDAsinh type trait.The HasSIMDAsinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAsinh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAsinh<T>::value;
constexpr bool value2 = blaze::HasSIMDAsinh_v<T>;

◆ HasSIMDAtan2_v

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

Auxiliary variable template for the HasSIMDAtan2 type trait.The HasSIMDAtan2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan2 class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAtan2<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDAtan2_v<T1,T2>;

◆ HasSIMDAtan_v

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

Auxiliary variable template for the HasSIMDAtan type trait.The HasSIMDAtan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtan class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAtan<T>::value;
constexpr bool value2 = blaze::HasSIMDAtan_v<T>;

◆ HasSIMDAtanh_v

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

Auxiliary variable template for the HasSIMDAtanh type trait.The HasSIMDAtanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDAtanh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDAtanh<T>::value;
constexpr bool value2 = blaze::HasSIMDAtanh_v<T>;

◆ HasSIMDCbrt_v

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

Auxiliary variable template for the HasSIMDCbrt type trait.The HasSIMDCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCbrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDCbrt<T>::value;
constexpr bool value2 = blaze::HasSIMDCbrt_v<T>;

◆ HasSIMDCeil_v

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

Auxiliary variable template for the HasSIMDCeil type trait.The HasSIMDCeil_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCeil class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDCeil<T>::value;
constexpr bool value2 = blaze::HasSIMDCeil_v<T>;

◆ HasSIMDConj_v

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

Auxiliary variable template for the HasSIMDConj type trait.The HasSIMDConj_v variable template provides a convenient shortcut to access the nested value of the HasSIMDConj class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDConj<T>::value;
constexpr bool value2 = blaze::HasSIMDConj_v<T>;

◆ HasSIMDCos_v

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

Auxiliary variable template for the HasSIMDCos type trait.The HasSIMDCos_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCos class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDCos<T>::value;
constexpr bool value2 = blaze::HasSIMDCos_v<T>;

◆ HasSIMDCosh_v

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

Auxiliary variable template for the HasSIMDCosh type trait.The HasSIMDCosh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDCosh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDCosh<T>::value;
constexpr bool value2 = blaze::HasSIMDCosh_v<T>;

◆ HasSIMDDiv_v

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

Auxiliary variable template for the HasSIMDDiv type trait.The HasSIMDDiv_v variable template provides a convenient shortcut to access the nested value of the HasSIMDDiv class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDDiv<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDDiv_v<T1,T2>;

◆ HasSIMDEqual_v

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

Auxiliary variable template for the HasSIMDEqual type trait.The HasSIMDEqual_v variable template provides a convenient shortcut to access the nested value of the HasSIMDEqual class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDEqual<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDEqual_v<T1,T2>;

◆ HasSIMDErf_v

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

Auxiliary variable template for the HasSIMDErf type trait.The HasSIMDErf_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErf class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDErf<T>::value;
constexpr bool value2 = blaze::HasSIMDErf_v<T>;

◆ HasSIMDErfc_v

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

Auxiliary variable template for the HasSIMDErfc type trait.The HasSIMDErfc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDErfc class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDErfc<T>::value;
constexpr bool value2 = blaze::HasSIMDErfc_v<T>;

◆ HasSIMDExp10_v

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

Auxiliary variable template for the HasSIMDExp10 type trait.The HasSIMDExp10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp10 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDExp10<T>::value;
constexpr bool value2 = blaze::HasSIMDExp10_v<T>;

◆ HasSIMDExp2_v

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

Auxiliary variable template for the HasSIMDExp2 type trait.The HasSIMDExp2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp2 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDExp2<T>::value;
constexpr bool value2 = blaze::HasSIMDExp2_v<T>;

◆ HasSIMDExp_v

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

Auxiliary variable template for the HasSIMDExp type trait.The HasSIMDExp_v variable template provides a convenient shortcut to access the nested value of the HasSIMDExp class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDExp<T>::value;
constexpr bool value2 = blaze::HasSIMDExp_v<T>;

◆ HasSIMDFloor_v

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

Auxiliary variable template for the HasSIMDFloor type trait.The HasSIMDFloor_v variable template provides a convenient shortcut to access the nested value of the HasSIMDFloor class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDFloor<T>::value;
constexpr bool value2 = blaze::HasSIMDFloor_v<T>;

◆ HasSIMDHypot_v

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

Auxiliary variable template for the HasSIMDHypot type trait.The HasSIMDHypot_v variable template provides a convenient shortcut to access the nested value of the HasSIMDHypot class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDHypot<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDHypot_v<T1,T2>;

◆ HasSIMDInvCbrt_v

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

Auxiliary variable template for the HasSIMDInvCbrt type trait.The HasSIMDInvCbrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvCbrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDInvCbrt<T>::value;
constexpr bool value2 = blaze::HasSIMDInvCbrt_v<T>;

◆ HasSIMDInvSqrt_v

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

Auxiliary variable template for the HasSIMDInvSqrt type trait.The HasSIMDInvSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDInvSqrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDInvSqrt<T>::value;
constexpr bool value2 = blaze::HasSIMDInvSqrt_v<T>;

◆ HasSIMDLog10_v

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

Auxiliary variable template for the HasSIMDLog10 type trait.The HasSIMDLog10_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog10 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDLog10<T>::value;
constexpr bool value2 = blaze::HasSIMDLog10_v<T>;

◆ HasSIMDLog2_v

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

Auxiliary variable template for the HasSIMDLog2 type trait.The HasSIMDLog2_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog2 class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDLog2<T>::value;
constexpr bool value2 = blaze::HasSIMDLog2_v<T>;

◆ HasSIMDLog_v

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

Auxiliary variable template for the HasSIMDLog type trait.The HasSIMDLog_v variable template provides a convenient shortcut to access the nested value of the HasSIMDLog class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDLog<T>::value;
constexpr bool value2 = blaze::HasSIMDLog_v<T>;

◆ HasSIMDMax_v

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

Auxiliary variable template for the HasSIMDMax type trait.The HasSIMDMax_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMax class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDMax<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDMax_v<T1,T2>;

◆ HasSIMDMin_v

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

Auxiliary variable template for the HasSIMDMin type trait.The HasSIMDMin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMin class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDMin<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDMin_v<T1,T2>;

◆ HasSIMDMult_v

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

Auxiliary variable template for the HasSIMDMult type trait.The HasSIMDMult_v variable template provides a convenient shortcut to access the nested value of the HasSIMDMult class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDMult<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDMult_v<T1,T2>;

◆ HasSIMDPow_v

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

Auxiliary variable template for the HasSIMDPow type trait.The HasSIMDPow_v variable template provides a convenient shortcut to access the nested value of the HasSIMDPow class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDPow<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDPow_v<T1,T2>;

◆ HasSIMDRound_v

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

Auxiliary variable template for the HasSIMDRound type trait.The HasSIMDRound_v variable template provides a convenient shortcut to access the nested value of the HasSIMDRound class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDRound<T>::value;
constexpr bool value2 = blaze::HasSIMDRound_v<T>;

◆ HasSIMDSign_v

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

Auxiliary variable template for the HasSIMDSign type trait.The HasSIMDSign_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSign class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDSign<T>::value;
constexpr bool value2 = blaze::HasSIMDSign_v<T>;

◆ HasSIMDSin_v

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

Auxiliary variable template for the HasSIMDSin type trait.The HasSIMDSin_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSin class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDSin<T>::value;
constexpr bool value2 = blaze::HasSIMDSin_v<T>;

◆ HasSIMDSinh_v

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

Auxiliary variable template for the HasSIMDSinh type trait.The HasSIMDSinh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSinh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDSinh<T>::value;
constexpr bool value2 = blaze::HasSIMDSinh_v<T>;

◆ HasSIMDSqrt_v

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

Auxiliary variable template for the HasSIMDSqrt type trait.The HasSIMDSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSqrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDSqrt<T>::value;
constexpr bool value2 = blaze::HasSIMDSqrt_v<T>;

◆ HasSIMDSub_v

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

Auxiliary variable template for the HasSIMDSub type trait.The HasSIMDSub_v variable template provides a convenient shortcut to access the nested value of the HasSIMDSub class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDSub<T1,T2>::value;
constexpr bool value2 = blaze::HasSIMDSub_v<T1,T2>;

◆ HasSIMDTan_v

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

Auxiliary variable template for the HasSIMDTan type trait.The HasSIMDTan_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTan class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDTan<T>::value;
constexpr bool value2 = blaze::HasSIMDTan_v<T>;

◆ HasSIMDTanh_v

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

Auxiliary variable template for the HasSIMDTanh type trait.The HasSIMDTanh_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTanh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDTanh<T>::value;
constexpr bool value2 = blaze::HasSIMDTanh_v<T>;

◆ HasSIMDTrunc_v

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

Auxiliary variable template for the HasSIMDTrunc type trait.The HasSIMDTrunc_v variable template provides a convenient shortcut to access the nested value of the HasSIMDTrunc class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSIMDTrunc<T>::value;
constexpr bool value2 = blaze::HasSIMDTrunc_v<T>;

◆ HasSin_v

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

Auxiliary variable template for the HasSin type trait.The HasSin_v variable template provides a convenient shortcut to access the nested value of the HasSin class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSin<T>::value;
constexpr bool value2 = blaze::HasSin_v<T>;

◆ HasSinh_v

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

Auxiliary variable template for the HasSinh type trait.The HasSinh_v variable template provides a convenient shortcut to access the nested value of the HasSinh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSinh<T>::value;
constexpr bool value2 = blaze::HasSinh_v<T>;

◆ HasSize_v

template<typename T , size_t Size>
constexpr bool blaze::HasSize_v = HasSize<T,Size>::value

Auxiliary variable template for the HasSize type trait.The HasSize_v variable template provides a convenient shortcut to access the nested value of the HasSize class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSize<T,8UL>::value;
constexpr bool value2 = blaze::HasSize_v<T,8UL>;

◆ HasSqrt_v

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

Auxiliary variable template for the HasSqrt type trait.The HasSqrt_v variable template provides a convenient shortcut to access the nested value of the HasSqrt class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasSqrt<T>::value;
constexpr bool value2 = blaze::HasSqrt_v<T>;

◆ HasSub_v

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

Auxiliary variable template for the HasSub type trait.The HasSub_v variable template provides a convenient shortcut to access the nested value of the HasSub class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasSub<T1,T2>::value;
constexpr bool value2 = blaze::HasSub_v<T1,T2>;

◆ HasTan_v

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

Auxiliary variable template for the HasTan type trait.The HasTan_v variable template provides a convenient shortcut to access the nested value of the HasTan class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasTan<T>::value;
constexpr bool value2 = blaze::HasTan_v<T>;

◆ HasTanh_v

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

Auxiliary variable template for the HasTanh type trait.The HasTanh_v variable template provides a convenient shortcut to access the nested value of the HasTanh class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasTanh<T>::value;
constexpr bool value2 = blaze::HasTanh_v<T>;

◆ HasTrunc_v

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

Auxiliary variable template for the HasTrunc type trait.The HasTrunc_v variable template provides a convenient shortcut to access the nested value of the HasTrunc class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::HasTrunc<T>::value;
constexpr bool value2 = blaze::HasTrunc_v<T>;

◆ HaveSameSize_v

template<typename T1 , typename T2 >
constexpr bool blaze::HaveSameSize_v = HaveSameSize<T1,T2>::value

Auxiliary variable template for the HaveSameSize type trait.The HaveSameSize_v variable template provides a convenient shortcut to access the nested value of the HaveSameSize class template. For instance, given the typew T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HaveSameSize<T1,T2>::value;
constexpr bool value2 = blaze::HaveSameSize_v<T1,T2>;

◆ IndexOf_v

template<typename TL , typename T >
constexpr size_t blaze::IndexOf_v = IndexOf<TL,T>::value

Auxiliary variable template for the IndexOf type trait.The IndexOf_v variable template provides a convenient shortcut to access the nested value of the IndexOf class template. For instance, given the type list TL and the type T the following two statements are identical:

constexpr size_t value1 = IndexOf<TL,T>::value;
constexpr size_t value2 = IndexOf_v<TL,T>;

◆ IsAdaptor_v

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

Auxiliary variable template for the IsAdaptor type trait.The IsAdaptor_v variable template provides a convenient shortcut to access the nested value of the IsAdaptor class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsAdaptor<T>::value;
constexpr bool value2 = blaze::IsAdaptor_v<T>;

◆ IsAddExpr_v

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

Auxiliary variable template for the IsAddExpr type trait.The IsAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsAddExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsAddExpr<T>::value;
constexpr bool value2 = blaze::IsAddExpr_v<T>;

◆ IsAligned_v

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

Auxiliary variable template for the IsAligned type trait.The IsAligned_v variable template provides a convenient shortcut to access the nested value of the IsAligned class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsAligned<T>::value;
constexpr bool value2 = blaze::IsAligned_v<T>;

◆ IsArithmetic_v

template<typename T >
constexpr bool blaze::IsArithmetic_v = IsArithmetic<T>::value

Auxiliary variable template for the IsArithmetic type trait.The IsArithmetic_v variable template provides a convenient shortcut to access the nested value of the IsArithmetic class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsArithmetic<T>::value;
constexpr bool value2 = blaze::IsArithmetic_v<T>;

◆ IsArray_v

template<typename T >
constexpr bool blaze::IsArray_v = IsArray<T>::value

Auxiliary variable template for the IsArray type trait.The IsArray_v variable template provides a convenient shortcut to access the nested value of the IsArray class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsArray<T>::value;
constexpr bool value2 = blaze::IsArray_v<T>;

◆ IsAssignable_v

template<typename T , typename U >
constexpr bool blaze::IsAssignable_v = IsAssignable<T,U>::value

Auxiliary variable template for the IsAssignable type trait.The IsAssignable_v variable template provides a convenient shortcut to access the nested value of the IsAssignable class template. For instance, given the types T and U the following two statements are identical:

constexpr bool value1 = blaze::IsAssignable<T,U>::value;
constexpr bool value2 = blaze::IsAssignable_v<T,U>;

◆ IsBand_v

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

Auxiliary variable template for the IsBand type trait.The IsBand_v variable template provides a convenient shortcut to access the nested value of the IsBand class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsBand<T>::value;
constexpr bool value2 = blaze::IsBand_v<T>;

◆ IsBaseOf_v

template<typename Base , typename Derived >
constexpr bool blaze::IsBaseOf_v = IsBaseOf<Base,Derived>::value

Auxiliary variable template for the IsBaseOf type trait.The IsBaseOf_v variable template provides a convenient shortcut to access the nested value of the IsBaseOf class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsBaseOf<T1,T2>::value;
constexpr bool value2 = blaze::IsBaseOf_v<T1,T2>;

◆ IsBinaryMapExpr_v

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

Auxiliary variable template for the IsBinaryMapExpr type trait.The IsBinaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsBinaryMapExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsBinaryMapExpr<T>::value;
constexpr bool value2 = blaze::IsBinaryMapExpr_v<T>;

◆ IsBLASCompatible_v

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

Auxiliary variable template for the IsBLASCompatible type trait.The IsBLASCompatible_v variable template provides a convenient shortcut to access the nested value of the IsBLASCompatible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsBLASCompatible<T>::value;
constexpr bool value2 = blaze::IsBLASCompatible_v<T>;

◆ IsBoolean_v

template<typename T >
constexpr bool blaze::IsBoolean_v = IsBoolean<T>::value

Auxiliary variable template for the IsBoolean type trait.The IsBoolean_v variable template provides a convenient shortcut to access the nested value of the IsBoolean class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsBoolean<T>::value;
constexpr bool value2 = blaze::IsBoolean_v<T>;

◆ IsBuiltin_v

template<typename T >
constexpr bool blaze::IsBuiltin_v = IsBuiltin<T>::value

Auxiliary variable template for the IsBuiltin type trait.The IsBuiltin_v variable template provides a convenient shortcut to access the nested value of the IsBuiltin class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsBuiltin<T>::value;
constexpr bool value2 = blaze::IsBuiltin_v<T>;

◆ IsCharacter_v

template<typename T >
constexpr bool blaze::IsCharacter_v = IsCharacter<T>::value

Auxiliary variable template for the IsCharacter type trait.The IsCharacter_v variable template provides a convenient shortcut to access the nested value of the IsCharacter class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCharacter<T>::value;
constexpr bool value2 = blaze::IsCharacter_v<T>;

◆ IsClass_v

template<typename T >
constexpr bool blaze::IsClass_v = IsClass<T>::value

Auxiliary variable template for the IsClass type trait.The IsClass_v variable template provides a convenient shortcut to access the nested value of the IsClass class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsClass<T>::value;
constexpr bool value2 = blaze::IsClass_v<T>;

◆ IsColumn_v

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

Auxiliary variable template for the IsColumn type trait.The IsColumn_v variable template provides a convenient shortcut to access the nested value of the IsColumn class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsColumn<T>::value;
constexpr bool value2 = blaze::IsColumn_v<T>;

◆ IsColumnMajorMatrix_v

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

Auxiliary variable template for the IsColumnMajorMatrix type trait.The IsColumnMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsColumnMajorMatrix class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsColumnMajorMatrix<T>::value;
constexpr bool value2 = blaze::IsColumnMajorMatrix_v<T>;

◆ IsColumns_v

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

Auxiliary variable template for the IsColumns type trait.The IsColumns_v variable template provides a convenient shortcut to access the nested value of the IsColumns class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsColumns<T>::value;
constexpr bool value2 = blaze::IsColumns_v<T>;

◆ IsColumnVector_v

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

Auxiliary variable template for the IsColumnVector type trait.The IsColumnVector_v variable template provides a convenient shortcut to access the nested value of the IsColumnVector class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsColumnVector<T>::value;
constexpr bool value2 = blaze::IsColumnVector_v<T>;

◆ IsCommutative_v

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

Auxiliary variable template for the IsCommutative type trait.The IsCommutative_v variable template provides a convenient shortcut to access the nested value of the IsCommutative class template. For instance, given the type1 T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsCommutative<T1,T2>::value;
constexpr bool value2 = blaze::IsCommutative_v<T1,T2>;

◆ IsComplex_v

template<typename T >
constexpr bool blaze::IsComplex_v = IsComplex<T>::value

Auxiliary variable template for the IsComplex type trait.The IsComplex_v variable template provides a convenient shortcut to access the nested value of the IsComplex class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsComplex<T>::value;
constexpr bool value2 = blaze::IsComplex_v<T>;

◆ IsComplexDouble_v

template<typename T >
constexpr bool blaze::IsComplexDouble_v = IsComplexDouble<T>::value

Auxiliary variable template for the IsComplexDouble type trait.The IsComplexDouble_v variable template provides a convenient shortcut to access the nested value of the IsComplexDouble class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsComplexDouble<T>::value;
constexpr bool value2 = blaze::IsComplexDouble_v<T>;

◆ IsComplexFloat_v

template<typename T >
constexpr bool blaze::IsComplexFloat_v = IsComplexFloat<T>::value

Auxiliary variable template for the IsComplexFloat type trait.The IsComplexFloat_v variable template provides a convenient shortcut to access the nested value of the IsComplexFloat class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsComplexFloat<T>::value;
constexpr bool value2 = blaze::IsComplexFloat_v<T>;

◆ IsComputation_v

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

Auxiliary variable template for the IsComputation type trait.The IsComputation_v variable template provides a convenient shortcut to access the nested value of the IsComputation class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsComputation<T>::value;
constexpr bool value2 = blaze::IsComputation_v<T>;

◆ IsConst_v

template<typename T >
constexpr bool blaze::IsConst_v = IsConst<T>::value

Auxiliary variable template for the IsConst type trait.The IsConst_v variable template provides a convenient shortcut to access the nested value of the IsConst class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsConst<T>::value;
constexpr bool value2 = blaze::IsConst_v<T>;

◆ IsConstructible_v

template<typename T , typename... Args>
constexpr bool blaze::IsConstructible_v = IsConstructible<T>::value

Auxiliary variable template for the IsConstructible type trait.The IsConstructible_v variable template provides a convenient shortcut to access the nested value of the IsConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical:

constexpr bool value2 = blaze::IsConstructible_v<T1,T2,T3>;

◆ IsContiguous_v

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

Auxiliary variable template for the IsContiguous type trait.The IsContiguous_v variable template provides a convenient shortcut to access the nested value of the IsContiguous class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsContiguous<T>::value;
constexpr bool value2 = blaze::IsContiguous_v<T>;

◆ IsConvertible_v

template<typename From , typename To >
constexpr bool blaze::IsConvertible_v = IsConvertible<From,To>::value

Auxiliary variable template for the IsConvertible type trait.The IsConvertible_v variable template provides a convenient shortcut to access the nested value of the IsConvertible class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsConvertible<T1,T2>::value;
constexpr bool value2 = blaze::IsConvertible_v<T1,T2>;

◆ IsCopyAssignable_v

template<typename T >
constexpr bool blaze::IsCopyAssignable_v = IsCopyAssignable<T>::value

Auxiliary variable template for the IsCopyAssignable type trait.The IsCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsCopyAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCopyAssignable<T>::value;
constexpr bool value2 = blaze::IsCopyAssignable_v<T>;

◆ IsCopyConstructible_v

template<typename T >
constexpr bool blaze::IsCopyConstructible_v = IsCopyConstructible<T>::value

Auxiliary variable template for the IsCopyConstructible type trait.The IsCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsCopyConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCopyConstructible<T>::value;
constexpr bool value2 = blaze::IsCopyConstructible_v<T>;

◆ IsCrossExpr_v

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

Auxiliary variable template for the IsCrossExpr type trait.The IsCrossExpr_v variable template provides a convenient shortcut to access the nested value of the IsCrossExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCrossExpr<T>::value;
constexpr bool value2 = blaze::IsCrossExpr_v<T>;

◆ IsCustom_v

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

Auxiliary variable template for the IsCustom type trait.The IsCustom_v variable template provides a convenient shortcut to access the nested value of the IsCustom class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsCustom<T>::value;
constexpr bool value2 = blaze::IsCustom_v<T>;

◆ IsDeclaration_v

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

Auxiliary variable template for the IsDeclaration type trait.The IsDeclaration_v variable template provides a convenient shortcut to access the nested value of the IsDeclaration class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclaration<T>::value;
constexpr bool value2 = blaze::IsDeclaration_v<T>;

◆ IsDeclDiagExpr_v

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

Auxiliary variable template for the IsDeclDiagExpr type trait.The IsDeclDiagExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclDiagExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclDiagExpr<T>::value;
constexpr bool value2 = blaze::IsDeclDiagExpr_v<T>;

◆ IsDeclExpr_v

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

Auxiliary variable template for the IsDeclExpr type trait.The IsDeclExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclExpr<T>::value;
constexpr bool value2 = blaze::IsDeclExpr_v<T>;

◆ IsDeclHermExpr_v

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

Auxiliary variable template for the IsDeclHermExpr type trait.The IsDeclHermExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclHermExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclHermExpr<T>::value;
constexpr bool value2 = blaze::IsDeclHermExpr_v<T>;

◆ IsDeclLowExpr_v

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

Auxiliary variable template for the IsDeclLowExpr type trait.The IsDeclLowExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclLowExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclLowExpr<T>::value;
constexpr bool value2 = blaze::IsDeclLowExpr_v<T>;

◆ IsDeclSymExpr_v

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

Auxiliary variable template for the IsDeclSymExpr type trait.The IsDeclSymExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclSymExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclSymExpr<T>::value;
constexpr bool value2 = blaze::IsDeclSymExpr_v<T>;

◆ IsDeclUppExpr_v

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

Auxiliary variable template for the IsDeclUppExpr type trait.The IsDeclUppExpr_v variable template provides a convenient shortcut to access the nested value of the IsDeclUppExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDeclUppExpr<T>::value;
constexpr bool value2 = blaze::IsDeclUppExpr_v<T>;

◆ IsDefaultConstructible_v

template<typename T >
constexpr bool blaze::IsDefaultConstructible_v = IsDefaultConstructible<T>::value

Auxiliary variable template for the IsDefaultConstructible type trait.The IsDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsDefaultConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsDefaultConstructible_v<T>;

◆ IsDenseMatrix_v

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

Auxiliary variable template for the IsDenseMatrix type trait.The IsDenseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsDenseMatrix class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDenseMatrix<T>::value;
constexpr bool value2 = blaze::IsDenseMatrix_v<T>;

◆ IsDenseVector_v

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

Auxiliary variable template for the IsDenseVector type trait.The IsDenseVector_v variable template provides a convenient shortcut to access the nested value of the IsDenseVector class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDenseVector<T>::value;
constexpr bool value2 = blaze::IsDenseVector_v<T>;

◆ IsDestructible_v

template<typename T >
constexpr bool blaze::IsDestructible_v = IsDestructible<T>::value

Auxiliary variable template for the IsDestructible type trait.The IsDestructible_v variable template provides a convenient shortcut to access the nested value of the IsDestructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDestructible<T>::value;
constexpr bool value2 = blaze::IsDestructible_v<T>;

◆ IsDiagonal_v

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

Auxiliary variable template for the IsDiagonal type trait.The IsDiagonal_v variable template provides a convenient shortcut to access the nested value of the IsDiagonal class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDiagonal<T>::value;
constexpr bool value2 = blaze::IsDiagonal_v<T>;

◆ IsDivExpr_v

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

Auxiliary variable template for the IsDivExpr type trait.The IsDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsDivExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDivExpr<T>::value;
constexpr bool value2 = blaze::IsDivExpr_v<T>;

◆ IsDouble_v

template<typename T >
constexpr bool blaze::IsDouble_v = IsDouble<T>::value

Auxiliary variable template for the IsDouble type trait.The IsDouble_v variable template provides a convenient shortcut to access the nested value of the IsDouble class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsDouble<T>::value;
constexpr bool value2 = blaze::IsDouble_v<T>;

◆ IsElements_v

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

Auxiliary variable template for the IsElements type trait.The IsElements_v variable template provides a convenient shortcut to access the nested value of the IsElements class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsElements<T>::value;
constexpr bool value2 = blaze::IsElements_v<T>;

◆ IsEmpty_v

template<typename T >
constexpr bool blaze::IsEmpty_v = IsEmpty<T>::value

Auxiliary variable template for the IsEmpty type trait.The IsEmpty_v variable template provides a convenient shortcut to access the nested value of the IsEmpty class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsEmpty<T>::value;
constexpr bool value2 = blaze::IsEmpty_v<T>;

◆ IsEnum_v

template<typename T >
constexpr bool blaze::IsEnum_v = IsEnum<T>::value

Auxiliary variable template for the IsEnum type trait.The IsEnum_v variable template provides a convenient shortcut to access the nested value of the IsEnum class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsEnum<T>::value;
constexpr bool value2 = blaze::IsEnum_v<T>;

◆ IsEvalExpr_v

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

Auxiliary variable template for the IsEvalExpr type trait.The IsEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsEvalExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsEvalExpr<T>::value;
constexpr bool value2 = blaze::IsEvalExpr_v<T>;

◆ IsExpandExpr_v

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

Auxiliary variable template for the IsExpandExpr type trait.The IsExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsExpandExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsExpandExpr<T>::value;
constexpr bool value2 = blaze::IsExpandExpr_v<T>;

◆ IsExpression_v

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

Auxiliary variable template for the IsExpression type trait.The IsExpression_v variable template provides a convenient shortcut to access the nested value of the IsExpression class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsExpression<T>::value;
constexpr bool value2 = blaze::IsExpression_v<T>;

◆ IsFloat_v

template<typename T >
constexpr bool blaze::IsFloat_v = IsFloat<T>::value

Auxiliary variable template for the IsFloat type trait.The IsFloat_v variable template provides a convenient shortcut to access the nested value of the IsFloat class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsFloat<T>::value;
constexpr bool value2 = blaze::IsFloat_v<T>;

◆ IsFloatingPoint_v

template<typename T >
constexpr bool blaze::IsFloatingPoint_v = IsFloatingPoint<T>::value

Auxiliary variable template for the IsFloatingPoint type trait.The IsFloatingPoint_v variable template provides a convenient shortcut to access the nested value of the IsFloatingPoint class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsFloatingPoint<T>::value;
constexpr bool value2 = blaze::IsFloatingPoint_v<T>;

◆ IsGeneral_v

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

Auxiliary variable template for the IsGeneral type trait.The IsGeneral_v variable template provides a convenient shortcut to access the nested value of the IsGeneral class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsGeneral<T>::value;
constexpr bool value2 = blaze::IsGeneral_v<T>;

◆ IsHermitian_v

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

Auxiliary variable template for the IsHermitian type trait.The IsHermitian_v variable template provides a convenient shortcut to access the nested value of the IsHermitian class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsHermitian<T>::value;
constexpr bool value2 = blaze::IsHermitian_v<T>;

◆ IsIdentity_v

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

Auxiliary variable template for the IsIdentity type trait.The IsIdentity_v variable template provides a convenient shortcut to access the nested value of the IsIdentity class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsIdentity<T>::value;
constexpr bool value2 = blaze::IsIdentity_v<T>;

◆ IsInitializer_v

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

Auxiliary variable template for the IsInitializer type trait.The IsInitializer_v variable template provides a convenient shortcut to access the nested value of the IsInitializer class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsInitializer<T>::value;
constexpr bool value2 = blaze::IsInitializer_v<T>;

◆ IsInteger_v

template<typename T >
constexpr bool blaze::IsInteger_v = IsInteger<T>::value

Auxiliary variable template for the IsInteger type trait.The IsInteger_v variable template provides a convenient shortcut to access the nested value of the IsInteger class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsInteger<T>::value;
constexpr bool value2 = blaze::IsInteger_v<T>;

◆ IsIntegral_v

template<typename T >
constexpr bool blaze::IsIntegral_v = IsIntegral<T>::value

Auxiliary variable template for the IsIntegral type trait.The IsIntegral_v variable template provides a convenient shortcut to access the nested value of the IsIntegral class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsIntegral<T>::value;
constexpr bool value2 = blaze::IsIntegral_v<T>;

◆ IsInvertible_v

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

Auxiliary variable template for the IsInvertible type trait.The IsInvertible_v variable template provides a convenient shortcut to access the nested value of the IsInvertible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsInvertible<T>::value;
constexpr bool value2 = blaze::IsInvertible_v<T>;

◆ IsLong_v

template<typename T >
constexpr bool blaze::IsLong_v = IsLong<T>::value

Auxiliary variable template for the IsLong type trait.The IsLong_v variable template provides a convenient shortcut to access the nested value of the IsLong class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsLong<T>::value;
constexpr bool value2 = blaze::IsLong_v<T>;

◆ IsLongDouble_v

template<typename T >
constexpr bool blaze::IsLongDouble_v = IsLongDouble<T>::value

Auxiliary variable template for the IsLongDouble type trait.The IsLongDouble_v variable template provides a convenient shortcut to access the nested value of the IsLongDouble class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsLongDouble<T>::value;
constexpr bool value2 = blaze::IsLongDouble_v<T>;

◆ IsLower_v

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

Auxiliary variable template for the IsLower type trait.The IsLower_v variable template provides a convenient shortcut to access the nested value of the IsLower class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsLower<T>::value;
constexpr bool value2 = blaze::IsLower_v<T>;

◆ IsLValueReference_v

template<typename T >
constexpr bool blaze::IsLValueReference_v = IsLValueReference<T>::value

Auxiliary variable template for the IsLValueReference type trait.The IsLValueReference_v variable template provides a convenient shortcut to access the nested value of the IsLValueReference class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsLValueReference<T>::value;
constexpr bool value2 = blaze::IsLValueReference_v<T>;

◆ IsMatEvalExpr_v

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

Auxiliary variable template for the IsMatEvalExpr type trait.The IsMatEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatEvalExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatEvalExpr<T>::value;
constexpr bool value2 = blaze::IsMatEvalExpr_v<T>;

◆ IsMatInvExpr_v

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

Auxiliary variable template for the IsMatInvExpr type trait.The IsMatInvExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatInvExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatInvExpr<T>::value;
constexpr bool value2 = blaze::IsMatInvExpr_v<T>;

◆ IsMatMapExpr_v

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

Auxiliary variable template for the IsMatMapExpr type trait.The IsMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMapExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatMapExpr<T>::value;
constexpr bool value2 = blaze::IsMatMapExpr_v<T>;

◆ IsMatMatAddExpr_v

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

Auxiliary variable template for the IsMatMatAddExpr type trait.The IsMatMatAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatAddExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatMatAddExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatAddExpr_v<T>;

◆ IsMatMatMapExpr_v

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

Auxiliary variable template for the IsMatMatMapExpr type trait.The IsMatMatMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMapExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatMatMapExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatMapExpr_v<T>;

◆ IsMatMatMultExpr_v

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

Auxiliary variable template for the IsMatMatMultExpr type trait.The IsMatMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatMatMultExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatMultExpr_v<T>;

◆ IsMatMatSubExpr_v

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

Auxiliary variable template for the IsMatMatSubExpr type trait.The IsMatMatSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatMatSubExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatMatSubExpr<T>::value;
constexpr bool value2 = blaze::IsMatMatSubExpr_v<T>;

◆ IsMatReduceExpr_v

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

Auxiliary variable template for the IsMatReduceExpr type trait.The IsMatReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatReduceExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatReduceExpr<T>::value;
constexpr bool value2 = blaze::IsMatReduceExpr_v<T>;

◆ IsMatrix_v

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

Auxiliary variable template for the IsMatrix type trait.The IsMatrix_v variable template provides a convenient shortcut to access the nested value of the IsMatrix class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatrix<T>::value;
constexpr bool value2 = blaze::IsMatrix_v<T>;

◆ IsMatScalarDivExpr_v

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

Auxiliary variable template for the IsMatScalarDivExpr type trait.The IsMatScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarDivExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatScalarDivExpr<T>::value;
constexpr bool value2 = blaze::IsMatScalarDivExpr_v<T>;

◆ IsMatScalarMultExpr_v

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

Auxiliary variable template for the IsMatScalarMultExpr type trait.The IsMatScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatScalarMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatScalarMultExpr<T>::value;
constexpr bool value2 = blaze::IsMatScalarMultExpr_v<T>;

◆ IsMatSerialExpr_v

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

Auxiliary variable template for the IsMatSerialExpr type trait.The IsMatSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatSerialExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatSerialExpr<T>::value;
constexpr bool value2 = blaze::IsMatSerialExpr_v<T>;

◆ IsMatTransExpr_v

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

Auxiliary variable template for the IsMatTransExpr type trait.The IsMatTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatTransExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatTransExpr<T>::value;
constexpr bool value2 = blaze::IsMatTransExpr_v<T>;

◆ IsMatVecMultExpr_v

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

Auxiliary variable template for the IsMatVecMultExpr type trait.The IsMatVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMatVecMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMatVecMultExpr<T>::value;
constexpr bool value2 = blaze::IsMatVecMultExpr_v<T>;

◆ IsMoveAssignable_v

template<typename T >
constexpr bool blaze::IsMoveAssignable_v = IsMoveAssignable<T>::value

Auxiliary variable template for the IsMoveAssignable type trait.The IsMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsMoveAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMoveAssignable<T>::value;
constexpr bool value2 = blaze::IsMoveAssignable_v<T>;

◆ IsMoveConstructible_v

template<typename T >
constexpr bool blaze::IsMoveConstructible_v = IsMoveConstructible<T>::value

Auxiliary variable template for the IsMoveConstructible type trait.The IsMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsMoveConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMoveConstructible<T>::value;
constexpr bool value2 = blaze::IsMoveConstructible_v<T>;

◆ IsMultExpr_v

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

Auxiliary variable template for the IsMultExpr type trait.The IsMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsMultExpr<T>::value;
constexpr bool value2 = blaze::IsMultExpr_v<T>;

◆ IsNothrowAssignable_v

template<typename T , typename U >
constexpr bool blaze::IsNothrowAssignable_v = IsNothrowAssignable<T,U>::value

Auxiliary variable template for the IsNothrowAssignable type trait.The IsNothrowAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowAssignable class template. For instance, given the types T and U the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowAssignable_v<T,U>;

◆ IsNothrowConstructible_v

template<typename T , typename... Args>
constexpr bool blaze::IsNothrowConstructible_v = IsNothrowConstructible<T>::value

Auxiliary variable template for the IsNothrowConstructible type trait.The IsNothrowConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowConstructible class template. For instance, given the types T1, T2 and T3 the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowConstructible_v<T1,T2,T3>;

◆ IsNothrowCopyAssignable_v

template<typename T >
constexpr bool blaze::IsNothrowCopyAssignable_v = IsNothrowCopyAssignable<T>::value

Auxiliary variable template for the IsNothrowCopyAssignable type trait.The IsNothrowCopyAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowCopyAssignable_v<T>;

◆ IsNothrowCopyConstructible_v

template<typename T >
constexpr bool blaze::IsNothrowCopyConstructible_v = IsNothrowCopyConstructible<T>::value

Auxiliary variable template for the IsNothrowCopyConstructible type trait.The IsNothrowCopyConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowCopyConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowCopyConstructible_v<T>;

◆ IsNothrowDefaultConstructible_v

template<typename T >
constexpr bool blaze::IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible<T>::value

Auxiliary variable template for the IsNothrowDefaultConstructible type trait.The IsNothrowDefaultConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDefaultConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowDefaultConstructible_v<T>;

◆ IsNothrowDestructible_v

template<typename T >
constexpr bool blaze::IsNothrowDestructible_v = IsNothrowDestructible<T>::value

Auxiliary variable template for the IsNothrowDestructible type trait.The IsNothrowDestructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowDestructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowDestructible_v<T>;

◆ IsNothrowMoveAssignable_v

template<typename T >
constexpr bool blaze::IsNothrowMoveAssignable_v = IsNothrowMoveAssignable<T>::value

Auxiliary variable template for the IsNothrowMoveAssignable type trait.The IsNothrowMoveAssignable_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowMoveAssignable_v<T>;

◆ IsNothrowMoveConstructible_v

template<typename T >
constexpr bool blaze::IsNothrowMoveConstructible_v = IsNothrowMoveConstructible<T>::value

Auxiliary variable template for the IsNothrowMoveConstructible type trait.The IsNothrowMoveConstructible_v variable template provides a convenient shortcut to access the nested value of the IsNothrowMoveConstructible class template. For instance, given the type T the following two statements are identical:

constexpr bool value2 = blaze::IsNothrowMoveConstructible_v<T>;

◆ IsNumeric_v

template<typename T >
constexpr bool blaze::IsNumeric_v = IsNumeric<T>::value

Auxiliary variable template for the IsNumeric type trait.The IsNumeric_v variable template provides a convenient shortcut to access the nested value of the IsNumeric class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsNumeric<T>::value;
constexpr bool value2 = blaze::IsNumeric_v<T>;

◆ IsNumericMatrix_v

template<typename T >
constexpr bool blaze::IsNumericMatrix_v = IsNumericMatrix<T>::value

Auxiliary variable template for the IsNumericMatrix type trait.The IsNumericMatrix_v variable template provides a convenient shortcut to access the nested value of the IsNumericMatrix class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsNumericMatrix<T>::value;
constexpr bool value2 = blaze::IsNumericMatrix_v<T>;

◆ IsNumericVector_v

template<typename T >
constexpr bool blaze::IsNumericVector_v = IsNumericVector<T>::value

Auxiliary variable template for the IsNumericVector type trait.The IsNumericVector_v variable template provides a convenient shortcut to access the nested value of the IsNumericVector class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsNumericVector<T>::value;
constexpr bool value2 = blaze::IsNumericVector_v<T>;

◆ IsObject_v

template<typename T >
constexpr bool blaze::IsObject_v = IsObject<T>::value

Auxiliary variable template for the IsObject type trait.The IsObject_v variable template provides a convenient shortcut to access the nested value of the IsObject class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsObject<T>::value;
constexpr bool value2 = blaze::IsObject_v<T>;

◆ IsOperation_v

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

Auxiliary variable template for the IsOperation type trait.The IsOperation_v variable template provides a convenient shortcut to access the nested value of the IsOperation class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsOperation<T>::value;
constexpr bool value2 = blaze::IsOperation_v<T>;

◆ IsOpposedView_v

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

Auxiliary variable template for the IsOpposedView type trait.The IsOpposedView_v variable template provides a convenient shortcut to access the nested value of the IsOpposedView class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsOpposedView<T>::value;
constexpr bool value2 = blaze::IsOpposedView_v<T>;

◆ IsPadded_v

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

Auxiliary variable template for the IsPadded type trait.The IsPadded_v variable template provides a convenient shortcut to access the nested value of the IsPadded class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsPadded<T>::value;
constexpr bool value2 = blaze::IsPadded_v<T>;

◆ IsPaddingEnabled_v

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

Auxiliary variable template for the IsPaddingEnabled type trait.The IsPaddingEnabled_v variable template provides a convenient shortcut to access the nested value of the IsPaddingEnabled class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsPaddingEnabled<T>::value;
constexpr bool value2 = blaze::IsPaddingEnabled_v<T>;

◆ IsPod_v

template<typename T >
constexpr bool blaze::IsPod_v = IsPod<T>::value

Auxiliary variable template for the IsPod type trait.The IsPod_v variable template provides a convenient shortcut to access the nested value of the IsPod class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsPod<T>::value;
constexpr bool value2 = blaze::IsPod_v<T>;

◆ IsPointer_v

template<typename T >
constexpr bool blaze::IsPointer_v = IsPointer<T>::value

Auxiliary variable template for the IsPointer type trait.The IsPointer_v variable template provides a convenient shortcut to access the nested value of the IsPointer class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsPointer<T>::value;
constexpr bool value2 = blaze::IsPointer_v<T>;

◆ IsProxy_v

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

Auxiliary variable template for the IsProxy type trait.The IsProxy_v variable template provides a convenient shortcut to access the nested value of the IsProxy class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsProxy<T>::value;
constexpr bool value2 = blaze::IsProxy_v<T>;

◆ IsReduceExpr_v

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

Auxiliary variable template for the IsReduceExpr type trait.The IsReduceExpr_v variable template provides a convenient shortcut to access the nested value of the IsReduceExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsReduceExpr<T>::value;
constexpr bool value2 = blaze::IsReduceExpr_v<T>;

◆ IsReference_v

template<typename T >
constexpr bool blaze::IsReference_v = IsReference<T>::value

Auxiliary variable template for the IsReference type trait.The IsReference_v variable template provides a convenient shortcut to access the nested value of the IsReference class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsReference<T>::value;
constexpr bool value2 = blaze::IsReference_v<T>;

◆ IsResizable_v

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

Auxiliary variable template for the IsResizable type trait.The IsResizable_v variable template provides a convenient shortcut to access the nested value of the IsResizable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsResizable<T>::value;
constexpr bool value2 = blaze::IsResizable_v<T>;

◆ IsRestricted_v

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

Auxiliary variable template for the IsRestricted type trait.The IsRestricted_v variable template provides a convenient shortcut to access the nested value of the IsRestricted class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRestricted<T>::value;
constexpr bool value2 = blaze::IsRestricted_v<T>;

◆ IsRow_v

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

Auxiliary variable template for the IsRow type trait.The IsRow_v variable template provides a convenient shortcut to access the nested value of the IsRow class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRow<T>::value;
constexpr bool value2 = blaze::IsRow_v<T>;

◆ IsRowMajorMatrix_v

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

Auxiliary variable template for the IsRowMajorMatrix type trait.The IsRowMajorMatrix_v variable template provides a convenient shortcut to access the nested value of the IsRowMajorMatrix class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRowMajorMatrix<T>::value;
constexpr bool value2 = blaze::IsRowMajorMatrix_v<T>;

◆ IsRows_v

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

Auxiliary variable template for the IsRows type trait.The IsRows_v variable template provides a convenient shortcut to access the nested value of the IsRows class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRows<T>::value;
constexpr bool value2 = blaze::IsRows_v<T>;

◆ IsRowVector_v

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

Auxiliary variable template for the IsRowVector type trait.The IsRowVector_v variable template provides a convenient shortcut to access the nested value of the IsRowVector class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRowVector<T>::value;
constexpr bool value2 = blaze::IsRowVector_v<T>;

◆ IsRValueReference_v

template<typename T >
constexpr bool blaze::IsRValueReference_v = IsRValueReference<T>::value

Auxiliary variable template for the IsRValueReference type trait.The IsRValueReference_v variable template provides a convenient shortcut to access the nested value of the IsRValueReference class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsRValueReference<T>::value;
constexpr bool value2 = blaze::IsRValueReference_v<T>;

◆ IsSame_v

template<typename A , typename B >
constexpr bool blaze::IsSame_v = IsSame<A,B>::value

Auxiliary variable template for the IsSame type trait.The IsSame_v variable template provides a convenient shortcut to access the nested value of the IsSame class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsSame<T1,T2>::value;
constexpr bool value2 = blaze::IsSame_v<T1,T2>;

◆ IsSchurExpr_v

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

Auxiliary variable template for the IsSchurExpr type trait.The IsSchurExpr_v variable template provides a convenient shortcut to access the nested value of the IsSchurExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSchurExpr<T>::value;
constexpr bool value2 = blaze::IsSchurExpr_v<T>;

◆ IsSerialExpr_v

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

Auxiliary variable template for the IsSerialExpr type trait.The IsSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsSerialExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSerialExpr<T>::value;
constexpr bool value2 = blaze::IsSerialExpr_v<T>;

◆ IsShort_v

template<typename T >
constexpr bool blaze::IsShort_v = IsShort<T>::value

Auxiliary variable template for the IsShort type trait.The IsShort_v variable template provides a convenient shortcut to access the nested value of the IsShort class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsShort<T>::value;
constexpr bool value2 = blaze::IsShort_v<T>;

◆ IsShrinkable_v

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

Auxiliary variable template for the IsShrinkable type trait.The IsShrinkable_v variable template provides a convenient shortcut to access the nested value of the IsShrinkable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsShrinkable<T>::value;
constexpr bool value2 = blaze::IsShrinkable_v<T>;

◆ IsSigned_v

template<typename T >
constexpr bool blaze::IsSigned_v = IsSigned<T>::value

Auxiliary variable template for the IsSigned type trait.The IsSigned_v variable template provides a convenient shortcut to access the nested value of the IsSigned class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSigned<T>::value;
constexpr bool value2 = blaze::IsSigned_v<T>;

◆ IsSIMDCombinable_v

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

Auxiliary variable template for the IsSIMDCombinable type trait.The IsSIMDCombinable_v variable template provides a convenient shortcut to access the nested value of the IsSIMDCombinable class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsSIMDCombinable<T1,T2>::value;
constexpr bool value2 = blaze::IsSIMDCombinable_v<T1,T2>;

◆ IsSIMDEnabled_v

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

Auxiliary variable template for the IsSIMDEnabled type trait.The IsSIMDEnabled_v variable template provides a convenient shortcut to access the nested value of the IsSIMDEnabled class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSIMDEnabled<T>::value;
constexpr bool value2 = blaze::IsSIMDEnabled_v<T>;

◆ IsSIMDPack_v

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

Auxiliary variable template for the IsSIMDPack type trait.The IsSIMDPack_v variable template provides a convenient shortcut to access the nested value of the IsSIMDPack class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSIMDPack<T>::value;
constexpr bool value2 = blaze::IsSIMDPack_v<T>;

◆ IsSMPAssignable_v

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

Auxiliary variable template for the IsSMPAssignable type trait.The IsSMPAssignable_v variable template provides a convenient shortcut to access the nested value of the IsSMPAssignable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSMPAssignable<T>::value;
constexpr bool value2 = blaze::IsSMPAssignable_v<T>;

◆ IsSparseElement_v

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

Auxiliary variable template for the IsSparseElement type trait.The IsSparseElement_v variable template provides a convenient shortcut to access the nested value of the IsSparseElement class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSparseElement<T>::value;
constexpr bool value2 = blaze::IsSparseElement_v<T>;

◆ IsSparseMatrix_v

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

Auxiliary variable template for the IsSparseMatrix type trait.The IsSparseMatrix_v variable template provides a convenient shortcut to access the nested value of the IsSparseMatrix class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSparseMatrix<T>::value;
constexpr bool value2 = blaze::IsSparseMatrix_v<T>;

◆ IsSparseVector_v

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

Auxiliary variable template for the IsSparseVector type trait.The IsSparseVector_v variable template provides a convenient shortcut to access the nested value of the IsSparseVector class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSparseVector<T>::value;
constexpr bool value2 = blaze::IsSparseVector_v<T>;

◆ IsSquare_v

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

Auxiliary variable template for the IsSquare type trait.The IsSquare_v variable template provides a convenient shortcut to access the nested value of the IsSquare class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSquare<T>::value;
constexpr bool value2 = blaze::IsSquare_v<T>;

◆ IsStatic_v

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

Auxiliary variable template for the IsStatic type trait.The IsStatic_v variable template provides a convenient shortcut to access the nested value of the IsStatic class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsStatic<T>::value;
constexpr bool value2 = blaze::IsStatic_v<T>;

◆ IsStrictlyLower_v

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

Auxiliary variable template for the IsStrictlyLower type trait.The IsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyLower class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsStrictlyLower<T>::value;
constexpr bool value2 = blaze::IsStrictlyLower_v<T>;

◆ IsStrictlySame_v

template<typename A , typename B >
constexpr bool blaze::IsStrictlySame_v = IsStrictlySame<A,B>::value

Auxiliary variable template for the IsStrictlySame type trait.The IsStrictlySame_v variable template provides a convenient shortcut to access the nested value of the IsStrictlySame class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsStrictlySame<T1,T2>::value;
constexpr bool value2 = blaze::IsStrictlySame_v<T1,T2>;

◆ IsStrictlyTriangular_v

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

Auxiliary variable template for the IsStrictlyTriangular type trait.The IsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyTriangular class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsStrictlyTriangular<T>::value;
constexpr bool value2 = blaze::IsStrictlyTriangular_v<T>;

◆ IsStrictlyUpper_v

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

Auxiliary variable template for the IsStrictlyUpper type trait.The IsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the IsStrictlyUpper class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsStrictlyUpper<T>::value;
constexpr bool value2 = blaze::IsStrictlyUpper_v<T>;

◆ IsSubExpr_v

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

Auxiliary variable template for the IsSubExpr type trait.The IsSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsSubExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSubExpr<T>::value;
constexpr bool value2 = blaze::IsSubExpr_v<T>;

◆ IsSubmatrix_v

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

Auxiliary variable template for the IsSubmatrix type trait.The IsSubmatrix_v variable template provides a convenient shortcut to access the nested value of the IsSubmatrix class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSubmatrix<T>::value;
constexpr bool value2 = blaze::IsSubmatrix_v<T>;

◆ IsSubvector_v

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

Auxiliary variable template for the IsSubvector type trait.The IsSubvector_v variable template provides a convenient shortcut to access the nested value of the IsSubvector class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSubvector<T>::value;
constexpr bool value2 = blaze::IsSubvector_v<T>;

◆ IsSymmetric_v

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

Auxiliary variable template for the IsSymmetric type trait.The IsSymmetric_v variable template provides a convenient shortcut to access the nested value of the IsSymmetric class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsSymmetric<T>::value;
constexpr bool value2 = blaze::IsSymmetric_v<T>;

◆ IsTemporary_v

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

Auxiliary variable template for the IsTemporary type trait.The IsTemporary_v variable template provides a convenient shortcut to access the nested value of the IsTemporary class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsTemporary<T>::value;
constexpr bool value2 = blaze::IsTemporary_v<T>;

◆ IsTransExpr_v

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

Auxiliary variable template for the IsTransExpr type trait.The IsTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsTransExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsTransExpr<T>::value;
constexpr bool value2 = blaze::IsTransExpr_v<T>;

◆ IsTransformation_v

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

Auxiliary variable template for the IsTransformation type trait.The IsTransformation_v variable template provides a convenient shortcut to access the nested value of the IsTransformation class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsTransformation<T>::value;
constexpr bool value2 = blaze::IsTransformation_v<T>;

◆ IsTriangular_v

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

Auxiliary variable template for the IsTriangular type trait.The IsTriangular_v variable template provides a convenient shortcut to access the nested value of the IsTriangular class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsTriangular<T>::value;
constexpr bool value2 = blaze::IsTriangular_v<T>;

◆ IsTVecMatMultExpr_v

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

Auxiliary variable template for the IsTVecMatMultExpr type trait.The IsTVecMatMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsTVecMatMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsTVecMatMultExpr<T>::value;
constexpr bool value2 = blaze::IsTVecMatMultExpr_v<T>;

◆ IsUnaryMapExpr_v

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

Auxiliary variable template for the IsUnaryMapExpr type trait.The IsUnaryMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsUnaryMapExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUnaryMapExpr<T>::value;
constexpr bool value2 = blaze::IsUnaryMapExpr_v<T>;

◆ IsUniform_v

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

Auxiliary variable template for the IsUniform type trait.The IsUniform_v variable template provides a convenient shortcut to access the nested value of the IsUniform class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUniform<T>::value;
constexpr bool value2 = blaze::IsUniform_v<T>;

◆ IsUniLower_v

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

Auxiliary variable template for the IsUniLower type trait.The IsUniLower_v variable template provides a convenient shortcut to access the nested value of the IsUniLower class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUniLower<T>::value;
constexpr bool value2 = blaze::IsUniLower_v<T>;

◆ IsUnion_v

template<typename T >
constexpr bool blaze::IsUnion_v = IsUnion<T>::value

Auxiliary variable template for the IsUnion type trait.The IsUnion_v variable template provides a convenient shortcut to access the nested value of the IsUnion class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUnion<T>::value;
constexpr bool value2 = blaze::IsUnion_v<T>;

◆ IsUniTriangular_v

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

Auxiliary variable template for the IsUniTriangular type trait.The IsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the IsUniTriangular class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUniTriangular<T>::value;
constexpr bool value2 = blaze::IsUniTriangular_v<T>;

◆ IsUniUpper_v

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

Auxiliary variable template for the IsUniUpper type trait.The IsUniUpper_v variable template provides a convenient shortcut to access the nested value of the IsUniUpper class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUniUpper<T>::value;
constexpr bool value2 = blaze::IsUniUpper_v<T>;

◆ IsUnsigned_v

template<typename T >
constexpr bool blaze::IsUnsigned_v = IsUnsigned<T>::value

Auxiliary variable template for the IsUnsigned type trait.The IsUnsigned_v variable template provides a convenient shortcut to access the nested value of the IsUnsigned class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUnsigned<T>::value;
constexpr bool value2 = blaze::IsUnsigned_v<T>;

◆ IsUpper_v

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

Auxiliary variable template for the IsUpper type trait.The IsUpper_v variable template provides a convenient shortcut to access the nested value of the IsUpper class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsUpper<T>::value;
constexpr bool value2 = blaze::IsUpper_v<T>;

◆ IsValid_v

template<typename T >
constexpr bool blaze::IsValid_v = IsValid<T>::value

Auxiliary variable template for the IsValid type trait.The IsValid_v variable template provides a convenient shortcut to access the nested value of the IsValid class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsValid<T>::value;
constexpr bool value2 = blaze::IsValid_v<T>;

◆ IsVecEvalExpr_v

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

Auxiliary variable template for the IsVecEvalExpr type trait.The IsVecEvalExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecEvalExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecEvalExpr<T>::value;
constexpr bool value2 = blaze::IsVecEvalExpr_v<T>;

◆ IsVecExpandExpr_v

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

Auxiliary variable template for the IsVecExpandExpr type trait.The IsVecExpandExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecExpandExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecExpandExpr<T>::value;
constexpr bool value2 = blaze::IsVecExpandExpr_v<T>;

◆ IsVecMapExpr_v

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

Auxiliary variable template for the IsVecMapExpr type trait.The IsVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecMapExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecMapExpr<T>::value;
constexpr bool value2 = blaze::IsVecMapExpr_v<T>;

◆ IsVecScalarDivExpr_v

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

Auxiliary variable template for the IsVecScalarDivExpr type trait.The IsVecScalarDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarDivExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecScalarDivExpr<T>::value;
constexpr bool value2 = blaze::IsVecScalarDivExpr_v<T>;

◆ IsVecScalarMultExpr_v

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

Auxiliary variable template for the IsVecScalarMultExpr type trait.The IsVecScalarMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecScalarMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecScalarMultExpr<T>::value;
constexpr bool value2 = blaze::IsVecScalarMultExpr_v<T>;

◆ IsVecSerialExpr_v

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

Auxiliary variable template for the IsVecSerialExpr type trait.The IsVecSerialExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecSerialExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecSerialExpr<T>::value;
constexpr bool value2 = blaze::IsVecSerialExpr_v<T>;

◆ IsVector_v

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

Auxiliary variable template for the IsVector type trait.The IsVector_v variable template provides a convenient shortcut to access the nested value of the IsVector class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVector<T>::value;
constexpr bool value2 = blaze::IsVector_v<T>;

◆ IsVectorizable_v

template<typename T >
constexpr bool blaze::IsVectorizable_v = IsVectorizable<T>::value

Auxiliary variable template for the IsVectorizable type trait.The IsVectorizable_v variable template provides a convenient shortcut to access the nested value of the IsVectorizable class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVectorizable<T>::value;
constexpr bool value2 = blaze::IsVectorizable_v<T>;

◆ IsVecTransExpr_v

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

Auxiliary variable template for the IsVecTransExpr type trait.The IsVecTransExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTransExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecTransExpr<T>::value;
constexpr bool value2 = blaze::IsVecTransExpr_v<T>;

◆ IsVecTVecMultExpr_v

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

Auxiliary variable template for the IsVecTVecMultExpr type trait.The IsVecTVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecTVecMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecTVecMultExpr<T>::value;
constexpr bool value2 = blaze::IsVecTVecMultExpr_v<T>;

◆ IsVecVecAddExpr_v

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

Auxiliary variable template for the IsVecVecAddExpr type trait.The IsVecVecAddExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecAddExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecVecAddExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecAddExpr_v<T>;

◆ IsVecVecDivExpr_v

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

Auxiliary variable template for the IsVecVecDivExpr type trait.The IsVecVecDivExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecDivExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecVecDivExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecDivExpr_v<T>;

◆ IsVecVecMapExpr_v

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

Auxiliary variable template for the IsVecVecMapExpr type trait.The IsVecVecMapExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMapExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecVecMapExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecMapExpr_v<T>;

◆ IsVecVecMultExpr_v

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

Auxiliary variable template for the IsVecVecMultExpr type trait.The IsVecVecMultExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecMultExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecVecMultExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecMultExpr_v<T>;

◆ IsVecVecSubExpr_v

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

Auxiliary variable template for the IsVecVecSubExpr type trait.The IsVecVecSubExpr_v variable template provides a convenient shortcut to access the nested value of the IsVecVecSubExpr class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVecVecSubExpr<T>::value;
constexpr bool value2 = blaze::IsVecVecSubExpr_v<T>;

◆ IsView_v

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

Auxiliary variable template for the IsView type trait.The IsView_v variable template provides a convenient shortcut to access the nested value of the IsView class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsView<T>::value;
constexpr bool value2 = blaze::IsView_v<T>;

◆ IsVoid_v

template<typename T >
constexpr bool blaze::IsVoid_v = IsVoid<T>::value

Auxiliary variable template for the IsVoid type trait.The IsVoid_v variable template provides a convenient shortcut to access the nested value of the IsVoid class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVoid<T>::value;
constexpr bool value2 = blaze::IsVoid_v<T>;

◆ IsVolatile_v

template<typename T >
constexpr bool blaze::IsVolatile_v = IsVolatile<T>::value

Auxiliary variable template for the IsVolatile type trait.The IsVolatile_v variable template provides a convenient shortcut to access the nested value of the IsVolatile class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsVolatile<T>::value;
constexpr bool value2 = blaze::IsVolatile_v<T>;

◆ IsZero_v

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

Auxiliary variable template for the IsZero type trait.The IsZero_v variable template provides a convenient shortcut to access the nested value of the IsZero class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::IsZero<T>::value;
constexpr bool value2 = blaze::IsZero_v<T>;

◆ Length_v

template<typename TL >
constexpr size_t blaze::Length_v = Length<TL>::value

Auxiliary variable template for the Length type trait.The Length_v variable template provides a convenient shortcut to access the nested value of the Length class template. For instance, given the type list TL the following two statements are identical:

constexpr size_t value1 = Length<TL>::value;
constexpr size_t value2 = Length_v<TL>;

◆ MaxSize_v

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

Auxiliary variable template for the MaxSize type trait.The MaxSize_v variable template provides a convenient shortcut to access the nested value of the MaxSize class template. For instance, given the type T and the dimension N the following two statements are identical:

constexpr size_t value1 = blaze::MaxSize<T,N>::value;
constexpr size_t value2 = blaze::MaxSize_v<T,N>;

◆ Rank_v

template<typename T >
constexpr size_t blaze::Rank_v = Rank<T>::value

Auxiliary variable template for the Rank type trait.The Rank_v variable template provides a convenient shortcut to access the nested value of the Rank class template. For instance, given the type T the following two statements are identical:

constexpr size_t value1 = blaze::Rank<T>::value;
constexpr size_t value2 = blaze::Rank_v<T>;

◆ RequiresEvaluation_v

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

Auxiliary variable template for the RequiresEvaluation type trait.The RequiresEvaluation_v variable template provides a convenient shortcut to access the nested value of the RequiresEvaluation class template. For instance, given the type T the following two statements are identical:

constexpr bool value1 = blaze::RequiresEvaluation<T>::value;
constexpr bool value2 = blaze::RequiresEvaluation_v<T>;

◆ Size_v

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

Auxiliary variable template for the Size type trait.The Size_v variable template provides a convenient shortcut to access the nested value of the Size class template. For instance, given the type T and the dimension N the following two statements are identical:

constexpr size_t value1 = blaze::Size<T,N>::value;
constexpr size_t value2 = blaze::Size_v<T,N>;

◆ StorageOrder_v

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

Auxiliary variable template for the StorageOrder type trait.The StorageOrder_v variable template provides a convenient shortcut to access the nested value of the StorageOrder class template. For instance, given the matrix type T the following two statements are identical:

constexpr bool value1 = blaze::StorageOrder<T>::value;
constexpr bool value2 = blaze::StorageOrder_v<T>;

◆ TransposeFlag_v

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

Auxiliary variable template for the TransposeFlag type trait.The TransposeFlag_v variable template provides a convenient shortcut to access the nested value of the TransposeFlag class template. For instance, given the vector type T the following two statements are identical:

constexpr bool value1 = blaze::TransposeFlag<T>::value;
constexpr bool value2 = blaze::TransposeFlag_v<T>;

◆ YieldsDiagonal_v

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

Auxiliary variable template for the YieldsDiagonal type trait.The YieldsDiagonal_v variable template provides a convenient shortcut to access the nested value of the YieldsDiagonal class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsDiagonal<OP,MT>::value;
constexpr bool value2 = blaze::YieldsDiagonal_v<OP,MT>;

◆ YieldsHermitian_v

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

Auxiliary variable template for the YieldsHermitian type trait.The YieldsHermitian_v variable template provides a convenient shortcut to access the nested value of the YieldsHermitian class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsHermitian<OP,MT>::value;
constexpr bool value2 = blaze::YieldsHermitian_v<OP,MT>;

◆ YieldsIdentity_v

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

Auxiliary variable template for the YieldsIdentity type trait.The YieldsIdentity_v variable template provides a convenient shortcut to access the nested value of the YieldsIdentity class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsIdentity<OP,MT>::value;
constexpr bool value2 = blaze::YieldsIdentity_v<OP,MT>;

◆ YieldsLower_v

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

Auxiliary variable template for the YieldsLower type trait.The YieldsLower_v variable template provides a convenient shortcut to access the nested value of the YieldsLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsLower<OP,MT>::value;
constexpr bool value2 = blaze::YieldsLower_v<OP,MT>;

◆ YieldsStrictlyLower_v

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

Auxiliary variable template for the YieldsStrictlyLower type trait.The YieldsStrictlyLower_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value2 = blaze::YieldsStrictlyLower_v<OP,MT>;

◆ YieldsStrictlyTriangular_v

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

Auxiliary variable template for the YieldsStrictlyTriangular type trait.The YieldsStrictlyTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value2 = blaze::YieldsStrictlyTriangular_v<OP,MT>;

◆ YieldsStrictlyUpper_v

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

Auxiliary variable template for the YieldsStrictlyUpper type trait.The YieldsStrictlyUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsStrictlyUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value2 = blaze::YieldsStrictlyUpper_v<OP,MT>;

◆ YieldsSymmetric_v

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

Auxiliary variable template for the YieldsSymmetric type trait.The YieldsSymmetric_v variable template provides a convenient shortcut to access the nested value of the YieldsSymmetric class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsSymmetric<OP,MT>::value;
constexpr bool value2 = blaze::YieldsSymmetric_v<OP,MT>;

◆ YieldsTriangular_v

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

Auxiliary variable template for the YieldsTriangular type trait.The YieldsTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsTriangular<OP,MT>::value;
constexpr bool value2 = blaze::YieldsTriangular_v<OP,MT>;

◆ YieldsUniform_v

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

Auxiliary variable template for the YieldsUniform type trait.The YieldsUniform_v variable template provides a convenient shortcut to access the nested value of the YieldsUniform class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical:

constexpr bool value1 = blaze::YieldsUniform<OP,T>::value;
constexpr bool value2 = blaze::YieldsUniform_v<OP,T>;

◆ YieldsUniLower_v

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

Auxiliary variable template for the YieldsUniLower type trait.The YieldsUniLower_v variable template provides a convenient shortcut to access the nested value of the YieldsUniLower class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsUniLower<OP,MT>::value;
constexpr bool value2 = blaze::YieldsUniLower_v<OP,MT>;

◆ YieldsUniTriangular_v

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

Auxiliary variable template for the YieldsUniTriangular type trait.The YieldsUniTriangular_v variable template provides a convenient shortcut to access the nested value of the YieldsUniTriangular class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value2 = blaze::YieldsUniTriangular_v<OP,MT>;

◆ YieldsUniUpper_v

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

Auxiliary variable template for the YieldsUniUpper type trait.The YieldsUniUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUniUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsUniUpper<OP,MT>::value;
constexpr bool value2 = blaze::YieldsUniUpper_v<OP,MT>;

◆ YieldsUpper_v

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

Auxiliary variable template for the YieldsUpper type trait.The YieldsUpper_v variable template provides a convenient shortcut to access the nested value of the YieldsUpper class template. For instance, given the operation OP and the matrix type MT the following two statements are identical:

constexpr bool value1 = blaze::YieldsUpper<OP,MT>::value;
constexpr bool value2 = blaze::YieldsUpper_v<OP,MT>;

◆ YieldsZero_v

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

Auxiliary variable template for the YieldsZero type trait.The YieldsZero_v variable template provides a convenient shortcut to access the nested value of the YieldsZero class template. For instance, given the operation OP and the vector or matrix type T the following two statements are identical:

constexpr bool value1 = blaze::YieldsZero<OP,T>::value;
constexpr bool value2 = blaze::YieldsZero_v<OP,T>;