llvm-docs/clang_doxygen/____clang__cuda__cmath_8h_source.html

 /*===---- __clang_cuda_cmath.h - Device-side CUDA cmath support ------------===

  *

  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

  * See https://llvm.org/LICENSE.txt for license information.

  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

  *

  *===-----------------------------------------------------------------------===

  */

 #ifndef __CLANG_CUDA_CMATH_H__

 #define __CLANG_CUDA_CMATH_H__

 #ifndef __CUDA__

 #error "This file is for CUDA compilation only."

 #endif


 #ifndef __OPENMP_NVPTX__

 #include <limits>

 #endif


 // CUDA lets us use various std math functions on the device side.  This file

 // works in concert with __clang_cuda_math_forward_declares.h to make this work.

 //

 // Specifically, the forward-declares header declares __device__ overloads for

 // these functions in the global namespace, then pulls them into namespace std

 // with 'using' statements.  Then this file implements those functions, after

 // their implementations have been pulled in.

 //

 // It's important that we declare the functions in the global namespace and pull

 // them into namespace std with using statements, as opposed to simply declaring

 // these functions in namespace std, because our device functions need to

 // overload the standard library functions, which may be declared in the global

 // namespace or in std, depending on the degree of conformance of the stdlib

 // implementation.  Declaring in the global namespace and pulling into namespace

 // std covers all of the known knowns.


 #ifdef __OPENMP_NVPTX__

 #define __DEVICE__ static constexpr __attribute__((always_inline, nothrow))

 #else

 #define __DEVICE__ static __device__ __inline__ __attribute__((always_inline))

 #endif


 __DEVICE__ long long abs(long long __n) { return ::llabs(__n); }

 __DEVICE__ long abs(long __n) { return ::labs(__n); }

 __DEVICE__ float abs(float __x) { return ::fabsf(__x); }

 __DEVICE__ double abs(double __x) { return ::fabs(__x); }

 __DEVICE__ float acos(float __x) { return ::acosf(__x); }

 __DEVICE__ float asin(float __x) { return ::asinf(__x); }

 __DEVICE__ float atan(float __x) { return ::atanf(__x); }

 __DEVICE__ float atan2(float __x, float __y) { return ::atan2f(__x, __y); }

 __DEVICE__ float ceil(float __x) { return ::ceilf(__x); }

 __DEVICE__ float cos(float __x) { return ::cosf(__x); }

 __DEVICE__ float cosh(float __x) { return ::coshf(__x); }

 __DEVICE__ float exp(float __x) { return ::expf(__x); }

 __DEVICE__ float fabs(float __x) { return ::fabsf(__x); }

 __DEVICE__ float floor(float __x) { return ::floorf(__x); }

 __DEVICE__ float fmod(float __x, float __y) { return ::fmodf(__x, __y); }

 __DEVICE__ int fpclassify(float __x) {

   return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,

                               FP_ZERO, __x);

 }

 __DEVICE__ int fpclassify(double __x) {

   return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,

                               FP_ZERO, __x);

 }

 __DEVICE__ float frexp(float __arg, int *__exp) {

   return ::frexpf(__arg, __exp);

 }


 // For inscrutable reasons, the CUDA headers define these functions for us on

 // Windows.

 #if !defined(_MSC_VER) || defined(__OPENMP_NVPTX__)


 // For OpenMP we work around some old system headers that have non-conforming

 // `isinf(float)` and `isnan(float)` implementations that return an `int`. We do

 // this by providing two versions of these functions, differing only in the

 // return type. To avoid conflicting definitions we disable implicit base

 // function generation. That means we will end up with two specializations, one

 // per type, but only one has a base function defined by the system header.

 #if defined(__OPENMP_NVPTX__)

 #pragma omp begin declare variant match(                                       \

     implementation = {extension(disable_implicit_base)})


 // FIXME: We lack an extension to customize the mangling of the variants, e.g.,

 //        add a suffix. This means we would clash with the names of the variants

 //        (note that we do not create implicit base functions here). To avoid

 //        this clash we add a new trait to some of them that is always true

 //        (this is LLVM after all ;)). It will only influence the mangled name

 //        of the variants inside the inner region and avoid the clash.

 #pragma omp begin declare variant match(implementation = {vendor(llvm)})


 __DEVICE__ int isinf(float __x) { return ::__isinff(__x); }

 __DEVICE__ int isinf(double __x) { return ::__isinf(__x); }

 __DEVICE__ int isfinite(float __x) { return ::__finitef(__x); }

 __DEVICE__ int isfinite(double __x) { return ::__isfinited(__x); }

 __DEVICE__ int isnan(float __x) { return ::__isnanf(__x); }

 __DEVICE__ int isnan(double __x) { return ::__isnan(__x); }


 #pragma omp end declare variant


 #endif


 __DEVICE__ bool isinf(float __x) { return ::__isinff(__x); }

 __DEVICE__ bool isinf(double __x) { return ::__isinf(__x); }

 __DEVICE__ bool isfinite(float __x) { return ::__finitef(__x); }

 // For inscrutable reasons, __finite(), the double-precision version of

 // __finitef, does not exist when compiling for MacOS.  __isfinited is available

 // everywhere and is just as good.

 __DEVICE__ bool isfinite(double __x) { return ::__isfinited(__x); }

 __DEVICE__ bool isnan(float __x) { return ::__isnanf(__x); }

 __DEVICE__ bool isnan(double __x) { return ::__isnan(__x); }


 #if defined(__OPENMP_NVPTX__)

 #pragma omp end declare variant

 #endif


 #endif


 __DEVICE__ bool isgreater(float __x, float __y) {

   return __builtin_isgreater(__x, __y);

 }

 __DEVICE__ bool isgreater(double __x, double __y) {

   return __builtin_isgreater(__x, __y);

 }

 __DEVICE__ bool isgreaterequal(float __x, float __y) {

   return __builtin_isgreaterequal(__x, __y);

 }

 __DEVICE__ bool isgreaterequal(double __x, double __y) {

   return __builtin_isgreaterequal(__x, __y);

 }

 __DEVICE__ bool isless(float __x, float __y) {

   return __builtin_isless(__x, __y);

 }

 __DEVICE__ bool isless(double __x, double __y) {

   return __builtin_isless(__x, __y);

 }

 __DEVICE__ bool islessequal(float __x, float __y) {

   return __builtin_islessequal(__x, __y);

 }

 __DEVICE__ bool islessequal(double __x, double __y) {

   return __builtin_islessequal(__x, __y);

 }

 __DEVICE__ bool islessgreater(float __x, float __y) {

   return __builtin_islessgreater(__x, __y);

 }

 __DEVICE__ bool islessgreater(double __x, double __y) {

   return __builtin_islessgreater(__x, __y);

 }

 __DEVICE__ bool isnormal(float __x) { return __builtin_isnormal(__x); }

 __DEVICE__ bool isnormal(double __x) { return __builtin_isnormal(__x); }

 __DEVICE__ bool isunordered(float __x, float __y) {

   return __builtin_isunordered(__x, __y);

 }

 __DEVICE__ bool isunordered(double __x, double __y) {

   return __builtin_isunordered(__x, __y);

 }

 __DEVICE__ float ldexp(float __arg, int __exp) {

   return ::ldexpf(__arg, __exp);

 }

 __DEVICE__ float log(float __x) { return ::logf(__x); }

 __DEVICE__ float log10(float __x) { return ::log10f(__x); }

 __DEVICE__ float modf(float __x, float *__iptr) { return ::modff(__x, __iptr); }

 __DEVICE__ float pow(float __base, float __exp) {

   return ::powf(__base, __exp);

 }

 __DEVICE__ float pow(float __base, int __iexp) {

   return ::powif(__base, __iexp);

 }

 __DEVICE__ double pow(double __base, int __iexp) {

   return ::powi(__base, __iexp);

 }

 __DEVICE__ bool signbit(float __x) { return ::__signbitf(__x); }

 __DEVICE__ bool signbit(double __x) { return ::__signbitd(__x); }

 __DEVICE__ float sin(float __x) { return ::sinf(__x); }

 __DEVICE__ float sinh(float __x) { return ::sinhf(__x); }

 __DEVICE__ float sqrt(float __x) { return ::sqrtf(__x); }

 __DEVICE__ float tan(float __x) { return ::tanf(__x); }

 __DEVICE__ float tanh(float __x) { return ::tanhf(__x); }


 // There was a redefinition error for this this overload in CUDA mode.

 // We restrict it to OpenMP mode for now, that is where it is actually needed

 // anyway.

 #ifdef __OPENMP_NVPTX__

 __DEVICE__ float remquo(float __n, float __d, int *__q) {

   return ::remquof(__n, __d, __q);

 }

 #endif


 // Notably missing above is nexttoward.  We omit it because

 // libdevice doesn't provide an implementation, and we don't want to be in the

 // business of implementing tricky libm functions in this header.


 #ifndef __OPENMP_NVPTX__


 // Now we've defined everything we promised we'd define in

 // __clang_cuda_math_forward_declares.h.  We need to do two additional things to

 // fix up our math functions.

 //

 // 1) Define __device__ overloads for e.g. sin(int).  The CUDA headers define

 //    only sin(float) and sin(double), which means that e.g. sin(0) is

 //    ambiguous.

 //

 // 2) Pull the __device__ overloads of "foobarf" math functions into namespace

 //    std.  These are defined in the CUDA headers in the global namespace,

 //    independent of everything else we've done here.


 // We can't use std::enable_if, because we want to be pre-C++11 compatible.  But

 // we go ahead and unconditionally define functions that are only available when

 // compiling for C++11 to match the behavior of the CUDA headers.

 template<bool __B, class __T = void>

 struct __clang_cuda_enable_if {};


 template <class __T> struct __clang_cuda_enable_if<true, __T> {

   typedef __T type;

 };


 // Defines an overload of __fn that accepts one integral argument, calls

 // __fn((double)x), and returns __retty.

 #define __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(__retty, __fn)                      \

   template <typename __T>                                                      \

   __DEVICE__                                                                   \

       typename __clang_cuda_enable_if<std::numeric_limits<__T>::is_integer,    \

                                       __retty>::type                           \

       __fn(__T __x) {                                                          \

     return ::__fn((double)__x);                                                \

   }


 // Defines an overload of __fn that accepts one two arithmetic arguments, calls

 // __fn((double)x, (double)y), and returns a double.

 //

 // Note this is different from OVERLOAD_1, which generates an overload that

 // accepts only *integral* arguments.

 #define __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(__retty, __fn)                      \

   template <typename __T1, typename __T2>                                      \

   __DEVICE__ typename __clang_cuda_enable_if<                                  \

       std::numeric_limits<__T1>::is_specialized &&                             \

           std::numeric_limits<__T2>::is_specialized,                           \

       __retty>::type                                                           \

   __fn(__T1 __x, __T2 __y) {                                                   \

     return __fn((double)__x, (double)__y);                                     \

   }


 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, acos)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, acosh)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, asin)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, asinh)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, atan)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, atan2);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, atanh)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, cbrt)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, ceil)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, copysign);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, cos)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, cosh)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, erf)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, erfc)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, exp)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, exp2)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, expm1)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, fabs)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, fdim);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, floor)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, fmax);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, fmin);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, fmod);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(int, fpclassify)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, hypot);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(int, ilogb)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, isfinite)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, isgreater);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, isgreaterequal);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, isinf);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, isless);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, islessequal);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, islessgreater);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, isnan);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, isnormal)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(bool, isunordered);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, lgamma)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log10)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log1p)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, log2)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, logb)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(long long, llrint)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(long long, llround)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(long, lrint)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(long, lround)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, nearbyint);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, nextafter);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, pow);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(double, remainder);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, rint);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, round);

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(bool, signbit)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, sin)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, sinh)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, sqrt)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, tan)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, tanh)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, tgamma)

 __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(double, trunc);


 #undef __CUDA_CLANG_FN_INTEGER_OVERLOAD_1

 #undef __CUDA_CLANG_FN_INTEGER_OVERLOAD_2


 // Overloads for functions that don't match the patterns expected by

 // __CUDA_CLANG_FN_INTEGER_OVERLOAD_{1,2}.

 template <typename __T1, typename __T2, typename __T3>

 __DEVICE__ typename __clang_cuda_enable_if<

     std::numeric_limits<__T1>::is_specialized &&

         std::numeric_limits<__T2>::is_specialized &&

         std::numeric_limits<__T3>::is_specialized,

     double>::type

 fma(__T1 __x, __T2 __y, __T3 __z) {

   return std::fma((double)__x, (double)__y, (double)__z);

 }


 template <typename __T>

 __DEVICE__ typename __clang_cuda_enable_if<std::numeric_limits<__T>::is_integer,

                                            double>::type

 frexp(__T __x, int *__exp) {

   return std::frexp((double)__x, __exp);

 }


 template <typename __T>

 __DEVICE__ typename __clang_cuda_enable_if<std::numeric_limits<__T>::is_integer,

                                            double>::type

 ldexp(__T __x, int __exp) {

   return std::ldexp((double)__x, __exp);

 }


 template <typename __T1, typename __T2>

 __DEVICE__ typename __clang_cuda_enable_if<

     std::numeric_limits<__T1>::is_specialized &&

         std::numeric_limits<__T2>::is_specialized,

     double>::type

 remquo(__T1 __x, __T2 __y, int *__quo) {

   return std::remquo((double)__x, (double)__y, __quo);

 }


 template <typename __T>

 __DEVICE__ typename __clang_cuda_enable_if<std::numeric_limits<__T>::is_integer,

                                            double>::type

 scalbln(__T __x, long __exp) {

   return std::scalbln((double)__x, __exp);

 }


 template <typename __T>

 __DEVICE__ typename __clang_cuda_enable_if<std::numeric_limits<__T>::is_integer,

                                            double>::type

 scalbn(__T __x, int __exp) {

   return std::scalbn((double)__x, __exp);

 }


 // We need to define these overloads in exactly the namespace our standard

 // library uses (including the right inline namespace), otherwise they won't be

 // picked up by other functions in the standard library (e.g. functions in

 // <complex>).  Thus the ugliness below.

 #ifdef _LIBCPP_BEGIN_NAMESPACE_STD

 _LIBCPP_BEGIN_NAMESPACE_STD

 #else

 namespace std {

 #ifdef _GLIBCXX_BEGIN_NAMESPACE_VERSION

 _GLIBCXX_BEGIN_NAMESPACE_VERSION

 #endif

 #endif


 // Pull the new overloads we defined above into namespace std.

 using ::acos;

 using ::acosh;

 using ::asin;

 using ::asinh;

 using ::atan;

 using ::atan2;

 using ::atanh;

 using ::cbrt;

 using ::ceil;

 using ::copysign;

 using ::cos;

 using ::cosh;

 using ::erf;

 using ::erfc;

 using ::exp;

 using ::exp2;

 using ::expm1;

 using ::fabs;

 using ::fdim;

 using ::floor;

 using ::fma;

 using ::fmax;

 using ::fmin;

 using ::fmod;

 using ::fpclassify;

 using ::frexp;

 using ::hypot;

 using ::ilogb;

 using ::isfinite;

 using ::isgreater;

 using ::isgreaterequal;

 using ::isless;

 using ::islessequal;

 using ::islessgreater;

 using ::isnormal;

 using ::isunordered;

 using ::ldexp;

 using ::lgamma;

 using ::llrint;

 using ::llround;

 using ::log;

 using ::log10;

 using ::log1p;

 using ::log2;

 using ::logb;

 using ::lrint;

 using ::lround;

 using ::nearbyint;

 using ::nextafter;

 using ::pow;

 using ::remainder;

 using ::remquo;

 using ::rint;

 using ::round;

 using ::scalbln;

 using ::scalbn;

 using ::signbit;

 using ::sin;

 using ::sinh;

 using ::sqrt;

 using ::tan;

 using ::tanh;

 using ::tgamma;

 using ::trunc;


 // Well this is fun: We need to pull these symbols in for libc++, but we can't

 // pull them in with libstdc++, because its ::isinf and ::isnan are different

 // than its std::isinf and std::isnan.

 #ifndef __GLIBCXX__

 using ::isinf;

 using ::isnan;

 #endif


 // Finally, pull the "foobarf" functions that CUDA defines in its headers into

 // namespace std.

 using ::acosf;

 using ::acoshf;

 using ::asinf;

 using ::asinhf;

 using ::atan2f;

 using ::atanf;

 using ::atanhf;

 using ::cbrtf;

 using ::ceilf;

 using ::copysignf;

 using ::cosf;

 using ::coshf;

 using ::erfcf;

 using ::erff;

 using ::exp2f;

 using ::expf;

 using ::expm1f;

 using ::fabsf;

 using ::fdimf;

 using ::floorf;

 using ::fmaf;

 using ::fmaxf;

 using ::fminf;

 using ::fmodf;

 using ::frexpf;

 using ::hypotf;

 using ::ilogbf;

 using ::ldexpf;

 using ::lgammaf;

 using ::llrintf;

 using ::llroundf;

 using ::log10f;

 using ::log1pf;

 using ::log2f;

 using ::logbf;

 using ::logf;

 using ::lrintf;

 using ::lroundf;

 using ::modff;

 using ::nearbyintf;

 using ::nextafterf;

 using ::powf;

 using ::remainderf;

 using ::remquof;

 using ::rintf;

 using ::roundf;

 using ::scalblnf;

 using ::scalbnf;

 using ::sinf;

 using ::sinhf;

 using ::sqrtf;

 using ::tanf;

 using ::tanhf;

 using ::tgammaf;

 using ::truncf;


 #ifdef _LIBCPP_END_NAMESPACE_STD

 _LIBCPP_END_NAMESPACE_STD

 #else

 #ifdef _GLIBCXX_BEGIN_NAMESPACE_VERSION

 _GLIBCXX_END_NAMESPACE_VERSION

 #endif

 } // namespace std

 #endif


 #endif // __OPENMP_NVPTX__


 #undef __DEVICE__


 #endif

