Blaze 3.9
Classes | Typedefs | Variables
Type traits

Classes

struct  blaze::MakeComplex< T >
 Converting the given type to the matching 'complex' type. More...
 
struct  blaze::AddConst< T >
 Addition of a top level 'const' qualifier. More...
 
struct  blaze::AddCV< T >
 Addition of a top level 'const' and 'volatile' qualifier. More...
 
struct  blaze::AddLValueReference< T >
 Addition of a top level reference. More...
 
struct  blaze::AddPointer< T >
 Addition of a top level pointer. More...
 
struct  blaze::AddRValueReference< T >
 Addition of a top level reference. More...
 
struct  blaze::AddVolatile< T >
 Addition of a top level 'volatile' qualifier. More...
 
struct  blaze::AlignmentOf< T >
 Evaluation of the required alignment of the given data type. More...
 
struct  blaze::All< TypeTrait, T1, T2, Ts >
 Compile time type check. More...
 
struct  blaze::AlwaysFalse< T >
 Type dependent compile time false. More...
 
struct  blaze::AlwaysTrue< T >
 Type dependent compile time true. More...
 
struct  blaze::Any< TypeTrait, T1, T2, Ts >
 Compile time type check. More...
 
struct  blaze::CommonType< T >
 Deduction of a type common to several types. More...
 
struct  blaze::Decay< T >
 Applies the type conversions for by-value function arguments. More...
 
struct  blaze::Extent< T, N >
 Compile time check for the size of array bounds. More...
 
struct  blaze::HasSize< T, S >
 Compile time size check. More...
 
struct  blaze::Has1Byte< T >
 Compile time size check. More...
 
struct  blaze::Has2Bytes< T >
 Compile time size check. More...
 
struct  blaze::Has4Bytes< T >
 Compile time size check. More...
 
struct  blaze::Has8Bytes< T >
 Compile time size check. More...
 
class  blaze::HaveSameSize< T1, T2 >
 Compile time size check. More...
 
struct  blaze::IsArithmetic< T >
 Compile time check for arithmetic data types. More...
 
struct  blaze::IsArray< T >
 Compile time type check. More...
 
struct  blaze::IsAssignable< T, U >
 Compile time type check. More...
 
struct  blaze::IsNothrowAssignable< T, U >
 Compile time type check. More...
 
struct  blaze::IsCopyAssignable< T >
 Compile time type check. More...
 
struct  blaze::IsNothrowCopyAssignable< T >
 Compile time type check. More...
 
struct  blaze::IsMoveAssignable< T >
 Compile time type check. More...
 
struct  blaze::IsNothrowMoveAssignable< T >
 Compile time type check. More...
 
class  blaze::IsBaseOf< Base, Derived >
 Compile time analysis of an inheritance relationship. More...
 
struct  blaze::IsBoolean< T >
 Compile time check for boolean types. More...
 
struct  blaze::IsBuiltin< T >
 Compile time check for built-in data types. More...
 
struct  blaze::IsCharacter< T >
 Compile time check for character types. More...
 
struct  blaze::IsClass< T >
 Compile time type check. More...
 
struct  blaze::IsComplex< T >
 Compile time check for complex types. More...
 
struct  blaze::IsComplexDouble< T >
 Compile time check for single precision complex types. More...
 
struct  blaze::IsComplexFloat< T >
 Compile time check for single precision complex types. More...
 
struct  blaze::IsConst< T >
 Compile time check for constant data types. More...
 
struct  blaze::IsConstructible< T, Args >
 Compile time type check. More...
 
struct  blaze::IsNothrowConstructible< T, Args >
 Compile time type check. More...
 
struct  blaze::IsDefaultConstructible< T >
 Compile time type check. More...
 
struct  blaze::IsNothrowDefaultConstructible< T >
 Compile time type check. More...
 
struct  blaze::IsCopyConstructible< T >
 Compile time type check. More...
 
struct  blaze::IsNothrowCopyConstructible< T >
 Compile time type check. More...
 
struct  blaze::IsMoveConstructible< T >
 Compile time type check. More...
 
struct  blaze::IsNothrowMoveConstructible< T >
 Compile time type check. More...
 
struct  blaze::IsConvertible< From, To >
 Compile time pointer relationship constraint. More...
 
struct  blaze::IsDestructible< T >
 Compile time type check. More...
 
struct  blaze::IsNothrowDestructible< T >
 Compile time type check. More...
 
struct  blaze::NoneSuch
 Default result type for the Detected_t type trait. More...
 
struct  blaze::IsDouble< T >
 Compile time check for double precision floating point types. More...
 
struct  blaze::IsEmpty< T >
 Compile time type check. More...
 
struct  blaze::IsEnum< T >
 Compile time check for complete enumeration types. More...
 
struct  blaze::IsFloat< T >
 Compile time check for single precision floating point types. More...
 
struct  blaze::IsFloatingPoint< T >
 Compile time check for floating point data types. More...
 
struct  blaze::IsInteger< T >
 Compile time check for integer types. More...
 
struct  blaze::IsIntegral< T >
 Compile time check for integral data types. More...
 
struct  blaze::IsLong< T >
 Compile time check for long integer types. More...
 
struct  blaze::IsLongDouble< T >
 Compile time check for extended precision floating point types. More...
 
struct  blaze::IsLValueReference< T >
 Compile time type check. More...
 
struct  blaze::IsNumeric< T >
 Compile time check for numeric types. More...
 
struct  blaze::IsObject< T >
 Compile time type check. More...
 
struct  blaze::IsPod< T >
 Compile time check for pod data types. More...
 
struct  blaze::IsPointer< T >
 Compile time type check. More...
 
struct  blaze::IsReference< T >
 Compile time type check. More...
 
struct  blaze::IsRValueReference< T >
 Compile time type check. More...
 
struct  blaze::IsStrictlySame< A, B >
 Compile time type relationship analysis. More...
 
struct  blaze::IsSame< A, B >
 Type relationship analysis. More...
 
struct  blaze::IsShort< T >
 Compile time check for short integer types. More...
 
struct  blaze::IsSigned< T >
 Compile time check for signed data types. More...
 
struct  blaze::IsUnion< T >
 Compile time check for union data types. More...
 
struct  blaze::IsUnsigned< T >
 Compile time check for unsigned data types. More...
 
struct  blaze::IsValid< T >
 Compile time type check. More...
 
struct  blaze::IsVectorizable< T >
 Compile time check for vectorizable types. More...
 
struct  blaze::IsVoid< T >
 Compile time check for the void data type. More...
 
struct  blaze::IsVolatile< T >
 Compile time check for volatile data types. More...
 
struct  blaze::MakeSigned< T >
 Compile time type conversion into a signed integral type. More...
 
struct  blaze::MakeUnsigned< T >
 Compile time type conversion into an unsigned integral type. More...
 
struct  blaze::Rank< T >
 Compile time check for array ranks. More...
 
struct  blaze::RemoveAllExtents< T >
 Removal of all array extents. More...
 
struct  blaze::RemoveConst< T >
 Removal of const-qualifiers. More...
 
struct  blaze::RemoveCV< T >
 Removal of top level cv-qualifiers. More...
 
struct  blaze::RemoveCVRef< T >
 Removal of top level cv-qualifiers. More...
 
struct  blaze::RemoveExtent< T >
 Removal of the top level array extent. More...
 
struct  blaze::RemoveLValueReference< T >
 Removal of reference modifiers. More...
 
struct  blaze::RemovePointer< T >
 Removal of pointer modifiers. More...
 
struct  blaze::RemoveReference< T >
 Removal of reference modifiers. More...
 
struct  blaze::RemoveRValueReference< T >
 Removal of reference modifiers. More...
 
struct  blaze::RemoveVolatile< T >
 Removal of volatile-qualifiers. More...
 

Typedefs

template<typename T >
using blaze::MakeComplex_t = typename MakeComplex< T >::Type
 Auxiliary alias declaration for the MakeComplex type trait. More...
 
template<typename TL , typename T >
using blaze::Append_t = typename Append< TL, T >::Type
 Auxiliary alias declaration for the Append class template. More...
 
template<typename TL , typename T >
using blaze::Erase_t = typename Erase< TL, T >::Type
 Auxiliary alias declaration for the Erase class template. More...
 
template<typename TL , typename T >
using blaze::EraseAll_t = typename EraseAll< TL, T >::Type
 Auxiliary alias declaration for the EraseAll class template. More...
 
template<typename TL , size_t Index>
using blaze::TypeAt_t = typename TypeAt< TL, Index >::Type
 Auxiliary alias declaration for the TypeAt class template. More...
 
template<typename TL >
using blaze::Unique_t = typename Unique< TL >::Type
 Auxiliary alias declaration for the Unique class template. More...
 
template<typename T >
using blaze::AddConst_t = typename AddConst< T >::Type
 Auxiliary alias declaration for the AddConst type trait. More...
 
template<typename T >
using blaze::AddCV_t = typename AddCV< T >::Type
 Auxiliary alias declaration for the AddCV type trait. More...
 
template<typename T >
using blaze::AddLValueReference_t = typename AddLValueReference< T >::Type
 Auxiliary alias declaration for the AddLValueReference type trait. More...
 
template<typename T >
using blaze::AddPointer_t = typename AddPointer< T >::Type
 Auxiliary alias declaration for the AddPointer type trait. More...
 
template<typename T >
using blaze::AddRValueReference_t = typename AddRValueReference< T >::Type
 Auxiliary alias declaration for the AddRValueReference type trait. More...
 
template<typename T >
using blaze::AddVolatile_t = typename AddVolatile< T >::Type
 Auxiliary alias declaration for the AddVolatile type trait. More...
 
template<typename... T>
using blaze::CommonType_t = typename CommonType< T... >::Type
 Auxiliary alias declaration for the CommonType type trait. More...
 
template<typename T >
using blaze::Decay_t = typename Decay< T >::Type
 Auxiliary alias declaration for the Decay type trait. More...
 
template<typename T1 , typename T2 >
using blaze::GreaterThan_t = decltype(std::declval< T1 >() > std::declval< T2 >())
 Auxiliary type alias for the HasGreaterThan type trait.
 
template<typename T1 , typename T2 >
using blaze::HasGreaterThan = IsDetected< GreaterThan_t, T1, T2 >
 Compile time check for the availability of a greater-than operation between two data types. More...
 
template<typename T1 , typename T2 >
using blaze::LessThan_t = decltype(std::declval< T1 >()< std::declval< T2 >())
 Auxiliary type alias for the HasLessThan type trait.
 
template<typename T1 , typename T2 >
using blaze::HasLessThan = IsDetected< LessThan_t, T1, T2 >
 Compile time check for the availability of a less-than operation between two data types. More...
 
template<typename Default , template< typename... > class OP, typename... Ts>
using blaze::DetectedOr = Detector< Default, void, OP, Ts... >
 Compile time detection of type properties. More...
 
template<template< typename... > class OP, typename... Ts>
using blaze::IsDetected = typename DetectedOr< NoneSuch, OP, Ts... >::Value_t
 Compile time detection of type properties. More...
 
template<template< typename... > class OP, typename... Ts>
using blaze::Detected_t = typename DetectedOr< NoneSuch, OP, Ts... >::Type
 Compile time detection of type properties. More...
 
template<typename Default , template< typename... > class OP, typename... Ts>
using blaze::DetectedOr_t = typename DetectedOr< Default, OP, Ts... >::Type
 Auxiliary variable template for the DetectedOr type trait. More...
 
template<typename T >
using blaze::MakeSigned_t = typename MakeSigned< T >::Type
 Auxiliary alias declaration for the MakeSigned type trait. More...
 
template<typename T >
using blaze::MakeUnsigned_t = typename MakeUnsigned< T >::Type
 Auxiliary alias declaration for the MakeUnsigned type trait. More...
 
template<typename T >
using blaze::RemoveAllExtents_t = typename RemoveAllExtents< T >::Type
 Auxiliary alias declaration for the RemoveAllExtents type trait. More...
 
