[libc++] Move functions in math.h into the versioned namespace

[philnik]

• Fix CI

[philnik]

Rebased

[ldionne]

Including <math.h> should not define functions in namespace std. Users should be required to use <cmath> in order to get that behavior. Otherwise, this is a portability trap (https://godbolt.org/z/434zs4zz3).

If you think that's necessary for constexpr cmath, I'd like to understand why.

Also, let's coordinate with D134938 to find a single way forward and avoid duplicate work.

libcxx/include/cmath

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _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;
 using ::asinl _LIBCPP_USING_IF_EXISTS;
 using ::atanl _LIBCPP_USING_IF_EXISTS;
 using ::atan2l _LIBCPP_USING_IF_EXISTS;
 using ::ceill _LIBCPP_USING_IF_EXISTS;
 using ::cosl _LIBCPP_USING_IF_EXISTS;

libcxx/include/math.h

 // back to C++ linkage before including these C++ headers.
 extern "C++" {
 
 #include <__type_traits/promote.h>
 #include <limits>
 #include <stdlib.h>
 #include <type_traits>
 
+_LIBCPP_BEGIN_NAMESPACE_STD
+
 // signbit
 
 #ifdef signbit
 
 template <class _A1>
 _LIBCPP_HIDE_FROM_ABI
 bool
 __libcpp_signbit(_A1 __x) _NOEXCEPT

 // div
 //
 // handled in stdlib.h
 
 // acos
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 acos(_A1 __x) _NOEXCEPT {return ::acos((double)__x);}
 
 // asin
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 asin(_A1 __x) _NOEXCEPT {return ::asin((double)__x);}
 
 // atan
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 atan(_A1 __x) _NOEXCEPT {return ::atan((double)__x);}
 
 // atan2
 
 #    if !defined(__sun__)
 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 <class _A1, class _A2>
 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 __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)__y, (__result_type)__x);
 }
 
 // ceil
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 ceil(_A1 __x) _NOEXCEPT {return ::ceil((double)__x);}
 
 // cos
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 cos(_A1 __x) _NOEXCEPT {return ::cos((double)__x);}
 
 // cosh
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 cosh(_A1 __x) _NOEXCEPT {return ::cosh((double)__x);}
 
 // exp
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 exp(_A1 __x) _NOEXCEPT {return ::exp((double)__x);}
 
 // fabs
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 fabs(_A1 __x) _NOEXCEPT {return ::fabs((double)__x);}
 
 // floor
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 floor(_A1 __x) _NOEXCEPT {return ::floor((double)__x);}
 
 // fmod
 
 #    if !defined(__sun__)
 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 <class _A1, class _A2>
 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 __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)__x, (__result_type)__y);
 }
 
 // frexp
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 frexp(_A1 __x, int* __e) _NOEXCEPT {return ::frexp((double)__x, __e);}
 
 // ldexp
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 ldexp(_A1 __x, int __e) _NOEXCEPT {return ::ldexp((double)__x, __e);}
 
 // log
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 log(_A1 __x) _NOEXCEPT {return ::log((double)__x);}
 
 // log10
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 log10(_A1 __x) _NOEXCEPT {return ::log10((double)__x);}
 
 // modf
 
 #    if !defined(__sun__)
 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_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 <class _A1, class _A2>
 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 __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)__x, (__result_type)__y);
 }
 
 // sin
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 sin(_A1 __x) _NOEXCEPT {return ::sin((double)__x);}
 
 // sinh
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 sinh(_A1 __x) _NOEXCEPT {return ::sinh((double)__x);}
 
 // sqrt
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 sqrt(_A1 __x) _NOEXCEPT {return ::sqrt((double)__x);}
 
 // tan
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 tan(_A1 __x) _NOEXCEPT {return ::tan((double)__x);}
 
 // tanh
 
 #    if !defined(__sun__)
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 tanh(_A1 __x) _NOEXCEPT {return ::tanh((double)__x);}
 
 // acosh
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 acosh(_A1 __x) _NOEXCEPT {return ::acosh((double)__x);}
 
 // asinh
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 asinh(_A1 __x) _NOEXCEPT {return ::asinh((double)__x);}
 
 // atanh
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 atanh(_A1 __x) _NOEXCEPT {return ::atanh((double)__x);}
 
 // cbrt
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 cbrt(_A1 __x) _NOEXCEPT {return ::cbrt((double)__x);}
 
 // copysign

 #if __has_builtin(__builtin_copysign)
     return __builtin_copysign((__result_type)__x, (__result_type)__y);
 #else
     return ::copysign((__result_type)__x, (__result_type)__y);
 #endif
 }
 
 inline _LIBCPP_HIDE_FROM_ABI float copysign(float __x, float __y) _NOEXCEPT {
-  return ::__libcpp_copysign(__x, __y);
+  return std::__libcpp_copysign(__x, __y);
 }
 
+using ::copysign _LIBCPP_USING_IF_EXISTS;
+
 inline _LIBCPP_HIDE_FROM_ABI long double copysign(long double __x, long double __y) _NOEXCEPT {
-  return ::__libcpp_copysign(__x, __y);
+  return std::__libcpp_copysign(__x, __y);
 }
 
 template <class _A1, class _A2>
 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 __x, _A2 __y) _NOEXCEPT {
-  return ::__libcpp_copysign(__x, __y);
+  return std::__libcpp_copysign(__x, __y);
 }
 
 // erf
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 erf(_A1 __x) _NOEXCEPT {return ::erf((double)__x);}
 
 // erfc
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 erfc(_A1 __x) _NOEXCEPT {return ::erfc((double)__x);}
 
 // exp2
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 exp2(_A1 __x) _NOEXCEPT {return ::exp2((double)__x);}
 
 // expm1
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 expm1(_A1 __x) _NOEXCEPT {return ::expm1((double)__x);}
 
 // fdim
 
 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 <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::__enable_if_t
 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,

 inline _LIBCPP_HIDE_FROM_ABI float       fma(float __x, float __y, float __z) _NOEXCEPT
 {
 #if __has_builtin(__builtin_fmaf)
     return __builtin_fmaf(__x, __y, __z);
 #else
     return ::fmaf(__x, __y, __z);
 #endif
 }