sinh
__DEVICE__ float sinh(float __x)
Compute hyperbolic sine.
Definition: __clang_cuda_cmath.h:173

fma
__DEVICE__ __clang_cuda_enable_if< std::numeric_limits< __T1 >::is_specialized &&std::numeric_limits< __T2 >::is_specialized &&std::numeric_limits< __T3 >::is_specialized, double >::type fma(__T1 __x, __T2 __y, __T3 __z)
Definition: __clang_cuda_cmath.h:313

remquo
__DEVICE__ __clang_cuda_enable_if< std::numeric_limits< __T1 >::is_specialized &&std::numeric_limits< __T2 >::is_specialized, double >::type remquo(__T1 __x, __T2 __y, int *__quo)
Definition: __clang_cuda_cmath.h:336

log10
__DEVICE__ float log10(float __x)
Compute a base 10 logarithm.
Definition: __clang_cuda_cmath.h:159

isunordered
__DEVICE__ bool isunordered(float __x, float __y)
Test if arguments are unordered.
Definition: __clang_cuda_cmath.h:149

scalbln
__DEVICE__ __clang_cuda_enable_if< std::numeric_limits< __T >::is_integer, double >::type scalbln(__T __x, long __exp)
Definition: __clang_cuda_cmath.h:343

isgreater
__DEVICE__ bool isgreater(float __x, float __y)
Returns the component-wise compare of x > y.
Definition: __clang_cuda_cmath.h:117