template<typename T >
using blaze::RemoveConst_t = typename RemoveConst< T >::Type
 Auxiliary alias declaration for the RemoveConst type trait. More...
 
template<typename T >
using blaze::RemoveCV_t = typename RemoveCV< T >::Type
 Auxiliary alias declaration for the RemoveCV type trait. More...
 
template<typename T >
using blaze::RemoveCVRef_t = typename RemoveCVRef< T >::Type
 Auxiliary alias declaration for the RemoveCVRef type trait. More...
 
template<typename T >
using blaze::RemoveExtent_t = typename RemoveExtent< T >::Type
 Auxiliary alias declaration for the RemoveExtent type trait. More...
 
template<typename T >
using blaze::RemoveLValueReference_t = typename RemoveLValueReference< T >::Type
 Auxiliary alias declaration for the RemoveLValueReference type trait. More...
 
template<typename T >
using blaze::RemovePointer_t = typename RemovePointer< T >::Type
 Auxiliary alias declaration for the RemovePointer type trait. More...
 
template<typename T >
using blaze::RemoveReference_t = typename RemoveReference< T >::Type
 Auxiliary alias declaration for the RemoveReference type trait. More...
 
template<typename T >
using blaze::RemoveRValueReference_t = typename RemoveRValueReference< T >::Type
 Auxiliary alias declaration for the RemoveRValueReference type trait. More...
 
template<typename T >
using blaze::RemoveVolatile_t = typename RemoveVolatile< T >::Type
 Auxiliary alias declaration for the RemoveVolatile type trait. More...
 
template<typename... Ts>
using blaze::Void_t = void
 Compile time type check. More...
 

Variables

template<typename T >
constexpr bool blaze::IsCUDAAssignable_v = IsCUDAAssignable<T>::value
 Auxiliary variable template for the IsCUDAAssignable type trait. More...
 
template<typename TL , typename T >
constexpr bool blaze::Contains_v = Contains<TL,T>::value
 Auxiliary variable template for the Contains type trait. More...
 
template<typename TL , typename T >
constexpr bool blaze::ContainsRelated_v = ContainsRelated<TL,T>::value
 Auxiliary variable template for the ContainsRelated type trait. More...
 
template<typename TL , typename T >
constexpr size_t blaze::IndexOf_v = IndexOf<TL,T>::value
 Auxiliary variable template for the IndexOf type trait. More...
 
template<typename TL >
constexpr size_t blaze::Length_v = Length<TL>::value
 Auxiliary variable template for the Length type trait. More...
 
template<typename T >
constexpr size_t blaze::AlignmentOf_v = AlignmentOf<T>::value
 Auxiliary variable template for the AlignmentOf type trait. 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. More...
 
template<typename T >
constexpr bool blaze::AlwaysFalse_v = false
 Auxiliary variable template for the AlwaysFalse type trait. More...
 
template<typename T >
constexpr bool blaze::AlwaysTrue_v = true
 Auxiliary variable template for the AlwaysTrue type trait. 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. 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. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasGreaterThan_v = HasGreaterThan<T1,T2>::value
 Auxiliary variable template for the HasGreaterThan type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HasLessThan_v = HasLessThan<T1,T2>::value
 Auxiliary variable template for the HasLessThan type trait. More...
 
template<typename T , size_t S>
constexpr bool blaze::HasSize_v = HasSize<T,S>::value
 Auxiliary variable template for the HasSize type trait. More...
 
template<typename T >
constexpr bool blaze::Has1Byte_v = Has1Byte<T>::value
 Auxiliary variable template for the Has1Byte type trait. More...
 
template<typename T >
constexpr bool blaze::Has2Bytes_v = Has2Bytes<T>::value
 Auxiliary variable template for the Has2Bytes type trait. More...
 
template<typename T >
constexpr bool blaze::Has4Bytes_v = Has4Bytes<T>::value
 Auxiliary variable template for the Has4Bytes type trait. More...
 
template<typename T >
constexpr bool blaze::Has8Bytes_v = Has8Bytes<T>::value
 Auxiliary variable template for the Has8Bytes type trait. More...
 
template<typename T1 , typename T2 >
constexpr bool blaze::HaveSameSize_v = HaveSameSize<T1,T2>::value
 Auxiliary variable template for the HaveSameSize type trait. More...
 
template<typename T >
constexpr bool blaze::IsArithmetic_v = IsArithmetic<T>::value
 Auxiliary variable template for the IsArithmetic type trait. More...
 
template<typename T >
constexpr bool blaze::IsArray_v = IsArray<T>::value
 Auxiliary variable template for the IsArray type trait. More...
 
template<typename T , typename U >
constexpr bool blaze::IsAssignable_v = IsAssignable<T,U>::value
 Auxiliary variable template for the IsAssignable type trait. More...
 
template<typename T , typename U >
constexpr bool blaze::IsNothrowAssignable_v = IsNothrowAssignable<T,U>::value
 Auxiliary variable template for the IsNothrowAssignable type trait. More...
 
template<typename T >
constexpr bool blaze::IsCopyAssignable_v = IsCopyAssignable<T>::value
 Auxiliary variable template for the IsCopyAssignable type trait. More...
 
template<typename T >
constexpr bool blaze::IsNothrowCopyAssignable_v = IsNothrowCopyAssignable<T>::value
 Auxiliary variable template for the IsNothrowCopyAssignable type trait. More...
 
template<typename T >
constexpr bool blaze::IsMoveAssignable_v = IsMoveAssignable<T>::value
 Auxiliary variable template for the IsMoveAssignable type trait. More...
 
template<typename T >
constexpr bool blaze::IsNothrowMoveAssignable_v = IsNothrowMoveAssignable<T>::value
 Auxiliary variable template for the IsNothrowMoveAssignable type trait. More...
 
template<typename Base , typename Derived >
constexpr bool blaze::IsBaseOf_v = IsBaseOf<Base,Derived>::value
 Auxiliary variable template for the IsBaseOf type trait. More...
 
