diff --git a/libcxx/include/cmath b/libcxx/include/cmath --- a/libcxx/include/cmath +++ b/libcxx/include/cmath @@ -328,153 +328,83 @@ _LIBCPP_BEGIN_NAMESPACE_STD -using ::signbit _LIBCPP_USING_IF_EXISTS; -using ::fpclassify _LIBCPP_USING_IF_EXISTS; -using ::isfinite _LIBCPP_USING_IF_EXISTS; -using ::isinf _LIBCPP_USING_IF_EXISTS; -using ::isnan _LIBCPP_USING_IF_EXISTS; -using ::isnormal _LIBCPP_USING_IF_EXISTS; -using ::isgreater _LIBCPP_USING_IF_EXISTS; -using ::isgreaterequal _LIBCPP_USING_IF_EXISTS; -using ::isless _LIBCPP_USING_IF_EXISTS; -using ::islessequal _LIBCPP_USING_IF_EXISTS; -using ::islessgreater _LIBCPP_USING_IF_EXISTS; -using ::isunordered _LIBCPP_USING_IF_EXISTS; -using ::isunordered _LIBCPP_USING_IF_EXISTS; - using ::float_t _LIBCPP_USING_IF_EXISTS; using ::double_t _LIBCPP_USING_IF_EXISTS; using ::abs _LIBCPP_USING_IF_EXISTS; -using ::acos _LIBCPP_USING_IF_EXISTS; using ::acosf _LIBCPP_USING_IF_EXISTS; -using ::asin _LIBCPP_USING_IF_EXISTS; using ::asinf _LIBCPP_USING_IF_EXISTS; -using ::atan _LIBCPP_USING_IF_EXISTS; using ::atanf _LIBCPP_USING_IF_EXISTS; -using ::atan2 _LIBCPP_USING_IF_EXISTS; using ::atan2f _LIBCPP_USING_IF_EXISTS; -using ::ceil _LIBCPP_USING_IF_EXISTS; using ::ceilf _LIBCPP_USING_IF_EXISTS; -using ::cos _LIBCPP_USING_IF_EXISTS; using ::cosf _LIBCPP_USING_IF_EXISTS; -using ::cosh _LIBCPP_USING_IF_EXISTS; using ::coshf _LIBCPP_USING_IF_EXISTS; -using ::exp _LIBCPP_USING_IF_EXISTS; using ::expf _LIBCPP_USING_IF_EXISTS; -using ::fabs _LIBCPP_USING_IF_EXISTS; using ::fabsf _LIBCPP_USING_IF_EXISTS; -using ::floor _LIBCPP_USING_IF_EXISTS; using ::floorf _LIBCPP_USING_IF_EXISTS; -using ::fmod _LIBCPP_USING_IF_EXISTS; using ::fmodf _LIBCPP_USING_IF_EXISTS; -using ::frexp _LIBCPP_USING_IF_EXISTS; using ::frexpf _LIBCPP_USING_IF_EXISTS; -using ::ldexp _LIBCPP_USING_IF_EXISTS; using ::ldexpf _LIBCPP_USING_IF_EXISTS; -using ::log _LIBCPP_USING_IF_EXISTS; using ::logf _LIBCPP_USING_IF_EXISTS; -using ::log10 _LIBCPP_USING_IF_EXISTS; using ::log10f _LIBCPP_USING_IF_EXISTS; -using ::modf _LIBCPP_USING_IF_EXISTS; using ::modff _LIBCPP_USING_IF_EXISTS; -using ::pow _LIBCPP_USING_IF_EXISTS; using ::powf _LIBCPP_USING_IF_EXISTS; -using ::sin _LIBCPP_USING_IF_EXISTS; using ::sinf _LIBCPP_USING_IF_EXISTS; -using ::sinh _LIBCPP_USING_IF_EXISTS; using ::sinhf _LIBCPP_USING_IF_EXISTS; -using ::sqrt _LIBCPP_USING_IF_EXISTS; using ::sqrtf _LIBCPP_USING_IF_EXISTS; -using ::tan _LIBCPP_USING_IF_EXISTS; using ::tanf _LIBCPP_USING_IF_EXISTS; -using ::tanh _LIBCPP_USING_IF_EXISTS; using ::tanhf _LIBCPP_USING_IF_EXISTS; -using ::acosh _LIBCPP_USING_IF_EXISTS; using ::acoshf _LIBCPP_USING_IF_EXISTS; -using ::asinh _LIBCPP_USING_IF_EXISTS; using ::asinhf _LIBCPP_USING_IF_EXISTS; -using ::atanh _LIBCPP_USING_IF_EXISTS; using ::atanhf _LIBCPP_USING_IF_EXISTS; -using ::cbrt _LIBCPP_USING_IF_EXISTS; using ::cbrtf _LIBCPP_USING_IF_EXISTS; -using ::copysign _LIBCPP_USING_IF_EXISTS; using ::copysignf _LIBCPP_USING_IF_EXISTS; -using ::erf _LIBCPP_USING_IF_EXISTS; using ::erff _LIBCPP_USING_IF_EXISTS; -using ::erfc _LIBCPP_USING_IF_EXISTS; using ::erfcf _LIBCPP_USING_IF_EXISTS; -using ::exp2 _LIBCPP_USING_IF_EXISTS; using ::exp2f _LIBCPP_USING_IF_EXISTS; -using ::expm1 _LIBCPP_USING_IF_EXISTS; using ::expm1f _LIBCPP_USING_IF_EXISTS; -using ::fdim _LIBCPP_USING_IF_EXISTS; using ::fdimf _LIBCPP_USING_IF_EXISTS; using ::fmaf _LIBCPP_USING_IF_EXISTS; -using ::fma _LIBCPP_USING_IF_EXISTS; -using ::fmax _LIBCPP_USING_IF_EXISTS; using ::fmaxf _LIBCPP_USING_IF_EXISTS; -using ::fmin _LIBCPP_USING_IF_EXISTS; using ::fminf _LIBCPP_USING_IF_EXISTS; -using ::hypot _LIBCPP_USING_IF_EXISTS; using ::hypotf _LIBCPP_USING_IF_EXISTS; -using ::ilogb _LIBCPP_USING_IF_EXISTS; using ::ilogbf _LIBCPP_USING_IF_EXISTS; -using ::lgamma _LIBCPP_USING_IF_EXISTS; using ::lgammaf _LIBCPP_USING_IF_EXISTS; -using ::llrint _LIBCPP_USING_IF_EXISTS; using ::llrintf _LIBCPP_USING_IF_EXISTS; -using ::llround _LIBCPP_USING_IF_EXISTS; using ::llroundf _LIBCPP_USING_IF_EXISTS; -using ::log1p _LIBCPP_USING_IF_EXISTS; using ::log1pf _LIBCPP_USING_IF_EXISTS; -using ::log2 _LIBCPP_USING_IF_EXISTS; using ::log2f _LIBCPP_USING_IF_EXISTS; -using ::logb _LIBCPP_USING_IF_EXISTS; using ::logbf _LIBCPP_USING_IF_EXISTS; -using ::lrint _LIBCPP_USING_IF_EXISTS; using ::lrintf _LIBCPP_USING_IF_EXISTS; -using ::lround _LIBCPP_USING_IF_EXISTS; using ::lroundf _LIBCPP_USING_IF_EXISTS; using ::nan _LIBCPP_USING_IF_EXISTS; using ::nanf _LIBCPP_USING_IF_EXISTS; -using ::nearbyint _LIBCPP_USING_IF_EXISTS; using ::nearbyintf _LIBCPP_USING_IF_EXISTS; -using ::nextafter _LIBCPP_USING_IF_EXISTS; using ::nextafterf _LIBCPP_USING_IF_EXISTS; -using ::nexttoward _LIBCPP_USING_IF_EXISTS; using ::nexttowardf _LIBCPP_USING_IF_EXISTS; -using ::remainder _LIBCPP_USING_IF_EXISTS; using ::remainderf _LIBCPP_USING_IF_EXISTS; -using ::remquo _LIBCPP_USING_IF_EXISTS; using ::remquof _LIBCPP_USING_IF_EXISTS; -using ::rint _LIBCPP_USING_IF_EXISTS; using ::rintf _LIBCPP_USING_IF_EXISTS; -using ::round _LIBCPP_USING_IF_EXISTS; using ::roundf _LIBCPP_USING_IF_EXISTS; -using ::scalbln _LIBCPP_USING_IF_EXISTS; using ::scalblnf _LIBCPP_USING_IF_EXISTS; -using ::scalbn _LIBCPP_USING_IF_EXISTS; using ::scalbnf _LIBCPP_USING_IF_EXISTS; -using ::tgamma _LIBCPP_USING_IF_EXISTS; using ::tgammaf _LIBCPP_USING_IF_EXISTS; -using ::trunc _LIBCPP_USING_IF_EXISTS; using ::truncf _LIBCPP_USING_IF_EXISTS; using ::acosl _LIBCPP_USING_IF_EXISTS; diff --git a/libcxx/include/math.h b/libcxx/include/math.h --- a/libcxx/include/math.h +++ b/libcxx/include/math.h @@ -310,41 +310,43 @@ #include #include +_LIBCPP_BEGIN_NAMESPACE_STD + // signbit #ifdef signbit template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT +__libcpp_signbit(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_signbit) - return __builtin_signbit(__lcpp_x); + return __builtin_signbit(__x); #else - return signbit(__lcpp_x); + return signbit(__x); #endif } #undef signbit template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, bool>::type -signbit(_A1 __lcpp_x) _NOEXCEPT +signbit(_A1 __x) _NOEXCEPT { - return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x); + return __libcpp_signbit((typename std::__promote<_A1>::type)__x); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type -signbit(_A1 __lcpp_x) _NOEXCEPT -{ return __lcpp_x < 0; } +signbit(_A1 __x) _NOEXCEPT +{ return __x < 0; } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type signbit(_A1) _NOEXCEPT @@ -353,22 +355,22 @@ #elif defined(_LIBCPP_MSVCRT) template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, bool>::type -signbit(_A1 __lcpp_x) _NOEXCEPT +signbit(_A1 __x) _NOEXCEPT { - return ::signbit(static_cast::type>(__lcpp_x)); + return ::signbit(static_cast::type>(__x)); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_integral<_A1>::value && std::is_signed<_A1>::value, bool>::type -signbit(_A1 __lcpp_x) _NOEXCEPT -{ return __lcpp_x < 0; } +signbit(_A1 __x) _NOEXCEPT +{ return __x < 0; } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type signbit(_A1) _NOEXCEPT @@ -381,49 +383,49 @@ #ifdef fpclassify template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI int -__libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT +__libcpp_fpclassify(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_fpclassify) return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL, - FP_ZERO, __lcpp_x); + FP_ZERO, __x); #else - return fpclassify(__lcpp_x); + return fpclassify(__x); #endif } #undef fpclassify template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, int>::type -fpclassify(_A1 __lcpp_x) _NOEXCEPT +fpclassify(_A1 __x) _NOEXCEPT { - return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x); + return __libcpp_fpclassify((typename std::__promote<_A1>::type)__x); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, int>::type -fpclassify(_A1 __lcpp_x) _NOEXCEPT -{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; } +fpclassify(_A1 __x) _NOEXCEPT +{ return __x == 0 ? FP_ZERO : FP_NORMAL; } #elif defined(_LIBCPP_MSVCRT) template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, bool>::type -fpclassify(_A1 __lcpp_x) _NOEXCEPT +fpclassify(_A1 __x) _NOEXCEPT { - return ::fpclassify(static_cast::type>(__lcpp_x)); + return ::fpclassify(static_cast::type>(__x)); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, int>::type -fpclassify(_A1 __lcpp_x) _NOEXCEPT -{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; } +fpclassify(_A1 __x) _NOEXCEPT +{ return __x == 0 ? FP_ZERO : FP_NORMAL; } #endif // fpclassify @@ -432,31 +434,31 @@ #ifdef isfinite template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT +__libcpp_isfinite(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_isfinite) - return __builtin_isfinite(__lcpp_x); + return __builtin_isfinite(__x); #else - return isfinite(__lcpp_x); + return isfinite(__x); #endif } #undef isfinite template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, bool>::type -isfinite(_A1 __lcpp_x) _NOEXCEPT +isfinite(_A1 __x) _NOEXCEPT { - return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x); + return __libcpp_isfinite((typename std::__promote<_A1>::type)__x); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, bool>::type @@ -470,31 +472,31 @@ #ifdef isinf template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT +__libcpp_isinf(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_isinf) - return __builtin_isinf(__lcpp_x); + return __builtin_isinf(__x); #else - return isinf(__lcpp_x); + return isinf(__x); #endif } #undef isinf template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity, bool>::type -isinf(_A1 __lcpp_x) _NOEXCEPT +isinf(_A1 __x) _NOEXCEPT { - return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x); + return __libcpp_isinf((typename std::__promote<_A1>::type)__x); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if< std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity, bool>::type @@ -502,17 +504,17 @@ { return false; } #ifdef _LIBCPP_PREFERRED_OVERLOAD -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI bool -isinf(float __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); } +isinf(float __x) _NOEXCEPT { return __libcpp_isinf(__x); } -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool -isinf(double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); } +isinf(double __x) _NOEXCEPT { return __libcpp_isinf(__x); } -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI bool -isinf(long double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); } +isinf(long double __x) _NOEXCEPT { return __libcpp_isinf(__x); } #endif #endif // isinf @@ -522,45 +524,45 @@ #ifdef isnan template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT +__libcpp_isnan(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_isnan) - return __builtin_isnan(__lcpp_x); + return __builtin_isnan(__x); #else - return isnan(__lcpp_x); + return isnan(__x); #endif } #undef isnan template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, bool>::type -isnan(_A1 __lcpp_x) _NOEXCEPT +isnan(_A1 __x) _NOEXCEPT { - return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x); + return __libcpp_isnan((typename std::__promote<_A1>::type)__x); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, bool>::type isnan(_A1) _NOEXCEPT { return false; } #ifdef _LIBCPP_PREFERRED_OVERLOAD -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI bool -isnan(float __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); } +isnan(float __x) _NOEXCEPT { return __libcpp_isnan(__x); } -inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD +inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_PREFERRED_OVERLOAD bool -isnan(double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); } +isnan(double __x) _NOEXCEPT { return __libcpp_isnan(__x); } -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI bool -isnan(long double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); } +isnan(long double __x) _NOEXCEPT { return __libcpp_isnan(__x); } #endif #endif // isnan @@ -570,32 +572,32 @@ #ifdef isnormal template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT +__libcpp_isnormal(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_isnormal) - return __builtin_isnormal(__lcpp_x); + return __builtin_isnormal(__x); #else - return isnormal(__lcpp_x); + return isnormal(__x); #endif } #undef isnormal template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, bool>::type -isnormal(_A1 __lcpp_x) _NOEXCEPT +isnormal(_A1 __x) _NOEXCEPT { - return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x); + return __libcpp_isnormal((typename std::__promote<_A1>::type)__x); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, bool>::type -isnormal(_A1 __lcpp_x) _NOEXCEPT -{ return __lcpp_x != 0; } +isnormal(_A1 __x) _NOEXCEPT +{ return __x != 0; } #endif // isnormal @@ -604,27 +606,27 @@ #ifdef isgreater template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +__libcpp_isgreater(_A1 __x, _A2 __y) _NOEXCEPT { - return isgreater(__lcpp_x, __lcpp_y); + return isgreater(__x, __y); } #undef isgreater template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type -isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +isgreater(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y); + return __libcpp_isgreater((type)__x, (type)__y); } #endif // isgreater @@ -634,27 +636,27 @@ #ifdef isgreaterequal template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +__libcpp_isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT { - return isgreaterequal(__lcpp_x, __lcpp_y); + return isgreaterequal(__x, __y); } #undef isgreaterequal template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type -isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +isgreaterequal(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y); + return __libcpp_isgreaterequal((type)__x, (type)__y); } #endif // isgreaterequal @@ -664,27 +666,27 @@ #ifdef isless template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +__libcpp_isless(_A1 __x, _A2 __y) _NOEXCEPT { - return isless(__lcpp_x, __lcpp_y); + return isless(__x, __y); } #undef isless template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type -isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +isless(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y); + return __libcpp_isless((type)__x, (type)__y); } #endif // isless @@ -694,27 +696,27 @@ #ifdef islessequal template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +__libcpp_islessequal(_A1 __x, _A2 __y) _NOEXCEPT { - return islessequal(__lcpp_x, __lcpp_y); + return islessequal(__x, __y); } #undef islessequal template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type -islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +islessequal(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y); + return __libcpp_islessequal((type)__x, (type)__y); } #endif // islessequal @@ -724,27 +726,27 @@ #ifdef islessgreater template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +__libcpp_islessgreater(_A1 __x, _A2 __y) _NOEXCEPT { - return islessgreater(__lcpp_x, __lcpp_y); + return islessgreater(__x, __y); } #undef islessgreater template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type -islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +islessgreater(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y); + return __libcpp_islessgreater((type)__x, (type)__y); } #endif // islessgreater @@ -754,27 +756,27 @@ #ifdef isunordered template -_LIBCPP_INLINE_VISIBILITY +_LIBCPP_HIDE_FROM_ABI bool -__libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +__libcpp_isunordered(_A1 __x, _A2 __y) _NOEXCEPT { - return isunordered(__lcpp_x, __lcpp_y); + return isunordered(__x, __y); } #undef isunordered template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, bool >::type -isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +isunordered(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type type; - return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y); + return __libcpp_isunordered((type)__x, (type)__y); } #endif // isunordered @@ -790,367 +792,393 @@ // acos # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return ::acosf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float acos(float __x) _NOEXCEPT {return ::acosf(__x);} +using ::acos _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double acos(long double __x) _NOEXCEPT {return ::acosl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -acos(_A1 __lcpp_x) _NOEXCEPT {return ::acos((double)__lcpp_x);} +acos(_A1 __x) _NOEXCEPT {return ::acos((double)__x);} // asin # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return ::asinf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return ::asinl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float asin(float __x) _NOEXCEPT {return ::asinf(__x);} +using ::asin _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double asin(long double __x) _NOEXCEPT {return ::asinl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -asin(_A1 __lcpp_x) _NOEXCEPT {return ::asin((double)__lcpp_x);} +asin(_A1 __x) _NOEXCEPT {return ::asin((double)__x);} // atan # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return ::atanf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return ::atanl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float atan(float __x) _NOEXCEPT {return ::atanf(__x);} +using ::atan _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double atan(long double __x) _NOEXCEPT {return ::atanl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -atan(_A1 __lcpp_x) _NOEXCEPT {return ::atan((double)__lcpp_x);} +atan(_A1 __x) _NOEXCEPT {return ::atan((double)__x);} // atan2 # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return ::atan2f(__lcpp_y, __lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return ::atan2l(__lcpp_y, __lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float atan2(float __y, float __x) _NOEXCEPT {return ::atan2f(__y, __x);} +using ::atan2 _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {return ::atan2l(__y, __x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT +atan2(_A1 __y, _A2 __x) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x); + return ::atan2((__result_type)__y, (__result_type)__x); } // ceil # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ::ceilf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ::ceill(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float ceil(float __x) _NOEXCEPT {return ::ceilf(__x);} +using ::ceil _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double ceil(long double __x) _NOEXCEPT {return ::ceill(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -ceil(_A1 __lcpp_x) _NOEXCEPT {return ::ceil((double)__lcpp_x);} +ceil(_A1 __x) _NOEXCEPT {return ::ceil((double)__x);} // cos # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return ::cosf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return ::cosl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float cos(float __x) _NOEXCEPT {return ::cosf(__x);} +using ::cos _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double cos(long double __x) _NOEXCEPT {return ::cosl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -cos(_A1 __lcpp_x) _NOEXCEPT {return ::cos((double)__lcpp_x);} +cos(_A1 __x) _NOEXCEPT {return ::cos((double)__x);} // cosh # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return ::coshf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return ::coshl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float cosh(float __x) _NOEXCEPT {return ::coshf(__x);} +using ::cosh _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double cosh(long double __x) _NOEXCEPT {return ::coshl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -cosh(_A1 __lcpp_x) _NOEXCEPT {return ::cosh((double)__lcpp_x);} +cosh(_A1 __x) _NOEXCEPT {return ::cosh((double)__x);} // exp # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return ::expf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return ::expl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float exp(float __x) _NOEXCEPT {return ::expf(__x);} +using ::exp _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double exp(long double __x) _NOEXCEPT {return ::expl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -exp(_A1 __lcpp_x) _NOEXCEPT {return ::exp((double)__lcpp_x);} +exp(_A1 __x) _NOEXCEPT {return ::exp((double)__x);} // fabs # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return ::fabsf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float fabs(float __x) _NOEXCEPT {return ::fabsf(__x);} +using ::fabs _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double fabs(long double __x) _NOEXCEPT {return ::fabsl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -fabs(_A1 __lcpp_x) _NOEXCEPT {return ::fabs((double)__lcpp_x);} +fabs(_A1 __x) _NOEXCEPT {return ::fabs((double)__x);} // floor # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return ::floorf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return ::floorl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float floor(float __x) _NOEXCEPT {return ::floorf(__x);} +using ::floor _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double floor(long double __x) _NOEXCEPT {return ::floorl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -floor(_A1 __lcpp_x) _NOEXCEPT {return ::floor((double)__lcpp_x);} +floor(_A1 __x) _NOEXCEPT {return ::floor((double)__x);} // fmod # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmodf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmodl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float fmod(float __x, float __y) _NOEXCEPT {return ::fmodf(__x, __y);} +using ::fmod _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double fmod(long double __x, long double __y) _NOEXCEPT {return ::fmodl(__x, __y);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +fmod(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::fmod((__result_type)__x, (__result_type)__y); } // frexp # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpf(__lcpp_x, __lcpp_e);} -inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpl(__lcpp_x, __lcpp_e);} +inline _LIBCPP_HIDE_FROM_ABI float frexp(float __x, int* __e) _NOEXCEPT {return ::frexpf(__x, __e);} +using ::frexp _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double frexp(long double __x, int* __e) _NOEXCEPT {return ::frexpl(__x, __e);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexp((double)__lcpp_x, __lcpp_e);} +frexp(_A1 __x, int* __e) _NOEXCEPT {return ::frexp((double)__x, __e);} // ldexp # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpf(__lcpp_x, __lcpp_e);} -inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpl(__lcpp_x, __lcpp_e);} +inline _LIBCPP_HIDE_FROM_ABI float ldexp(float __x, int __e) _NOEXCEPT {return ::ldexpf(__x, __e);} +using ::ldexp _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double ldexp(long double __x, int __e) _NOEXCEPT {return ::ldexpl(__x, __e);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexp((double)__lcpp_x, __lcpp_e);} +ldexp(_A1 __x, int __e) _NOEXCEPT {return ::ldexp((double)__x, __e);} // log # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return ::logf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return ::logl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float log(float __x) _NOEXCEPT {return ::logf(__x);} +using ::log _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double log(long double __x) _NOEXCEPT {return ::logl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -log(_A1 __lcpp_x) _NOEXCEPT {return ::log((double)__lcpp_x);} +log(_A1 __x) _NOEXCEPT {return ::log((double)__x);} // log10 # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return ::log10f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return ::log10l(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float log10(float __x) _NOEXCEPT {return ::log10f(__x);} +using ::log10 _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double log10(long double __x) _NOEXCEPT {return ::log10l(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -log10(_A1 __lcpp_x) _NOEXCEPT {return ::log10((double)__lcpp_x);} +log10(_A1 __x) _NOEXCEPT {return ::log10((double)__x);} // modf # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return ::modff(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return ::modfl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float modf(float __x, float* __y) _NOEXCEPT {return ::modff(__x, __y);} +using ::modf _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double modf(long double __x, long double* __y) _NOEXCEPT {return ::modfl(__x, __y);} # endif // pow # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::powf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::powl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float pow(float __x, float __y) _NOEXCEPT {return ::powf(__x, __y);} +using ::pow _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double pow(long double __x, long double __y) _NOEXCEPT {return ::powl(__x, __y);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +pow(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::pow((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::pow((__result_type)__x, (__result_type)__y); } // sin # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return ::sinf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return ::sinl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float sin(float __x) _NOEXCEPT {return ::sinf(__x);} +using ::sin _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double sin(long double __x) _NOEXCEPT {return ::sinl(__x);} #endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -sin(_A1 __lcpp_x) _NOEXCEPT {return ::sin((double)__lcpp_x);} +sin(_A1 __x) _NOEXCEPT {return ::sin((double)__x);} // sinh # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return ::sinhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return ::sinhl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float sinh(float __x) _NOEXCEPT {return ::sinhf(__x);} +using ::sinh _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double sinh(long double __x) _NOEXCEPT {return ::sinhl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -sinh(_A1 __lcpp_x) _NOEXCEPT {return ::sinh((double)__lcpp_x);} +sinh(_A1 __x) _NOEXCEPT {return ::sinh((double)__x);} // sqrt # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return ::sqrtf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return ::sqrtl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float sqrt(float __x) _NOEXCEPT {return ::sqrtf(__x);} +using ::sqrt _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double sqrt(long double __x) _NOEXCEPT {return ::sqrtl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -sqrt(_A1 __lcpp_x) _NOEXCEPT {return ::sqrt((double)__lcpp_x);} +sqrt(_A1 __x) _NOEXCEPT {return ::sqrt((double)__x);} // tan # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return ::tanf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return ::tanl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float tan(float __x) _NOEXCEPT {return ::tanf(__x);} +using ::tan _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double tan(long double __x) _NOEXCEPT {return ::tanl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -tan(_A1 __lcpp_x) _NOEXCEPT {return ::tan((double)__lcpp_x);} +tan(_A1 __x) _NOEXCEPT {return ::tan((double)__x);} // tanh # if !defined(__sun__) -inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return ::tanhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return ::tanhl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float tanh(float __x) _NOEXCEPT {return ::tanhf(__x);} +using ::tanh _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double tanh(long double __x) _NOEXCEPT {return ::tanhl(__x);} # endif template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -tanh(_A1 __lcpp_x) _NOEXCEPT {return ::tanh((double)__lcpp_x);} +tanh(_A1 __x) _NOEXCEPT {return ::tanh((double)__x);} // acosh -inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return ::acoshf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return ::acoshl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float acosh(float __x) _NOEXCEPT {return ::acoshf(__x);} +using ::acosh _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double acosh(long double __x) _NOEXCEPT {return ::acoshl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -acosh(_A1 __lcpp_x) _NOEXCEPT {return ::acosh((double)__lcpp_x);} +acosh(_A1 __x) _NOEXCEPT {return ::acosh((double)__x);} // asinh -inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return ::asinhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return ::asinhl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float asinh(float __x) _NOEXCEPT {return ::asinhf(__x);} +using ::asinh _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double asinh(long double __x) _NOEXCEPT {return ::asinhl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -asinh(_A1 __lcpp_x) _NOEXCEPT {return ::asinh((double)__lcpp_x);} +asinh(_A1 __x) _NOEXCEPT {return ::asinh((double)__x);} // atanh -inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return ::atanhf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return ::atanhl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float atanh(float __x) _NOEXCEPT {return ::atanhf(__x);} +using ::atanh _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double atanh(long double __x) _NOEXCEPT {return ::atanhl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -atanh(_A1 __lcpp_x) _NOEXCEPT {return ::atanh((double)__lcpp_x);} +atanh(_A1 __x) _NOEXCEPT {return ::atanh((double)__x);} // cbrt -inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return ::cbrtf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return ::cbrtl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float cbrt(float __x) _NOEXCEPT {return ::cbrtf(__x);} +using ::cbrt _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double cbrt(long double __x) _NOEXCEPT {return ::cbrtl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -cbrt(_A1 __lcpp_x) _NOEXCEPT {return ::cbrt((double)__lcpp_x);} +cbrt(_A1 __x) _NOEXCEPT {return ::cbrt((double)__x);} // copysign #if __has_builtin(__builtin_copysignf) _LIBCPP_CONSTEXPR #endif -inline _LIBCPP_INLINE_VISIBILITY float __libcpp_copysign(float __lcpp_x, float __lcpp_y) _NOEXCEPT { +inline _LIBCPP_HIDE_FROM_ABI float __libcpp_copysign(float __x, float __y) _NOEXCEPT { #if __has_builtin(__builtin_copysignf) - return __builtin_copysignf(__lcpp_x, __lcpp_y); + return __builtin_copysignf(__x, __y); #else - return ::copysignf(__lcpp_x, __lcpp_y); + return ::copysignf(__x, __y); #endif } #if __has_builtin(__builtin_copysign) _LIBCPP_CONSTEXPR #endif -inline _LIBCPP_INLINE_VISIBILITY double __libcpp_copysign(double __lcpp_x, double __lcpp_y) _NOEXCEPT { +inline _LIBCPP_HIDE_FROM_ABI double __libcpp_copysign(double __x, double __y) _NOEXCEPT { #if __has_builtin(__builtin_copysign) - return __builtin_copysign(__lcpp_x, __lcpp_y); + return __builtin_copysign(__x, __y); #else - return ::copysign(__lcpp_x, __lcpp_y); + return ::copysign(__x, __y); #endif } #if __has_builtin(__builtin_copysignl) _LIBCPP_CONSTEXPR #endif -inline _LIBCPP_INLINE_VISIBILITY long double __libcpp_copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT { +inline _LIBCPP_HIDE_FROM_ABI long double __libcpp_copysign(long double __x, long double __y) _NOEXCEPT { #if __has_builtin(__builtin_copysignl) - return __builtin_copysignl(__lcpp_x, __lcpp_y); + return __builtin_copysignl(__x, __y); #else - return ::copysignl(__lcpp_x, __lcpp_y); + return ::copysignl(__x, __y); #endif } @@ -1158,126 +1186,136 @@ #if __has_builtin(__builtin_copysign) _LIBCPP_CONSTEXPR #endif -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -__libcpp_copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT { +__libcpp_copysign(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); #if __has_builtin(__builtin_copysign) - return __builtin_copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return __builtin_copysign((__result_type)__x, (__result_type)__y); #else - return ::copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::copysign((__result_type)__x, (__result_type)__y); #endif } -inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x, float __lcpp_y) _NOEXCEPT { - return ::__libcpp_copysign(__lcpp_x, __lcpp_y); +inline _LIBCPP_HIDE_FROM_ABI float copysign(float __x, float __y) _NOEXCEPT { + return std::__libcpp_copysign(__x, __y); } -inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT { - return ::__libcpp_copysign(__lcpp_x, __lcpp_y); +using ::copysign _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long double copysign(long double __x, long double __y) _NOEXCEPT { + return std::__libcpp_copysign(__x, __y); } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type - copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT { - return ::__libcpp_copysign(__lcpp_x, __lcpp_y); + copysign(_A1 __x, _A2 __y) _NOEXCEPT { + return std::__libcpp_copysign(__x, __y); } // erf -inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return ::erff(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return ::erfl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float erf(float __x) _NOEXCEPT {return ::erff(__x);} +using ::erf _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double erf(long double __x) _NOEXCEPT {return ::erfl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -erf(_A1 __lcpp_x) _NOEXCEPT {return ::erf((double)__lcpp_x);} +erf(_A1 __x) _NOEXCEPT {return ::erf((double)__x);} // erfc -inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return ::erfcf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return ::erfcl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float erfc(float __x) _NOEXCEPT {return ::erfcf(__x);} +using ::erfc _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double erfc(long double __x) _NOEXCEPT {return ::erfcl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -erfc(_A1 __lcpp_x) _NOEXCEPT {return ::erfc((double)__lcpp_x);} +erfc(_A1 __x) _NOEXCEPT {return ::erfc((double)__x);} // exp2 -inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return ::exp2f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return ::exp2l(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float exp2(float __x) _NOEXCEPT {return ::exp2f(__x);} +using ::exp2 _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double exp2(long double __x) _NOEXCEPT {return ::exp2l(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -exp2(_A1 __lcpp_x) _NOEXCEPT {return ::exp2((double)__lcpp_x);} +exp2(_A1 __x) _NOEXCEPT {return ::exp2((double)__x);} // expm1 -inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return ::expm1f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return ::expm1l(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float expm1(float __x) _NOEXCEPT {return ::expm1f(__x);} +using ::expm1 _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double expm1(long double __x) _NOEXCEPT {return ::expm1l(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -expm1(_A1 __lcpp_x) _NOEXCEPT {return ::expm1((double)__lcpp_x);} +expm1(_A1 __x) _NOEXCEPT {return ::expm1((double)__x);} // fdim -inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fdimf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fdiml(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float fdim(float __x, float __y) _NOEXCEPT {return ::fdimf(__x, __y);} +using ::fdim _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double fdim(long double __x, long double __y) _NOEXCEPT {return ::fdiml(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +fdim(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::fdim((__result_type)__x, (__result_type)__y); } // fma -inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI float fma(float __x, float __y, float __z) _NOEXCEPT { #if __has_builtin(__builtin_fmaf) - return __builtin_fmaf(__lcpp_x, __lcpp_y, __lcpp_z); + return __builtin_fmaf(__x, __y, __z); #else - return ::fmaf(__lcpp_x, __lcpp_y, __lcpp_z); + return ::fmaf(__x, __y, __z); #endif } -inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT + +using ::fma _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long double fma(long double __x, long double __y, long double __z) _NOEXCEPT { #if __has_builtin(__builtin_fmal) - return __builtin_fmal(__lcpp_x, __lcpp_y, __lcpp_z); + return __builtin_fmal(__x, __y, __z); #else - return ::fmal(__lcpp_x, __lcpp_y, __lcpp_z); + return ::fmal(__x, __y, __z); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && @@ -1285,253 +1323,273 @@ std::is_arithmetic<_A3>::value, std::__promote<_A1, _A2, _A3> >::type -fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT +fma(_A1 __x, _A2 __y, _A3 __z) _NOEXCEPT { typedef typename std::__promote<_A1, _A2, _A3>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value && std::_IsSame<_A3, __result_type>::value)), ""); #if __has_builtin(__builtin_fma) - return __builtin_fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z); + return __builtin_fma((__result_type)__x, (__result_type)__y, (__result_type)__z); #else - return ::fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z); + return ::fma((__result_type)__x, (__result_type)__y, (__result_type)__z); #endif } // fmax -inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fmaxf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmaxl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float fmax(float __x, float __y) _NOEXCEPT {return ::fmaxf(__x, __y);} +using ::fmax _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double fmax(long double __x, long double __y) _NOEXCEPT {return ::fmaxl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +fmax(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::fmax((__result_type)__x, (__result_type)__y); } // fmin -inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::fminf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fminl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float fmin(float __x, float __y) _NOEXCEPT {return ::fminf(__x, __y);} +using ::fmin _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double fmin(long double __x, long double __y) _NOEXCEPT {return ::fminl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +fmin(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::fmin((__result_type)__x, (__result_type)__y); } // hypot -inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::hypotf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::hypotl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y) _NOEXCEPT {return ::hypotf(__x, __y);} +using ::hypot _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y) _NOEXCEPT {return ::hypotl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +hypot(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::hypot((__result_type)__x, (__result_type)__y); } // ilogb -inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ::ilogbf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ::ilogbl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __x) _NOEXCEPT {return ::ilogbf(__x);} +using ::ilogb _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI int ilogb(long double __x) _NOEXCEPT {return ::ilogbl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, int>::type -ilogb(_A1 __lcpp_x) _NOEXCEPT {return ::ilogb((double)__lcpp_x);} +ilogb(_A1 __x) _NOEXCEPT {return ::ilogb((double)__x);} // lgamma -inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return ::lgammaf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return ::lgammal(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float lgamma(float __x) _NOEXCEPT {return ::lgammaf(__x);} +using ::lgamma _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double lgamma(long double __x) _NOEXCEPT {return ::lgammal(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -lgamma(_A1 __lcpp_x) _NOEXCEPT {return ::lgamma((double)__lcpp_x);} +lgamma(_A1 __x) _NOEXCEPT {return ::lgamma((double)__x);} // llrint -inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI long long llrint(float __x) _NOEXCEPT { #if __has_builtin(__builtin_llrintf) - return __builtin_llrintf(__lcpp_x); + return __builtin_llrintf(__x); #else - return ::llrintf(__lcpp_x); + return ::llrintf(__x); #endif } -inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT + +using ::llrint _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long long llrint(long double __x) _NOEXCEPT { #if __has_builtin(__builtin_llrintl) - return __builtin_llrintl(__lcpp_x); + return __builtin_llrintl(__x); #else - return ::llrintl(__lcpp_x); + return ::llrintl(__x); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, long long>::type -llrint(_A1 __lcpp_x) _NOEXCEPT +llrint(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_llrint) - return __builtin_llrint((double)__lcpp_x); + return __builtin_llrint((double)__x); #else - return ::llrint((double)__lcpp_x); + return ::llrint((double)__x); #endif } // llround -inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI long long llround(float __x) _NOEXCEPT { #if __has_builtin(__builtin_llroundf) - return __builtin_llroundf(__lcpp_x); + return __builtin_llroundf(__x); #else - return ::llroundf(__lcpp_x); + return ::llroundf(__x); #endif } -inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT + +using ::llround _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long long llround(long double __x) _NOEXCEPT { #if __has_builtin(__builtin_llroundl) - return __builtin_llroundl(__lcpp_x); + return __builtin_llroundl(__x); #else - return ::llroundl(__lcpp_x); + return ::llroundl(__x); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, long long>::type -llround(_A1 __lcpp_x) _NOEXCEPT +llround(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_llround) - return __builtin_llround((double)__lcpp_x); + return __builtin_llround((double)__x); #else - return ::llround((double)__lcpp_x); + return ::llround((double)__x); #endif } // log1p -inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return ::log1pf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return ::log1pl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float log1p(float __x) _NOEXCEPT {return ::log1pf(__x);} +using ::log1p _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double log1p(long double __x) _NOEXCEPT {return ::log1pl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -log1p(_A1 __lcpp_x) _NOEXCEPT {return ::log1p((double)__lcpp_x);} +log1p(_A1 __x) _NOEXCEPT {return ::log1p((double)__x);} // log2 -inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return ::log2f(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return ::log2l(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float log2(float __x) _NOEXCEPT {return ::log2f(__x);} +using ::log2 _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double log2(long double __x) _NOEXCEPT {return ::log2l(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -log2(_A1 __lcpp_x) _NOEXCEPT {return ::log2((double)__lcpp_x);} +log2(_A1 __x) _NOEXCEPT {return ::log2((double)__x);} // logb -inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return ::logbf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return ::logbl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float logb(float __x) _NOEXCEPT {return ::logbf(__x);} +using ::logb _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double logb(long double __x) _NOEXCEPT {return ::logbl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -logb(_A1 __lcpp_x) _NOEXCEPT {return ::logb((double)__lcpp_x);} +logb(_A1 __x) _NOEXCEPT {return ::logb((double)__x);} // lrint -inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI long lrint(float __x) _NOEXCEPT { #if __has_builtin(__builtin_lrintf) - return __builtin_lrintf(__lcpp_x); + return __builtin_lrintf(__x); #else - return ::lrintf(__lcpp_x); + return ::lrintf(__x); #endif } -inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT + +using ::lrint _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long lrint(long double __x) _NOEXCEPT { #if __has_builtin(__builtin_lrintl) - return __builtin_lrintl(__lcpp_x); + return __builtin_lrintl(__x); #else - return ::lrintl(__lcpp_x); + return ::lrintl(__x); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, long>::type -lrint(_A1 __lcpp_x) _NOEXCEPT +lrint(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_lrint) - return __builtin_lrint((double)__lcpp_x); + return __builtin_lrint((double)__x); #else - return ::lrint((double)__lcpp_x); + return ::lrint((double)__x); #endif } // lround -inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI long lround(float __x) _NOEXCEPT { #if __has_builtin(__builtin_lroundf) - return __builtin_lroundf(__lcpp_x); + return __builtin_lroundf(__x); #else - return ::lroundf(__lcpp_x); + return ::lroundf(__x); #endif } -inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT + +using ::lround _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long lround(long double __x) _NOEXCEPT { #if __has_builtin(__builtin_lroundl) - return __builtin_lroundl(__lcpp_x); + return __builtin_lroundl(__x); #else - return ::lroundl(__lcpp_x); + return ::lroundl(__x); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, long>::type -lround(_A1 __lcpp_x) _NOEXCEPT +lround(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_lround) - return __builtin_lround((double)__lcpp_x); + return __builtin_lround((double)__x); #else - return ::lround((double)__lcpp_x); + return ::lround((double)__x); #endif } @@ -1539,210 +1597,314 @@ // nearbyint -inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return ::nearbyintf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return ::nearbyintl(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float nearbyint(float __x) _NOEXCEPT {return ::nearbyintf(__x);} +using ::nearbyint _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double nearbyint(long double __x) _NOEXCEPT {return ::nearbyintl(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -nearbyint(_A1 __lcpp_x) _NOEXCEPT {return ::nearbyint((double)__lcpp_x);} +nearbyint(_A1 __x) _NOEXCEPT {return ::nearbyint((double)__x);} // nextafter -inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::nextafterf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nextafterl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float nextafter(float __x, float __y) _NOEXCEPT {return ::nextafterf(__x, __y);} +using ::nextafter _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double nextafter(long double __x, long double __y) _NOEXCEPT {return ::nextafterl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +nextafter(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::nextafter((__result_type)__x, (__result_type)__y); } // nexttoward -inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float nexttoward(float __x, long double __y) _NOEXCEPT {return ::nexttowardf(__x, __y);} +using ::nexttoward _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double nexttoward(long double __x, long double __y) _NOEXCEPT {return ::nexttowardl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttoward((double)__lcpp_x, __lcpp_y);} +nexttoward(_A1 __x, long double __y) _NOEXCEPT {return ::nexttoward((double)__x, __y);} // remainder -inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return ::remainderf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::remainderl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float remainder(float __x, float __y) _NOEXCEPT {return ::remainderf(__x, __y);} +using ::remainder _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double remainder(long double __x, long double __y) _NOEXCEPT {return ::remainderl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT +remainder(_A1 __x, _A2 __y) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y); + return ::remainder((__result_type)__x, (__result_type)__y); } // remquo -inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquof(__lcpp_x, __lcpp_y, __lcpp_z);} -inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquol(__lcpp_x, __lcpp_y, __lcpp_z);} +inline _LIBCPP_HIDE_FROM_ABI float remquo(float __x, float __y, int* __z) _NOEXCEPT {return ::remquof(__x, __y, __z);} +using ::remquo _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {return ::remquol(__x, __y, __z);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::__enable_if_t < std::is_arithmetic<_A1>::value && std::is_arithmetic<_A2>::value, std::__promote<_A1, _A2> >::type -remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT +remquo(_A1 __x, _A2 __y, int* __z) _NOEXCEPT { typedef typename std::__promote<_A1, _A2>::type __result_type; static_assert((!(std::_IsSame<_A1, __result_type>::value && std::_IsSame<_A2, __result_type>::value)), ""); - return ::remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z); + return ::remquo((__result_type)__x, (__result_type)__y, __z); } // rint -inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI float rint(float __x) _NOEXCEPT { #if __has_builtin(__builtin_rintf) - return __builtin_rintf(__lcpp_x); + return __builtin_rintf(__x); #else - return ::rintf(__lcpp_x); + return ::rintf(__x); #endif } -inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT + +using ::rint _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long double rint(long double __x) _NOEXCEPT { #if __has_builtin(__builtin_rintl) - return __builtin_rintl(__lcpp_x); + return __builtin_rintl(__x); #else - return ::rintl(__lcpp_x); + return ::rintl(__x); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -rint(_A1 __lcpp_x) _NOEXCEPT +rint(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_rint) - return __builtin_rint((double)__lcpp_x); + return __builtin_rint((double)__x); #else - return ::rint((double)__lcpp_x); + return ::rint((double)__x); #endif } // round -inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI float round(float __x) _NOEXCEPT { #if __has_builtin(__builtin_round) - return __builtin_round(__lcpp_x); + return __builtin_round(__x); #else - return ::round(__lcpp_x); + return ::round(__x); #endif } -inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT + +using ::round _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long double round(long double __x) _NOEXCEPT { #if __has_builtin(__builtin_roundl) - return __builtin_roundl(__lcpp_x); + return __builtin_roundl(__x); #else - return ::roundl(__lcpp_x); + return ::roundl(__x); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -round(_A1 __lcpp_x) _NOEXCEPT +round(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_round) - return __builtin_round((double)__lcpp_x); + return __builtin_round((double)__x); #else - return ::round((double)__lcpp_x); + return ::round((double)__x); #endif } // scalbln -inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float scalbln(float __x, long __y) _NOEXCEPT {return ::scalblnf(__x, __y);} +using ::scalbln _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double scalbln(long double __x, long __y) _NOEXCEPT {return ::scalblnl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalbln((double)__lcpp_x, __lcpp_y);} +scalbln(_A1 __x, long __y) _NOEXCEPT {return ::scalbln((double)__x, __y);} // scalbn -inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnf(__lcpp_x, __lcpp_y);} -inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnl(__lcpp_x, __lcpp_y);} +inline _LIBCPP_HIDE_FROM_ABI float scalbn(float __x, int __y) _NOEXCEPT {return ::scalbnf(__x, __y);} +using ::scalbn _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double scalbn(long double __x, int __y) _NOEXCEPT {return ::scalbnl(__x, __y);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbn((double)__lcpp_x, __lcpp_y);} +scalbn(_A1 __x, int __y) _NOEXCEPT {return ::scalbn((double)__x, __y);} // tgamma -inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return ::tgammaf(__lcpp_x);} -inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return ::tgammal(__lcpp_x);} +inline _LIBCPP_HIDE_FROM_ABI float tgamma(float __x) _NOEXCEPT {return ::tgammaf(__x);} +using ::tgamma _LIBCPP_USING_IF_EXISTS; +inline _LIBCPP_HIDE_FROM_ABI long double tgamma(long double __x) _NOEXCEPT {return ::tgammal(__x);} template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -tgamma(_A1 __lcpp_x) _NOEXCEPT {return ::tgamma((double)__lcpp_x);} +tgamma(_A1 __x) _NOEXCEPT {return ::tgamma((double)__x);} // trunc -inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT +inline _LIBCPP_HIDE_FROM_ABI float trunc(float __x) _NOEXCEPT { #if __has_builtin(__builtin_trunc) - return __builtin_trunc(__lcpp_x); + return __builtin_trunc(__x); #else - return ::trunc(__lcpp_x); + return ::trunc(__x); #endif } -inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT + +using ::trunc _LIBCPP_USING_IF_EXISTS; + +inline _LIBCPP_HIDE_FROM_ABI long double trunc(long double __x) _NOEXCEPT { #if __has_builtin(__builtin_truncl) - return __builtin_truncl(__lcpp_x); + return __builtin_truncl(__x); #else - return ::truncl(__lcpp_x); + return ::truncl(__x); #endif } template -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_HIDE_FROM_ABI typename std::enable_if::value, double>::type -trunc(_A1 __lcpp_x) _NOEXCEPT +trunc(_A1 __x) _NOEXCEPT { #if __has_builtin(__builtin_trunc) - return __builtin_trunc((double)__lcpp_x); + return __builtin_trunc((double)__x); #else - return ::trunc((double)__lcpp_x); + return ::trunc((double)__x); #endif } +_LIBCPP_END_NAMESPACE_STD + +using std::signbit; +using std::fpclassify; +using std::isfinite; +using std::isinf; +using std::isnan; +using std::isnormal; +using std::isgreater; +using std::isgreaterequal; +using std::isless; +using std::islessequal; +using std::islessgreater; +using std::isunordered; +using std::isunordered; + +using std::acos; +using std::asin; +using std::atan; +using std::atan2; +using std::ceil; +using std::cos; +using std::cosh; + +using std::exp; + +using std::fabs; +using std::floor; + +using std::fmod; + +using std::frexp; +using std::ldexp; + +using std::log; + +using std::log10; +using std::modf; + +using std::pow; + +using std::sin; +using std::sinh; + +using std::sqrt; +using std::tan; + +using std::tanh; + +using std::acosh; +using std::asinh; +using std::atanh; +using std::cbrt; + +using std::copysign; + +using std::erf; +using std::erfc; +using std::exp2; +using std::expm1; +using std::fdim; +using std::fma; +using std::fmax; +using std::fmin; +using std::hypot; +using std::ilogb; +using std::lgamma; +using std::llrint; +using std::llround; +using std::log1p; +using std::log2; +using std::logb; +using std::lrint; +using std::lround; + +using std::nearbyint; +using std::nextafter; +using std::nexttoward; +using std::remainder; +using std::remquo; +using std::rint; +using std::round; +using std::scalbln; +using std::scalbn; +using std::tgamma; +using std::trunc; + } // extern "C++" #endif // __cplusplus