diff options
Diffstat (limited to 'include/cmath')
| -rw-r--r-- | include/cmath | 1640 |
1 files changed, 1640 insertions, 0 deletions
diff --git a/include/cmath b/include/cmath new file mode 100644 index 0000000..ab67112 --- /dev/null +++ b/include/cmath @@ -0,0 +1,1640 @@ +// -*- C++ -*- +//===---------------------------- cmath -----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_CMATH +#define _LIBCPP_CMATH + +/* + cmath synopsis + +Macros: + + HUGE_VAL + HUGE_VALF // C99 + HUGE_VALL // C99 + INFINITY // C99 + NAN // C99 + FP_INFINITE // C99 + FP_NAN // C99 + FP_NORMAL // C99 + FP_SUBNORMAL // C99 + FP_ZERO // C99 + FP_FAST_FMA // C99 + FP_FAST_FMAF // C99 + FP_FAST_FMAL // C99 + FP_ILOGB0 // C99 + FP_ILOGBNAN // C99 + MATH_ERRNO // C99 + MATH_ERREXCEPT // C99 + math_errhandling // C99 + +namespace std +{ + +Types: + + float_t // C99 + double_t // C99 + +// C90 + +floating_point abs(floating_point x); + +floating_point acos (arithmetic x); +float acosf(float x); +long double acosl(long double x); + +floating_point asin (arithmetic x); +float asinf(float x); +long double asinl(long double x); + +floating_point atan (arithmetic x); +float atanf(float x); +long double atanl(long double x); + +floating_point atan2 (arithmetic y, arithmetic x); +float atan2f(float y, float x); +long double atan2l(long double y, long double x); + +floating_point ceil (arithmetic x); +float ceilf(float x); +long double ceill(long double x); + +floating_point cos (arithmetic x); +float cosf(float x); +long double cosl(long double x); + +floating_point cosh (arithmetic x); +float coshf(float x); +long double coshl(long double x); + +floating_point exp (arithmetic x); +float expf(float x); +long double expl(long double x); + +floating_point fabs (arithmetic x); +float fabsf(float x); +long double fabsl(long double x); + +floating_point floor (arithmetic x); +float floorf(float x); +long double floorl(long double x); + +floating_point fmod (arithmetic x, arithmetic y); +float fmodf(float x, float y); +long double fmodl(long double x, long double y); + +floating_point frexp (arithmetic value, int* exp); +float frexpf(float value, int* exp); +long double frexpl(long double value, int* exp); + +floating_point ldexp (arithmetic value, int exp); +float ldexpf(float value, int exp); +long double ldexpl(long double value, int exp); + +floating_point log (arithmetic x); +float logf(float x); +long double logl(long double x); + +floating_point log10 (arithmetic x); +float log10f(float x); +long double log10l(long double x); + +floating_point modf (floating_point value, floating_point* iptr); +float modff(float value, float* iptr); +long double modfl(long double value, long double* iptr); + +floating_point pow (arithmetic x, arithmetic y); +float powf(float x, float y); +long double powl(long double x, long double y); + +floating_point sin (arithmetic x); +float sinf(float x); +long double sinl(long double x); + +floating_point sinh (arithmetic x); +float sinhf(float x); +long double sinhl(long double x); + +floating_point sqrt (arithmetic x); +float sqrtf(float x); +long double sqrtl(long double x); + +floating_point tan (arithmetic x); +float tanf(float x); +long double tanl(long double x); + +floating_point tanh (arithmetic x); +float tanhf(float x); +long double tanhl(long double x); + +// C99 + +bool signbit(floating_point x); + +int fpclassify(floating_point x); + +bool isfinite(floating_point x); +bool isinf(floating_point x); +bool isnan(floating_point x); +bool isnormal(floating_point x); + +bool isgreater(floating_point x, floating_point y); +bool isgreaterequal(floating_point x, floating_point y); +bool isless(floating_point x, floating_point y); +bool islessequal(floating_point x, floating_point y); +bool islessgreater(floating_point x, floating_point y); +bool isunordered(floating_point x, floating_point y); + +floating_point acosh (arithmetic x); +float acoshf(float x); +long double acoshl(long double x); + +floating_point asinh (arithmetic x); +float asinhf(float x); +long double asinhl(long double x); + +floating_point atanh (arithmetic x); +float atanhf(float x); +long double atanhl(long double x); + +floating_point cbrt (arithmetic x); +float cbrtf(float x); +long double cbrtl(long double x); + +floating_point copysign (arithmetic x, arithmetic y); +float copysignf(float x, float y); +long double copysignl(long double x, long double y); + +floating_point erf (arithmetic x); +float erff(float x); +long double erfl(long double x); + +floating_point erfc (arithmetic x); +float erfcf(float x); +long double erfcl(long double x); + +floating_point exp2 (arithmetic x); +float exp2f(float x); +long double exp2l(long double x); + +floating_point expm1 (arithmetic x); +float expm1f(float x); +long double expm1l(long double x); + +floating_point fdim (arithmetic x, arithmetic y); +float fdimf(float x, float y); +long double fdiml(long double x, long double y); + +floating_point fma (arithmetic x, arithmetic y, arithmetic z); +float fmaf(float x, float y, float z); +long double fmal(long double x, long double y, long double z); + +floating_point fmax (arithmetic x, arithmetic y); +float fmaxf(float x, float y); +long double fmaxl(long double x, long double y); + +floating_point fmin (arithmetic x, arithmetic y); +float fminf(float x, float y); +long double fminl(long double x, long double y); + +floating_point hypot (arithmetic x, arithmetic y); +float hypotf(float x, float y); +long double hypotl(long double x, long double y); + +int ilogb (arithmetic x); +int ilogbf(float x); +int ilogbl(long double x); + +floating_point lgamma (arithmetic x); +float lgammaf(float x); +long double lgammal(long double x); + +long long llrint (arithmetic x); +long long llrintf(float x); +long long llrintl(long double x); + +long long llround (arithmetic x); +long long llroundf(float x); +long long llroundl(long double x); + +floating_point log1p (arithmetic x); +float log1pf(float x); +long double log1pl(long double x); + +floating_point log2 (arithmetic x); +float log2f(float x); +long double log2l(long double x); + +floating_point logb (arithmetic x); +float logbf(float x); +long double logbl(long double x); + +long lrint (arithmetic x); +long lrintf(float x); +long lrintl(long double x); + +long lround (arithmetic x); +long lroundf(float x); +long lroundl(long double x); + +double nan (const char* str); +float nanf(const char* str); +long double nanl(const char* str); + +floating_point nearbyint (arithmetic x); +float nearbyintf(float x); +long double nearbyintl(long double x); + +floating_point nextafter (arithmetic x, arithmetic y); +float nextafterf(float x, float y); +long double nextafterl(long double x, long double y); + +floating_point nexttoward (arithmetic x, long double y); +float nexttowardf(float x, long double y); +long double nexttowardl(long double x, long double y); + +floating_point remainder (arithmetic x, arithmetic y); +float remainderf(float x, float y); +long double remainderl(long double x, long double y); + +floating_point remquo (arithmetic x, arithmetic y, int* pquo); +float remquof(float x, float y, int* pquo); +long double remquol(long double x, long double y, int* pquo); + +floating_point rint (arithmetic x); +float rintf(float x); +long double rintl(long double x); + +floating_point round (arithmetic x); +float roundf(float x); +long double roundl(long double x); + +floating_point scalbln (arithmetic x, long ex); +float scalblnf(float x, long ex); +long double scalblnl(long double x, long ex); + +floating_point scalbn (arithmetic x, int ex); +float scalbnf(float x, int ex); +long double scalbnl(long double x, int ex); + +floating_point tgamma (arithmetic x); +float tgammaf(float x); +long double tgammal(long double x); + +floating_point trunc (arithmetic x); +float truncf(float x); +long double truncl(long double x); + +} // std + +*/ + +#include <__config> +#include <math.h> +#include <type_traits> + +#ifdef _MSC_VER +#include "support/win32/math_win32.h" +#endif + +#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) +#pragma GCC system_header +#endif + +// signbit + +#ifdef signbit + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_signbit(_A1 __x) +{ + return signbit(__x); +} + +#undef signbit + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type +signbit(_A1 __x) +{ + return __libcpp_signbit(__x); +} + +#endif // signbit + +// fpclassify + +#ifdef fpclassify + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +int +__libcpp_fpclassify(_A1 __x) +{ + return fpclassify(__x); +} + +#undef fpclassify + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_floating_point<_A1>::value, int>::type +fpclassify(_A1 __x) +{ + return __libcpp_fpclassify(__x); +} + +#endif // fpclassify + +// isfinite + +#ifdef isfinite + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isfinite(_A1 __x) +{ + return isfinite(__x); +} + +#undef isfinite + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type +isfinite(_A1 __x) +{ + return __libcpp_isfinite(__x); +} + +#endif // isfinite + +// isinf + +#ifdef isinf + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isinf(_A1 __x) +{ + return isinf(__x); +} + +#undef isinf + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type +isinf(_A1 __x) +{ + return __libcpp_isinf(__x); +} + +#endif // isinf + +// isnan + +#ifdef isnan + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isnan(_A1 __x) +{ + return isnan(__x); +} + +#undef isnan + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type +isnan(_A1 __x) +{ + return __libcpp_isnan(__x); +} + +#endif // isnan + +// isnormal + +#ifdef isnormal + +template <class _A1> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isnormal(_A1 __x) +{ + return isnormal(__x); +} + +#undef isnormal + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type +isnormal(_A1 __x) +{ + return __libcpp_isnormal(__x); +} + +#endif // isnormal + +// isgreater + +#ifdef isgreater + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isgreater(_A1 __x, _A2 __y) +{ + return isgreater(__x, __y); +} + +#undef isgreater + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_floating_point<_A1>::value && + std::is_floating_point<_A2>::value, + bool +>::type +isgreater(_A1 __x, _A2 __y) +{ + return __libcpp_isgreater(__x, __y); +} + +#endif // isgreater + +// isgreaterequal + +#ifdef isgreaterequal + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isgreaterequal(_A1 __x, _A2 __y) +{ + return isgreaterequal(__x, __y); +} + +#undef isgreaterequal + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_floating_point<_A1>::value && + std::is_floating_point<_A2>::value, + bool +>::type +isgreaterequal(_A1 __x, _A2 __y) +{ + return __libcpp_isgreaterequal(__x, __y); +} + +#endif // isgreaterequal + +// isless + +#ifdef isless + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isless(_A1 __x, _A2 __y) +{ + return isless(__x, __y); +} + +#undef isless + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_floating_point<_A1>::value && + std::is_floating_point<_A2>::value, + bool +>::type +isless(_A1 __x, _A2 __y) +{ + return __libcpp_isless(__x, __y); +} + +#endif // isless + +// islessequal + +#ifdef islessequal + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_islessequal(_A1 __x, _A2 __y) +{ + return islessequal(__x, __y); +} + +#undef islessequal + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_floating_point<_A1>::value && + std::is_floating_point<_A2>::value, + bool +>::type +islessequal(_A1 __x, _A2 __y) +{ + return __libcpp_islessequal(__x, __y); +} + +#endif // islessequal + +// islessgreater + +#ifdef islessgreater + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_islessgreater(_A1 __x, _A2 __y) +{ + return islessgreater(__x, __y); +} + +#undef islessgreater + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_floating_point<_A1>::value && + std::is_floating_point<_A2>::value, + bool +>::type +islessgreater(_A1 __x, _A2 __y) +{ + return __libcpp_islessgreater(__x, __y); +} + +#endif // islessgreater + +// isunordered + +#ifdef isunordered + +template <class _A1, class _A2> +_LIBCPP_ALWAYS_INLINE +bool +__libcpp_isunordered(_A1 __x, _A2 __y) +{ + return isunordered(__x, __y); +} + +#undef isunordered + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename std::enable_if +< + std::is_floating_point<_A1>::value && + std::is_floating_point<_A2>::value, + bool +>::type +isunordered(_A1 __x, _A2 __y) +{ + return __libcpp_isunordered(__x, __y); +} + +#endif // isunordered + +_LIBCPP_BEGIN_NAMESPACE_STD + +using ::signbit; +using ::fpclassify; +using ::isfinite; +using ::isinf; +using ::isnan; +using ::isnormal; +using ::isgreater; +using ::isgreaterequal; +using ::isless; +using ::islessequal; +using ::islessgreater; +using ::isunordered; +using ::isunordered; + +using ::float_t; +using ::double_t; + +// abs + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_floating_point<_A1>::value, _A1>::type +abs(_A1 __x) {return fabs(__x);} + +// acos + +using ::acos; +using ::acosf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float acos(float __x) {return acosf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __x) {return acosl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +acos(_A1 __x) {return acos((double)__x);} + +// asin + +using ::asin; +using ::asinf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float asin(float __x) {return asinf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __x) {return asinl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +asin(_A1 __x) {return asin((double)__x);} + +// atan + +using ::atan; +using ::atanf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float atan(float __x) {return atanf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __x) {return atanl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +atan(_A1 __x) {return atan((double)__x);} + +// atan2 + +using ::atan2; +using ::atan2f; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float atan2(float __y, float __x) {return atan2f(__y, __x);} +inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __y, long double __x) {return atan2l(__y, __x);} +#endif + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +atan2(_A1 __y, _A2 __x) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return atan2((__result_type)__y, (__result_type)__x); +} + +// ceil + +using ::ceil; +using ::ceilf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float ceil(float __x) {return ceilf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __x) {return ceill(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +ceil(_A1 __x) {return ceil((double)__x);} + +// cos + +using ::cos; +using ::cosf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float cos(float __x) {return cosf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __x) {return cosl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_ALWAYS_INLINE _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +cos(_A1 __x) {return cos((double)__x);} + +// cosh + +using ::cosh; +using ::coshf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float cosh(float __x) {return coshf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __x) {return coshl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +cosh(_A1 __x) {return cosh((double)__x);} + +// exp + +using ::exp; +using ::expf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float exp(float __x) {return expf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __x) {return expl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +exp(_A1 __x) {return exp((double)__x);} + +// fabs + +using ::fabs; +using ::fabsf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float fabs(float __x) {return fabsf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __x) {return fabsl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +fabs(_A1 __x) {return fabs((double)__x);} + +// floor + +using ::floor; +using ::floorf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float floor(float __x) {return floorf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __x) {return floorl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +floor(_A1 __x) {return floor((double)__x);} + +// fmod + +using ::fmod; +using ::fmodf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float fmod(float __x, float __y) {return fmodf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __x, long double __y) {return fmodl(__x, __y);} +#endif + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +fmod(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return fmod((__result_type)__x, (__result_type)__y); +} + +// frexp + +using ::frexp; +using ::frexpf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float frexp(float __x, int* __e) {return frexpf(__x, __e);} +inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __x, int* __e) {return frexpl(__x, __e);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +frexp(_A1 __x, int* __e) {return frexp((double)__x, __e);} + +// ldexp + +using ::ldexp; +using ::ldexpf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __x, int __e) {return ldexpf(__x, __e);} +inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __x, int __e) {return ldexpl(__x, __e);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +ldexp(_A1 __x, int __e) {return ldexp((double)__x, __e);} + +// log + +using ::log; +using ::logf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float log(float __x) {return logf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double log(long double __x) {return logl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +log(_A1 __x) {return log((double)__x);} + +// log10 + +using ::log10; +using ::log10f; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float log10(float __x) {return log10f(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __x) {return log10l(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +log10(_A1 __x) {return log10((double)__x);} + +// modf + +using ::modf; +using ::modff; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float modf(float __x, float* __y) {return modff(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __x, long double* __y) {return modfl(__x, __y);} +#endif + +// pow + +using ::pow; +using ::powf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float pow(float __x, float __y) {return powf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __x, long double __y) {return powl(__x, __y);} +#endif + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +pow(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return pow((__result_type)__x, (__result_type)__y); +} + +// sin + +using ::sin; +using ::sinf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float sin(float __x) {return sinf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __x) {return sinl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +sin(_A1 __x) {return sin((double)__x);} + +// sinh + +using ::sinh; +using ::sinhf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float sinh(float __x) {return sinhf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __x) {return sinhl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +sinh(_A1 __x) {return sinh((double)__x);} + +// sqrt + +using ::sqrt; +using ::sqrtf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __x) {return sqrtf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __x) {return sqrtl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +sqrt(_A1 __x) {return sqrt((double)__x);} + +// tan + +using ::tan; +using ::tanf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float tan(float __x) {return tanf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __x) {return tanl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +tan(_A1 __x) {return tan((double)__x);} + +// tanh + +using ::tanh; +using ::tanhf; + +#ifndef _MSC_VER +inline _LIBCPP_INLINE_VISIBILITY float tanh(float __x) {return tanhf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __x) {return tanhl(__x);} +#endif + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +tanh(_A1 __x) {return tanh((double)__x);} + +// acosh + +#ifndef _MSC_VER +using ::acosh; +using ::acoshf; + +inline _LIBCPP_INLINE_VISIBILITY float acosh(float __x) {return acoshf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __x) {return acoshl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +acosh(_A1 __x) {return acosh((double)__x);} +#endif + +// asinh + +#ifndef _MSC_VER +using ::asinh; +using ::asinhf; + +inline _LIBCPP_INLINE_VISIBILITY float asinh(float __x) {return asinhf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __x) {return asinhl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +asinh(_A1 __x) {return asinh((double)__x);} +#endif + +// atanh + +#ifndef _MSC_VER +using ::atanh; +using ::atanhf; + +inline _LIBCPP_INLINE_VISIBILITY float atanh(float __x) {return atanhf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __x) {return atanhl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +atanh(_A1 __x) {return atanh((double)__x);} +#endif + +// cbrt + +#ifndef _MSC_VER +using ::cbrt; +using ::cbrtf; + +inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __x) {return cbrtf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __x) {return cbrtl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +cbrt(_A1 __x) {return cbrt((double)__x);} +#endif + +// copysign + +using ::copysign; +using ::copysignf; + +inline _LIBCPP_INLINE_VISIBILITY float copysign(float __x, float __y) {return copysignf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __x, long double __y) {return copysignl(__x, __y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +copysign(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return copysign((__result_type)__x, (__result_type)__y); +} + +#ifndef _MSC_VER + +// erf + +using ::erf; +using ::erff; + +inline _LIBCPP_INLINE_VISIBILITY float erf(float __x) {return erff(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __x) {return erfl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +erf(_A1 __x) {return erf((double)__x);} + +// erfc + +using ::erfc; +using ::erfcf; + +inline _LIBCPP_INLINE_VISIBILITY float erfc(float __x) {return erfcf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __x) {return erfcl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +erfc(_A1 __x) {return erfc((double)__x);} + +// exp2 + +using ::exp2; +using ::exp2f; + +inline _LIBCPP_INLINE_VISIBILITY float exp2(float __x) {return exp2f(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __x) {return exp2l(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +exp2(_A1 __x) {return exp2((double)__x);} + +// expm1 + +using ::expm1; +using ::expm1f; + +inline _LIBCPP_INLINE_VISIBILITY float expm1(float __x) {return expm1f(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __x) {return expm1l(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +expm1(_A1 __x) {return expm1((double)__x);} + +// fdim + +using ::fdim; +using ::fdimf; + +inline _LIBCPP_INLINE_VISIBILITY float fdim(float __x, float __y) {return fdimf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __x, long double __y) {return fdiml(__x, __y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +fdim(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return fdim((__result_type)__x, (__result_type)__y); +} + +// fma + +inline _LIBCPP_INLINE_VISIBILITY float fmaf(float __x, float __y, float __z) {return (float)((double)__x*__y + __z);} +#define FP_FAST_FMAF + +using ::fma; + +inline _LIBCPP_INLINE_VISIBILITY float fma(float __x, float __y, float __z) {return fmaf(__x, __y, __z);} +inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __x, long double __y, long double __z) {return fmal(__x, __y, __z);} + +template <class _A1, class _A2, class _A3> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value && + is_arithmetic<_A3>::value, + typename __promote<_A1, _A2, _A3>::type +>::type +fma(_A1 __x, _A2 __y, _A3 __z) +{ + typedef typename __promote<_A1, _A2, _A3>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value && + is_same<_A3, __result_type>::value)), ""); + return fma((__result_type)__x, (__result_type)__y, (__result_type)__z); +} + +// fmax + +using ::fmax; +using ::fmaxf; + +inline _LIBCPP_INLINE_VISIBILITY float fmax(float __x, float __y) {return fmaxf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __x, long double __y) {return fmaxl(__x, __y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +fmax(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return fmax((__result_type)__x, (__result_type)__y); +} + +// fmin + +using ::fmin; +using ::fminf; + +inline _LIBCPP_INLINE_VISIBILITY float fmin(float __x, float __y) {return fminf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __x, long double __y) {return fminl(__x, __y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +fmin(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return fmin((__result_type)__x, (__result_type)__y); +} + +// hypot + +using ::hypot; +using ::hypotf; + +inline _LIBCPP_INLINE_VISIBILITY float hypot(float __x, float __y) {return hypotf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __x, long double __y) {return hypotl(__x, __y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +hypot(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return hypot((__result_type)__x, (__result_type)__y); +} + +// ilogb + +using ::ilogb; +using ::ilogbf; + +inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __x) {return ilogbf(__x);} +inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __x) {return ilogbl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, int>::type +ilogb(_A1 __x) {return ilogb((double)__x);} + +// lgamma + +using ::lgamma; +using ::lgammaf; + +inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __x) {return lgammaf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __x) {return lgammal(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +lgamma(_A1 __x) {return lgamma((double)__x);} + +// llrint + +using ::llrint; +using ::llrintf; + +inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __x) {return llrintf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __x) {return llrintl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, long long>::type +llrint(_A1 __x) {return llrint((double)__x);} + +// llround + +using ::llround; +using ::llroundf; + +inline _LIBCPP_INLINE_VISIBILITY long long llround(float __x) {return llroundf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __x) {return llroundl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, long long>::type +llround(_A1 __x) {return llround((double)__x);} + +// log1p + +using ::log1p; +using ::log1pf; + +inline _LIBCPP_INLINE_VISIBILITY float log1p(float __x) {return log1pf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __x) {return log1pl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +log1p(_A1 __x) {return log1p((double)__x);} + +// log2 + +using ::log2; +using ::log2f; + +inline _LIBCPP_INLINE_VISIBILITY float log2(float __x) {return log2f(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __x) {return log2l(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +log2(_A1 __x) {return log2((double)__x);} + +// logb + +using ::logb; +using ::logbf; + +inline _LIBCPP_INLINE_VISIBILITY float logb(float __x) {return logbf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __x) {return logbl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +logb(_A1 __x) {return logb((double)__x);} + +// lrint + +using ::lrint; +using ::lrintf; + +inline _LIBCPP_INLINE_VISIBILITY long lrint(float __x) {return lrintf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __x) {return lrintl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, long>::type +lrint(_A1 __x) {return lrint((double)__x);} + +// lround + +using ::lround; +using ::lroundf; + +inline _LIBCPP_INLINE_VISIBILITY long lround(float __x) {return lroundf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long lround(long double __x) {return lroundl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, long>::type +lround(_A1 __x) {return lround((double)__x);} + +// nan + +using ::nan; +using ::nanf; + +// nearbyint + +using ::nearbyint; +using ::nearbyintf; + +inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __x) {return nearbyintf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __x) {return nearbyintl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +nearbyint(_A1 __x) {return nearbyint((double)__x);} + +// nextafter + +using ::nextafter; +using ::nextafterf; + +inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __x, float __y) {return nextafterf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __x, long double __y) {return nextafterl(__x, __y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +nextafter(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return nextafter((__result_type)__x, (__result_type)__y); +} + +// nexttoward + +using ::nexttoward; +using ::nexttowardf; + +inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __x, long double __y) {return nexttowardf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __x, long double __y) {return nexttowardl(__x, __y);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +nexttoward(_A1 __x, long double __y) {return nexttoward((double)__x, __y);} + +// remainder + +using ::remainder; +using ::remainderf; + +inline _LIBCPP_INLINE_VISIBILITY float remainder(float __x, float __y) {return remainderf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __x, long double __y) {return remainderl(__x, __y);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +remainder(_A1 __x, _A2 __y) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return remainder((__result_type)__x, (__result_type)__y); +} + +// remquo + +using ::remquo; +using ::remquof; + +inline _LIBCPP_INLINE_VISIBILITY float remquo(float __x, float __y, int* __z) {return remquof(__x, __y, __z);} +inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __x, long double __y, int* __z) {return remquol(__x, __y, __z);} + +template <class _A1, class _A2> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if +< + is_arithmetic<_A1>::value && + is_arithmetic<_A2>::value, + typename __promote<_A1, _A2>::type +>::type +remquo(_A1 __x, _A2 __y, int* __z) +{ + typedef typename __promote<_A1, _A2>::type __result_type; + static_assert((!(is_same<_A1, __result_type>::value && + is_same<_A2, __result_type>::value)), ""); + return remquo((__result_type)__x, (__result_type)__y, __z); +} + +// rint + +using ::rint; +using ::rintf; + +inline _LIBCPP_INLINE_VISIBILITY float rint(float __x) {return rintf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __x) {return rintl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +rint(_A1 __x) {return rint((double)__x);} + +// round + +using ::round; +using ::roundf; + +inline _LIBCPP_INLINE_VISIBILITY float round(float __x) {return roundf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double round(long double __x) {return roundl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +round(_A1 __x) {return round((double)__x);} + +// scalbln + +using ::scalbln; +using ::scalblnf; + +inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __x, long __y) {return scalblnf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __x, long __y) {return scalblnl(__x, __y);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +scalbln(_A1 __x, long __y) {return scalbln((double)__x, __y);} + +// scalbn + +using ::scalbn; +using ::scalbnf; + +inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __x, int __y) {return scalbnf(__x, __y);} +inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __x, int __y) {return scalbnl(__x, __y);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +scalbn(_A1 __x, int __y) {return scalbn((double)__x, __y);} + +// tgamma + +using ::tgamma; +using ::tgammaf; + +inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __x) {return tgammaf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __x) {return tgammal(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +tgamma(_A1 __x) {return tgamma((double)__x);} + +// trunc + +using ::trunc; +using ::truncf; + +inline _LIBCPP_INLINE_VISIBILITY float trunc(float __x) {return truncf(__x);} +inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __x) {return truncl(__x);} + +template <class _A1> +inline _LIBCPP_INLINE_VISIBILITY +typename enable_if<is_integral<_A1>::value, double>::type +trunc(_A1 __x) {return trunc((double)__x);} + +#endif // !_MSC_VER + +using ::acosl; +using ::asinl; +using ::atanl; +using ::atan2l; +using ::ceill; +using ::cosl; +using ::coshl; +using ::expl; +using ::fabsl; +using ::floorl; +using ::fmodl; +using ::frexpl; +using ::ldexpl; +using ::logl; +using ::log10l; +using ::modfl; +using ::powl; +using ::sinl; +using ::sinhl; +using ::sqrtl; +using ::tanl; +#ifndef _MSC_VER +using ::tanhl; +using ::acoshl; +using ::asinhl; +using ::atanhl; +using ::cbrtl; +#endif !_MSC_VER +using ::copysignl; +#ifndef _MSC_VER +using ::erfl; +using ::erfcl; +using ::exp2l; +using ::expm1l; +using ::fdiml; +using ::fmal; +using ::fmaxl; +using ::fminl; +using ::hypotl; +using ::ilogbl; +using ::lgammal; +using ::llrintl; +using ::llroundl; +using ::log1pl; +using ::log2l; +using ::logbl; +using ::lrintl; +using ::lroundl; +using ::nanl; +using ::nearbyintl; +using ::nextafterl; +using ::nexttowardl; +using ::remainderl; +using ::remquol; +using ::rintl; +using ::roundl; +using ::scalblnl; +using ::scalbnl; +using ::tgammal; +using ::truncl; +#endif // !_MSC_VER + +_LIBCPP_END_NAMESPACE_STD + +#endif // _LIBCPP_CMATH |