template<typename T >
constexpr bool blaze::IsBoolean_v = IsBoolean<T>::value
 Auxiliary variable template for the IsBoolean type trait. More...
 
template<typename T >
constexpr bool blaze::IsBuiltin_v = IsBuiltin<T>::value
 Auxiliary variable template for the IsBuiltin type trait. More...
 
template<typename T >
constexpr bool blaze::IsCharacter_v = IsCharacter<T>::value
 Auxiliary variable template for the IsCharacter type trait. More...
 
template<typename T >
constexpr bool blaze::IsClass_v = IsClass<T>::value
 Auxiliary variable template for the IsClass type trait. More...
 
template<typename T >
constexpr bool blaze::IsComplex_v = IsComplex<T>::value
 Auxiliary variable template for the IsComplex type trait. More...
 
template<typename T >
constexpr bool blaze::IsComplexDouble_v = IsComplexDouble<T>::value
 Auxiliary variable template for the IsComplexDouble type trait. More...
 
template<typename T >
constexpr bool blaze::IsComplexFloat_v = IsComplexFloat<T>::value
 Auxiliary variable template for the IsComplexFloat type trait. More...
 
template<typename T >
constexpr bool blaze::IsConst_v = IsConst<T>::value
 Auxiliary variable template for the IsConst type trait. More...
 
template<typename T , typename... Args>
constexpr bool blaze::IsConstructible_v = IsConstructible<T>::value
 Auxiliary variable template for the IsConstructible type trait. More...
 
template<typename T , typename... Args>
constexpr bool blaze::IsNothrowConstructible_v = IsNothrowConstructible<T>::value
 Auxiliary variable template for the IsNothrowConstructible type trait. More...
 
template<typename T >
constexpr bool blaze::IsDefaultConstructible_v = IsDefaultConstructible<T>::value
 Auxiliary variable template for the IsDefaultConstructible type trait. More...
 
template<typename T >
constexpr bool blaze::IsNothrowDefaultConstructible_v = IsNothrowDefaultConstructible<T>::value
 Auxiliary variable template for the IsNothrowDefaultConstructible type trait. More...
 
template<typename T >
constexpr bool blaze::IsCopyConstructible_v = IsCopyConstructible<T>::value
 Auxiliary variable template for the IsCopyConstructible type trait. More...
 
template<typename T >
constexpr bool blaze::IsNothrowCopyConstructible_v = IsNothrowCopyConstructible<T>::value
 Auxiliary variable template for the IsNothrowCopyConstructible type trait. More...
 
template<typename T >
constexpr bool blaze::IsMoveConstructible_v = IsMoveConstructible<T>::value
 Auxiliary variable template for the IsMoveConstructible type trait. More...
 
template<typename T >
constexpr bool blaze::IsNothrowMoveConstructible_v = IsNothrowMoveConstructible<T>::value
 Auxiliary variable template for the IsNothrowMoveConstructible type trait. More...
 
template<typename From , typename To >
constexpr bool blaze::IsConvertible_v = IsConvertible<From,To>::value
 Auxiliary variable template for the IsConvertible type trait. More...
 
template<typename T >
constexpr bool blaze::IsDestructible_v = IsDestructible<T>::value
 Auxiliary variable template for the IsDestructible type trait. More...
 
template<typename T >
constexpr bool blaze::IsNothrowDestructible_v = IsNothrowDestructible<T>::value
 Auxiliary variable template for the IsNothrowDestructible type trait. More...
 
template<template< typename... > class OP, typename... Ts>
constexpr bool blaze::IsDetected_v = IsDetected<OP,Ts...>::value
 Auxiliary variable template for the IsDetected type trait. More...
 
template<typename T >
constexpr bool blaze::IsDouble_v = IsDouble<T>::value
 Auxiliary variable template for the IsDouble type trait. More...
 
template<typename T >
constexpr bool blaze::IsEmpty_v = IsEmpty<T>::value
 Auxiliary variable template for the IsEmpty type trait. More...
 
template<typename T >
constexpr bool blaze::IsEnum_v = IsEnum<T>::value
 Auxiliary variable template for the IsEnum type trait. More...
 
template<typename T >
constexpr bool blaze::IsFloat_v = IsFloat<T>::value
 Auxiliary variable template for the IsFloat type trait. More...
 
template<typename T >
constexpr bool blaze::IsFloatingPoint_v = IsFloatingPoint<T>::value
 Auxiliary variable template for the IsFloatingPoint type trait. More...
 
template<typename T >
constexpr bool blaze::IsInteger_v = IsInteger<T>::value
 Auxiliary variable template for the IsInteger type trait. More...
 
template<typename T >
constexpr bool blaze::IsIntegral_v = IsIntegral<T>::value
 Auxiliary variable template for the IsIntegral type trait. More...
 
template<typename T >
constexpr bool blaze::IsLong_v = IsLong<T>::value
 Auxiliary variable template for the IsLong type trait. More...
 
template<typename T >
constexpr bool blaze::IsLongDouble_v = IsLongDouble<T>::value
 Auxiliary variable template for the IsLongDouble type trait. More...
 
template<typename T >
constexpr bool blaze::IsLValueReference_v = IsLValueReference<T>::value
 Auxiliary variable template for the IsLValueReference type trait. More...
 
template<typename T >
constexpr bool blaze::IsNumeric_v = IsNumeric<T>::value
 Auxiliary variable template for the IsNumeric type trait. More...
 
template<typename T >
constexpr bool blaze::IsObject_v = IsObject<T>::value
 Auxiliary variable template for the IsObject type trait. More...
 
template<typename T >
constexpr bool blaze::IsPod_v = IsPod<T>::value
 Auxiliary variable template for the IsPod type trait. More...
 
template<typename T >
constexpr bool blaze::IsPointer_v = IsPointer<T>::value
 Auxiliary variable template for the IsPointer type trait. More...
 
template<typename T >
constexpr bool blaze::IsReference_v = IsReference<T>::value
 Auxiliary variable template for the IsReference type trait. More...
 