tanh
__DEVICE__ float tanh(float __x)
Compute hyperbolic tangent.
Definition: __clang_cuda_cmath.h:176

islessgreater
__DEVICE__ bool islessgreater(float __x, float __y)
Returns the component-wise compare of (x < y) || (x > y) .
Definition: __clang_cuda_cmath.h:141

isnan
__DEVICE__ bool isnan(float __x)
Test for a NaN.
Definition: __clang_cuda_cmath.h:108

fpclassify
__DEVICE__ int fpclassify(float __x)
Definition: __clang_cuda_cmath.h:56

sin
__DEVICE__ float sin(float __x)
Compute sine.
Definition: __clang_cuda_cmath.h:172

scalbn
__DEVICE__ __clang_cuda_enable_if< std::numeric_limits< __T >::is_integer, double >::type scalbn(__T __x, int __exp)
Definition: __clang_cuda_cmath.h:350

isfinite
__DEVICE__ bool isfinite(float __x)
Test for finite value.
Definition: __clang_cuda_cmath.h:103

cos
__DEVICE__ float cos(float __x)
Compute cosine.
Definition: __clang_cuda_cmath.h:50

floor
__DEVICE__ float floor(float __x)
Round to integral value using the round to -ve infinity rounding mode.
Definition: __clang_cuda_cmath.h:54

signbit
__DEVICE__ bool signbit(float __x)
Test for sign bit.
Definition: __clang_cuda_cmath.h:170

isinf
__DEVICE__ bool isinf(float __x)
Test for infinity value (+ve or -ve) .
Definition: __clang_cuda_cmath.h:101

asin
__DEVICE__ float asin(float __x)
Arc sine function.
Definition: __clang_cuda_cmath.h:46

fmod
__DEVICE__ float fmod(float __x, float __y)
Modulus.
Definition: __clang_cuda_cmath.h:55

__DEVICE__
#define __DEVICE__
Definition: __clang_cuda_cmath.h:38

acos
__DEVICE__ float acos(float __x)
Arc cosine function.
Definition: __clang_cuda_cmath.h:45

pow
__DEVICE__ float pow(float __base, float __exp)
Compute x to the power y.
Definition: __clang_cuda_cmath.h:161

ceil
__DEVICE__ float ceil(float __x)
Round to integral value using the round to positive infinity rounding mode.
Definition: __clang_cuda_cmath.h:49

tan
__DEVICE__ float tan(float __x)
Compute tangent.
Definition: __clang_cuda_cmath.h:175

sqrt
__DEVICE__ float sqrt(float __x)
Compute square root.
Definition: __clang_cuda_cmath.h:174

