Math wrappers

group NVCV_CPP_CUDATOOLS_MATHWRAPPERS

Defines

NVCV_CUDA_BINARY_SIMD(TYPE_U, INTRINSIC)

NVCV_CUDA_UNARY_SIMD(TYPE_U, INTRINSIC)

Enums

enum class RoundMode : int

Values:

enumerator NEAREST

enumerator DOWN

enumerator UP

enumerator ZERO

enumerator DEFAULT

Functions

template<RoundMode RM, typename T, typename U, class = Require<(!std::is_same_v<T, U>)&&((NumComponents<T> == NumComponents) || (NumComponents<T> == 0 && HasTypeTraits))>> inline __host__ __device__ auto round (U u)

Metafunction to round all elements of the input.

This function rounds all elements of the input and returns the result with the same type as the input. Optionally, the base type of the result may be specified by the template argument type T. For instance, a float4 can have its 4 elements rounded into a float4 result, or to a different result type, such as T=int or T=int4, where the result will be int4 with the rounded results (see example below). Also optionally, the round mode RM can be specified, as one of RoundMode, e.g. RoundMode::DOWN. It is a requirement of round that the input source type has type traits and the optional result type T is either a regular C type or has the same number of components as the input type.

using FloatType = MakeType<float, 4>;
FloatType res = ...;
FloatType float_rounded = round(res);
ConvertBaseTypeTo<int, FloatType> int_rounded = round<int>(res);

Template Parameters:

RM – Optional round mode to be used, cf. RoundMode.
U – Type of the source value (with 1 to 4 elements) passed as (and inferred from) argument u.
T – Optional type that defines the result of the round.

Parameters:

u – [in] Source value to round all elements with its same type or T.

Returns:

The value with all elements rounded.

template<typename T, typename U, class = Require<(!std::is_same_v<T, U>)&&((NumComponents<T> == NumComponents) || (NumComponents<T> == 0 && HasTypeTraits))>> inline __host__ __device__ auto round (U u)

Overload of round function.

It does specifies target round type T and uses default round mode RoundMode::DEFAULT.

template<RoundMode RM, typename U> inline __host__ __device__ auto round (U u)

Overload of round function.

It does not specify target round type T, using input source type U instead.

template<typename U> inline __host__ __device__ auto round (U u)

Overload of round function.

It does not specify target round type T, using input source type U instead, and uses default round mode RoundMode::DEFAULT.

template<typename U, class = Require<HasTypeTraits>> inline __host__ __device__ U min (U a, U b)

Metafunction to compute the minimum of two inputs per element.

This function finds the minimum of two inputs per element and returns the result with the same type as the input. For instance, two int4 inputs {1, 2, 3, 4} and {4, 3, 2, 1} yield the minimum {1, 2, 2, 1} as int4 as well (see example below). It is a requirement of min that the input source type has type traits.

using IntType = MakeType<int, 4>;
IntType a = {1, 2, 3, 4}, b = {4, 3, 2, 1};
IntType ab_min = min(a, b); // = {1, 2, 2, 1}

Template Parameters:: U – Type of the two source arguments and the return type.
Parameters:: u – [in] Input value to compute \( min(x_a, x_b) \) where \( x_a \) ( \( x_b \)) is each element of \( a \) ( \( b \)).
Returns:: The return value with one minimum per element.

template<typename U, class = Require<HasTypeTraits>> inline __host__ __device__ U max (U a, U b)

Metafunction to compute the maximum of two inputs per element.

This function finds the maximum of two inputs per element and returns the result with the same type as the input. For instance, two int4 inputs {1, 2, 3, 4} and {4, 3, 2, 1} yield the maximum {4, 3, 3, 4} as int4 as well (see example below). It is a requirement of max that the input source type has type traits.

using IntType = MakeType<int, 4>;
IntType a = {1, 2, 3, 4}, b = {4, 3, 2, 1};
IntType ab_max = max(a, b); // = {4, 3, 3, 4}

Template Parameters:: U – Type of the two source arguments and the return type.
Parameters:: u – [in] Input value to compute \( max(x_a, x_b) \) where \( x_a \) ( \( x_b \)) is each element of \( a \) ( \( b \)).
Returns:: The return value with maximums per element.

template<typename U, typename S, class = Require<(NumComponents == NumComponents<S>) || (HasTypeTraits && NumComponents<S> == 0)>> inline __host__ __device__ U pow (U x, S y)

Metafunction to compute the power of all elements of the input.

This function computes the power of all elements of the input x and returns the result with the same type as the input. It is a requirement of pow that the input x has the same number of components of the power y or y is a scalar (and the type of x has type traits).

Template Parameters:

U – Type of the source argument x and the return type.
S – Type of the source argument y power (use a regular C type for scalar).

