# HIP MATH APIs Documentation HIP supports most of the device functions supported by CUDA. Way to find the unsupported one is to search for the function and check its description Note: This document is not human generated. Any changes to this file will be discarded. Please make changes to Python3 script docs/markdown/device_md_gen.py ## For Developers If you add or fixed a device function, make sure to add a signature of the function and definition later. For example, if you want to add `__device__ float __dotf(float4, float4)`, which does a dot product on 4 float vector components The way to add to the header is, ```cpp __device__ static float __dotf(float4, float4); /*Way down in the file....*/ __device__ static inline float __dotf(float4 x, float4 y) { /*implementation*/ } ``` This helps python script to add the device function newly declared into markdown documentation (as it looks at functions with `;` at the end and `__device__` at the beginning) The next step would be to add Description to `deviceFuncDesc` dictionary in python script. From the above example, it can be writtern as, `deviceFuncDesc['__dotf'] = 'This functions takes 2 4 component float vector and outputs dot product across them'` ### acosf ```cpp __device__ float acosf(float x); ``` **Description:** This function returns floating point of arc cosine from a floating point input ### acoshf ```cpp __device__ float acoshf(float x); ``` **Description:** Supported ### asinf ```cpp __device__ float asinf(float x); ``` **Description:** Supported ### asinhf ```cpp __device__ float asinhf(float x); ``` **Description:** Supported ### atan2f ```cpp __device__ float atan2f(float y, float x); ``` **Description:** Supported ### atanf ```cpp __device__ float atanf(float x); ``` **Description:** Supported ### atanhf ```cpp __device__ float atanhf(float x); ``` **Description:** Supported ### cbrtf ```cpp __device__ float cbrtf(float x); ``` **Description:** Supported ### ceilf ```cpp __device__ float ceilf(float x); ``` **Description:** Supported ### copysignf ```cpp __device__ float copysignf(float x, float y); ``` **Description:** Supported ### cosf ```cpp __device__ float cosf(float x); ``` **Description:** Supported ### coshf ```cpp __device__ float coshf(float x); ``` **Description:** Supported ### cospif ```cpp __device__ float cospif(float x); ``` **Description:** Supported ### cyl_bessel_i0f ```cpp //__device__ float cyl_bessel_i0f(float x); ``` **Description:** **NOT Supported** ### cyl_bessel_i1f ```cpp //__device__ float cyl_bessel_i1f(float x); ``` **Description:** **NOT Supported** ### erfcf ```cpp __device__ float erfcf(float x); ``` **Description:** Supported ### erfcinvf ```cpp __device__ float erfcinvf(float y); ``` **Description:** Supported ### erfcxf ```cpp __device__ float erfcxf(float x); ``` **Description:** Supported ### erff ```cpp __device__ float erff(float x); ``` **Description:** Supported ### erfinvf ```cpp __device__ float erfinvf(float y); ``` **Description:** Supported ### exp10f ```cpp __device__ float exp10f(float x); ``` **Description:** Supported ### exp2f ```cpp __device__ float exp2f(float x); ``` **Description:** Supported ### expf ```cpp __device__ float expf(float x); ``` **Description:** Supported ### expm1f ```cpp __device__ float expm1f(float x); ``` **Description:** Supported ### fabsf ```cpp __device__ float fabsf(float x); ``` **Description:** Supported ### fdimf ```cpp __device__ float fdimf(float x, float y); ``` **Description:** Supported ### fdividef ```cpp __device__ float fdividef(float x, float y); ``` **Description:** Supported ### floorf ```cpp __device__ float floorf(float x); ``` **Description:** Supported ### fmaf ```cpp __device__ float fmaf(float x, float y, float z); ``` **Description:** Supported ### fmaxf ```cpp __device__ float fmaxf(float x, float y); ``` **Description:** Supported ### fminf ```cpp __device__ float fminf(float x, float y); ``` **Description:** Supported ### fmodf ```cpp __device__ float fmodf(float x, float y); ``` **Description:** Supported ### frexpf ```cpp //__device__ float frexpf(float x, int* nptr); ``` **Description:** **NOT Supported** ### hypotf ```cpp __device__ float hypotf(float x, float y); ``` **Description:** Supported ### ilogbf ```cpp __device__ float ilogbf(float x); ``` **Description:** Supported ### isfinite ```cpp __device__ int isfinite(float a); ``` **Description:** Supported ### isinf ```cpp __device__ unsigned isinf(float a); ``` **Description:** Supported ### isnan ```cpp __device__ unsigned isnan(float a); ``` **Description:** Supported ### j0f ```cpp __device__ float j0f(float x); ``` **Description:** Supported ### j1f ```cpp __device__ float j1f(float x); ``` **Description:** Supported ### jnf ```cpp __device__ float jnf(int n, float x); ``` **Description:** Supported ### ldexpf ```cpp __device__ float ldexpf(float x, int exp); ``` **Description:** Supported ### lgammaf ```cpp //__device__ float lgammaf(float x); ``` **Description:** **NOT Supported** ### llrintf ```cpp __device__ long long int llrintf(float x); ``` **Description:** Supported ### llroundf ```cpp __device__ long long int llroundf(float x); ``` **Description:** Supported ### log10f ```cpp __device__ float log10f(float x); ``` **Description:** Supported ### log1pf ```cpp __device__ float log1pf(float x); ``` **Description:** Supported ### logbf ```cpp __device__ float logbf(float x); ``` **Description:** Supported ### lrintf ```cpp __device__ long int lrintf(float x); ``` **Description:** Supported ### lroundf ```cpp __device__ long int lroundf(float x); ``` **Description:** Supported ### modff ```cpp //__device__ float modff(float x, float *iptr); ``` **Description:** **NOT Supported** ### nanf ```cpp __device__ float nanf(const char* tagp); ``` **Description:** Supported ### nearbyintf ```cpp __device__ float nearbyintf(float x); ``` **Description:** Supported ### nextafterf ```cpp //__device__ float nextafterf(float x, float y); ``` **Description:** **NOT Supported** ### norm3df ```cpp __device__ float norm3df(float a, float b, float c); ``` **Description:** Supported ### norm4df ```cpp __device__ float norm4df(float a, float b, float c, float d); ``` **Description:** Supported ### normcdff ```cpp __device__ float normcdff(float y); ``` **Description:** Supported ### normcdfinvf ```cpp __device__ float normcdfinvf(float y); ``` **Description:** Supported ### normf ```cpp __device__ float normf(int dim, const float *a); ``` **Description:** Supported ### powf ```cpp __device__ float powf(float x, float y); ``` **Description:** Supported ### rcbrtf ```cpp __device__ float rcbrtf(float x); ``` **Description:** Supported ### remainderf ```cpp __device__ float remainderf(float x, float y); ``` **Description:** Supported ### remquof ```cpp __device__ float remquof(float x, float y, int *quo); ``` **Description:** Supported ### rhypotf ```cpp __device__ float rhypotf(float x, float y); ``` **Description:** Supported ### rintf ```cpp __device__ float rintf(float x); ``` **Description:** Supported ### rnorm3df ```cpp __device__ float rnorm3df(float a, float b, float c); ``` **Description:** Supported ### rnorm4df ```cpp __device__ float rnorm4df(float a, float b, float c, float d); ``` **Description:** Supported ### rnormf ```cpp __device__ float rnormf(int dim, const float* a); ``` **Description:** Supported ### roundf ```cpp __device__ float roundf(float x); ``` **Description:** Supported ### rsqrtf ```cpp __device__ float rsqrtf(float x); ``` **Description:** Supported ### scalblnf ```cpp __device__ float scalblnf(float x, long int n); ``` **Description:** Supported ### scalbnf ```cpp __device__ float scalbnf(float x, int n); ``` **Description:** Supported ### signbit ```cpp __device__ int signbit(float a); ``` **Description:** Supported ### sincosf ```cpp __device__ void sincosf(float x, float *sptr, float *cptr); ``` **Description:** Supported ### sincospif ```cpp __device__ void sincospif(float x, float *sptr, float *cptr); ``` **Description:** Supported ### sinf ```cpp __device__ float sinf(float x); ``` **Description:** Supported ### sinhf ```cpp __device__ float sinhf(float x); ``` **Description:** Supported ### sinpif ```cpp __device__ float sinpif(float x); ``` **Description:** Supported ### sqrtf ```cpp __device__ float sqrtf(float x); ``` **Description:** Supported ### tanf ```cpp __device__ float tanf(float x); ``` **Description:** Supported ### tanhf ```cpp __device__ float tanhf(float x); ``` **Description:** Supported ### tgammaf ```cpp __device__ float tgammaf(float x); ``` **Description:** Supported ### truncf ```cpp __device__ float truncf(float x); ``` **Description:** Supported ### y0f ```cpp __device__ float y0f(float x); ``` **Description:** Supported ### y1f ```cpp __device__ float y1f(float x); ``` **Description:** Supported ### ynf ```cpp __device__ float ynf(int n, float x); ``` **Description:** Supported ### acos ```cpp __device__ double acos(double x); ``` **Description:** Supported ### acosh ```cpp __device__ double acosh(double x); ``` **Description:** Supported ### asin ```cpp __device__ double asin(double x); ``` **Description:** Supported ### asinh ```cpp __device__ double asinh(double x); ``` **Description:** Supported ### atan ```cpp __device__ double atan(double x); ``` **Description:** Supported ### atan2 ```cpp __device__ double atan2(double y, double x); ``` **Description:** Supported ### atanh ```cpp __device__ double atanh(double x); ``` **Description:** Supported ### cbrt ```cpp __device__ double cbrt(double x); ``` **Description:** Supported ### ceil ```cpp __device__ double ceil(double x); ``` **Description:** Supported ### copysign ```cpp __device__ double copysign(double x, double y); ``` **Description:** Supported ### cos ```cpp __device__ double cos(double x); ``` **Description:** Supported ### cosh ```cpp __device__ double cosh(double x); ``` **Description:** Supported ### cospi ```cpp __device__ double cospi(double x); ``` **Description:** Supported ### cyl_bessel_i0 ```cpp //__device__ double cyl_bessel_i0(double x); ``` **Description:** **NOT Supported** ### cyl_bessel_i1 ```cpp //__device__ double cyl_bessel_i1(double x); ``` **Description:** **NOT Supported** ### erf ```cpp __device__ double erf(double x); ``` **Description:** Supported ### erfc ```cpp __device__ double erfc(double x); ``` **Description:** Supported ### erfcinv ```cpp __device__ double erfcinv(double y); ``` **Description:** Supported ### erfcx ```cpp __device__ double erfcx(double x); ``` **Description:** Supported ### erfinv ```cpp __device__ double erfinv(double x); ``` **Description:** Supported ### exp ```cpp __device__ double exp(double x); ``` **Description:** Supported ### exp10 ```cpp __device__ double exp10(double x); ``` **Description:** Supported ### exp2 ```cpp __device__ double exp2(double x); ``` **Description:** Supported ### expm1 ```cpp __device__ double expm1(double x); ``` **Description:** Supported ### fabs ```cpp __device__ double fabs(double x); ``` **Description:** Supported ### fdim ```cpp __device__ double fdim(double x, double y); ``` **Description:** Supported ### floor ```cpp __device__ double floor(double x); ``` **Description:** Supported ### fma ```cpp __device__ double fma(double x, double y, double z); ``` **Description:** Supported ### fmax ```cpp __device__ double fmax(double x, double y); ``` **Description:** Supported ### fmin ```cpp __device__ double fmin(double x, double y); ``` **Description:** Supported ### fmod ```cpp __device__ double fmod(double x, double y); ``` **Description:** Supported ### frexp ```cpp //__device__ double frexp(double x, int *nptr); ``` **Description:** **NOT Supported** ### hypot ```cpp __device__ double hypot(double x, double y); ``` **Description:** Supported ### ilogb ```cpp __device__ double ilogb(double x); ``` **Description:** Supported ### isfinite ```cpp __device__ int isfinite(double x); ``` **Description:** Supported ### isinf ```cpp __device__ unsigned isinf(double x); ``` **Description:** Supported ### isnan ```cpp __device__ unsigned isnan(double x); ``` **Description:** Supported ### j0 ```cpp __device__ double j0(double x); ``` **Description:** Supported ### j1 ```cpp __device__ double j1(double x); ``` **Description:** Supported ### jn ```cpp __device__ double jn(int n, double x); ``` **Description:** Supported ### ldexp ```cpp __device__ double ldexp(double x, int exp); ``` **Description:** Supported ### lgamma ```cpp __device__ double lgamma(double x); ``` **Description:** Supported ### llrint ```cpp __device__ long long llrint(double x); ``` **Description:** Supported ### llround ```cpp __device__ long long llround(double x); ``` **Description:** Supported ### log ```cpp __device__ double log(double x); ``` **Description:** Supported ### log10 ```cpp __device__ double log10(double x); ``` **Description:** Supported ### log1p ```cpp __device__ double log1p(double x); ``` **Description:** Supported ### log2 ```cpp __device__ double log2(double x); ``` **Description:** Supported ### logb ```cpp __device__ double logb(double x); ``` **Description:** Supported ### lrint ```cpp __device__ long int lrint(double x); ``` **Description:** Supported ### lround ```cpp __device__ long int lround(double x); ``` **Description:** Supported ### modf ```cpp //__device__ double modf(double x, double *iptr); ``` **Description:** **NOT Supported** ### nan ```cpp __device__ double nan(const char* tagp); ``` **Description:** Supported ### nearbyint ```cpp __device__ double nearbyint(double x); ``` **Description:** Supported ### nextafter ```cpp __device__ double nextafter(double x, double y); ``` **Description:** Supported ### norm ```cpp __device__ double norm(int dim, const double* t); ``` **Description:** Supported ### norm3d ```cpp __device__ double norm3d(double a, double b, double c); ``` **Description:** Supported ### norm4d ```cpp __device__ double norm4d(double a, double b, double c, double d); ``` **Description:** Supported ### normcdf ```cpp __device__ double normcdf(double y); ``` **Description:** Supported ### normcdfinv ```cpp __device__ double normcdfinv(double y); ``` **Description:** Supported ### pow ```cpp __device__ double pow(double x, double y); ``` **Description:** Supported ### rcbrt ```cpp __device__ double rcbrt(double x); ``` **Description:** Supported ### remainder ```cpp __device__ double remainder(double x, double y); ``` **Description:** Supported ### remquo ```cpp //__device__ double remquo(double x, double y, int *quo); ``` **Description:** **NOT Supported** ### rhypot ```cpp __device__ double rhypot(double x, double y); ``` **Description:** Supported ### rint ```cpp __device__ double rint(double x); ``` **Description:** Supported ### rnorm ```cpp __device__ double rnorm(int dim, const double* t); ``` **Description:** Supported ### rnorm3d ```cpp __device__ double rnorm3d(double a, double b, double c); ``` **Description:** Supported ### rnorm4d ```cpp __device__ double rnorm4d(double a, double b, double c, double d); ``` **Description:** Supported ### round ```cpp __device__ double round(double x); ``` **Description:** Supported ### rsqrt ```cpp __device__ double rsqrt(double x); ``` **Description:** Supported ### scalbln ```cpp __device__ double scalbln(double x, long int n); ``` **Description:** Supported ### scalbn ```cpp __device__ double scalbn(double x, int n); ``` **Description:** Supported ### signbit ```cpp __device__ int signbit(double a); ``` **Description:** Supported ### sin ```cpp __device__ double sin(double a); ``` **Description:** Supported ### sincos ```cpp __device__ void sincos(double x, double *sptr, double *cptr); ``` **Description:** Supported ### sincospi ```cpp __device__ void sincospi(double x, double *sptr, double *cptr); ``` **Description:** Supported ### sinh ```cpp __device__ double sinh(double x); ``` **Description:** Supported ### sinpi ```cpp __device__ double sinpi(double x); ``` **Description:** Supported ### sqrt ```cpp __device__ double sqrt(double x); ``` **Description:** Supported ### tan ```cpp __device__ double tan(double x); ``` **Description:** Supported ### tanh ```cpp __device__ double tanh(double x); ``` **Description:** Supported ### tgamma ```cpp __device__ double tgamma(double x); ``` **Description:** Supported ### trunc ```cpp __device__ double trunc(double x); ``` **Description:** Supported ### y0 ```cpp __device__ double y0(double x); ``` **Description:** Supported ### y1 ```cpp __device__ double y1(double y); ``` **Description:** Supported ### yn ```cpp __device__ double yn(int n, double x); ``` **Description:** Supported ### __cosf ```cpp __device__ float __cosf(float x); ``` **Description:** Supported ### __exp10f ```cpp __device__ float __exp10f(float x); ``` **Description:** Supported ### __expf ```cpp __device__ float __expf(float x); ``` **Description:** Supported ### __fadd_rd ```cpp __device__ static float __fadd_rd(float x, float y); ``` **Description:** Unsupported ### __fadd_rn ```cpp __device__ static float __fadd_rn(float x, float y); ``` **Description:** Unsupported ### __fadd_ru ```cpp __device__ static float __fadd_ru(float x, float y); ``` **Description:** Unsupported ### __fadd_rz ```cpp __device__ static float __fadd_rz(float x, float y); ``` **Description:** Unsupported ### __fdiv_rd ```cpp __device__ static float __fdiv_rd(float x, float y); ``` **Description:** Unsupported ### __fdiv_rn ```cpp __device__ static float __fdiv_rn(float x, float y); ``` **Description:** Unsupported ### __fdiv_ru ```cpp __device__ static float __fdiv_ru(float x, float y); ``` **Description:** Unsupported ### __fdiv_rz ```cpp __device__ static float __fdiv_rz(float x, float y); ``` **Description:** Unsupported ### __fdividef ```cpp __device__ static float __fdividef(float x, float y); ``` **Description:** Supported ### __fmaf_rd ```cpp __device__ float __fmaf_rd(float x, float y, float z); ``` **Description:** Unsupported ### __fmaf_rn ```cpp __device__ float __fmaf_rn(float x, float y, float z); ``` **Description:** Unsupported ### __fmaf_ru ```cpp __device__ float __fmaf_ru(float x, float y, float z); ``` **Description:** Unsupported ### __fmaf_rz ```cpp __device__ float __fmaf_rz(float x, float y, float z); ``` **Description:** Unsupported ### __fmul_rd ```cpp __device__ static float __fmul_rd(float x, float y); ``` **Description:** Unsupported ### __fmul_rn ```cpp __device__ static float __fmul_rn(float x, float y); ``` **Description:** Unsupported ### __fmul_ru ```cpp __device__ static float __fmul_ru(float x, float y); ``` **Description:** Unsupported ### __fmul_rz ```cpp __device__ static float __fmul_rz(float x, float y); ``` **Description:** Unsupported ### __frcp_rd ```cpp __device__ float __frcp_rd(float x); ``` **Description:** Unsupported ### __frcp_rn ```cpp __device__ float __frcp_rn(float x); ``` **Description:** Unsupported ### __frcp_ru ```cpp __device__ float __frcp_ru(float x); ``` **Description:** Unsupported ### __frcp_rz ```cpp __device__ float __frcp_rz(float x); ``` **Description:** Unsupported ### __frsqrt_rn ```cpp __device__ float __frsqrt_rn(float x); ``` **Description:** Unsupported ### __fsqrt_rd ```cpp __device__ float __fsqrt_rd(float x); ``` **Description:** Unsupported ### __fsqrt_rn ```cpp __device__ float __fsqrt_rn(float x); ``` **Description:** Unsupported ### __fsqrt_ru ```cpp __device__ float __fsqrt_ru(float x); ``` **Description:** Unsupported ### __fsqrt_rz ```cpp __device__ float __fsqrt_rz(float x); ``` **Description:** Unsupported ### __fsub_rd ```cpp __device__ static float __fsub_rd(float x, float y); ``` **Description:** Unsupported ### __fsub_rn ```cpp __device__ static float __fsub_rn(float x, float y); ``` **Description:** Unsupported ### __fsub_ru ```cpp __device__ static float __fsub_ru(float x, float y); ``` **Description:** Unsupported ### __fsub_rz ```cpp __device__ static float __fsub_rz(float x, float y); ``` **Description:** Unsupported ### __log10f ```cpp __device__ float __log10f(float x); ``` **Description:** Supported ### __log2f ```cpp __device__ float __log2f(float x); ``` **Description:** Supported ### __logf ```cpp __device__ float __logf(float x); ``` **Description:** Supported ### __powf ```cpp __device__ float __powf(float base, float exponent); ``` **Description:** Supported ### __saturatef ```cpp __device__ static float __saturatef(float x); ``` **Description:** Supported ### __sincosf ```cpp __device__ void __sincosf(float x, float *s, float *c); ``` **Description:** Supported ### __sinf ```cpp __device__ float __sinf(float x); ``` **Description:** Supported ### __tanf ```cpp __device__ float __tanf(float x); ``` **Description:** Supported ### __dadd_rd ```cpp __device__ static double __dadd_rd(double x, double y); ``` **Description:** Unsupported ### __dadd_rn ```cpp __device__ static double __dadd_rn(double x, double y); ``` **Description:** Unsupported ### __dadd_ru ```cpp __device__ static double __dadd_ru(double x, double y); ``` **Description:** Unsupported ### __dadd_rz ```cpp __device__ static double __dadd_rz(double x, double y); ``` **Description:** Unsupported ### __ddiv_rd ```cpp __device__ static double __ddiv_rd(double x, double y); ``` **Description:** Unsupported ### __ddiv_rn ```cpp __device__ static double __ddiv_rn(double x, double y); ``` **Description:** Unsupported ### __ddiv_ru ```cpp __device__ static double __ddiv_ru(double x, double y); ``` **Description:** Unsupported ### __ddiv_rz ```cpp __device__ static double __ddiv_rz(double x, double y); ``` **Description:** Unsupported ### __dmul_rd ```cpp __device__ static double __dmul_rd(double x, double y); ``` **Description:** Unsupported ### __dmul_rn ```cpp __device__ static double __dmul_rn(double x, double y); ``` **Description:** Unsupported ### __dmul_ru ```cpp __device__ static double __dmul_ru(double x, double y); ``` **Description:** Unsupported ### __dmul_rz ```cpp __device__ static double __dmul_rz(double x, double y); ``` **Description:** Unsupported ### __drcp_rd ```cpp __device__ double __drcp_rd(double x); ``` **Description:** Unsupported ### __drcp_rn ```cpp __device__ double __drcp_rn(double x); ``` **Description:** Unsupported ### __drcp_ru ```cpp __device__ double __drcp_ru(double x); ``` **Description:** Unsupported ### __drcp_rz ```cpp __device__ double __drcp_rz(double x); ``` **Description:** Unsupported ### __dsqrt_rd ```cpp __device__ double __dsqrt_rd(double x); ``` **Description:** Unsupported ### __dsqrt_rn ```cpp __device__ double __dsqrt_rn(double x); ``` **Description:** Unsupported ### __dsqrt_ru ```cpp __device__ double __dsqrt_ru(double x); ``` **Description:** Unsupported ### __dsqrt_rz ```cpp __device__ double __dsqrt_rz(double x); ``` **Description:** Unsupported ### __dsub_rd ```cpp __device__ static double __dsub_rd(double x, double y); ``` **Description:** Unsupported ### __dsub_rn ```cpp __device__ static double __dsub_rn(double x, double y); ``` **Description:** Unsupported ### __dsub_ru ```cpp __device__ static double __dsub_ru(double x, double y); ``` **Description:** Unsupported ### __dsub_rz ```cpp __device__ static double __dsub_rz(double x, double y); ``` **Description:** Unsupported ### __fma_rd ```cpp __device__ double __fma_rd(double x, double y, double z); ``` **Description:** Unsupported ### __fma_rn ```cpp __device__ double __fma_rn(double x, double y, double z); ``` **Description:** Unsupported ### __fma_ru ```cpp __device__ double __fma_ru(double x, double y, double z); ``` **Description:** Unsupported ### __fma_rz ```cpp __device__ double __fma_rz(double x, double y, double z); ``` **Description:** Unsupported ### __brev ```cpp __device__ unsigned int __brev( unsigned int x); ``` **Description:** Supported ### __brevll ```cpp __device__ unsigned long long int __brevll( unsigned long long int x); ``` **Description:** Supported ### __byte_perm ```cpp __device__ unsigned int __byte_perm(unsigned int x, unsigned int y, unsigned int s); ``` **Description:** Supported ### __clz ```cpp __device__ unsigned int __clz(int x); ``` **Description:** Supported ### __clzll ```cpp __device__ unsigned int __clzll(long long int x); ``` **Description:** Supported ### __ffs ```cpp __device__ unsigned int __ffs(int x); ``` **Description:** Supported ### __ffsll ```cpp __device__ unsigned int __ffsll(long long int x); ``` **Description:** Supported ### __hadd ```cpp __device__ static unsigned int __hadd(int x, int y); ``` **Description:** Supported ### __mul24 ```cpp __device__ static int __mul24(int x, int y); ``` **Description:** Supported ### __mul64hi ```cpp __device__ long long int __mul64hi(long long int x, long long int y); ``` **Description:** Supported ### __mulhi ```cpp __device__ static int __mulhi(int x, int y); ``` **Description:** Supported ### __popc ```cpp __device__ unsigned int __popc(unsigned int x); ``` **Description:** Supported ### __popcll ```cpp __device__ unsigned int __popcll(unsigned long long int x); ``` **Description:** Supported ### __rhadd ```cpp __device__ static int __rhadd(int x, int y); ``` **Description:** Supported ### __sad ```cpp __device__ static unsigned int __sad(int x, int y, int z); ``` **Description:** Supported ### __uhadd ```cpp __device__ static unsigned int __uhadd(unsigned int x, unsigned int y); ``` **Description:** Supported ### __umul24 ```cpp __device__ static int __umul24(unsigned int x, unsigned int y); ``` **Description:** Supported ### __umul64hi ```cpp __device__ unsigned long long int __umul64hi(unsigned long long int x, unsigned long long int y); ``` **Description:** Supported ### __umulhi ```cpp __device__ static unsigned int __umulhi(unsigned int x, unsigned int y); ``` **Description:** Supported ### __urhadd ```cpp __device__ static unsigned int __urhadd(unsigned int x, unsigned int y); ``` **Description:** Supported ### __usad ```cpp __device__ static unsigned int __usad(unsigned int x, unsigned int y, unsigned int z); ``` **Description:** Supported ### __double2float_rd ```cpp __device__ float __double2float_rd(double x); ``` **Description:** Supported ### __double2float_rn ```cpp __device__ float __double2float_rn(double x); ``` **Description:** Supported ### __double2float_ru ```cpp __device__ float __double2float_ru(double x); ``` **Description:** Supported ### __double2float_rz ```cpp __device__ float __double2float_rz(double x); ``` **Description:** Supported ### __double2hiint ```cpp __device__ int __double2hiint(double x); ``` **Description:** Supported ### __double2int_rd ```cpp __device__ int __double2int_rd(double x); ``` **Description:** Supported ### __double2int_rn ```cpp __device__ int __double2int_rn(double x); ``` **Description:** Supported ### __double2int_ru ```cpp __device__ int __double2int_ru(double x); ``` **Description:** Supported ### __double2int_rz ```cpp __device__ int __double2int_rz(double x); ``` **Description:** Supported ### __double2ll_rd ```cpp __device__ long long int __double2ll_rd(double x); ``` **Description:** Supported ### __double2ll_rn ```cpp __device__ long long int __double2ll_rn(double x); ``` **Description:** Supported ### __double2ll_ru ```cpp __device__ long long int __double2ll_ru(double x); ``` **Description:** Supported ### __double2ll_rz ```cpp __device__ long long int __double2ll_rz(double x); ``` **Description:** Supported ### __double2loint ```cpp __device__ int __double2loint(double x); ``` **Description:** Supported ### __double2uint_rd ```cpp __device__ unsigned int __double2uint_rd(double x); ``` **Description:** Supported ### __double2uint_rn ```cpp __device__ unsigned int __double2uint_rn(double x); ``` **Description:** Supported ### __double2uint_ru ```cpp __device__ unsigned int __double2uint_ru(double x); ``` **Description:** Supported ### __double2uint_rz ```cpp __device__ unsigned int __double2uint_rz(double x); ``` **Description:** Supported ### __double2ull_rd ```cpp __device__ unsigned long long int __double2ull_rd(double x); ``` **Description:** Supported ### __double2ull_rn ```cpp __device__ unsigned long long int __double2ull_rn(double x); ``` **Description:** Supported ### __double2ull_ru ```cpp __device__ unsigned long long int __double2ull_ru(double x); ``` **Description:** Supported ### __double2ull_rz ```cpp __device__ unsigned long long int __double2ull_rz(double x); ``` **Description:** Supported ### __double_as_longlong ```cpp __device__ long long int __double_as_longlong(double x); ``` **Description:** Supported ### __float2half_rn ```cpp __device__ unsigned short __float2half_rn(float x); ``` **Description:** Supported ### __half2float ```cpp __device__ float __half2float(unsigned short); ``` **Description:** Supported ### __float2half_rn ```cpp __device__ __half __float2half_rn(float x); ``` **Description:** Supported ### __half2float ```cpp __device__ float __half2float(__half); ``` **Description:** Supported ### __float2int_rd ```cpp __device__ int __float2int_rd(float x); ``` **Description:** Supported ### __float2int_rn ```cpp __device__ int __float2int_rn(float x); ``` **Description:** Supported ### __float2int_ru ```cpp __device__ int __float2int_ru(float x); ``` **Description:** Supported ### __float2int_rz ```cpp __device__ int __float2int_rz(float x); ``` **Description:** Supported ### __float2ll_rd ```cpp __device__ long long int __float2ll_rd(float x); ``` **Description:** Supported ### __float2ll_rn ```cpp __device__ long long int __float2ll_rn(float x); ``` **Description:** Supported ### __float2ll_ru ```cpp __device__ long long int __float2ll_ru(float x); ``` **Description:** Supported ### __float2ll_rz ```cpp __device__ long long int __float2ll_rz(float x); ``` **Description:** Supported ### __float2uint_rd ```cpp __device__ unsigned int __float2uint_rd(float x); ``` **Description:** Supported ### __float2uint_rn ```cpp __device__ unsigned int __float2uint_rn(float x); ``` **Description:** Supported ### __float2uint_ru ```cpp __device__ unsigned int __float2uint_ru(float x); ``` **Description:** Supported ### __float2uint_rz ```cpp __device__ unsigned int __float2uint_rz(float x); ``` **Description:** Supported ### __float2ull_rd ```cpp __device__ unsigned long long int __float2ull_rd(float x); ``` **Description:** Supported ### __float2ull_rn ```cpp __device__ unsigned long long int __float2ull_rn(float x); ``` **Description:** Supported ### __float2ull_ru ```cpp __device__ unsigned long long int __float2ull_ru(float x); ``` **Description:** Supported ### __float2ull_rz ```cpp __device__ unsigned long long int __float2ull_rz(float x); ``` **Description:** Supported ### __float_as_int ```cpp __device__ int __float_as_int(float x); ``` **Description:** Supported ### __float_as_uint ```cpp __device__ unsigned int __float_as_uint(float x); ``` **Description:** Supported ### __hiloint2double ```cpp __device__ double __hiloint2double(int hi, int lo); ``` **Description:** Supported ### __int2double_rn ```cpp __device__ double __int2double_rn(int x); ``` **Description:** Supported ### __int2float_rd ```cpp __device__ float __int2float_rd(int x); ``` **Description:** Supported ### __int2float_rn ```cpp __device__ float __int2float_rn(int x); ``` **Description:** Supported ### __int2float_ru ```cpp __device__ float __int2float_ru(int x); ``` **Description:** Supported ### __int2float_rz ```cpp __device__ float __int2float_rz(int x); ``` **Description:** Supported ### __int_as_float ```cpp __device__ float __int_as_float(int x); ``` **Description:** Supported ### __ll2double_rd ```cpp __device__ double __ll2double_rd(long long int x); ``` **Description:** Supported ### __ll2double_rn ```cpp __device__ double __ll2double_rn(long long int x); ``` **Description:** Supported ### __ll2double_ru ```cpp __device__ double __ll2double_ru(long long int x); ``` **Description:** Supported ### __ll2double_rz ```cpp __device__ double __ll2double_rz(long long int x); ``` **Description:** Supported ### __ll2float_rd ```cpp __device__ float __ll2float_rd(long long int x); ``` **Description:** Supported ### __ll2float_rn ```cpp __device__ float __ll2float_rn(long long int x); ``` **Description:** Supported ### __ll2float_ru ```cpp __device__ float __ll2float_ru(long long int x); ``` **Description:** Supported ### __ll2float_rz ```cpp __device__ float __ll2float_rz(long long int x); ``` **Description:** Supported ### __longlong_as_double ```cpp __device__ double __longlong_as_double(long long int x); ``` **Description:** Supported ### __uint2double_rn ```cpp __device__ double __uint2double_rn(int x); ``` **Description:** Supported ### __uint2float_rd ```cpp __device__ float __uint2float_rd(unsigned int x); ``` **Description:** Supported ### __uint2float_rn ```cpp __device__ float __uint2float_rn(unsigned int x); ``` **Description:** Supported ### __uint2float_ru ```cpp __device__ float __uint2float_ru(unsigned int x); ``` **Description:** Supported ### __uint2float_rz ```cpp __device__ float __uint2float_rz(unsigned int x); ``` **Description:** Supported ### __uint_as_float ```cpp __device__ float __uint_as_float(unsigned int x); ``` **Description:** Supported ### __ull2double_rd ```cpp __device__ double __ull2double_rd(unsigned long long int x); ``` **Description:** Supported ### __ull2double_rn ```cpp __device__ double __ull2double_rn(unsigned long long int x); ``` **Description:** Supported ### __ull2double_ru ```cpp __device__ double __ull2double_ru(unsigned long long int x); ``` **Description:** Supported ### __ull2double_rz ```cpp __device__ double __ull2double_rz(unsigned long long int x); ``` **Description:** Supported ### __ull2float_rd ```cpp __device__ float __ull2float_rd(unsigned long long int x); ``` **Description:** Supported ### __ull2float_rn ```cpp __device__ float __ull2float_rn(unsigned long long int x); ``` **Description:** Supported ### __ull2float_ru ```cpp __device__ float __ull2float_ru(unsigned long long int x); ``` **Description:** Supported ### __ull2float_rz ```cpp __device__ float __ull2float_rz(unsigned long long int x); ``` **Description:** Supported ### __hadd ```cpp __device__ static __half __hadd(const __half a, const __half b); ``` **Description:** Supported ### __hadd_sat ```cpp __device__ static __half __hadd_sat(__half a, __half b); ``` **Description:** Supported ### __hfma ```cpp __device__ static __half __hfma(__half a, __half b, __half c); ``` **Description:** Supported ### __hfma_sat ```cpp __device__ static __half __hfma_sat(__half a, __half b, __half c); ``` **Description:** Supported ### __hmul ```cpp __device__ static __half __hmul(__half a, __half b); ``` **Description:** Supported ### __hmul_sat ```cpp __device__ static __half __hmul_sat(__half a, __half b); ``` **Description:** Supported ### __hneg ```cpp __device__ static __half __hneg(__half a); ``` **Description:** Supported ### __hsub ```cpp __device__ static __half __hsub(__half a, __half b); ``` **Description:** Supported ### __hsub_sat ```cpp __device__ static __half __hsub_sat(__half a, __half b); ``` **Description:** Supported ### hdiv ```cpp __device__ static __half hdiv(__half a, __half b); ``` **Description:** Supported ### __hadd2 ```cpp __device__ static __half2 __hadd2(__half2 a, __half2 b); ``` **Description:** Supported ### __hadd2_sat ```cpp __device__ static __half2 __hadd2_sat(__half2 a, __half2 b); ``` **Description:** Supported ### __hfma2 ```cpp __device__ static __half2 __hfma2(__half2 a, __half2 b, __half2 c); ``` **Description:** Supported ### __hfma2_sat ```cpp __device__ static __half2 __hfma2_sat(__half2 a, __half2 b, __half2 c); ``` **Description:** Supported ### __hmul2 ```cpp __device__ static __half2 __hmul2(__half2 a, __half2 b); ``` **Description:** Supported ### __hmul2_sat ```cpp __device__ static __half2 __hmul2_sat(__half2 a, __half2 b); ``` **Description:** Supported ### __hsub2 ```cpp __device__ static __half2 __hsub2(__half2 a, __half2 b); ``` **Description:** Supported ### __hneg2 ```cpp __device__ static __half2 __hneg2(__half2 a); ``` **Description:** Supported ### __hsub2_sat ```cpp __device__ static __half2 __hsub2_sat(__half2 a, __half2 b); ``` **Description:** Supported ### h2div ```cpp __device__ static __half2 h2div(__half2 a, __half2 b); ``` **Description:** Supported ### __heq ```cpp __device__ bool __heq(__half a, __half b); ``` **Description:** Supported ### __hge ```cpp __device__ bool __hge(__half a, __half b); ``` **Description:** Supported ### __hgt ```cpp __device__ bool __hgt(__half a, __half b); ``` **Description:** Supported ### __hisinf ```cpp __device__ bool __hisinf(__half a); ``` **Description:** Supported ### __hisnan ```cpp __device__ bool __hisnan(__half a); ``` **Description:** Supported ### __hle ```cpp __device__ bool __hle(__half a, __half b); ``` **Description:** Supported ### __hlt ```cpp __device__ bool __hlt(__half a, __half b); ``` **Description:** Supported ### __hne ```cpp __device__ bool __hne(__half a, __half b); ``` **Description:** Supported ### __hbeq2 ```cpp __device__ bool __hbeq2(__half2 a, __half2 b); ``` **Description:** Supported ### __hbge2 ```cpp __device__ bool __hbge2(__half2 a, __half2 b); ``` **Description:** Supported ### __hbgt2 ```cpp __device__ bool __hbgt2(__half2 a, __half2 b); ``` **Description:** Supported ### __hble2 ```cpp __device__ bool __hble2(__half2 a, __half2 b); ``` **Description:** Supported ### __hblt2 ```cpp __device__ bool __hblt2(__half2 a, __half2 b); ``` **Description:** Supported ### __hbne2 ```cpp __device__ bool __hbne2(__half2 a, __half2 b); ``` **Description:** Supported ### __heq2 ```cpp __device__ __half2 __heq2(__half2 a, __half2 b); ``` **Description:** Supported ### __hge2 ```cpp __device__ __half2 __hge2(__half2 a, __half2 b); ``` **Description:** Supported ### __hgt2 ```cpp __device__ __half2 __hgt2(__half2 a, __half2 b); ``` **Description:** Supported ### __hisnan2 ```cpp __device__ __half2 __hisnan2(__half2 a); ``` **Description:** Supported ### __hle2 ```cpp __device__ __half2 __hle2(__half2 a, __half2 b); ``` **Description:** Supported ### __hlt2 ```cpp __device__ __half2 __hlt2(__half2 a, __half2 b); ``` **Description:** Supported ### __hne2 ```cpp __device__ __half2 __hne2(__half2 a, __half2 b); ``` **Description:** Supported ### hceil ```cpp __device__ static __half hceil(const __half h); ``` **Description:** Supported ### hcos ```cpp __device__ static __half hcos(const __half h); ``` **Description:** Supported ### hexp ```cpp __device__ static __half hexp(const __half h); ``` **Description:** Supported ### hexp10 ```cpp __device__ static __half hexp10(const __half h); ``` **Description:** Supported ### hexp2 ```cpp __device__ static __half hexp2(const __half h); ``` **Description:** Supported ### hfloor ```cpp __device__ static __half hfloor(const __half h); ``` **Description:** Supported ### hlog ```cpp __device__ static __half hlog(const __half h); ``` **Description:** Supported ### hlog10 ```cpp __device__ static __half hlog10(const __half h); ``` **Description:** Supported ### hlog2 ```cpp __device__ static __half hlog2(const __half h); ``` **Description:** Supported ### hrcp ```cpp //__device__ static __half hrcp(const __half h); ``` **Description:** **NOT Supported** ### hrint ```cpp __device__ static __half hrint(const __half h); ``` **Description:** Supported ### hsin ```cpp __device__ static __half hsin(const __half h); ``` **Description:** Supported ### hsqrt ```cpp __device__ static __half hsqrt(const __half a); ``` **Description:** Supported ### htrunc ```cpp __device__ static __half htrunc(const __half a); ``` **Description:** Supported ### h2ceil ```cpp __device__ static __half2 h2ceil(const __half2 h); ``` **Description:** Supported ### h2exp ```cpp __device__ static __half2 h2exp(const __half2 h); ``` **Description:** Supported ### h2exp10 ```cpp __device__ static __half2 h2exp10(const __half2 h); ``` **Description:** Supported ### h2exp2 ```cpp __device__ static __half2 h2exp2(const __half2 h); ``` **Description:** Supported ### h2floor ```cpp __device__ static __half2 h2floor(const __half2 h); ``` **Description:** Supported ### h2log ```cpp __device__ static __half2 h2log(const __half2 h); ``` **Description:** Supported ### h2log10 ```cpp __device__ static __half2 h2log10(const __half2 h); ``` **Description:** Supported ### h2log2 ```cpp __device__ static __half2 h2log2(const __half2 h); ``` **Description:** Supported ### h2rcp ```cpp __device__ static __half2 h2rcp(const __half2 h); ``` **Description:** Supported ### h2rsqrt ```cpp __device__ static __half2 h2rsqrt(const __half2 h); ``` **Description:** Supported ### h2sin ```cpp __device__ static __half2 h2sin(const __half2 h); ``` **Description:** Supported ### h2sqrt ```cpp __device__ static __half2 h2sqrt(const __half2 h); ``` **Description:** Supported ### __float22half2_rn ```cpp __device__ __half2 __float22half2_rn(const float2 a); ``` **Description:** Supported ### __float2half ```cpp __device__ __half __float2half(const float a); ``` **Description:** Supported ### __float2half2_rn ```cpp __device__ __half2 __float2half2_rn(const float a); ``` **Description:** Supported ### __float2half_rd ```cpp __device__ __half __float2half_rd(const float a); ``` **Description:** Supported ### __float2half_rn ```cpp __device__ __half __float2half_rn(const float a); ``` **Description:** Supported ### __float2half_ru ```cpp __device__ __half __float2half_ru(const float a); ``` **Description:** Supported ### __float2half_rz ```cpp __device__ __half __float2half_rz(const float a); ``` **Description:** Supported ### __floats2half2_rn ```cpp __device__ __half2 __floats2half2_rn(const float a, const float b); ``` **Description:** Supported ### __half22float2 ```cpp __device__ float2 __half22float2(const __half2 a); ``` **Description:** Supported ### __half2float ```cpp __device__ float __half2float(const __half a); ``` **Description:** Supported ### half2half2 ```cpp __device__ __half2 half2half2(const __half a); ``` **Description:** Supported ### __half2int_rd ```cpp __device__ int __half2int_rd(__half h); ``` **Description:** Supported ### __half2int_rn ```cpp __device__ int __half2int_rn(__half h); ``` **Description:** Supported ### __half2int_ru ```cpp __device__ int __half2int_ru(__half h); ``` **Description:** Supported ### __half2int_rz ```cpp __device__ int __half2int_rz(__half h); ``` **Description:** Supported ### __half2ll_rd ```cpp __device__ long long int __half2ll_rd(__half h); ``` **Description:** Supported ### __half2ll_rn ```cpp __device__ long long int __half2ll_rn(__half h); ``` **Description:** Supported ### __half2ll_ru ```cpp __device__ long long int __half2ll_ru(__half h); ``` **Description:** Supported ### __half2ll_rz ```cpp __device__ long long int __half2ll_rz(__half h); ``` **Description:** Supported ### __half2short_rd ```cpp __device__ short __half2short_rd(__half h); ``` **Description:** Supported ### __half2short_rn ```cpp __device__ short __half2short_rn(__half h); ``` **Description:** Supported ### __half2short_ru ```cpp __device__ short __half2short_ru(__half h); ``` **Description:** Supported ### __half2short_rz ```cpp __device__ short __half2short_rz(__half h); ``` **Description:** Supported ### __half2uint_rd ```cpp __device__ unsigned int __half2uint_rd(__half h); ``` **Description:** Supported ### __half2uint_rn ```cpp __device__ unsigned int __half2uint_rn(__half h); ``` **Description:** Supported ### __half2uint_ru ```cpp __device__ unsigned int __half2uint_ru(__half h); ``` **Description:** Supported ### __half2uint_rz ```cpp __device__ unsigned int __half2uint_rz(__half h); ``` **Description:** Supported ### __half2ull_rd ```cpp __device__ unsigned long long int __half2ull_rd(__half h); ``` **Description:** Supported ### __half2ull_rn ```cpp __device__ unsigned long long int __half2ull_rn(__half h); ``` **Description:** Supported ### __half2ull_ru ```cpp __device__ unsigned long long int __half2ull_ru(__half h); ``` **Description:** Supported ### __half2ull_rz ```cpp __device__ unsigned long long int __half2ull_rz(__half h); ``` **Description:** Supported ### __half2ushort_rd ```cpp __device__ unsigned short int __half2ushort_rd(__half h); ``` **Description:** Supported ### __half2ushort_rn ```cpp __device__ unsigned short int __half2ushort_rn(__half h); ``` **Description:** Supported ### __half2ushort_ru ```cpp __device__ unsigned short int __half2ushort_ru(__half h); ``` **Description:** Supported ### __half2ushort_rz ```cpp __device__ unsigned short int __half2ushort_rz(__half h); ``` **Description:** Supported ### __half_as_short ```cpp __device__ short int __half_as_short(const __half h); ``` **Description:** Supported ### __half_as_ushort ```cpp __device__ unsigned short int __half_as_ushort(const __half h); ``` **Description:** Supported ### __halves2half2 ```cpp __device__ __half2 __halves2half2(const __half a, const __half b); ``` **Description:** Supported ### __high2float ```cpp __device__ float __high2float(const __half2 a); ``` **Description:** Supported ### __high2half ```cpp __device__ __half __high2half(const __half2 a); ``` **Description:** Supported ### __high2half2 ```cpp __device__ __half2 __high2half2(const __half2 a); ``` **Description:** Supported ### __highs2half2 ```cpp __device__ __half2 __highs2half2(const __half2 a, const __half2 b); ``` **Description:** Supported ### __int2half_rd ```cpp __device__ __half __int2half_rd(int i); ``` **Description:** Supported ### __int2half_rn ```cpp __device__ __half __int2half_rn(int i); ``` **Description:** Supported ### __int2half_ru ```cpp __device__ __half __int2half_ru(int i); ``` **Description:** Supported ### __int2half_rz ```cpp __device__ __half __int2half_rz(int i); ``` **Description:** Supported ### __ll2half_rd ```cpp __device__ __half __ll2half_rd(long long int i); ``` **Description:** Supported ### __ll2half_rn ```cpp __device__ __half __ll2half_rn(long long int i); ``` **Description:** Supported ### __ll2half_ru ```cpp __device__ __half __ll2half_ru(long long int i); ``` **Description:** Supported ### __ll2half_rz ```cpp __device__ __half __ll2half_rz(long long int i); ``` **Description:** Supported ### __low2float ```cpp __device__ float __low2float(const __half2 a); ``` **Description:** Supported ### __low2half ```cpp __device__ __half __low2half(const __half2 a); ``` **Description:** Supported ### __low2half2 ```cpp __device__ __half2 __low2half2(const __half2 a, const __half2 b); ``` **Description:** Supported ### __low2half2 ```cpp __device__ __half2 __low2half2(const __half2 a); ``` **Description:** Supported ### __lowhigh2highlow ```cpp __device__ __half2 __lowhigh2highlow(const __half2 a); ``` **Description:** Supported ### __lows2half2 ```cpp __device__ __half2 __lows2half2(const __half2 a, const __half2 b); ``` **Description:** Supported ### __short2half_rd ```cpp __device__ __half __short2half_rd(short int i); ``` **Description:** Supported ### __short2half_rn ```cpp __device__ __half __short2half_rn(short int i); ``` **Description:** Supported ### __short2half_ru ```cpp __device__ __half __short2half_ru(short int i); ``` **Description:** Supported ### __short2half_rz ```cpp __device__ __half __short2half_rz(short int i); ``` **Description:** Supported ### __uint2half_rd ```cpp __device__ __half __uint2half_rd(unsigned int i); ``` **Description:** Supported ### __uint2half_rn ```cpp __device__ __half __uint2half_rn(unsigned int i); ``` **Description:** Supported ### __uint2half_ru ```cpp __device__ __half __uint2half_ru(unsigned int i); ``` **Description:** Supported ### __uint2half_rz ```cpp __device__ __half __uint2half_rz(unsigned int i); ``` **Description:** Supported ### __ull2half_rd ```cpp __device__ __half __ull2half_rd(unsigned long long int i); ``` **Description:** Supported ### __ull2half_rn ```cpp __device__ __half __ull2half_rn(unsigned long long int i); ``` **Description:** Supported ### __ull2half_ru ```cpp __device__ __half __ull2half_ru(unsigned long long int i); ``` **Description:** Supported ### __ull2half_rz ```cpp __device__ __half __ull2half_rz(unsigned long long int i); ``` **Description:** Supported ### __ushort2half_rd ```cpp __device__ __half __ushort2half_rd(unsigned short int i); ``` **Description:** Supported ### __ushort2half_rn ```cpp __device__ __half __ushort2half_rn(unsigned short int i); ``` **Description:** Supported ### __ushort2half_ru ```cpp __device__ __half __ushort2half_ru(unsigned short int i); ``` **Description:** Supported ### __ushort2half_rz ```cpp __device__ __half __ushort2half_rz(unsigned short int i); ``` **Description:** Supported ### __ushort_as_half ```cpp __device__ __half __ushort_as_half(const unsigned short int i); ``` **Description:** Supported