log
__DEVICE__ float log(float __x)
Compute natural logarithm.
Definition: __clang_cuda_cmath.h:158

modf
__DEVICE__ float modf(float __x, float *__iptr)
Definition: __clang_cuda_cmath.h:160

__CUDA_CLANG_FN_INTEGER_OVERLOAD_1
#define __CUDA_CLANG_FN_INTEGER_OVERLOAD_1(__retty, __fn)
Definition: __clang_cuda_cmath.h:217

islessequal
__DEVICE__ bool islessequal(float __x, float __y)
Returns the component-wise compare of x <= y.
Definition: __clang_cuda_cmath.h:135

frexp
__DEVICE__ float frexp(float __arg, int *__exp)
Definition: __clang_cuda_cmath.h:64

__CUDA_CLANG_FN_INTEGER_OVERLOAD_2
#define __CUDA_CLANG_FN_INTEGER_OVERLOAD_2(__retty, __fn)
Definition: __clang_cuda_cmath.h:231

exp
__DEVICE__ float exp(float __x)
Compute the base e exponential function of x.
Definition: __clang_cuda_cmath.h:52

abs
__DEVICE__ long long abs(long long __n)
Definition: __clang_cuda_cmath.h:41

isless
__DEVICE__ bool isless(float __x, float __y)
Returns the component-wise compare of x < y.
Definition: __clang_cuda_cmath.h:129