Parameters:

x – [in] Input value to compute \( x^y \).
y – [in] Input power to compute \( x^y \).

Returns:

The return value with all elements as the result of the power.

template<typename U, class = Require<HasTypeTraits>> inline __host__ __device__ U exp (U u)

Metafunction to compute the natural (base e) exponential of all elements of the input.

This function computes the natural (base e) exponential of all elements of the input and returns the result with the same type as the input. It is a requirement of exp that the input source type has type traits.

Template Parameters:: U – Type of the source argument and the return type.
Parameters:: u – [in] Input value to compute \( e^x \) where \( x \) is each element of \( u \).
Returns:: The return value with all elements as the result of the natural (base e) exponential.

template<typename U, class = Require<HasTypeTraits>> inline __host__ __device__ U sqrt (U u)

Metafunction to compute the square root of all elements of the input.

This function computes the square root of all elements of the input and returns the result with the same type as the input. It is a requirement of sqrt that the input source type has type traits.

Template Parameters:: U – Type of the source argument and the return type.
Parameters:: u – [in] Input value to compute \( \sqrt{x} \) where \( x \) is each element of \( u \).
Returns:: The return value with all elements as the result of the square root.

template<typename U, class = Require<HasTypeTraits>> inline __host__ __device__ U abs (U u)

Metafunction to compute the absolute value of all elements of the input.

This function computes the absolute value of all elements of the input and returns the result with the same type as the input. For instance, an int4 input {-1, 2, -3, 4} yields the absolute {1, 2, 3, 4} as int4 as well (see example below). It is a requirement of abs that the input source type has type traits.

using IntType = MakeType<int, 4>;
IntType a = {-1, 2, -3, 4};
IntType a_abs = abs(a); // = {1, 2, 3, 4}

Template Parameters:: U – Type of the source argument and the return type.
Parameters:: u – [in] Input value to compute \( |x| \) where \( x \) is each element of \( u \).
Returns:: The return value with the absolute of all elements.

template<typename U, typename S, class = Require<(NumComponents == NumComponents<S>) || (HasTypeTraits && NumComponents<S> == 0)>> inline __host__ __device__ U clamp (U u, S lo, S hi)

Metafunction to clamp all elements of the input.

This function clamps all elements of the input u between lo and hi and returns the result with the same type as the input. It is a requirement of clamp that the input u has the same number of components of the range values lo and hi or both are scalars (and the type of u has type traits).

Template Parameters:

U – Type of the source argument u and the return type.
S – Type of the source argument lo and hi (use a regular C type for scalar).

Parameters:

u – [in] Input value to clamp.
lo – [in] Input clamp range low value.
hi – [in] Input clamp range high value.

Returns:

The return value with all elements clamped.

namespace detail

Typedefs

template<typename T, NVCVBorderType B> using BorderVarShapeWrapImpl = BorderIWImpl<ImageBatchVarShapeWrap<T>, B>

template<typename T, NVCVBorderType B> using BorderVarShapeWrapNHWCImpl = BorderIWImpl<ImageBatchVarShapeWrapNHWC<T>, B>

template<class FROM, class TO> using CopyConstness_t = typename CopyConstness<FROM, TO>::type

template<class T, int C> using MakeType_t = typename detail::MakeType<T, C>::type

template<class BT, class T> using ConvertBaseTypeTo_t = typename ConvertBaseTypeTo<BT, T>::type

Functions

template<typename U> inline __host__ U RoundEvenImpl (U u)

template<typename T, typename U, int RM = FE_TONEAREST> inline __host__ __device__ T RoundImpl (U u)

template<typename U> inline __host__ __device__ U MinImpl (U a, U b)

template<typename U> inline __host__ __device__ U MaxImpl (U a, U b)

template<typename U, typename S> inline __host__ __device__ U PowImpl (U x, S y)

template<typename U> inline __host__ __device__ U ExpImpl (U u)

template<typename U> inline __host__ __device__ U SqrtImpl (U u)

template<typename U> inline __host__ __device__ U AbsImpl (U u)

template<typename U, typename S> inline __host__ __device__ U ClampImpl (U u, S lo, S hi)

template<typename T, typename U> inline __host__ __device__ T RangeCastImpl (U u)

template<typename T, typename U> inline __host__ __device__ T BaseSaturateCastImpl (U u)

template<typename T, typename U> inline __host__ __device__ T SaturateCastImpl (U u)

template<> __host__ __device__ __forceinline__ unsigned char SaturateCastImpl< unsigned char, signed char > (signed char u)

template<> __host__ __device__ __forceinline__ unsigned char SaturateCastImpl< unsigned char, short > (short u)

template<> __host__ __device__ __forceinline__ unsigned char SaturateCastImpl< unsigned char, unsigned short > (unsigned short u)