+
+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(__x, __y, __z);
 #else
     return ::fmal(__x, __y, __z);
 #endif
 }

 #else
     return ::fma((__result_type)__x, (__result_type)__y, (__result_type)__z);
 #endif
 }
 
 // fmax
 
 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 <class _A1, class _A2>
 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 __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)__x, (__result_type)__y);
 }
 
 // fmin
 
 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 <class _A1, class _A2>
 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 __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)__x, (__result_type)__y);
 }
 
 // hypot
 
 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 <class _A1, class _A2>
 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 __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)__x, (__result_type)__y);
 }
 
 // ilogb
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, int>::type
 ilogb(_A1 __x) _NOEXCEPT {return ::ilogb((double)__x);}
 
 // lgamma
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 lgamma(_A1 __x) _NOEXCEPT {return ::lgamma((double)__x);}
 
 // llrint
 
 inline _LIBCPP_HIDE_FROM_ABI long long llrint(float __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_llrintf)
     return __builtin_llrintf(__x);
 #else
     return ::llrintf(__x);
 #endif
 }
+
+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(__x);
 #else
     return ::llrintl(__x);
 #endif
 }

 inline _LIBCPP_HIDE_FROM_ABI long long llround(float __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_llroundf)
     return __builtin_llroundf(__x);
 #else
     return ::llroundf(__x);
 #endif
 }
+
+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(__x);
 #else
     return ::llroundl(__x);
 #endif
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, long long>::type
 llround(_A1 __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_llround)
     return __builtin_llround((double)__x);
 #else
     return ::llround((double)__x);
 #endif
 }
 
 // log1p
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 log1p(_A1 __x) _NOEXCEPT {return ::log1p((double)__x);}
 
 // log2
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 log2(_A1 __x) _NOEXCEPT {return ::log2((double)__x);}
 
 // logb
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 logb(_A1 __x) _NOEXCEPT {return ::logb((double)__x);}
 
 // lrint
 
 inline _LIBCPP_HIDE_FROM_ABI long lrint(float __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_lrintf)
     return __builtin_lrintf(__x);
 #else
     return ::lrintf(__x);
 #endif
 }
+
+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(__x);
 #else
     return ::lrintl(__x);
 #endif
 }

 inline _LIBCPP_HIDE_FROM_ABI long lround(float __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_lroundf)
     return __builtin_lroundf(__x);
 #else
     return ::lroundf(__x);
 #endif
 }
+
+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(__x);
 #else
     return ::lroundl(__x);
 #endif
 }

 #endif
 }
 
 // nan
 
 // nearbyint
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 nearbyint(_A1 __x) _NOEXCEPT {return ::nearbyint((double)__x);}
 
 // nextafter
 
 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 <class _A1, class _A2>
 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 __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)__x, (__result_type)__y);
 }
 
 // nexttoward
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 nexttoward(_A1 __x, long double __y) _NOEXCEPT {return ::nexttoward((double)__x, __y);}
 
 // remainder
 
 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 <class _A1, class _A2>
 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 __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)__x, (__result_type)__y);
 }
 
 // remquo
 
 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 <class _A1, class _A2>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::__enable_if_t
 <
     std::is_arithmetic<_A1>::value &&
     std::is_arithmetic<_A2>::value,

 inline _LIBCPP_HIDE_FROM_ABI float       rint(float __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_rintf)
     return __builtin_rintf(__x);
 #else
     return ::rintf(__x);
 #endif
 }
+
+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(__x);
 #else
     return ::rintl(__x);
 #endif
 }

 inline _LIBCPP_HIDE_FROM_ABI float       round(float __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_round)
     return __builtin_round(__x);
 #else
     return ::round(__x);
 #endif
 }
+
+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(__x);
 #else
     return ::roundl(__x);
 #endif
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 round(_A1 __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_round)
     return __builtin_round((double)__x);
 #else
     return ::round((double)__x);
 #endif
 }
 
 // scalbln
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 scalbln(_A1 __x, long __y) _NOEXCEPT {return ::scalbln((double)__x, __y);}
 
 // scalbn
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 scalbn(_A1 __x, int __y) _NOEXCEPT {return ::scalbn((double)__x, __y);}
 
 // tgamma
 
 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 <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 tgamma(_A1 __x) _NOEXCEPT {return ::tgamma((double)__x);}
 
 // trunc
 
 inline _LIBCPP_HIDE_FROM_ABI float       trunc(float __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_trunc)
     return __builtin_trunc(__x);
 #else
     return ::trunc(__x);
 #endif
 }
+
+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(__x);
 #else
     return ::truncl(__x);
 #endif
 }
 
 template <class _A1>
 inline _LIBCPP_HIDE_FROM_ABI
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 trunc(_A1 __x) _NOEXCEPT
 {
 #if __has_builtin(__builtin_trunc)
     return __builtin_trunc((double)__x);
 #else
     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
 
 #else // _LIBCPP_MATH_H
 
 // This include lives outside the header guard in order to support an MSVC
 // extension which allows users to do: