diff options
Diffstat (limited to 'libcxx/include/cmath')
| -rw-r--r-- | libcxx/include/cmath | 1668 |
1 files changed, 0 insertions, 1668 deletions
diff --git a/libcxx/include/cmath b/libcxx/include/cmath deleted file mode 100644 index 026889f81e5b..000000000000 --- a/libcxx/include/cmath +++ /dev/null @@ -1,1668 +0,0 @@ -// -*- 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);} - -#ifndef __sun__ - -// 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);} - -#endif // __sun__ -// exp - -using ::exp; -using ::expf; - -#ifndef __sun__ - -#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 - -#endif //__sun__ -using ::fmod; -using ::fmodf; -#ifndef __sun__ - -#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 - -#endif // __sun__ -using ::log; -using ::logf; -#ifndef __sun__ - -#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 - -#endif // __sun__ -using ::pow; -using ::powf; - -#ifndef __sun__ - -#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 - -#endif // __sun__ -using ::sqrt; -using ::sqrtf; - - -#if !(defined(_MSC_VER) || defined(__sun__)) -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 __sun__ - -#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 -#endif // _MSC_VER -#endif // __sun__ -using ::nan; -using ::nanf; -#ifndef __sun__ -#ifndef _MSC_VER - -// 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 - -#else -using ::lgamma; -using ::lgammaf; -#endif // __sun__ -_LIBCPP_END_NAMESPACE_STD - -#endif // _LIBCPP_CMATH |