template<> __host__ __device__ __forceinline__ unsigned char SaturateCastImpl< unsigned char, int > (int u)

template<> __host__ __device__ __forceinline__ unsigned char SaturateCastImpl< unsigned char, unsigned int > (unsigned int u)

template<> __host__ __device__ __forceinline__ unsigned char SaturateCastImpl< unsigned char, float > (float u)

template<> __host__ __device__ __forceinline__ unsigned char SaturateCastImpl< unsigned char, double > (double u)

template<> __host__ __device__ __forceinline__ signed char SaturateCastImpl< signed char, unsigned char > (unsigned char u)

template<> __host__ __device__ __forceinline__ signed char SaturateCastImpl< signed char, short > (short u)

template<> __host__ __device__ __forceinline__ signed char SaturateCastImpl< signed char, unsigned short > (unsigned short u)

template<> __host__ __device__ __forceinline__ signed char SaturateCastImpl< signed char, int > (int u)

template<> __host__ __device__ __forceinline__ signed char SaturateCastImpl< signed char, unsigned int > (unsigned int u)

template<> __host__ __device__ __forceinline__ signed char SaturateCastImpl< signed char, float > (float u)

template<> __host__ __device__ __forceinline__ signed char SaturateCastImpl< signed char, double > (double u)

template<> __host__ __device__ __forceinline__ unsigned short SaturateCastImpl< unsigned short, signed char > (signed char u)

template<> __host__ __device__ __forceinline__ unsigned short SaturateCastImpl< unsigned short, short > (short u)

template<> __host__ __device__ __forceinline__ unsigned short SaturateCastImpl< unsigned short, int > (int u)

template<> __host__ __device__ __forceinline__ unsigned short SaturateCastImpl< unsigned short, unsigned int > (unsigned int u)

template<> __host__ __device__ __forceinline__ unsigned short SaturateCastImpl< unsigned short, float > (float u)

template<> __host__ __device__ __forceinline__ unsigned short SaturateCastImpl< unsigned short, double > (double u)

template<> __host__ __device__ __forceinline__ short SaturateCastImpl< short, unsigned short > (unsigned short u)

template<> __host__ __device__ __forceinline__ short SaturateCastImpl< short, int > (int u)

template<> __host__ __device__ __forceinline__ short SaturateCastImpl< short, unsigned int > (unsigned int u)

template<> __host__ __device__ __forceinline__ short SaturateCastImpl< short, float > (float u)

template<> __host__ __device__ __forceinline__ short SaturateCastImpl< short, double > (double u)

template<> __host__ __device__ __forceinline__ int SaturateCastImpl< int, unsigned int > (unsigned int u)

template<> __host__ __device__ __forceinline__ int SaturateCastImpl< int, float > (float u)

template<> __host__ __device__ __forceinline__ int SaturateCastImpl< int, double > (double u)

template<> __host__ __device__ __forceinline__ unsigned int SaturateCastImpl< unsigned int, signed char > (signed char u)

template<> __host__ __device__ __forceinline__ unsigned int SaturateCastImpl< unsigned int, short > (short u)

template<> __host__ __device__ __forceinline__ unsigned int SaturateCastImpl< unsigned int, int > (int u)

template<> __host__ __device__ __forceinline__ unsigned int SaturateCastImpl< unsigned int, float > (float u)

template<> __host__ __device__ __forceinline__ unsigned int SaturateCastImpl< unsigned int, double > (double u)

template<typename T, typename U, typename RT, RoundMode RM> inline __host__ __device__ RT RoundImpl (U u)

Variables

template<class T, class U, class = Require<HasTypeTraits<T, U>>> constexpr bool IsSameCompound = IsCompound<T> && TypeTraits<T>::components == TypeTraits::components

template<typename T, typename U, class = Require<HasTypeTraits<T, U>>> constexpr bool OneIsCompound = (TypeTraits<T>::components == 0 && TypeTraits::components >= 1) || (TypeTraits<T>::components >= 1 && TypeTraits::components == 0) || IsSameCompound<T, U>

template<typename T, class = Require<HasTypeTraits<T>>> constexpr bool IsIntegral = std::is_integral_v<typename TypeTraits<T>::base_type>

template<typename T, typename U, class = Require<HasTypeTraits<T, U>>> constexpr bool OneIsCompoundAndBothAreIntegral = OneIsCompound<T, U> && IsIntegral<T> && IsIntegral

template<typename T, class = Require<HasTypeTraits<T>>> constexpr bool IsIntegralCompound = IsIntegral<T> && IsCompound<T>

template<class IW, NVCVBorderType B> class BorderIWImpl: #include <BorderVarShapeWrap.hpp>

