[libc++] Rewrite <cmath>

[philnik]

Summary

The <cmath> implementation has a few things that I wanted to change. I originally planned to do them one at a time, but noticed that the changes essentially amount to a rewrite of the header, so I did that instead.

Specifically the changes are:

• Replacing _LIBCPP_INLINE_VISIBILITY with _LIBCPP_HIDE_FROM_ABI
• Moving the enable_ifs from the return type to a defaulted template parameter
• Removing the libcpp prefix on the argument names
• Granularizing the header
• Moving the functions into the versioned namespace
• Using builtins for the math functions

The libcpp prefix has been added for compatibility with newlib in D5080, but I think we can remove the workaround. We use __x elsewhere and newlib doesn't use __x in it's implementation since 2015 for GCC 2.97 and later. I think even older newlibs shouldn't be affected, since we don't rely on the macros from the libc with this patch.

The main functional change here is switching to builtins for all functions. This has multiple benefits:

• We can provide the full overload set of all functions without having to include the libc math.h
• We can support <cmath> during constant evaluation, even on platforms which don't have the functions implemented (once P0533R9 is implemented)
• Platforms with an incomplete implementation of math.h can use libc++ (there will be a link-time error if the functions are used instead of a compile-time error when trying to build libc++)

The main disadvantage of this patch is that it adds a double overload for all functions, but I think this is outweighed by the benefits, especially since the overloads are all just forwarding to __builtin_<function name>.

[philnik]

• Generate files

[philnik]

• try to fix CI

[philnik]

Rewrite the rest of math.h

[philnik]

• Try to fix CI

[philnik]

• Try to fix CI

[philnik]

• Fix tests

[philnik]

• Try to fix CI

[ldionne]

libcxx/include/__cmath/angular_functions.h

2

This change needs to be split into multiple patches that can be reviewed and validated on their own, especially since cmath and math.h interact with the C library, which makes them even more tricky. You already outlined in your commit message all the different things that this patch does, and I think each of them can be a separate patch. I know this is more work, but I think it's the only way to land this.

libcxx/include/CMakeLists.txt