fabs
__DEVICE__ float fabs(float __x)
Compute absolute value of a floating-point number.
Definition: __clang_cuda_cmath.h:53

isnormal
__DEVICE__ bool isnormal(float __x)
Test for a normal value.
Definition: __clang_cuda_cmath.h:147

atan2
__DEVICE__ float atan2(float __x, float __y)
Arc tangent of y / x.
Definition: __clang_cuda_cmath.h:48

atan
__DEVICE__ float atan(float __x)
Arc tangent function.
Definition: __clang_cuda_cmath.h:47

cosh
__DEVICE__ float cosh(float __x)
Compute hyperbolic cosine.
Definition: __clang_cuda_cmath.h:51

ldexp
__DEVICE__ float ldexp(float __arg, int __exp)
Multiply x by 2 to the power n.
Definition: __clang_cuda_cmath.h:155

isgreaterequal
__DEVICE__ bool isgreaterequal(float __x, float __y)
Returns the component-wise compare of x >= y.
Definition: __clang_cuda_cmath.h:123

__isinff
__DEVICE__ int __isinff(float __a)
Definition: __clang_cuda_device_functions.h:438

__isnan
__DEVICE__ int __isnan(double __a)
Definition: __clang_cuda_device_functions.h:442

__isinf
__DEVICE__ int __isinf(double __a)
Definition: __clang_cuda_device_functions.h:437

__signbitf
__DEVICE__ int __signbitf(float __a)
Definition: __clang_cuda_device_functions.h:519

__finitef
__DEVICE__ int __finitef(float __a)
Definition: __clang_cuda_device_functions.h:227

__signbitd
__DEVICE__ int __signbitd(double __a)
Definition: __clang_cuda_device_functions.h:518

__isnanf
__DEVICE__ int __isnanf(float __a)
Definition: __clang_cuda_device_functions.h:443

__isfinited
__DEVICE__ int __isfinited(double __a)
Definition: __clang_cuda_device_functions.h:436

powi
__DEVICE__ double powi(double __a, int __b)
Definition: __clang_cuda_math.h:232