Subclassed by nvcv::cuda::BorderVarShapeWrap< T, B >, nvcv::cuda::BorderVarShapeWrap< T, NVCV_BORDER_CONSTANT >, nvcv::cuda::BorderVarShapeWrapNHWC< T, B >, nvcv::cuda::BorderVarShapeWrapNHWC< T, NVCV_BORDER_CONSTANT >

template<class TW, NVCVBorderType B, bool... ActiveDimensions> class BorderWrapImpl: #include <BorderWrap.hpp>

template<class BT, class T> struct ConvertBaseTypeTo: #include <Metaprogramming.hpp>

template<class BT, class T> struct ConvertBaseTypeTo<BT, const T>: #include <Metaprogramming.hpp>

template<class BT, class T> struct ConvertBaseTypeTo<BT, volatile const T>: #include <Metaprogramming.hpp>

template<class BT, class T> struct ConvertBaseTypeTo<BT, volatile T>: #include <Metaprogramming.hpp>

template<class FROM, class TO> struct CopyConstness: #include <Metaprogramming.hpp>

template<class FROM, class TO> struct CopyConstness<const FROM, TO>: #include <Metaprogramming.hpp>

template<typename T, typename = void> struct HasTypeTraits_t : public false_type: #include <Metaprogramming.hpp>

template<typename T> base_type > > : public true_type: #include <Metaprogramming.hpp>

template<typename T, NVCVBorderType B, NVCVInterpolationType I> class InterpolationVarShapeWrapImpl: #include <InterpolationVarShapeWrap.hpp>

Subclassed by nvcv::cuda::InterpolationVarShapeWrap< T, B, I >

template<class BW, NVCVInterpolationType I> class InterpolationWrapImpl: #include <InterpolationWrap.hpp>

Subclassed by nvcv::cuda::InterpolationWrap< BW, I >

template<class T, int C> struct MakeType: #include <Metaprogramming.hpp>

template<> struct MakeType<char, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<char, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<char, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<char, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<char, 4>: #include <Metaprogramming.hpp>

template<class T, int C> struct MakeType<const T, C>: #include <Metaprogramming.hpp>

template<class T, int C> struct MakeType<volatile const T, C>: #include <Metaprogramming.hpp>

template<> struct MakeType<double, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<double, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<double, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<double, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<double, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<float, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<float, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<float, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<float, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<float, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<int, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<int, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<int, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<int, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<int, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<long long, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<long long, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<long long, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<long long, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<long long, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<long, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<long, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<long, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<long, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<long, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<short, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<short, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<short, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<short, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<short, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<signed char, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<signed char, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<signed char, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<signed char, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<signed char, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned char, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned char, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned char, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned char, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned char, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned int, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned int, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned int, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned int, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned int, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long long, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long long, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long long, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long long, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long long, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned long, 4>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned short, 0>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned short, 1>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned short, 2>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned short, 3>: #include <Metaprogramming.hpp>

template<> struct MakeType<unsigned short, 4>: #include <Metaprogramming.hpp>

template<class T, int C> struct MakeType<volatile T, C>: #include <Metaprogramming.hpp>

template<class T> struct TypeTraits: #include <Metaprogramming.hpp>

Subclassed by nvcv::cuda::detail::TypeTraits< const T >, nvcv::cuda::detail::TypeTraits< const volatile T >, nvcv::cuda::detail::TypeTraits< volatile T >

template<> struct TypeTraits<char>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<char1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<char2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<char3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<char4>: #include <Metaprogramming.hpp>

template<class T> struct TypeTraits<const T> : public nvcv::cuda::detail::TypeTraits<T>: #include <Metaprogramming.hpp>

template<class T> struct TypeTraits<volatile const T> : public nvcv::cuda::detail::TypeTraits<T>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<dim3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<double>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<double1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<double2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<double3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<double4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<float>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<float1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<float2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<float3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<float4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<int>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<int1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<int2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<int3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<int4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<long>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<long long>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<long1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<long2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<long3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<long4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<longlong1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<longlong2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<longlong3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<longlong4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<short>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<short1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<short2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<short3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<short4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<signed char>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uchar1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uchar2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uchar3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uchar4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uint1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uint2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uint3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<uint4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulong1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulong2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulong3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulong4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulonglong1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulonglong2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulonglong3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ulonglong4>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<unsigned char>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<unsigned int>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<unsigned long>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<unsigned long long>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<unsigned short>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ushort1>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ushort2>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ushort3>: #include <Metaprogramming.hpp>

template<> struct TypeTraits<ushort4>: #include <Metaprogramming.hpp>

template<class T> struct TypeTraits<volatile T> : public nvcv::cuda::detail::TypeTraits<T>: #include <Metaprogramming.hpp>