DPC++ Runtime
Runtime libraries for oneAPI DPC++
builtins_legacy_marray_vec.hpp File Reference
Include dependency graph for builtins_legacy_marray_vec.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces

 sycl
 
 sycl::_V1
 
 sycl::_V1::native
 
 sycl::_V1::half_precision
 

Macros

#define __FAST_MATH_GENFLOAT(T)   (detail::is_svgenfloat_v<T>)
 
#define __FAST_MATH_SGENFLOAT(T)   (detail::is_sgenfloat_v<T>)
 
#define __SYCL_MATH_FUNCTION_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_OVERLOAD(NAME)
 
#define __SYCL_MATH_FUNCTION_OVERLOAD_FM(NAME)
 
#define __SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_2_OVERLOAD(NAME)
 
#define __SYCL_MATH_FUNCTION_2_SGENFLOAT_Y_OVERLOAD(NAME)
 
#define __SYCL_MATH_FUNCTION_2_GENINT_Y_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_2_INT_Y_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MATH_FUNCTION_3_OVERLOAD(NAME)
 
#define __SYCL_MARRAY_MATH_FUNCTION_W_GENPTR_ARG_OVERLOAD_IMPL(NAME, ARGPTR, ...)
 
#define __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD( NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD( NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_MATH_FUNCTION_REMQUO_OVERLOAD(NAME, ...)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, ...)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_UNOP_OVERLOAD(NAME, ARG, ...)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD(NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_ABS_U_OVERLOAD(NAME, ARG, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_ABS_I_OVERLOAD(NAME, ARG, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_UNOP_OVERLOAD(NAME, ARG, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_OVERLOAD(NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_RET_U_OVERLOAD(NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_OVERLOAD(NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_2ND_ARG_SCALAR_OVERLOAD( NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD( NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD(NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD(NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_2ND_3RD_ARGS_SCALAR_OVERLOAD( NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_2ND_3RD_ARGS_SCALAR_OVERLOAD( NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_U_OVERLOAD(NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_I_OVERLOAD(NAME, ARG1, ARG2, ARG3, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_MUL24_U_OVERLOAD(NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_MUL24_I_OVERLOAD(NAME, ARG1, ARG2, ...)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_OVERLOAD_IMPL(NAME)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_UU_OVERLOAD(NAME, KBIT)
 
#define __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_IU_OVERLOAD(NAME, KBIT)
 
#define __SYCL_MARRAY_GEOMETRIC_FUNCTION_OVERLOAD_IMPL(NAME, ...)
 
#define __SYCL_MARRAY_GEOMETRIC_FUNCTION_IS_GENGEOMARRAY_BINOP_OVERLOAD(NAME)
 
#define __SYCL_MARRAY_RELATIONAL_FUNCTION_BINOP_OVERLOAD(NAME)
 
#define __SYCL_MARRAY_RELATIONAL_FUNCTION_UNOP_OVERLOAD(NAME)
 
#define __SYCL_NATIVE_MATH_FUNCTION_OVERLOAD(NAME)
 
#define __SYCL_NATIVE_MATH_FUNCTION_2_OVERLOAD(NAME)
 
#define __SYCL_HALF_PRECISION_MATH_FUNCTION_OVERLOAD(NAME)
 
#define __SYCL_HALF_PRECISION_MATH_FUNCTION_2_OVERLOAD(NAME)
 

Functions

template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< int, N > > sycl::_V1::ilogb (marray< T, N > x)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< __FAST_MATH_SGENFLOAT(T), marray< T, N > > sycl::_V1::powr (marray< T, N > x, marray< T, N > y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > sycl::_V1::ldexp (marray< T, N > x, marray< int, N > k)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > sycl::_V1::ldexp (marray< T, N > x, int k)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > sycl::_V1::pown (marray< T, N > x, marray< int, N > y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > sycl::_V1::rootn (marray< T, N > x, marray< int, N > y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > sycl::_V1::pown (marray< T, N > x, int y)
 
template<typename T , size_t N>
__SYCL_ALWAYS_INLINE std::enable_if_t< detail::is_sgenfloat_v< T >, marray< T, N > > sycl::_V1::rootn (marray< T, N > x, int y)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > sycl::_V1::fmax (T x, typename T::element_type y)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > sycl::_V1::fmin (T x, typename T::element_type y)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > sycl::_V1::ldexp (T x, int k)
 
template<typename T , typename T2 >
std::enable_if_t< detail::is_vgenfloat_v< T > &&detail::is_intn_v< T2 >, T > sycl::_V1::ldexp (T x, T2 k)
 
 sycl::_V1::__SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD (fract, x, iptr, x[j]) __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD(modf
 
x[j] sycl::_V1::__SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD (sincos, x, cosval, x[j]) __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD(frexp
 
x[j] x[j] sycl::_V1::__SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD (lgamma_r, x, signp, x[j]) template< typename T
 
x[j] x[j] size_t N std::enable_if_t< detail::is_nan_type_v< T > &&detail::is_non_deprecated_nan_type_v< T >, marray< detail::nan_return_t< T >, N > > sycl::_V1::nan (marray< T, N > nancode)
 
template<typename T , size_t N>
 sycl::_V1::__SYCL_DEPRECATED ("This is a deprecated argument type for SYCL nan built-in function.") std
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > sycl::_V1::clamp (T x, typename T::element_type minval, typename T::element_type maxval)
 
template<typename T >
 sycl::_V1::std::enable_if_t< detail::is_vgenfloat_v< T >, T > (max)(T x
 
template<typename T >
 sycl::_V1::std::enable_if_t< detail::is_vgenfloat_v< T >, T > (min)(T x
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > sycl::_V1::mix (T x, T y, typename T::element_type a)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > sycl::_V1::step (typename T::element_type edge, T x)
 
template<typename T >
std::enable_if_t< detail::is_vgenfloat_v< T >, T > sycl::_V1::smoothstep (typename T::element_type edge0, typename T::element_type edge1, T x)
 
 sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD ((min), T x, detail::marray_element_t< T > y, x[i], y) __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD((max)
 
T detail::marray_element_t< T > y sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD (step, detail::marray_element_t< T > edge, T x, edge, x[i]) __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(clamp
 
T detail::marray_element_t< T > y T T T maxval[i] sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (clamp, T x, detail::marray_element_t< T > minval, detail::marray_element_t< T > maxval, x[i], minval, maxval) __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(mix
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (mix, T x, T y, detail::marray_element_t< T > a, x[i], y[i], a) __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD(smoothstep
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T T T x[i] sycl::_V1::__SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (smoothstep, detail::marray_element_t< T > edge0, detail::marray_element_t< T > edge1, T x, edge0, edge1, x[i]) template< typename T > std
 
template<typename T >
std::enable_if_t< detail::is_vigeninteger_v< T >, T > sycl::_V1::clamp (T x, typename T::element_type minval, typename T::element_type maxval)
 
template<typename T >
std::enable_if_t< detail::is_vugeninteger_v< T >, T > sycl::_V1::clamp (T x, typename T::element_type minval, typename T::element_type maxval)
 
template<typename T >
 sycl::_V1::std::enable_if_t< detail::is_vigeninteger_v< T >, T > (max)(T x
 
template<typename T >
 sycl::_V1::std::enable_if_t< detail::is_vugeninteger_v< T >, T > (max)(T x
 
template<typename T >
 sycl::_V1::std::enable_if_t< detail::is_vigeninteger_v< T >, T > (min)(T x
 
template<typename T >
 sycl::_V1::std::enable_if_t< detail::is_vugeninteger_v< T >, T > (min)(T x
 
 sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_RET_U_OVERLOAD (abs_diff, x, y, x[j], y[j]) __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_2ND_ARG_SCALAR_OVERLOAD((max)
 
sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD ((max), x, y, x[j], y) __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_2ND_ARG_SCALAR_OVERLOAD((min)
 
y y sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD ((min), x, y, x[j], y) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD(clamp
 
y y maxval[j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD (clamp, x, minval, maxval, x[j], minval[j], maxval[j]) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_2ND_3RD_ARGS_SCALAR_OVERLOAD(clamp
 
y y maxval[j] maxval sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_2ND_3RD_ARGS_SCALAR_OVERLOAD (clamp, x, minval, maxval, x[j], minval, maxval) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD(mad_hi
 
y y maxval[j] maxval c[j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD (mad_hi, a, b, c, a[j], b[j], c[j]) __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD(mad_sat
 
y y maxval[j] maxval c[j] c[j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD (mad_sat, a, b, c, a[j], b[j], c[j]) __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_U_OVERLOAD(mad24
 
y y maxval[j] maxval c[j] c[j] z[j] sycl::_V1::__SYCL_MARRAY_INTEGER_FUNCTION_MAD24_I_OVERLOAD (mad24, x, y, z, x[j], y[j], z[j]) template< typename T > std
 
template<typename T >
std::enable_if_t< detail::is_vgengeofloat_v< T >, float > sycl::_V1::dot (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_vgengeodouble_v< T >, double > sycl::_V1::dot (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_vgengeohalf_v< T >, half > sycl::_V1::dot (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float sycl::_V1::distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
double sycl::_V1::distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeohalf_v<T>, T>>
half sycl::_V1::distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float sycl::_V1::length (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
double sycl::_V1::length (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeohalf_v<T>, T>>
half sycl::_V1::length (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeofloat_v< T >, T > sycl::_V1::normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeodouble_v< T >, T > sycl::_V1::normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeohalf_v< T >, T > sycl::_V1::normalize (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float sycl::_V1::fast_distance (T p0, T p1)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
 sycl::_V1::__SYCL_DEPRECATED ("fast_distance for double precision types is non-standard " "and has been deprecated") double fast_distance(T p0
 
template<typename T , typename = std::enable_if_t<detail::is_gengeofloat_v<T>, T>>
float sycl::_V1::fast_length (T p)
 
template<typename T , typename = std::enable_if_t<detail::is_gengeodouble_v<T>, T>>
 sycl::_V1::__SYCL_DEPRECATED ("fast_length for double precision types is non-standard " "and has been deprecated") double fast_length(T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeofloat_v< T >, T > sycl::_V1::fast_normalize (T p)
 
template<typename T >
 sycl::_V1::__SYCL_DEPRECATED ("fast_normalize for double precision types is non-standard " "and has been deprecated") std
 
template<typename T >
std::enable_if_t< detail::is_gencrossmarray_v< T >, T > sycl::_V1::cross (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarray_v< T >, T > sycl::_V1::normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarrayfloat_v< T >, T > sycl::_V1::fast_normalize (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarray_v< T >, detail::marray_element_t< T > > sycl::_V1::length (T p)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarrayfloat_v< T >, detail::marray_element_t< T > > sycl::_V1::fast_distance (T p0, T p1)
 
template<typename T >
std::enable_if_t< detail::is_gengeomarrayfloat_v< T >, detail::marray_element_t< T > > sycl::_V1::fast_length (T p)
 
template<typename T >
std::enable_if_t< detail::is_vigeninteger_v< T >, int > sycl::_V1::any (T x)
 
template<typename T >
std::enable_if_t< detail::is_vigeninteger_v< T >, int > sycl::_V1::all (T x)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_sigeninteger_v< T >, bool > sycl::_V1::any (marray< T, N > x)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_sigeninteger_v< T >, bool > sycl::_V1::all (marray< T, N > x)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_gentype_v< T >, marray< T, N > > sycl::_V1::bitselect (marray< T, N > a, marray< T, N > b, marray< T, N > c)
 
template<typename T , size_t N>
std::enable_if_t< detail::is_gentype_v< T >, marray< T, N > > sycl::_V1::select (marray< T, N > a, marray< T, N > b, marray< bool, N > c)
 

Variables

 sycl::_V1::x { return (M_PI / 180) * x
 
 sycl::_V1::iptr
 
x[j] sycl::_V1::exp
 
T::element_type sycl::_V1::y
 
T detail::marray_element_t< T > y T T sycl::_V1::minval
 
T detail::marray_element_t< T > y T T T sycl::_V1::maxval
 
T detail::marray_element_t< T > y T T T maxval[i] T T T sycl::_V1::a
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T sycl::_V1::edge0
 
T detail::marray_element_t< T > y T T T maxval[i] T T T a[i] T T sycl::_V1::edge1
 
y y maxval[j] maxval sycl::_V1::b
 
y y maxval[j] maxval sycl::_V1::c
 
y y maxval[j] maxval c[j] c[j] sycl::_V1::z
 
sycl::_V1::p1
 

Macro Definition Documentation

◆ __FAST_MATH_GENFLOAT

#define __FAST_MATH_GENFLOAT (   T)    (detail::is_svgenfloat_v<T>)

Definition at line 45 of file builtins_legacy_marray_vec.hpp.

◆ __FAST_MATH_SGENFLOAT

#define __FAST_MATH_SGENFLOAT (   T)    (detail::is_sgenfloat_v<T>)

Definition at line 46 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_HALF_PRECISION_MATH_FUNCTION_2_OVERLOAD

#define __SYCL_HALF_PRECISION_MATH_FUNCTION_2_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME(marray<float, N> x, \
marray<float, N> y) { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_half_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2), detail::to_vec2(y, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = \
__sycl_std::__invoke_half_##NAME<float>(x[N - 1], y[N - 1]); \
} \
return res; \
}
#define __SYCL_ALWAYS_INLINE
void memcpy(void *Dst, const void *Src, size_t Size)
Definition: memcpy.hpp:16
vec< T, 2 > to_vec2(marray< T, N > X, size_t Start)

Definition at line 1254 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_HALF_PRECISION_MATH_FUNCTION_OVERLOAD

#define __SYCL_HALF_PRECISION_MATH_FUNCTION_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME(marray<float, N> x) { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_half_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_half_##NAME<float>(x[N - 1]); \
} \
return res; \
}

Definition at line 1224 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD

#define __SYCL_MARRAY_COMMON_FUNCTION_BINOP_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat_v<T>>> \
T NAME(ARG1, ARG2) { \
__SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 518 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL

#define __SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL (   NAME,
  ... 
)
Value:
T res; \
for (int i = 0; i < T::size(); i++) { \
res[i] = NAME(__VA_ARGS__); \
} \
return res;

Definition at line 498 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD

#define __SYCL_MARRAY_COMMON_FUNCTION_TEROP_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat_v<T>>> \
T NAME(ARG1, ARG2, ARG3) { \
__SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_COMMON_FUNCTION_UNOP_OVERLOAD

#define __SYCL_MARRAY_COMMON_FUNCTION_UNOP_OVERLOAD (   NAME,
  ARG,
  ... 
)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat_v<T>>> \
T NAME(ARG) { \
__SYCL_MARRAY_COMMON_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 505 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_GEOMETRIC_FUNCTION_IS_GENGEOMARRAY_BINOP_OVERLOAD

#define __SYCL_MARRAY_GEOMETRIC_FUNCTION_IS_GENGEOMARRAY_BINOP_OVERLOAD (   NAME)
Value:
template <typename T> \
std::enable_if_t<detail::is_gengeomarray_v<T>, detail::marray_element_t<T>> \
NAME(T p0, T p1) { \
return NAME(detail::to_vec(p0), detail::to_vec(p1)); \
}
vec< T, N > to_vec(marray< T, N > X)

Definition at line 1043 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_GEOMETRIC_FUNCTION_OVERLOAD_IMPL

#define __SYCL_MARRAY_GEOMETRIC_FUNCTION_OVERLOAD_IMPL (   NAME,
  ... 
)
Value:
vec<detail::marray_element_t<T>, T::size()> result_v; \
result_v = NAME(__VA_ARGS__); \
return detail::to_marray(result_v);
marray< T, N > to_marray(vec< T, N > X)

Definition at line 1019 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_ABS_I_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_ABS_I_OVERLOAD (   NAME,
  ARG,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 643 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_ABS_U_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_ABS_U_OVERLOAD (   NAME,
  ARG,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 636 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_2ND_ARG_SCALAR_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, T ARG2) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 700 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 685 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_RET_U_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_I_RET_U_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger_v<T>, \
marray<detail::make_unsigned_t<T>, N>> \
NAME(marray<T, N> ARG1, marray<T, N> ARG2) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 676 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_2ND_ARG_SCALAR_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_2ND_ARG_SCALAR_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, T ARG2) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 692 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_BINOP_U_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 669 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_I_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_I_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger32bit_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2, marray<T, N> ARG3) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_U_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_MAD24_U_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger32bit_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2, marray<T, N> ARG3) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_MUL24_I_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_MUL24_I_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger32bit_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_MUL24_U_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_MUL24_U_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger32bit_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL

#define __SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL (   NAME,
  ... 
)
Value:
marray<T, N> res; \
for (int j = 0; j < N; j++) { \
res[j] = NAME(__VA_ARGS__); \
} \
return res;

Definition at line 628 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_2ND_3RD_ARGS_SCALAR_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_2ND_3RD_ARGS_SCALAR_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, T ARG2, T ARG3) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_I_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_igeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2, marray<T, N> ARG3) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_2ND_3RD_ARGS_SCALAR_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_2ND_3RD_ARGS_SCALAR_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, T ARG2, T ARG3) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_TEROP_U_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ARG3,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG1, marray<T, N> ARG2, marray<T, N> ARG3) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

◆ __SYCL_MARRAY_INTEGER_FUNCTION_UNOP_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_UNOP_OVERLOAD (   NAME,
  ARG,
  ... 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_geninteger_v<T>, marray<T, N>> NAME( \
marray<T, N> ARG) { \
__SYCL_MARRAY_INTEGER_FUNCTION_OVERLOAD_IMPL(NAME, __VA_ARGS__) \
}

Definition at line 656 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_IU_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_IU_OVERLOAD (   NAME,
  KBIT 
)
Value:
template <typename T, typename T2, size_t N> \
std::enable_if_t<detail::is_igeninteger##KBIT##_v<T> && \
detail::is_ugeninteger##KBIT##_v<T2>, \
detail::make_larger_t<marray<T, N>>> \
NAME(marray<T, N> hi, marray<T2, N> lo) { \
__SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_OVERLOAD_IMPL(NAME) \
}
std::bool_constant< is_ugeninteger_v< T > > is_ugeninteger

◆ __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_OVERLOAD_IMPL

#define __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_OVERLOAD_IMPL (   NAME)
Value:
detail::make_larger_t<marray<T, N>> res; \
for (int j = 0; j < N; j++) { \
res[j] = NAME(hi[j], lo[j]); \
} \
return res;

◆ __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_UU_OVERLOAD

#define __SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_UU_OVERLOAD (   NAME,
  KBIT 
)
Value:
template <typename T, size_t N> \
std::enable_if_t<detail::is_ugeninteger##KBIT##_v<T>, \
detail::make_larger_t<marray<T, N>>> \
NAME(marray<T, N> hi, marray<T, N> lo) { \
__SYCL_MARRAY_INTEGER_FUNCTION_UPSAMPLE_OVERLOAD_IMPL(NAME) \
}

◆ __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD

#define __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENFLOATPTR_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N, typename T2, \
access::address_space AddressSpace, access::decorated IsDecorated> \
std::enable_if_t< \
detail::is_svgenfloat_v<T> && \
detail::is_genfloatptr_marray_v<T2, AddressSpace, IsDecorated>, \
marray<T, N>> \
NAME(marray<T, N> ARG1, multi_ptr<T2, AddressSpace, IsDecorated> ARG2) { \
__SYCL_MARRAY_MATH_FUNCTION_W_GENPTR_ARG_OVERLOAD_IMPL(NAME, ARG2, \
__VA_ARGS__) \
}

Definition at line 353 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD

#define __SYCL_MARRAY_MATH_FUNCTION_BINOP_2ND_ARG_GENINTPTR_OVERLOAD (   NAME,
  ARG1,
  ARG2,
  ... 
)
Value:
template <typename T, size_t N, typename T2, \
access::address_space AddressSpace, access::decorated IsDecorated> \
std::enable_if_t< \
detail::is_svgenfloat_v<T> && \
detail::is_genintptr_marray_v<T2, AddressSpace, IsDecorated>, \
marray<T, N>> \
NAME(marray<T, N> ARG1, multi_ptr<T2, AddressSpace, IsDecorated> ARG2) { \
__SYCL_MARRAY_MATH_FUNCTION_W_GENPTR_ARG_OVERLOAD_IMPL(NAME, ARG2, \
__VA_ARGS__) \
}

◆ __SYCL_MARRAY_MATH_FUNCTION_REMQUO_OVERLOAD

#define __SYCL_MARRAY_MATH_FUNCTION_REMQUO_OVERLOAD (   NAME,
  ... 
)
Value:
template <typename T, size_t N, typename T2, \
access::address_space AddressSpace, access::decorated IsDecorated> \
std::enable_if_t< \
detail::is_svgenfloat_v<T> && \
detail::is_genintptr_marray_v<T2, AddressSpace, IsDecorated>, \
marray<T, N>> \
NAME(marray<T, N> x, marray<T, N> y, \
multi_ptr<T2, AddressSpace, IsDecorated> quo) { \
__SYCL_MARRAY_MATH_FUNCTION_W_GENPTR_ARG_OVERLOAD_IMPL(NAME, quo, \
__VA_ARGS__) \
}

◆ __SYCL_MARRAY_MATH_FUNCTION_W_GENPTR_ARG_OVERLOAD_IMPL

#define __SYCL_MARRAY_MATH_FUNCTION_W_GENPTR_ARG_OVERLOAD_IMPL (   NAME,
  ARGPTR,
  ... 
)
Value:
marray<T, N> res; \
for (int j = 0; j < N; j++) { \
res[j] = \
NAME(__VA_ARGS__, \
address_space_cast<AddressSpace, IsDecorated, \
detail::marray_element_t<T2>>(&(*ARGPTR)[j])); \
} \
return res;

Definition at line 342 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_RELATIONAL_FUNCTION_BINOP_OVERLOAD

#define __SYCL_MARRAY_RELATIONAL_FUNCTION_BINOP_OVERLOAD (   NAME)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat_v<T>>> \
sycl::marray<bool, T::size()> NAME(T x, T y) { \
sycl::marray<bool, T::size()> res; \
for (int i = 0; i < x.size(); i++) { \
res[i] = NAME(x[i], y[i]); \
} \
return res; \
}

Definition at line 1081 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MARRAY_RELATIONAL_FUNCTION_UNOP_OVERLOAD

#define __SYCL_MARRAY_RELATIONAL_FUNCTION_UNOP_OVERLOAD (   NAME)
Value:
template <typename T, \
typename = std::enable_if_t<detail::is_mgenfloat_v<T>>> \
sycl::marray<bool, T::size()> NAME(T x) { \
sycl::marray<bool, T::size()> res; \
for (int i = 0; i < x.size(); i++) { \
res[i] = NAME(x[i]); \
} \
return res; \
}

Definition at line 1092 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_2_GENINT_Y_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_2_GENINT_Y_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N; i++) { \
res[i] = __sycl_std::__invoke_##NAME<T>(x[i], y[i]); \
} \
return res;

Definition at line 240 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_2_INT_Y_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_2_INT_Y_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N; i++) { \
res[i] = __sycl_std::__invoke_##NAME<T>(x[i], y); \
} \
return res;

Definition at line 262 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_2_OVERLOAD

#define __SYCL_MATH_FUNCTION_2_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat_v<T>, marray<T, N>> \
NAME(marray<T, N> x, marray<T, N> y) { \
__SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL(NAME) \
}

Definition at line 160 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_2_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_##NAME<vec<T, 2>>( \
detail::to_vec2(x, i * 2), detail::to_vec2(y, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_##NAME<T>(x[N - 1], y[N - 1]); \
} \
return res;

Definition at line 148 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_2_SGENFLOAT_Y_OVERLOAD

#define __SYCL_MATH_FUNCTION_2_SGENFLOAT_Y_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat_v<T>, marray<T, N>> \
NAME(marray<T, N> x, T y) { \
marray<T, N> res; \
sycl::vec<T, 2> y_vec{y, y}; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_##NAME<vec<T, 2>>( \
detail::to_vec2(x, i * 2), y_vec); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_##NAME<T>(x[N - 1], y_vec[0]); \
} \
return res; \
}

Definition at line 193 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_3_OVERLOAD

#define __SYCL_MATH_FUNCTION_3_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat_v<T>, marray<T, N>> \
NAME(marray<T, N> x, marray<T, N> y, marray<T, N> z) { \
marray<T, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_##NAME<vec<T, 2>>( \
detail::to_vec2(z, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = \
__sycl_std::__invoke_##NAME<T>(x[N - 1], y[N - 1], z[N - 1]); \
} \
return res; \
}
y y maxval[j] maxval c[j] c[j] z

Definition at line 285 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_OVERLOAD

#define __SYCL_MATH_FUNCTION_OVERLOAD (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<detail::is_sgenfloat_v<T>, marray<T, N>> \
NAME(marray<T, N> x) { \
__SYCL_MATH_FUNCTION_OVERLOAD_IMPL(NAME) \
}

Definition at line 67 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_OVERLOAD_FM

#define __SYCL_MATH_FUNCTION_OVERLOAD_FM (   NAME)
Value:
template <typename T, size_t N> \
inline __SYCL_ALWAYS_INLINE \
std::enable_if_t<__FAST_MATH_SGENFLOAT(T), marray<T, N>> \
NAME(marray<T, N> x) { \
__SYCL_MATH_FUNCTION_OVERLOAD_IMPL(NAME) \
}
#define __FAST_MATH_SGENFLOAT(T)

Definition at line 109 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_MATH_FUNCTION_OVERLOAD_IMPL

#define __SYCL_MATH_FUNCTION_OVERLOAD_IMPL (   NAME)
Value:
marray<T, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
vec<T, 2> partial_res = \
__sycl_std::__invoke_##NAME<vec<T, 2>>(detail::to_vec2(x, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<T, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_##NAME<T>(x[N - 1]); \
} \
return res;

Definition at line 55 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_NATIVE_MATH_FUNCTION_2_OVERLOAD

#define __SYCL_NATIVE_MATH_FUNCTION_2_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME(marray<float, N> x, \
marray<float, N> y) { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_native_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2), detail::to_vec2(y, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = \
__sycl_std::__invoke_native_##NAME<float>(x[N - 1], y[N - 1]); \
} \
return res; \
}

Definition at line 1199 of file builtins_legacy_marray_vec.hpp.

◆ __SYCL_NATIVE_MATH_FUNCTION_OVERLOAD

#define __SYCL_NATIVE_MATH_FUNCTION_OVERLOAD (   NAME)
Value:
template <size_t N> \
inline __SYCL_ALWAYS_INLINE marray<float, N> NAME(marray<float, N> x) { \
marray<float, N> res; \
for (size_t i = 0; i < N / 2; i++) { \
auto partial_res = __sycl_std::__invoke_native_##NAME<vec<float, 2>>( \
detail::to_vec2(x, i * 2)); \
std::memcpy(&res[i * 2], &partial_res, sizeof(vec<float, 2>)); \
} \
if (N % 2) { \
res[N - 1] = __sycl_std::__invoke_native_##NAME<float>(x[N - 1]); \
} \
return res; \
}

Definition at line 1169 of file builtins_legacy_marray_vec.hpp.