fabsf
__DEVICE__ float fabsf(float __a)
Definition: __clang_cuda_math.h:112

fmodf
__DEVICE__ float fmodf(float __a, float __b)
Definition: __clang_cuda_math.h:136

remainderf
__DEVICE__ float remainderf(float __a, float __b)
Definition: __clang_cuda_math.h:239

exp2f
__DEVICE__ float exp2f(float __a)
Definition: __clang_cuda_math.h:108

acosf
__DEVICE__ float acosf(float __a)
Definition: __clang_cuda_math.h:59

fmaf
__DEVICE__ float fmaf(float __a, float __b, float __c)
Definition: __clang_cuda_math.h:128

cbrtf
__DEVICE__ float cbrtf(float __a)
Definition: __clang_cuda_math.h:73

remquof
__DEVICE__ float remquof(float __a, float __b, int *__c)
Definition: __clang_cuda_math.h:245

tanf
__DEVICE__ float tanf(float __a)
Definition: __clang_cuda_math.h:316

labs
__DEVICE__ long labs(long __a)
Definition: __clang_cuda_math.h:152

nextafterf
__DEVICE__ float nextafterf(float __a, float __b)
Definition: __clang_cuda_math.h:205

fmaxf
__DEVICE__ float fmaxf(float __a, float __b)
Definition: __clang_cuda_math.h:132

llabs
__DEVICE__ long long llabs(long long __a)
Definition: __clang_cuda_math.h:158

fminf
__DEVICE__ float fminf(float __a, float __b)
Definition: __clang_cuda_math.h:134

log2f
__DEVICE__ float log2f(float __a)
Definition: __clang_cuda_math.h:177

copysignf
__DEVICE__ float copysignf(float __a, float __b)
Definition: __clang_cuda_math.h:79

truncf
__DEVICE__ float truncf(float __a)
Definition: __clang_cuda_math.h:322

fdimf
__DEVICE__ float fdimf(float __a, float __b)
Definition: __clang_cuda_math.h:114

lrintf
__DEVICE__ long lrintf(float __a)
Definition: __clang_cuda_math.h:192

llrintf
__DEVICE__ long long llrintf(float __a)
Definition: __clang_cuda_math.h:166

cosf
__DEVICE__ float cosf(float __a)
Definition: __clang_cuda_math.h:83

sinf
__DEVICE__ float sinf(float __a)
Definition: __clang_cuda_math.h:306

logf
__DEVICE__ float logf(float __a)
Definition: __clang_cuda_math.h:182

erff
__DEVICE__ float erff(float __a)
Definition: __clang_cuda_math.h:101

floorf
__DEVICE__ float floorf(float __f)
Definition: __clang_cuda_math.h:124

ceilf
__DEVICE__ float ceilf(float __a)
Definition: __clang_cuda_math.h:75

nearbyintf
__DEVICE__ float nearbyintf(float __a)
Definition: __clang_cuda_math.h:201

atanf
__DEVICE__ float atanf(float __a)
Definition: __clang_cuda_math.h:69

atanhf
__DEVICE__ float atanhf(float __a)
Definition: __clang_cuda_math.h:71

tanhf
__DEVICE__ float tanhf(float __a)
Definition: __clang_cuda_math.h:318

rintf
__DEVICE__ float rintf(float __a)
Definition: __clang_cuda_math.h:256

atan2f
__DEVICE__ float atan2f(float __a, float __b)
Definition: __clang_cuda_math.h:68

sinhf
__DEVICE__ float sinhf(float __a)
Definition: __clang_cuda_math.h:310

acoshf
__DEVICE__ float acoshf(float __a)
Definition: __clang_cuda_math.h:61

log10f
__DEVICE__ float log10f(float __a)
Definition: __clang_cuda_math.h:173

ldexpf
__DEVICE__ float ldexpf(float __a, int __b)
Definition: __clang_cuda_math.h:155

modff
__DEVICE__ float modff(float __a, float *__b)
Definition: __clang_cuda_math.h:199

logbf
__DEVICE__ float logbf(float __a)
Definition: __clang_cuda_math.h:181

powif
__DEVICE__ float powif(float __a, int __b)
Definition: __clang_cuda_math.h:233

coshf
__DEVICE__ float coshf(float __a)
Definition: __clang_cuda_math.h:87

