Blaze  3.6
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, S >
 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 S 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::RemoveCVRef< T >
 Removal of top level cv-qualifiers.The RemoveCVRef type trait removes any reference modifiers and 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 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::RemoveCVRef_t = typename RemoveCVRef< T >::Type
 Auxiliary alias declaration for the RemoveCVRef type trait.The RemoveCVRef_t alias declaration provides a convenient shortcut to access the nested Type of the RemoveCVRef 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::IsCUDAAssignable_v = IsCUDAAssignable<T>::value
 Auxiliary variable template for the IsCUDAAssignable type trait.The IsCUDAAssignable_v variable template provides a convenient shortcut to access the nested value of the IsCUDAAssignable class template. For instance, given the 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 S>
constexpr bool blaze::HasSize_v = HasSize<T,S>::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>;

◆ 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;

◆ 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>;

◆ RemoveCVRef_t

template<typename T >
using blaze::RemoveCVRef_t = typedef typename RemoveCVRef<T>::Type

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

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

◆ 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>;

◆ 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>;

◆ HasSize_v

template<typename T , size_t S>
constexpr bool blaze::HasSize_v = HasSize<T,S>::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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ IsCUDAAssignable_v

template<typename T >
constexpr bool blaze::IsCUDAAssignable_v = IsCUDAAssignable<T>::value

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

constexpr bool value1 = blaze::IsCUDAAssignable<T>::value;
constexpr bool value2 = blaze::IsCUDAAssignable_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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;

◆ 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>;