set(files
   __chrono/steady_clock.h
   __chrono/system_clock.h
   __chrono/time_point.h
   __chrono/weekday.h
   __chrono/year.h
   __chrono/year_month.h
   __chrono/year_month_day.h
   __chrono/year_month_weekday.h
+  __cmath/angular_functions.h
+  __cmath/arithmetic.h
+  __cmath/compare.h
+  __cmath/copysign.h
+  __cmath/fabs.h
+  __cmath/fdim.h
+  __cmath/fminmax.h
+  __cmath/frexp.h
+  __cmath/logarithm.h
+  __cmath/modf.h
+  __cmath/nextafter.h
+  __cmath/nexttoward.h
+  __cmath/remainder.h
+  __cmath/remquo.h
+  __cmath/rounding.h
+  __cmath/signbit.h
+  __cmath/tgamma.h
+  __cmath/traits.h
   __compare/common_comparison_category.h
   __compare/compare_partial_order_fallback.h
   __compare/compare_strong_order_fallback.h
   __compare/compare_three_way.h
   __compare/compare_three_way_result.h
   __compare/compare_weak_order_fallback.h
   __compare/is_eq.h
   __compare/ordering.h

libcxx/include/__cmath/angular_functions.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_ANGULAR_FUNCTIONS_H
+#define _LIBCPP___CMATH_ANGULAR_FUNCTIONS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float acos(float __v) _NOEXCEPT { return __builtin_acosf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double acos(double __v) _NOEXCEPT {
+  return __builtin_acos(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double acos(long double __v) _NOEXCEPT { return __builtin_acosl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double acos(_Tp __v) _NOEXCEPT {
+  return __builtin_acos(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float asin(float __v) _NOEXCEPT { return __builtin_asinf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double asin(double __v) _NOEXCEPT {
+  return __builtin_asin(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double asin(long double __v) _NOEXCEPT { return __builtin_asinl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double asin(_Tp __v) _NOEXCEPT {
+  return __builtin_asin(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float atan(float __v) _NOEXCEPT { return __builtin_atanf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double atan(double __v) _NOEXCEPT {
+  return __builtin_atan(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double atan(long double __v) _NOEXCEPT { return __builtin_atanl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double atan(_Tp __v) {
+  return __builtin_atan(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float atan2(float __y, float __x) _NOEXCEPT { return __builtin_atan2f(__y, __x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double atan2(double __y, double __x) _NOEXCEPT {
+  return __builtin_atan2(__y, __x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double atan2(long double __y, long double __x) _NOEXCEPT {
+  return __builtin_atan2l(__y, __x);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type atan2(_Tp __y, _Up __x) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::atan2(static_cast<__result_type>(__y), static_cast<__result_type>(__x));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float cos(float __v) _NOEXCEPT { return __builtin_cosf(__v); }
+
+template <class = int>
+inline _LIBCPP_HIDE_FROM_ABI double cos(double __v) _NOEXCEPT {
+  return __builtin_cos(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double cos(long double __v) _NOEXCEPT { return __builtin_cosl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double cos(_Tp __v) _NOEXCEPT {
+  return __builtin_cos(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float cosh(float __v) _NOEXCEPT { return __builtin_coshf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double cosh(double __v) _NOEXCEPT {
+  return __builtin_cosh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double cosh(long double __v) _NOEXCEPT { return __builtin_coshl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double cosh(_Tp __v) _NOEXCEPT {
+  return __builtin_cosh(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float sin(float __v) _NOEXCEPT { return __builtin_sinf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double sin(double __v) _NOEXCEPT {
+  return __builtin_sin(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double sin(long double __v) _NOEXCEPT { return __builtin_sinl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double sin(_Tp __v) _NOEXCEPT {
+  return __builtin_sin(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float sinh(float __v) _NOEXCEPT { return __builtin_sinhf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double sinh(double __v) _NOEXCEPT {
+  return __builtin_sinh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double sinh(long double __v) _NOEXCEPT { return __builtin_sinhl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double sinh(_Tp __v) _NOEXCEPT {
+  return __builtin_sinh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float tan(float __v) _NOEXCEPT { return __builtin_tanf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double tan(double __v) _NOEXCEPT {
+  return __builtin_tan(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double tan(long double __v) _NOEXCEPT { return __builtin_tanl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double tan(_Tp __v) _NOEXCEPT {
+  return __builtin_tan(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float tanh(float __v) _NOEXCEPT { return __builtin_tanhf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double tanh(double __v) _NOEXCEPT {
+  return __builtin_tanh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double tanh(long double __v) _NOEXCEPT { return __builtin_tanhl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double tanh(_Tp __v) _NOEXCEPT {
+  return __builtin_tanh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float acosh(float __v) _NOEXCEPT { return __builtin_acoshf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double acosh(double __v) _NOEXCEPT {
+  return __builtin_acosh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double acosh(long double __v) _NOEXCEPT { return __builtin_acoshl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double acosh(_Tp __v) _NOEXCEPT {
+  return __builtin_acosh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float asinh(float __v) _NOEXCEPT { return __builtin_asinhf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double asinh(double __v) _NOEXCEPT {
+  return __builtin_asinh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double asinh(long double __v) _NOEXCEPT { return __builtin_asinhl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double asinh(_Tp __v) _NOEXCEPT {
+  return __builtin_asinh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float atanh(float __v) _NOEXCEPT { return __builtin_atanhf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double atanh(double __v) _NOEXCEPT {
+  return __builtin_atanh(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double atanh(long double __v) _NOEXCEPT { return __builtin_atanhl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double atanh(_Tp __v) _NOEXCEPT {
+  return __builtin_atanh(__v);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::acos;
+using std::acosh;
+using std::asin;
+using std::asinh;
+using std::atan;
+using std::atan2;
+using std::atanh;
+using std::cos;
+using std::cosh;
+using std::sin;
+using std::sinh;
+using std::tan;
+using std::tanh;
+
+#endif // _LIBCPP___CMATH_ANGULAR_FUNCTIONS_H

libcxx/include/__cmath/arithmetic.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_ARITHMETIC_H
+#define _LIBCPP___CMATH_ARITHMETIC_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float exp(float __v) _NOEXCEPT { return __builtin_expf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double exp(double __v) _NOEXCEPT {
+  return __builtin_exp(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double exp(long double __v) _NOEXCEPT { return __builtin_expl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double exp(_Tp __v) _NOEXCEPT {
+  return __builtin_exp(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float fmod(float __x, float __y) _NOEXCEPT { return __builtin_fmodf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fmod(double __x, double __y) _NOEXCEPT {
+  return __builtin_fmod(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fmod(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fmodl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type fmod(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::fmod(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float ldexp(float __x, int __exp) _NOEXCEPT { return __builtin_ldexpf(__x, __exp); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double ldexp(double __x, int __exp) _NOEXCEPT {
+  return __builtin_ldexp(__x, __exp);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double ldexp(long double __x, int __exp) _NOEXCEPT {
+  return __builtin_ldexpl(__x, __exp);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double ldexp(_Tp __x, int __exp) _NOEXCEPT {
+  return __builtin_ldexp(static_cast<double>(__x), __exp);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float pow(float __x, float __y) _NOEXCEPT { return __builtin_powf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double pow(double __x, double __y) _NOEXCEPT {
+  return __builtin_pow(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double pow(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_powl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type pow(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::pow(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float sqrt(float __x) _NOEXCEPT { return __builtin_sqrtf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double sqrt(double __x) _NOEXCEPT {
+  return __builtin_sqrt(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double sqrt(long double __x) _NOEXCEPT { return __builtin_sqrtl(__x); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double sqrt(_Tp __v) _NOEXCEPT {
+  return __builtin_sqrt(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float cbrt(float __x) _NOEXCEPT { return __builtin_cbrtf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double cbrt(double __x) _NOEXCEPT {
+  return __builtin_cbrt(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double cbrt(long double __x) _NOEXCEPT { return __builtin_cbrtl(__x); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double cbrt(_Tp __v) _NOEXCEPT {
+  return __builtin_cbrt(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float exp2(float __v) _NOEXCEPT { return __builtin_exp2f(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double exp2(double __v) _NOEXCEPT {
+  return __builtin_exp2(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double exp2(long double __v) _NOEXCEPT { return __builtin_exp2l(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double exp2(_Tp __v) _NOEXCEPT {
+  return __builtin_exp2(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float expm1(float __v) _NOEXCEPT { return __builtin_expm1f(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double expm1(double __v) _NOEXCEPT {
+  return __builtin_expm1(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double expm1(long double __v) _NOEXCEPT { return __builtin_expm1l(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double expm1(_Tp __v) _NOEXCEPT {
+  return __builtin_expm1(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float erf(float __v) _NOEXCEPT { return __builtin_erff(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double erf(double __v) _NOEXCEPT {
+  return __builtin_erf(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double erf(long double __v) _NOEXCEPT { return __builtin_erfl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double erf(_Tp __v) _NOEXCEPT {
+  return __builtin_erf(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float erfc(float __v) _NOEXCEPT { return __builtin_erfcf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double erfc(double __v) _NOEXCEPT {
+  return __builtin_erfc(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double erfc(long double __v) _NOEXCEPT { return __builtin_erfcl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double erfc(_Tp __v) {
+  return __builtin_erfc(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float fma(float __x, float __y, float __z) _NOEXCEPT {
+  return __builtin_fmaf(__x, __y, __z);
+}
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fma(double __x, double __y, double __z) _NOEXCEPT {
+  return __builtin_fma(__x, __y, __z);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fma(long double __x, long double __y, long double __z) _NOEXCEPT {
+  return __builtin_fmal(__x, __y, __z);
+}
+
+template <class _T1,
+          class _T2,
+          class _T3,
+          __enable_if_t<is_arithmetic<_T1>::value && is_arithmetic<_T2>::value && is_arithmetic<_T3>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_T1, _T2, _T3>::type fma(_T1 __x, _T2 __y, _T3 __z) _NOEXCEPT {
+  using __result_type = typename __promote<_T1, _T2, _T3>::type;
+  return std::fma(static_cast<__result_type>(__x), static_cast<__result_type>(__y), static_cast<__result_type>(__z));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float hypot(float __x, float __y) _NOEXCEPT { return __builtin_hypotf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double hypot(double __x, double __y) _NOEXCEPT {
+  return __builtin_hypot(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double hypot(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_hypotl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type hypot(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::hypot(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float scalbln(float __x, long __exp) _NOEXCEPT { return __builtin_scalblnf(__x, __exp); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double scalbln(double __x, long __exp) _NOEXCEPT {
+  return __builtin_scalbln(__x, __exp);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double scalbln(long double __x, long __exp) _NOEXCEPT {
+  return __builtin_scalblnl(__x, __exp);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double scalbln(_Tp __v, long __exp) _NOEXCEPT {
+  return __builtin_scalbln(static_cast<double>(__v), __exp);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float scalbn(float __x, int __exp) _NOEXCEPT { return __builtin_scalbnf(__x, __exp); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double scalbn(double __x, int __exp) _NOEXCEPT {
+  return __builtin_scalbn(__x, __exp);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double scalbn(long double __x, int __exp) _NOEXCEPT {
+  return __builtin_scalbnl(__x, __exp);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double scalbn(_Tp __x, int __exp) _NOEXCEPT {
+  return __builtin_scalbn(static_cast<double>(__x), __exp);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::cbrt;
+using std::erf;
+using std::erfc;
+using std::exp;
+using std::exp2;
+using std::expm1;
+using std::fma;
+using std::fmod;
+using std::hypot;
+using std::ldexp;
+using std::pow;
+using std::scalbln;
+using std::scalbn;
+using std::sqrt;
+
+#endif // _LIBCPP___CMATH_ARITHMETIC_H

libcxx/include/__cmath/compare.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_COMPARE_H
+#define _LIBCPP___CMATH_COMPARE_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp,
+          class _Up,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isless(_Tp __lhs, _Up __rhs) _NOEXCEPT {
+  return __builtin_isless(__lhs, __rhs);
+}
+
+template <class _Tp,
+          class _Up,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool islessequal(_Tp __lhs, _Up __rhs) _NOEXCEPT {
+  return __builtin_islessequal(__lhs, __rhs);
+}
+
+template <class _Tp,
+          class _Up,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool islessgreater(_Tp __lhs, _Up __rhs) _NOEXCEPT {
+  return __builtin_islessgreater(__lhs, __rhs);
+}
+
+template <class _Tp,
+          class _Up,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isgreaterequal(_Tp __lhs, _Up __rhs) _NOEXCEPT {
+  return __builtin_isgreaterequal(__lhs, __rhs);
+}
+
+template <class _Tp,
+          class _Up,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isgreater(_Tp __lhs, _Up __rhs) _NOEXCEPT {
+  return __builtin_isgreater(__lhs, __rhs);
+}
+
+template <class _Tp,
+          class _Up,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isunordered(_Tp __lhs, _Up __rhs) _NOEXCEPT {
+  return __builtin_isunordered(__lhs, __rhs);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::isgreater;
+using std::isgreaterequal;
+using std::isless;
+using std::islessequal;
+using std::islessgreater;
+using std::isunordered;
+
+#endif // _LIBCPP___CMATH_COMPARE_H

libcxx/include/__cmath/copysign.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_COPYSIGN_H
+#define _LIBCPP___CMATH_COPYSIGN_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_INLINE_VISIBILITY float copysign(float __x, float __y) _NOEXCEPT {
+  return __builtin_copysignf(__x, __y);
+}
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double copysign(double __x, double __y) _NOEXCEPT {
+  return __builtin_copysign(__x, __y);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_copysignl(__x, __y);
+}
+
+template <class _Tp,
+          class _Up,
+          __enable_if_t< std::is_arithmetic<_Tp>::value && std::is_arithmetic<_Up>::value, int> = 0>
+inline _LIBCPP_INLINE_VISIBILITY typename __promote<_Tp, _Up>::type copysign(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::copysign(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::copysign;
+
+#endif // _LIBCPP___CMATH_COPYSIGN_H

libcxx/include/__cmath/fabs.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_FABS_H
+#define _LIBCPP___CMATH_FABS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float fabs(float __v) _NOEXCEPT { return __builtin_fabsf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fabs(double __v) _NOEXCEPT {
+  return __builtin_fabs(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fabs(long double __v) _NOEXCEPT { return __builtin_fabsl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double fabs(_Tp __v) _NOEXCEPT {
+  return __builtin_fabs(static_cast<double>(__v));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::fabs;
+
+#endif // _LIBCPP___CMATH_FABS_H

libcxx/include/__cmath/fdim.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_FDIM_H
+#define _LIBCPP___CMATH_FDIM_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float fdim(float __x, float __y) _NOEXCEPT { return __builtin_fdimf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fdim(double __x, double __y) _NOEXCEPT {
+  return __builtin_fdim(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fdim(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fdiml(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type fdim(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::fdim(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::fdim;
+
+#endif // _LIBCPP___CMATH_FDIM_H

libcxx/include/__cmath/fminmax.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_FMINMAX_H
+#define _LIBCPP___CMATH_FMINMAX_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float fmax(float __x, float __y) _NOEXCEPT { return __builtin_fmaxf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fmax(double __x, double __y) _NOEXCEPT {
+  return __builtin_fmax(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fmax(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fmaxl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type fmax(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::fmax(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float fmin(float __x, float __y) _NOEXCEPT { return __builtin_fminf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double fmin(double __x, double __y) _NOEXCEPT {
+  return __builtin_fmin(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double fmin(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_fminl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type fmin(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::fmin(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::fmax;
+using std::fmin;
+
+#endif // _LIBCPP___CMATH_FMINMAX_H

libcxx/include/__cmath/frexp.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_FREXP_H
+#define _LIBCPP___CMATH_FREXP_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float frexp(float __x, int* __exp) _NOEXCEPT { return __builtin_frexpf(__x, __exp); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double frexp(double __x, int* __exp) _NOEXCEPT {
+  return __builtin_frexp(__x, __exp);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double frexp(long double __x, int* __exp) _NOEXCEPT {
+  return __builtin_frexpl(__x, __exp);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double frexp(_Tp __x, int* __exp) _NOEXCEPT {
+  return __builtin_frexp(static_cast<double>(__x), __exp);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::frexp;
+
+#endif // _LIBCPP___CMATH_FREXP_H

libcxx/include/__cmath/logarithm.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_ISNORMAL_H
+#define _LIBCPP___CMATH_ISNORMAL_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float log(float __x) _NOEXCEPT { return __builtin_logf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log(double __x) _NOEXCEPT {
+  return __builtin_log(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log(long double __x) _NOEXCEPT { return __builtin_logl(__x); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double log(_Tp __x) _NOEXCEPT {
+  return __builtin_log(static_cast<double>(__x));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float log10(float __x) _NOEXCEPT { return __builtin_log10f(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log10(double __x) _NOEXCEPT {
+  return __builtin_log10(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log10(long double __x) _NOEXCEPT { return __builtin_log10l(__x); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double log10(_Tp __v) _NOEXCEPT {
+  return __builtin_log10(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float log2(float __x) _NOEXCEPT { return __builtin_log2f(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log2(double __x) _NOEXCEPT {
+  return __builtin_log2(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log2(long double __x) _NOEXCEPT { return __builtin_log2l(__x); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double log2(_Tp __v) _NOEXCEPT {
+  return __builtin_log2(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float log1p(float __v) _NOEXCEPT { return __builtin_log1pf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double log1p(double __v) _NOEXCEPT {
+  return __builtin_log1p(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double log1p(long double __v) _NOEXCEPT { return __builtin_log1pl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double log1p(_Tp __v) _NOEXCEPT {
+  return __builtin_log1p(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float logb(float __v) _NOEXCEPT { return __builtin_logbf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double logb(double __v) _NOEXCEPT {
+  return __builtin_logb(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double logb(long double __v) _NOEXCEPT { return __builtin_logbl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double logb(_Tp __v) _NOEXCEPT {
+  return __builtin_logb(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __v) _NOEXCEPT { return __builtin_ilogbf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI int ilogb(double __v) _NOEXCEPT {
+  return __builtin_ilogb(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI int ilogb(long double __v) _NOEXCEPT { return __builtin_ilogbl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI int ilogb(_Tp __v) _NOEXCEPT {
+  return __builtin_ilogb(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float lgamma(float __v) _NOEXCEPT { return __builtin_lgammaf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double lgamma(double __v) _NOEXCEPT {
+  return __builtin_lgamma(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double lgamma(long double __v) _NOEXCEPT { return __builtin_lgammal(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double lgamma(_Tp __v) _NOEXCEPT {
+  return __builtin_lgamma(static_cast<double>(__v));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::ilogb;
+using std::lgamma;
+using std::log;
+using std::log10;
+using std::log1p;
+using std::log2;
+using std::logb;
+
+#endif // _LIBCPP___CMATH_ISNORMAL_H

libcxx/include/__cmath/modf.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_MODF_H
+#define _LIBCPP___CMATH_MODF_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float modf(float __x, float* __y) _NOEXCEPT { return __builtin_modff(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double modf(double __x, double* __y) _NOEXCEPT {
+  return __builtin_modf(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double modf(long double __x, long double* __y) _NOEXCEPT {
+  return __builtin_modfl(__x, __y);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::modf;
+
+#endif // _LIBCPP___CMATH_MODF_H

libcxx/include/__cmath/nextafter.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_NEXTAFTER_H
+#define _LIBCPP___CMATH_NEXTAFTER_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float nextafter(float __x, float __y) _NOEXCEPT { return __builtin_nextafterf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double nextafter(double __x, double __y) _NOEXCEPT {
+  return __builtin_nextafter(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double nextafter(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_nextafterl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type nextafter(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::nextafter(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::nextafter;
+
+#endif // _LIBCPP___CMATH_NEXTAFTER_H

libcxx/include/__cmath/nexttoward.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_NEXTTOWARD_H
+#define _LIBCPP___CMATH_NEXTTOWARD_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float nexttoward(float __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttowardf(__x, __y);
+}
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double nexttoward(double __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttoward(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double nexttoward(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttowardl(__x, __y);
+}
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double nexttoward(_Tp __x, long double __y) _NOEXCEPT {
+  return __builtin_nexttoward(static_cast<double>(__x), __y);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::nexttoward;
+
+#endif // _LIBCPP___CMATH_NEXTTOWARD_H

libcxx/include/__cmath/remainder.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_REMAINDER_H
+#define _LIBCPP___CMATH_REMAINDER_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float remainder(float __x, float __y) _NOEXCEPT { return __builtin_remainderf(__x, __y); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double remainder(double __x, double __y) _NOEXCEPT {
+  return __builtin_remainder(__x, __y);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double remainder(long double __x, long double __y) _NOEXCEPT {
+  return __builtin_remainderl(__x, __y);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type remainder(_Tp __x, _Up __y) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::remainder(static_cast<__result_type>(__x), static_cast<__result_type>(__y));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::remainder;
+
+#endif // _LIBCPP___CMATH_REMAINDER_H

libcxx/include/__cmath/remquo.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_REMQUO_H
+#define _LIBCPP___CMATH_REMQUO_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <__type_traits/promote.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float remquo(float __x, float __y, int* __z) _NOEXCEPT {
+  return __builtin_remquof(__x, __y, __z);
+}
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double remquo(double __x, double __y, int* __z) _NOEXCEPT {
+  return __builtin_remquo(__x, __y, __z);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double remquo(long double __x, long double __y, int* __z) _NOEXCEPT {
+  return __builtin_remquol(__x, __y, __z);
+}
+
+template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI typename __promote<_Tp, _Up>::type remquo(_Tp __x, _Up __y, int* __z) _NOEXCEPT {
+  using __result_type = typename __promote<_Tp, _Up>::type;
+  return std::remquo(static_cast<__result_type>(__x), static_cast<__result_type>(__y), __z);
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::remquo;
+
+#endif // _LIBCPP___CMATH_REMQUO_H

libcxx/include/__cmath/rounding.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_ROUNDING_H
+#define _LIBCPP___CMATH_ROUNDING_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float ceil(float __v) _NOEXCEPT { return __builtin_ceilf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double ceil(double __v) {
+  return __builtin_ceil(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double ceil(long double __v) _NOEXCEPT { return __builtin_ceill(__v); }
+
+template <class _Tp, __enable_if_t<std::is_integral<_Tp>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double ceil(_Tp __v) _NOEXCEPT {
+  return __builtin_ceil(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float floor(float __v) _NOEXCEPT { return __builtin_floorf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double floor(double __v) _NOEXCEPT {
+  return __builtin_ceil(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double floor(long double __v) _NOEXCEPT { return __builtin_floorl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double floor(_Tp __v) _NOEXCEPT {
+  return __builtin_floor(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long long llround(float __v) _NOEXCEPT { return __builtin_llroundf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long long llround(double __v) _NOEXCEPT {
+  return __builtin_llround(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long long llround(long double __v) _NOEXCEPT { return __builtin_llroundl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI long long llround(_Tp __v) _NOEXCEPT {
+  return __builtin_llround(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long lrint(float __v) _NOEXCEPT { return __builtin_lrintf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long lrint(double __v) _NOEXCEPT {
+  return __builtin_lrint(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long lrint(long double __v) _NOEXCEPT { return __builtin_lrintl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI long lrint(_Tp __v) _NOEXCEPT {
+  return __builtin_lrint(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long long llrint(float __v) _NOEXCEPT { return __builtin_llrintf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long long llrint(double __v) _NOEXCEPT {
+  return __builtin_llrint(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long long llrint(long double __v) _NOEXCEPT { return __builtin_llrintl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI long long llrint(_Tp __v) _NOEXCEPT {
+  return __builtin_llrint(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long lround(float __v) _NOEXCEPT { return __builtin_lroundf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI long lround(double __v) _NOEXCEPT {
+  return __builtin_lround(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long lround(long double __v) _NOEXCEPT { return __builtin_lroundl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI long lround(_Tp __v) _NOEXCEPT {
+  return __builtin_lround(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float nearbyint(float __v) _NOEXCEPT { return __builtin_nearbyintf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double nearbyint(double __v) _NOEXCEPT {
+  return __builtin_nearbyint(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double nearbyint(long double __v) _NOEXCEPT { return __builtin_nearbyintl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double nearbyint(_Tp __v) _NOEXCEPT {
+  return __builtin_nearbyint(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float rint(float __v) _NOEXCEPT { return __builtin_rintf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double rint(double __v) _NOEXCEPT {
+  return __builtin_rint(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double rint(long double __v) _NOEXCEPT { return __builtin_rintl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double rint(_Tp __v) _NOEXCEPT {
+  return __builtin_rint(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float round(float __v) _NOEXCEPT { return __builtin_roundf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double round(double __v) _NOEXCEPT {
+  return __builtin_round(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double round(long double __v) _NOEXCEPT { return __builtin_roundl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double round(_Tp __v) _NOEXCEPT {
+  return __builtin_round(static_cast<double>(__v));
+}
+
+inline _LIBCPP_HIDE_FROM_ABI float trunc(float __v) _NOEXCEPT { return __builtin_truncf(__v); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double trunc(double __v) _NOEXCEPT {
+  return __builtin_trunc(__v);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double trunc(long double __v) _NOEXCEPT { return __builtin_truncl(__v); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI double trunc(_Tp __v) _NOEXCEPT {
+  return __builtin_trunc(static_cast<double>(__v));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::ceil;
+using std::floor;
+using std::llrint;
+using std::llround;
+using std::lrint;
+using std::lround;
+using std::nearbyint;
+using std::rint;
+using std::round;
+using std::trunc;
+
+#endif // _LIBCPP___CMATH_ROUNDING_H

libcxx/include/__cmath/signbit.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_SIGNBIT_H
+#define _LIBCPP___CMATH_SIGNBIT_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_floating_point.h>
+#include <__type_traits/is_integral.h>
+#include <__type_traits/is_signed.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp, std::__enable_if_t<std::is_floating_point<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool signbit(_Tp __v) _NOEXCEPT {
+  return __builtin_signbit(__v);
+}
+
+template <class _Tp, std::__enable_if_t<std::is_integral<_Tp>::value && std::is_signed<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool signbit(_Tp __v) _NOEXCEPT {
+  return __v < 0;
+}
+
+template <class _Tp, std::__enable_if_t<std::is_integral<_Tp>::value && !std::is_signed<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool signbit(_Tp) _NOEXCEPT {
+  return false;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::signbit;
+
+#endif // _LIBCPP___CMATH_SIGNBIT_H

libcxx/include/__cmath/tgamma.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_TGAMMA_H
+#define _LIBCPP___CMATH_TGAMMA_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_integral.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+inline _LIBCPP_HIDE_FROM_ABI float tgamma(float __x) _NOEXCEPT { return __builtin_tgammaf(__x); }
+
+template <class = int>
+_LIBCPP_HIDE_FROM_ABI double tgamma(double __x) _NOEXCEPT {
+  return __builtin_tgamma(__x);
+}
+
+inline _LIBCPP_HIDE_FROM_ABI long double tgamma(long double __x) _NOEXCEPT { return __builtin_tgammal(__x); }
+
+template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI double tgamma(_Tp __x) _NOEXCEPT {
+  return __builtin_tgamma(static_cast<double>(__x));
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::tgamma;
+
+#endif // _LIBCPP___CMATH_TGAMMA_H

libcxx/include/__cmath/traits.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___CMATH_TRAITS_H
+#define _LIBCPP___CMATH_TRAITS_H
+
+#include <__config>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_arithmetic.h>
+#include <limits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::numeric_limits<_Tp>::has_infinity, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI bool isfinite(_Tp __lcpp_x) _NOEXCEPT {
+  return __builtin_isfinite(__lcpp_x);
+}
+
+template <class _Tp,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && !std::numeric_limits<_Tp>::has_infinity, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI bool isfinite(_Tp) _NOEXCEPT {
+  return true;
+}
+
+template <class _Tp,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && std::numeric_limits<_Tp>::has_infinity, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isinf(_Tp __v) _NOEXCEPT {
+  return __builtin_isinf(__v);
+}
+
+template <class _Tp,
+          std::__enable_if_t<std::is_arithmetic<_Tp>::value && !std::numeric_limits<_Tp>::has_infinity, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isinf(_Tp) _NOEXCEPT {
+  return false;
+}
+
+template <class _Tp, std::__enable_if_t<std::is_floating_point<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isnan(_Tp __v) _NOEXCEPT {
+  return __builtin_isnan(__v);
+}
+
+template <class _Tp, std::__enable_if_t<std::is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isnan(_Tp) _NOEXCEPT {
+  return false;
+}
+
+template <class _Tp, std::__enable_if_t<std::is_floating_point<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isnormal(_Tp __v) _NOEXCEPT {
+  return __builtin_isnormal(__v);
+}
+
+template <class _Tp, std::__enable_if_t<std::is_integral<_Tp>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI bool isnormal(_Tp __v) _NOEXCEPT {
+  return __v != 0;
+}
+
+_LIBCPP_END_NAMESPACE_STD
+
+using std::isfinite;
+using std::isinf;
+using std::isnan;
+using std::isnormal;
+
+#endif // _LIBCPP___CMATH_TRAITS_H

libcxx/include/__compare/strong_order.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___COMPARE_STRONG_ORDER
 #define _LIBCPP___COMPARE_STRONG_ORDER
 
 #include <__bit/bit_cast.h>
+#include <__cmath/frexp.h>
+#include <__cmath/signbit.h>
+#include <__cmath/traits.h>
 #include <__compare/compare_three_way.h>
 #include <__compare/ordering.h>
 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/priority_tag.h>
-#include <cmath>
 #include <cstdint>
 #include <limits>
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
 #endif
 

libcxx/include/__compare/weak_order.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___COMPARE_WEAK_ORDER
 #define _LIBCPP___COMPARE_WEAK_ORDER
 
+#include <__cmath/signbit.h>
+#include <__cmath/traits.h>
 #include <__compare/compare_three_way.h>
 #include <__compare/ordering.h>
 #include <__compare/strong_order.h>
 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/priority_tag.h>
-#include <cmath>
 #include <type_traits>
 
 #ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 

libcxx/include/__format/formatter_floating_point.h

 #define _LIBCPP___FORMAT_FORMATTER_FLOATING_POINT_H
 
 #include <__algorithm/copy_n.h>
 #include <__algorithm/find.h>
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__algorithm/rotate.h>
 #include <__algorithm/transform.h>
+#include <__cmath/signbit.h>
+#include <__cmath/traits.h>
 #include <__concepts/arithmetic.h>
 #include <__concepts/same_as.h>
 #include <__config>
 #include <__format/concepts.h>
 #include <__format/format_parse_context.h>
 #include <__format/formatter.h>
 #include <__format/formatter_integral.h>
 #include <__format/formatter_output.h>

libcxx/include/__hash_table

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___HASH_TABLE
 #define _LIBCPP___HASH_TABLE
 
 #include <__algorithm/max.h>
 #include <__algorithm/min.h>
 #include <__assert>
 #include <__bits> // __libcpp_clz
+#include <__cmath/rounding.h>
 #include <__config>
 #include <__debug>
 #include <__functional/hash.h>
 #include <__iterator/iterator_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/compressed_pair.h>
 #include <__memory/pointer_traits.h>
 #include <__memory/swap_allocator.h>
 #include <__memory/unique_ptr.h>
 #include <__type_traits/can_extract_key.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/swap.h>
-#include <cmath>
 #include <cstring>
 #include <initializer_list>
+#include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
#if _LIBCPP_STD_VER > 14
     _NodeHandle __node_handle_extract(const_iterator __it);
 #endif
 
     void clear() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY void __rehash_unique(size_type __n) { __rehash<true>(__n); }
     _LIBCPP_INLINE_VISIBILITY void __rehash_multi(size_type __n) { __rehash<false>(__n); }
     _LIBCPP_INLINE_VISIBILITY void __reserve_unique(size_type __n)
     {
-        __rehash_unique(static_cast<size_type>(ceil(__n / max_load_factor())));
+        __rehash_unique(static_cast<size_type>(std::ceil(__n / max_load_factor())));
     }
     _LIBCPP_INLINE_VISIBILITY void __reserve_multi(size_type __n)
     {
-        __rehash_multi(static_cast<size_type>(ceil(__n / max_load_factor())));
+        __rehash_multi(static_cast<size_type>(std::ceil(__n / max_load_factor())));
     }
 
     _LIBCPP_INLINE_VISIBILITY
     size_type bucket_count() const _NOEXCEPT
     {
         return __bucket_list_.get_deleter().size();
     }
 

libcxx/include/__random/binomial_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_BINOMIAL_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
 #include <__config>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <cmath>
 #include <iosfwd>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header

libcxx/include/__random/cauchy_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_CAUCHY_DISTRIBUTION_H
 
+#include <__cmath/angular_functions.h>
 #include <__config>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
-#include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/extreme_value_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_EXTREME_VALUE_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
+#include <__cmath/logarithm.h>
 #include <__config>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
-#include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/gamma_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_GAMMA_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
+#include <__cmath/logarithm.h>
 #include <__config>
 #include <__random/exponential_distribution.h>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
-#include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/lognormal_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_LOGNORMAL_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
 #include <__config>
 #include <__random/normal_distribution.h>
-#include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/normal_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_NORMAL_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
+#include <__cmath/logarithm.h>
 #include <__config>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
-#include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/piecewise_linear_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
 
 #include <__algorithm/upper_bound.h>
+#include <__cmath/arithmetic.h>
 #include <__config>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <iosfwd>
 #include <numeric>
 #include <vector>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/__random/poisson_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_POISSON_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
+#include <__cmath/logarithm.h>
+#include <__cmath/rounding.h>
+#include <__cmath/traits.h>
 #include <__config>
 #include <__random/clamp_to_integral.h>
 #include <__random/exponential_distribution.h>
 #include <__random/is_valid.h>
 #include <__random/normal_distribution.h>
 #include <__random/uniform_real_distribution.h>
-#include <cmath>
+#include <cstdlib>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/student_t_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_STUDENT_T_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
 #include <__config>
 #include <__random/gamma_distribution.h>
 #include <__random/is_valid.h>
 #include <__random/normal_distribution.h>
-#include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/__random/weibull_distribution.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_WEIBULL_DISTRIBUTION_H
 
+#include <__cmath/arithmetic.h>
 #include <__config>
 #include <__random/exponential_distribution.h>
-#include <cmath>
 #include <iosfwd>
 #include <limits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS

libcxx/include/charconv

 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__availability>
 #include <__bits>
 #include <__charconv/chars_format.h>
 #include <__charconv/from_chars_result.h>
 #include <__charconv/tables.h>
 #include <__charconv/to_chars_base_10.h>
 #include <__charconv/to_chars_result.h>
+#include <__cmath/logarithm.h>
 #include <__config>
 #include <__debug>
 #include <__errc>
 #include <__type_traits/make_32_64_or_128_bit.h>
 #include <__utility/unreachable.h>
-#include <cmath> // for log2f
 #include <cstdint>
 #include <cstdlib>
 #include <cstring>
 #include <limits>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
__from_chars_integral(const char* __first, const char* __last, _Tp& __value,
     if (__base == 10)
         return __from_chars_atoi(__first, __last, __value);
 
     return __subject_seq_combinator(
         __first, __last, __value,
         [](const char* __p, const char* __lastp, _Tp& __val,
            int __b) -> from_chars_result {
             using __tl = numeric_limits<_Tp>;
-            auto __digits = __tl::digits / log2f(float(__b));
+            auto __digits = __tl::digits / std::log2(float(__b));
             _Tp __x = __in_pattern(*__p++, __b).__val, __y = 0;
 
             for (int __i = 1; __p != __lastp; ++__i, ++__p)
             {
                 if (auto __c = __in_pattern(*__p, __b))
                 {
                     if (__i < __digits - 1)
                         __x = __x * __b + __c.__val;

 #  endif // _LIBCPP_STD_VER > 14
 #endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cmath>
 #  include <iosfwd>
 #endif
 
 #endif // _LIBCPP_CHARCONV

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 ::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;

libcxx/include/compare

 #include <__compare/weak_order.h>
 #include <__config>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cmath>
+#endif
+
 #endif // _LIBCPP_COMPARE

libcxx/include/complex

sqrt(const complex<_Tp>& __x)
     if (__libcpp_isinf_or_builtin(__x.imag()))
         return complex<_Tp>(_Tp(INFINITY), __x.imag());
     if (__libcpp_isinf_or_builtin(__x.real()))
     {
         if (__x.real() > _Tp(0))
             return complex<_Tp>(__x.real(), __libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : copysign(_Tp(0), __x.imag()));
         return complex<_Tp>(__libcpp_isnan_or_builtin(__x.imag()) ? __x.imag() : _Tp(0), copysign(__x.real(), __x.imag()));
     }
-    return polar(sqrt(abs(__x)), arg(__x) / _Tp(2));
+    return std::polar(std::sqrt(std::abs(__x)), std::arg(__x) / _Tp(2));
 }
 
 // exp
 
 template<class _Tp>
 _LIBCPP_HIDE_FROM_ABI complex<_Tp>
 exp(const complex<_Tp>& __x)
 {

libcxx/include/ext/hash_map

operator!=(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
            const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 } // namespace __gnu_cxx
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cmath>
 #  include <iterator>
 #endif
 
 #endif // _LIBCPP_HASH_MAP

libcxx/include/ext/hash_set

operator!=(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
            const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
 {
     return !(__x == __y);
 }
 
 } // namespace __gnu_cxx
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <cmath>
 #  include <iterator>
 #endif
 
 #endif // _LIBCPP_HASH_SET

libcxx/include/math.h

 #include <__config>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #include_next <math.h>
 
-#ifdef __cplusplus
-
-// We support including .h headers inside 'extern "C"' contexts, so switch
-// back to C++ linkage before including these C++ headers.
-extern "C++" {
-
-#include <__type_traits/promote.h>
-#include <limits>
-#include <stdlib.h>
-#include <type_traits>
-
-// signbit
-
-#ifdef signbit
-
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT
-{
-#if __has_builtin(__builtin_signbit)
-    return __builtin_signbit(__lcpp_x);
-#else
-    return signbit(__lcpp_x);
-#endif
-}
-
-#undef signbit
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
-signbit(_A1 __lcpp_x) _NOEXCEPT
-{
-    return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-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; }
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<
-    std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
-signbit(_A1) _NOEXCEPT
-{ return false; }
-
-#elif defined(_LIBCPP_MSVCRT)
-
-template <typename _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
-signbit(_A1 __lcpp_x) _NOEXCEPT
-{
-  return ::signbit(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-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; }
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<
-    std::is_integral<_A1>::value && !std::is_signed<_A1>::value, bool>::type
-signbit(_A1) _NOEXCEPT
-{ return false; }
-
-#endif // signbit
-
-// fpclassify
-
 #ifdef fpclassify
-
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-int
-__libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT
-{
-#if __has_builtin(__builtin_fpclassify)
-  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, FP_SUBNORMAL,
-                                FP_ZERO, __lcpp_x);
-#else
-    return fpclassify(__lcpp_x);
-#endif
-}
-
-#undef fpclassify
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_floating_point<_A1>::value, int>::type
-fpclassify(_A1 __lcpp_x) _NOEXCEPT
-{
-    return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_integral<_A1>::value, int>::type
-fpclassify(_A1 __lcpp_x) _NOEXCEPT
-{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }
-
-#elif defined(_LIBCPP_MSVCRT)
-
-template <typename _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
-fpclassify(_A1 __lcpp_x) _NOEXCEPT
-{
-  return ::fpclassify(static_cast<typename std::__promote<_A1>::type>(__lcpp_x));
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_integral<_A1>::value, int>::type
-fpclassify(_A1 __lcpp_x) _NOEXCEPT
-{ return __lcpp_x == 0 ? FP_ZERO : FP_NORMAL; }
-
-#endif // fpclassify
-
-// isfinite
-
-#ifdef isfinite
-
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
-{
-#if __has_builtin(__builtin_isfinite)
-    return __builtin_isfinite(__lcpp_x);
-#else
-    return isfinite(__lcpp_x);
-#endif
-}
-
-#undef isfinite
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<
-    std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
-    bool>::type
-isfinite(_A1 __lcpp_x) _NOEXCEPT
-{
-    return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<
-    std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
-    bool>::type
-isfinite(_A1) _NOEXCEPT
-{ return true; }
-
-#endif // isfinite
-
-// isinf
-
-#ifdef isinf
-
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
-{
-#if __has_builtin(__builtin_isinf)
-    return __builtin_isinf(__lcpp_x);
-#else
-    return isinf(__lcpp_x);
-#endif
-}
-
-#undef isinf
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<
-    std::is_arithmetic<_A1>::value && std::numeric_limits<_A1>::has_infinity,
-    bool>::type
-isinf(_A1 __lcpp_x) _NOEXCEPT
-{
-    return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<
-    std::is_arithmetic<_A1>::value && !std::numeric_limits<_A1>::has_infinity,
-    bool>::type
-isinf(_A1) _NOEXCEPT
-{ return false; }
-
-#ifdef _LIBCPP_PREFERRED_OVERLOAD
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isinf(float __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
-
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-bool
-isinf(double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isinf(long double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
+#  undef fpclassify
 #endif
 
-#endif // isinf
-
-// isnan
-
-#ifdef isnan
-
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
-{
-#if __has_builtin(__builtin_isnan)
-    return __builtin_isnan(__lcpp_x);
-#else
-    return isnan(__lcpp_x);
-#endif
-}
-
-#undef isnan
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
-isnan(_A1 __lcpp_x) _NOEXCEPT
-{
-    return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_integral<_A1>::value, bool>::type
-isnan(_A1) _NOEXCEPT
-{ return false; }
-
-#ifdef _LIBCPP_PREFERRED_OVERLOAD
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isnan(float __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
-
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_PREFERRED_OVERLOAD
-bool
-isnan(double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
-
-inline _LIBCPP_INLINE_VISIBILITY
-bool
-isnan(long double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
-#endif
-
-#endif // isnan
-
-// isnormal
-
-#ifdef isnormal
-
-template <class _A1>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT
-{
-#if __has_builtin(__builtin_isnormal)
-    return __builtin_isnormal(__lcpp_x);
-#else
-    return isnormal(__lcpp_x);
-#endif
-}
-
-#undef isnormal
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_floating_point<_A1>::value, bool>::type
-isnormal(_A1 __lcpp_x) _NOEXCEPT
-{
-    return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_integral<_A1>::value, bool>::type
-isnormal(_A1 __lcpp_x) _NOEXCEPT
-{ return __lcpp_x != 0; }
-
-#endif // isnormal
-
-// isgreater
-
-#ifdef isgreater
-
-template <class _A1, class _A2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
-    return isgreater(__lcpp_x, __lcpp_y);
-}
-
-#undef isgreater
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    bool
->::type
-isgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_isgreater((type)__lcpp_x, (type)__lcpp_y);
-}
-
-#endif // isgreater
-
-// isgreaterequal
-
-#ifdef isgreaterequal
-
-template <class _A1, class _A2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
-    return isgreaterequal(__lcpp_x, __lcpp_y);
-}
-
-#undef isgreaterequal
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if
-<
-    std::is_arithmetic<_A1>::value &&
-    std::is_arithmetic<_A2>::value,
-    bool
->::type
-isgreaterequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
-    typedef typename std::__promote<_A1, _A2>::type type;
-    return __libcpp_isgreaterequal((type)__lcpp_x, (type)__lcpp_y);
-}
-
-#endif // isgreaterequal
-
-// isless
-
 #ifdef isless
-
-template <class _A1, class _A2>
-_LIBCPP_INLINE_VISIBILITY
-bool
-__libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{