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