template<typename T >
constexpr bool blaze::IsRValueReference_v = IsRValueReference<T>::value
 Auxiliary variable template for the IsRValueReference type trait. More...
 
template<typename A , typename B >
constexpr bool blaze::IsStrictlySame_v = IsStrictlySame<A,B>::value
 Auxiliary variable template for the IsStrictlySame type trait. More...
 
template<typename A , typename B >
constexpr bool blaze::IsSame_v = IsSame<A,B>::value
 Auxiliary variable template for the IsSame type trait. More...
 
template<typename T >
constexpr bool blaze::IsShort_v = IsShort<T>::value
 Auxiliary variable template for the IsShort type trait. More...
 
template<typename T >
constexpr bool blaze::IsSigned_v = IsSigned<T>::value
 Auxiliary variable template for the IsSigned type trait. More...
 
template<typename T >
constexpr bool blaze::IsUnion_v = IsUnion<T>::value
 Auxiliary variable template for the IsUnion type trait. More...
 
template<typename T >
constexpr bool blaze::IsUnsigned_v = IsUnsigned<T>::value
 Auxiliary variable template for the IsUnsigned type trait. More...
 
template<typename T >
constexpr bool blaze::IsValid_v = IsValid<T>::value
 Auxiliary variable template for the IsValid type trait. More...
 
template<typename T >
constexpr bool blaze::IsVectorizable_v = IsVectorizable<T>::value
 Auxiliary variable template for the IsVectorizable type trait. More...
 
template<typename T >
constexpr bool blaze::IsVoid_v = IsVoid<T>::value
 Auxiliary variable template for the IsVoid type trait. More...
 
template<typename T >
constexpr bool blaze::IsVolatile_v = IsVolatile<T>::value
 Auxiliary variable template for the IsVolatile type trait. More...
 
template<typename T >
constexpr size_t blaze::Rank_v = Rank<T>::value
 Auxiliary variable template for the Rank type trait. 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>;
typename AddConst< T >::Type AddConst_t
Auxiliary alias declaration for the AddConst type trait.
Definition: AddConst.h:95
Addition of a top level 'const' qualifier.
Definition: AddConst.h:70

◆ 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>;
typename AddCV< T >::Type AddCV_t
Auxiliary alias declaration for the AddCV type trait.
Definition: AddCV.h:96
Addition of a top level 'const' and 'volatile' qualifier.
Definition: AddCV.h:71

◆ AddLValueReference_t

template<typename T >
using blaze::AddLValueReference_t = typedef typename AddLValueReference<T>::Type

Auxiliary alias declaration for the AddLValueReference type trait.

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

using Type1 = typename blaze::AddLValueReference<T>::Type;
typename AddLValueReference< T >::Type AddLValueReference_t
Auxiliary alias declaration for the AddLValueReference type trait.
Definition: AddLValueReference.h:97
Addition of a top level reference.
Definition: AddLValueReference.h:72

◆ 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>;
typename AddPointer< T >::Type AddPointer_t
Auxiliary alias declaration for the AddPointer type trait.
Definition: AddPointer.h:95
Addition of a top level pointer.
Definition: AddPointer.h:70

◆ AddRValueReference_t

template<typename T >
using blaze::AddRValueReference_t = typedef typename AddRValueReference<T>::Type

Auxiliary alias declaration for the AddRValueReference type trait.

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

using Type1 = typename blaze::AddRValueReference<T>::Type;
typename AddRValueReference< T >::Type AddRValueReference_t
Auxiliary alias declaration for the AddRValueReference type trait.
Definition: AddRValueReference.h:95
Addition of a top level reference.
Definition: AddRValueReference.h:70

◆ 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;
typename AddVolatile< T >::Type AddVolatile_t
Auxiliary alias declaration for the AddVolatile type trait.
Definition: AddVolatile.h:95
Addition of a top level 'volatile' qualifier.
Definition: AddVolatile.h:70

◆ 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>;
typename Append< TL, T >::Type Append_t
Auxiliary alias declaration for the Append class template.
Definition: Append.h:118
Appending a type to a type list.
Definition: Append.h:69

◆ 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;
typename CommonType< T... >::Type CommonType_t
Auxiliary alias declaration for the CommonType type trait.
Definition: CommonType.h:95
Deduction of a type common to several types.
Definition: CommonType.h:70

◆ 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>;
typename Decay< T >::Type Decay_t
Auxiliary alias declaration for the Decay type trait.
Definition: Decay.h:98
Applies the type conversions for by-value function arguments.
Definition: Decay.h:73

◆ Detected_t

template<template< typename... > class OP, typename... Ts>
using blaze::Detected_t = typedef typename DetectedOr<NoneSuch,OP,Ts...>::Type

Compile time detection of type properties.

The Detected_t type trait determines if the given OP can be evaluated for the given types Ts. In case OP can be successfully evaluated, DetectedOr evaluates to OP<Ts...>. Otherwise it evaluates to NoneSuch.

template<class T>
using Diff_t = typename T::difference_type;
struct C { using difference_type = int; };
struct D { };
static_assert( IsSame_v< Detected_t<Diff_t, C>, int > , "C's difference_type should be int!" );
static_assert( IsSame_v< Detected_t<Diff_t, D>, NoneSuch >, "D should not have a difference type!");

◆ DetectedOr

template<typename Default , template< typename... > class OP, typename... Ts>
using blaze::DetectedOr = typedef Detector<Default,void,OP,Ts...>

Compile time detection of type properties.

The DetectedOr type trait determines if the given OP can be evaluated for the given types Ts. In case OP can be successfully evaluated, Detected_t evaluates to OP<Ts...>. Otherwise it evaluates to Default.

template<class T>
using Diff_t = typename T::difference_type;
struct C { using difference_type = int; };
struct D { };
template< typename T >
using difference_type = typename DetectedOr<ptrdiff_t, Diff_t, T>::Type;
static_assert( IsSame_v< difference_type<C>, int > , "C's difference_type should be int!" );
static_assert( IsSame_v< difference_type<D>, ptrdiff_t >, "D's difference_type should be ptrdiff_t!");
Pointer difference type of the Blaze library.