asinhf
__DEVICE__ float asinhf(float __a)
Definition: __clang_cuda_math.h:65

roundf
__DEVICE__ float roundf(float __a)
Definition: __clang_cuda_math.h:170

lroundf
__DEVICE__ long lroundf(float __a)
Definition: __clang_cuda_math.h:194

scalbnf
__DEVICE__ float scalbnf(float __a, int __b)
Definition: __clang_cuda_math.h:278

erfcf
__DEVICE__ float erfcf(float __a)
Definition: __clang_cuda_math.h:96

ilogbf
__DEVICE__ int ilogbf(float __a)
Definition: __clang_cuda_math.h:142

powf
__DEVICE__ float powf(float __a, float __b)
Definition: __clang_cuda_math.h:231

frexpf
__DEVICE__ float frexpf(float __a, int *__b)
Definition: __clang_cuda_math.h:138

sqrtf
__DEVICE__ float sqrtf(float __a)
Definition: __clang_cuda_math.h:314

expf
__DEVICE__ float expf(float __a)
Definition: __clang_cuda_math.h:109

expm1f
__DEVICE__ float expm1f(float __a)
Definition: __clang_cuda_math.h:111

scalblnf
__DEVICE__ float scalblnf(float __a, long __b)
Definition: __clang_cuda_math.h:286

tgammaf
__DEVICE__ float tgammaf(float __a)
Definition: __clang_cuda_math.h:320

log1pf
__DEVICE__ float log1pf(float __a)
Definition: __clang_cuda_math.h:175

lgammaf
__DEVICE__ float lgammaf(float __a)
Definition: __clang_cuda_math.h:157

llroundf
__DEVICE__ long long llroundf(float __a)
Definition: __clang_cuda_math.h:168

hypotf
__DEVICE__ float hypotf(float __a, float __b)
Definition: __clang_cuda_math.h:140

asinf
__DEVICE__ float asinf(float __a)
Definition: __clang_cuda_math.h:63

__y
static __inline__ uint32_t uint32_t __y
Definition: arm_acle.h:122

clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:774

std
Definition: Format.h:5433

true
#define true
Definition: stdbool.h:25

__clang_cuda_enable_if< true, __T >::type
__T type
Definition: __clang_cuda_cmath.h:212

__clang_cuda_enable_if
Definition: __clang_cuda_cmath.h:209

fmin
#define fmin(__x, __y)
Definition: tgmath.h:780

ilogb
#define ilogb(__x)
Definition: tgmath.h:851

copysign
#define copysign(__x, __y)
Definition: tgmath.h:618

erf
#define erf(__x)
Definition: tgmath.h:636

atanh
#define atanh(__x)
Definition: tgmath.h:228

nextafter
#define nextafter(__x, __y)
Definition: tgmath.h:1055

asinh
#define asinh(__x)
Definition: tgmath.h:199

erfc
#define erfc(__x)
Definition: tgmath.h:653

hypot
#define hypot(__x, __y)
Definition: tgmath.h:833

exp2
#define exp2(__x)
Definition: tgmath.h:670

cbrt
#define cbrt(__x)
Definition: tgmath.h:584

log2
#define log2(__x)
Definition: tgmath.h:970

llround
#define llround(__x)
Definition: tgmath.h:919

trunc
#define trunc(__x)
Definition: tgmath.h:1216

fmax
#define fmax(__x, __y)
Definition: tgmath.h:762

acosh
#define acosh(__x)
Definition: tgmath.h:170

tgamma
#define tgamma(__x)
Definition: tgmath.h:1199

round
#define round(__x)
Definition: tgmath.h:1148

llrint
#define llrint(__x)
Definition: tgmath.h:902

log1p
#define log1p(__x)
Definition: tgmath.h:953

rint
#define rint(__x)
Definition: tgmath.h:1131

expm1
#define expm1(__x)
Definition: tgmath.h:687

remainder
#define remainder(__x, __y)
Definition: tgmath.h:1090

fdim
#define fdim(__x, __y)
Definition: tgmath.h:704

lgamma
#define lgamma(__x)
Definition: tgmath.h:885

lrint
#define lrint(__x)
Definition: tgmath.h:1004

logb
#define logb(__x)
Definition: tgmath.h:987

nearbyint
#define nearbyint(__x)
Definition: tgmath.h:1038

lround
#define lround(__x)
Definition: tgmath.h:1021