◆ DetectedOr_t

template<typename Default , template< typename... > class OP, typename... Ts>
using blaze::DetectedOr_t = typedef typename DetectedOr<Default,OP,Ts...>::Type

Auxiliary variable template for the DetectedOr type trait.

The DetectedOr_t variable template provides a convenient shortcut to access the nested Type of the DetectedOr class template. For instance, given the type Default, the template OP and the two types T1 and T2 the following two statements are identical:

Detector< Default, void, OP, Ts... > DetectedOr
Compile time detection of type properties.
Definition: IsDetected.h:116
typename DetectedOr< Default, OP, Ts... >::Type DetectedOr_t
Auxiliary variable template for the DetectedOr type trait.
Definition: IsDetected.h:211

◆ 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>;
typename Erase< TL, T >::Type Erase_t
Auxiliary alias declaration for the Erase class template.
Definition: Erase.h:138
Erasing the first occurrence of a type from a type list.
Definition: Erase.h:74

◆ 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>;
typename EraseAll< TL, T >::Type EraseAll_t
Auxiliary alias declaration for the EraseAll class template.
Definition: EraseAll.h:138
Erasing all occurrences of a type from a type list.
Definition: EraseAll.h:74

◆ HasGreaterThan

template<typename T1 , typename T2 >
using blaze::HasGreaterThan = typedef IsDetected< GreaterThan_t, T1, T2 >

Compile time check for the availability of a greater-than operation between two data types.

This type trait determines whether the given data types T1 and T2 can be used in a greater-than operation. If the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.

blaze::HasGreaterThan< int*, std::string* > // Is derived from FalseType
IsDetected< GreaterThan_t, T1, T2 > HasGreaterThan
Compile time check for the availability of a greater-than operation between two data types.
Definition: HasGreaterThan.h:84

◆ HasLessThan

template<typename T1 , typename T2 >
using blaze::HasLessThan = typedef IsDetected< LessThan_t, T1, T2 >

Compile time check for the availability of a less-than operation between two data types.

This type trait determines whether the given data types T1 and T2 can be used in a less-than operation. If the operation is available, the value member constant is set to true, the nested type definition Type is TrueType, and the class derives from TrueType. Otherwise value is set to false, Type is FalseType, and the class derives from FalseType.

blaze::HasLessThan< volatile int*, int* > // Is derived from TrueType
blaze::HasLessThan< int*, std::string* > // Is derived from FalseType
IsDetected< LessThan_t, T1, T2 > HasLessThan
Compile time check for the availability of a less-than operation between two data types.
Definition: HasLessThan.h:84

◆ IsDetected

template<template< typename... > class OP, typename... Ts>
using blaze::IsDetected = typedef typename DetectedOr<NoneSuch,OP,Ts...>::Value_t

Compile time detection of type properties.

The IsDetected type trait determines if the given OP can be evaluated for the given types Ts. In case OP can be successfully evaluated, IsDetected is an alias for TrueType. Otherwise it is an alias for FalseType.

template<class T>
using CopyAssign_t = decltype( std::declval<T&>() = std::declval<const T&>() );
struct A { };
struct B { void operator=( const B& ) = delete; };
static_assert( IsDetected_v<CopyAssign_t, A> , "A should be copy assignable!" );
static_assert( !IsDetected_v<CopyAssign_t, B>, "B should not be copy assignable!");
template<class T>
using Diff_t = typename T::difference_type;
struct C { using difference_type = int; };
struct D { };
static_assert( IsDetected_v<Diff_t, C> , "C should have a difference type!" );
static_assert( !IsDetected_v<Diff_t, D>, "D should not have a difference type!");

◆ MakeComplex_t

template<typename T >
using blaze::MakeComplex_t = typedef typename MakeComplex<T>::Type

Auxiliary alias declaration for the MakeComplex type trait.

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

using Type1 = typename blaze::MakeComplex<T>::Type;
typename MakeComplex< T >::Type MakeComplex_t
Auxiliary alias declaration for the MakeComplex type trait.
Definition: MakeComplex.h:204
Converting the given type to the matching 'complex' type.
Definition: MakeComplex.h:74

◆ 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>;
typename MakeSigned< T >::Type MakeSigned_t
Auxiliary alias declaration for the MakeSigned type trait.
Definition: MakeSigned.h:99
Compile time type conversion into a signed integral type.
Definition: MakeSigned.h:74

◆ 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;
typename MakeUnsigned< T >::Type MakeUnsigned_t
Auxiliary alias declaration for the MakeUnsigned type trait.
Definition: MakeUnsigned.h:99
Compile time type conversion into an unsigned integral type.
Definition: MakeUnsigned.h:74

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

using Type1 = typename blaze::RemoveAllExtents<T>::Type;
typename RemoveAllExtents< T >::Type RemoveAllExtents_t
Auxiliary alias declaration for the RemoveAllExtents type trait.
Definition: RemoveAllExtents.h:96
Removal of all array extents.
Definition: RemoveAllExtents.h:71

◆ 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;
typename RemoveConst< T >::Type RemoveConst_t
Auxiliary alias declaration for the RemoveConst type trait.
Definition: RemoveConst.h:96
Removal of const-qualifiers.
Definition: RemoveConst.h:71

◆ 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>;
typename RemoveCV< T >::Type RemoveCV_t
Auxiliary alias declaration for the RemoveCV type trait.
Definition: RemoveCV.h:97
Removal of top level cv-qualifiers.
Definition: RemoveCV.h:72

◆ 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;
typename RemoveCVRef< T >::Type RemoveCVRef_t
Auxiliary alias declaration for the RemoveCVRef type trait.
Definition: RemoveCVRef.h:99
Removal of top level cv-qualifiers.
Definition: RemoveCVRef.h:74

◆ 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;
typename RemoveExtent< T >::Type RemoveExtent_t
Auxiliary alias declaration for the RemoveExtent type trait.
Definition: RemoveExtent.h:95
Removal of the top level array extent.
Definition: RemoveExtent.h:70

◆ RemoveLValueReference_t

template<typename T >
using blaze::RemoveLValueReference_t = typedef typename RemoveLValueReference<T>::Type

Auxiliary alias declaration for the RemoveLValueReference type trait.

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

typename RemoveLValueReference< T >::Type RemoveLValueReference_t
Auxiliary alias declaration for the RemoveLValueReference type trait.
Definition: RemoveLValueReference.h:105
Removal of reference modifiers.
Definition: RemoveLValueReference.h:65

◆ 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;
typename RemovePointer< T >::Type RemovePointer_t
Auxiliary alias declaration for the RemovePointer type trait.
Definition: RemovePointer.h:95
Removal of pointer modifiers.
Definition: RemovePointer.h:70

◆ 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;
typename RemoveReference< T >::Type RemoveReference_t
Auxiliary alias declaration for the RemoveReference type trait.
Definition: RemoveReference.h:95
Removal of reference modifiers.
Definition: RemoveReference.h:70

◆ RemoveRValueReference_t

template<typename T >
using blaze::RemoveRValueReference_t = typedef typename RemoveRValueReference<T>::Type

Auxiliary alias declaration for the RemoveRValueReference type trait.

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

typename RemoveRValueReference< T >::Type RemoveRValueReference_t
Auxiliary alias declaration for the RemoveRValueReference type trait.
Definition: RemoveRValueReference.h:105
Removal of reference modifiers.
Definition: RemoveRValueReference.h:65

◆ 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;
typename RemoveVolatile< T >::Type RemoveVolatile_t
Auxiliary alias declaration for the RemoveVolatile type trait.
Definition: RemoveVolatile.h:97
Removal of volatile-qualifiers.
Definition: RemoveVolatile.h:72

◆ 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>;
typename TypeAt< TL, Index >::Type TypeAt_t
Auxiliary alias declaration for the TypeAt class template.
Definition: TypeAt.h:139
Indexing a type list.
Definition: TypeAt.h:75

◆ 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>;
typename Unique< TL >::Type Unique_t
Auxiliary alias declaration for the Unique class template.
Definition: Unique.h:125
Erasing all duplicates from a type list.
Definition: Unique.h:73

◆ 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 {};
BoolConstant< true > TrueType
Type traits base class.
Definition: IntegralConstant.h:132
Availability of an addition operator for the given data types.
Definition: HasAdd.h:107
Generic wrapper for a compile time constant integral value.
Definition: IntegralConstant.h:74

Variable Documentation

◆ AlignmentOf_v

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

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>;
Evaluation of the required alignment of the given data type.
Definition: AlignmentOf.h:182

◆ All_v

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

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>;
Compile time type check.
Definition: All.h:85

◆ AlwaysFalse_v

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

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>;
Type dependent compile time false.
Definition: AlwaysFalse.h:65

◆ AlwaysTrue_v

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

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>;
Type dependent compile time true.
Definition: AlwaysTrue.h:65

◆ Any_v

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

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>;
Compile time type check.
Definition: Any.h:85

◆ Contains_v

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

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>;
Searching a type list.
Definition: Contains.h:77

◆ ContainsRelated_v

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

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>;
Searching a type list.
Definition: ContainsRelated.h:90

◆ Extent_v

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

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>;
Compile time check for the size of array bounds.
Definition: Extent.h:79

◆ Has1Byte_v

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

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>;
Compile time size check.
Definition: HasSize.h:205

◆ Has2Bytes_v

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

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>;
Compile time size check.
Definition: HasSize.h:257

◆ Has4Bytes_v

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

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>;
Compile time size check.
Definition: HasSize.h:309

◆ Has8Bytes_v

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

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>;
Compile time size check.
Definition: HasSize.h:361

◆ HasGreaterThan_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasGreaterThan_v = HasGreaterThan<T1,T2>::value
constexpr

Auxiliary variable template for the HasGreaterThan type trait.

The HasGreaterThan_v variable template provides a convenient shortcut to access the nested value of the HasGreaterThan class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasGreaterThan<T1,T2>::value;
constexpr bool value2 = blaze::HasGreaterThan_v<T1,T2>;

◆ HasLessThan_v

template<typename T1 , typename T2 >
constexpr bool blaze::HasLessThan_v = HasLessThan<T1,T2>::value
constexpr

Auxiliary variable template for the HasLessThan type trait.

The HasLessThan_v variable template provides a convenient shortcut to access the nested value of the HasLessThan class template. For instance, given the types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::HasLessThan<T1,T2>::value;
constexpr bool value2 = blaze::HasLessThan_v<T1,T2>;

◆ HasSize_v

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

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>;
Compile time size check.
Definition: HasSize.h:77

◆ HaveSameSize_v

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

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>;
Compile time size check.
Definition: HaveSameSize.h:93

◆ IndexOf_v

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

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>;
Searching a type list.
Definition: IndexOf.h:75

◆ IsArithmetic_v

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

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>;
Compile time check for arithmetic data types.
Definition: IsArithmetic.h:80

◆ IsArray_v

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

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>;
Compile time type check.
Definition: IsArray.h:77

◆ IsAssignable_v

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

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>;
Compile time type check.
Definition: IsAssignable.h:73

◆ IsBaseOf_v

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

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>;
Compile time analysis of an inheritance relationship.
Definition: IsBaseOf.h:82

◆ IsBoolean_v

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

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>;
Compile time check for boolean types.
Definition: IsBoolean.h:76

◆ IsBuiltin_v

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

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>;
Compile time check for built-in data types.
Definition: IsBuiltin.h:77

◆ IsCharacter_v

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

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>;
Compile time check for character types.
Definition: IsCharacter.h:77

◆ IsClass_v

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

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>;
Compile time type check.
Definition: IsClass.h:79

◆ IsComplex_v

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

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>;
Compile time check for complex types.
Definition: IsComplex.h:77

◆ IsComplexDouble_v

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

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>;
Compile time check for single precision complex types.
Definition: IsComplexDouble.h:77

◆ IsComplexFloat_v

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

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>;
Compile time check for single precision complex types.
Definition: IsComplexFloat.h:77

◆ IsConst_v

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

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>;
Compile time check for constant data types.
Definition: IsConst.h:77

◆ IsConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:73

◆ IsConvertible_v

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

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>;
Compile time pointer relationship constraint.
Definition: IsConvertible.h:89

◆ IsCopyAssignable_v

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

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>;
Compile time type check.
Definition: IsAssignable.h:170

◆ IsCopyConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:265

◆ IsCUDAAssignable_v

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

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>;
Compile time check for data types.
Definition: IsCUDAAssignable.h:123

◆ IsDefaultConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:169

◆ IsDestructible_v

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

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>;
Compile time type check.
Definition: IsDestructible.h:74

◆ IsDetected_v

template<template< typename... > class OP, typename... Ts>
constexpr bool blaze::IsDetected_v = IsDetected<OP,Ts...>::value
constexpr

Auxiliary variable template for the IsDetected type trait.

The IsDetected_v variable template provides a convenient shortcut to access the nested value of the IsDetected class template. For instance, given the template OP and the two types T1 and T2 the following two statements are identical:

constexpr bool value1 = blaze::IsDetected<OP,T1,T2>::value;
constexpr bool value2 = blaze::IsDetected_v<OP,T1,T2>;
typename DetectedOr< NoneSuch, OP, Ts... >::Value_t IsDetected
Compile time detection of type properties.
Definition: IsDetected.h:151

◆ IsDouble_v

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

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>;
Compile time check for double precision floating point types.
Definition: IsDouble.h:76

◆ IsEmpty_v

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

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>;
Compile time type check.
Definition: IsEmpty.h:80

◆ IsEnum_v

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

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>;
Compile time check for complete enumeration types.
Definition: IsEnum.h:82

◆ IsFloat_v

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

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>;
Compile time check for single precision floating point types.
Definition: IsFloat.h:76

◆ IsFloatingPoint_v

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

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>;
Compile time check for floating point data types.
Definition: IsFloatingPoint.h:77

◆ IsInteger_v

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

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>;
Compile time check for integer types.
Definition: IsInteger.h:81

◆ IsIntegral_v

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

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>;
Compile time check for integral data types.
Definition: IsIntegral.h:77

◆ IsLong_v

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

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>;
Compile time check for long integer types.
Definition: IsLong.h:77

◆ IsLongDouble_v

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

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>;
Compile time check for extended precision floating point types.
Definition: IsLongDouble.h:76

◆ IsLValueReference_v

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

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>;
Compile time type check.
Definition: IsLValueReference.h:78

◆ IsMoveAssignable_v

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

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>;
Compile time type check.
Definition: IsAssignable.h:267

◆ IsMoveConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:361

◆ IsNothrowAssignable_v

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

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>;
Compile time type check.
Definition: IsAssignable.h:122

◆ IsNothrowConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:121

◆ IsNothrowCopyAssignable_v

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

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>;
Compile time type check.
Definition: IsAssignable.h:219

◆ IsNothrowCopyConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:313

◆ IsNothrowDefaultConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:217

◆ IsNothrowDestructible_v

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

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>;
Compile time type check.
Definition: IsDestructible.h:123

◆ IsNothrowMoveAssignable_v

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

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>;
Compile time type check.
Definition: IsAssignable.h:316

◆ IsNothrowMoveConstructible_v

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

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>;
Compile time type check.
Definition: IsConstructible.h:409

◆ IsNumeric_v

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

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>;
Compile time check for numeric types.
Definition: IsNumeric.h:81

◆ IsObject_v

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

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>;
Compile time type check.
Definition: IsObject.h:78

◆ IsPod_v

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

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>;
Compile time check for pod data types.
Definition: IsPod.h:89

◆ IsPointer_v

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

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>;
Compile time type check.
Definition: IsPointer.h:77

◆ IsReference_v

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

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>;
Compile time type check.
Definition: IsReference.h:77

◆ IsRValueReference_v

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

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>;
Compile time type check.
Definition: IsRValueReference.h:79

◆ IsSame_v

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

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>;
Type relationship analysis.
Definition: IsSame.h:141

◆ IsShort_v

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

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>;
Compile time check for short integer types.
Definition: IsShort.h:77

◆ IsSigned_v

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

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>;
Compile time check for signed data types.
Definition: IsSigned.h:79

◆ IsStrictlySame_v

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

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>;
Compile time type relationship analysis.
Definition: IsSame.h:77

◆ IsUnion_v

template<typename T >
constexpr bool blaze::IsUnion_v = IsUnion<T>::value
constexpr

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>;
Compile time check for union data types.
Definition: IsUnion.h:80

◆ IsUnsigned_v

template<typename T >
constexpr bool blaze::IsUnsigned_v = IsUnsigned<T>::value
constexpr

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>;
Compile time check for unsigned data types.
Definition: IsUnsigned.h:79

◆ IsValid_v

template<typename T >
constexpr bool blaze::IsValid_v = IsValid<T>::value
constexpr

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>;
Compile time type check.
Definition: IsValid.h:77

◆ IsVectorizable_v

template<typename T >
constexpr bool blaze::IsVectorizable_v = IsVectorizable<T>::value
constexpr

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>;
Compile time check for vectorizable types.
Definition: IsVectorizable.h:139

◆ IsVoid_v

template<typename T >
constexpr bool blaze::IsVoid_v = IsVoid<T>::value
constexpr

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>;
Compile time check for the void data type.
Definition: IsVoid.h:77

◆ IsVolatile_v

template<typename T >
constexpr bool blaze::IsVolatile_v = IsVolatile<T>::value
constexpr

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>;
Compile time check for volatile data types.
Definition: IsVolatile.h:77

◆ Length_v

template<typename TL >
constexpr size_t blaze::Length_v = Length<TL>::value
constexpr

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>;
Calculating the length of a type list.
Definition: Length.h:71

◆ Rank_v

template<typename T >
constexpr size_t blaze::Rank_v = Rank<T>::value
constexpr

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>;
Compile time check for array ranks.
Definition: Rank.h:74