[libcxx] r249742 - Split <math.h> out of <cmath>.
Richard Smith via cfe-commits
cfe-commits at lists.llvm.org
Thu Oct 8 13:40:34 PDT 2015
Author: rsmith
Date: Thu Oct 8 15:40:34 2015
New Revision: 249742
URL: http://llvm.org/viewvc/llvm-project?rev=249742&view=rev
Log:
Split <math.h> out of <cmath>.
Added:
libcxx/trunk/include/math.h
- copied, changed from r249736, libcxx/trunk/include/cmath
libcxx/trunk/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp
libcxx/trunk/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp
Modified:
libcxx/trunk/include/cmath
libcxx/trunk/test/std/depr/depr.c.headers/math_h.pass.cpp
Modified: libcxx/trunk/include/cmath
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/cmath?rev=249742&r1=249741&r2=249742&view=diff
==============================================================================
--- libcxx/trunk/include/cmath (original)
+++ libcxx/trunk/include/cmath Thu Oct 8 15:40:34 2015
@@ -299,340 +299,11 @@ long double truncl(long double x);
#include <__config>
#include <math.h>
-#include <type_traits>
-
-#ifdef _LIBCPP_MSVCRT
-#include "support/win32/math_win32.h"
-#endif
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
#pragma GCC system_header
#endif
-// signbit
-
-#ifdef signbit
-
-template <class _A1>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_signbit(_A1 __lcpp_x) _NOEXCEPT
-{
- return signbit(__lcpp_x);
-}
-
-#undef signbit
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
-signbit(_A1 __lcpp_x) _NOEXCEPT
-{
- return __libcpp_signbit((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-#endif // signbit
-
-// fpclassify
-
-#ifdef fpclassify
-
-template <class _A1>
-_LIBCPP_ALWAYS_INLINE
-int
-__libcpp_fpclassify(_A1 __lcpp_x) _NOEXCEPT
-{
- return fpclassify(__lcpp_x);
-}
-
-#undef fpclassify
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_arithmetic<_A1>::value, int>::type
-fpclassify(_A1 __lcpp_x) _NOEXCEPT
-{
- return __libcpp_fpclassify((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-#endif // fpclassify
-
-// isfinite
-
-#ifdef isfinite
-
-template <class _A1>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_isfinite(_A1 __lcpp_x) _NOEXCEPT
-{
- return isfinite(__lcpp_x);
-}
-
-#undef isfinite
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
-isfinite(_A1 __lcpp_x) _NOEXCEPT
-{
- return __libcpp_isfinite((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-#endif // isfinite
-
-// isinf
-
-#ifdef isinf
-
-template <class _A1>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_isinf(_A1 __lcpp_x) _NOEXCEPT
-{
- return isinf(__lcpp_x);
-}
-
-#undef isinf
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
-isinf(_A1 __lcpp_x) _NOEXCEPT
-{
- return __libcpp_isinf((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-#endif // isinf
-
-// isnan
-
-#ifdef isnan
-
-template <class _A1>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_isnan(_A1 __lcpp_x) _NOEXCEPT
-{
- return isnan(__lcpp_x);
-}
-
-#undef isnan
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
-isnan(_A1 __lcpp_x) _NOEXCEPT
-{
- return __libcpp_isnan((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-#endif // isnan
-
-// isnormal
-
-#ifdef isnormal
-
-template <class _A1>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_isnormal(_A1 __lcpp_x) _NOEXCEPT
-{
- return isnormal(__lcpp_x);
-}
-
-#undef isnormal
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename std::enable_if<std::is_arithmetic<_A1>::value, bool>::type
-isnormal(_A1 __lcpp_x) _NOEXCEPT
-{
- return __libcpp_isnormal((typename std::__promote<_A1>::type)__lcpp_x);
-}
-
-#endif // isnormal
-
-// isgreater
-
-#ifdef isgreater
-
-template <class _A1, class _A2>
-_LIBCPP_ALWAYS_INLINE
-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_ALWAYS_INLINE
-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_ALWAYS_INLINE
-bool
-__libcpp_isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- return isless(__lcpp_x, __lcpp_y);
-}
-
-#undef isless
-
-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
-isless(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename std::__promote<_A1, _A2>::type type;
- return __libcpp_isless((type)__lcpp_x, (type)__lcpp_y);
-}
-
-#endif // isless
-
-// islessequal
-
-#ifdef islessequal
-
-template <class _A1, class _A2>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- return islessequal(__lcpp_x, __lcpp_y);
-}
-
-#undef islessequal
-
-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
-islessequal(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename std::__promote<_A1, _A2>::type type;
- return __libcpp_islessequal((type)__lcpp_x, (type)__lcpp_y);
-}
-
-#endif // islessequal
-
-// islessgreater
-
-#ifdef islessgreater
-
-template <class _A1, class _A2>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- return islessgreater(__lcpp_x, __lcpp_y);
-}
-
-#undef islessgreater
-
-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
-islessgreater(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename std::__promote<_A1, _A2>::type type;
- return __libcpp_islessgreater((type)__lcpp_x, (type)__lcpp_y);
-}
-
-#endif // islessgreater
-
-// isunordered
-
-#ifdef isunordered
-
-template <class _A1, class _A2>
-_LIBCPP_ALWAYS_INLINE
-bool
-__libcpp_isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- return isunordered(__lcpp_x, __lcpp_y);
-}
-
-#undef isunordered
-
-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
-isunordered(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename std::__promote<_A1, _A2>::type type;
- return __libcpp_isunordered((type)__lcpp_x, (type)__lcpp_y);
-}
-
-#endif // isunordered
-
_LIBCPP_BEGIN_NAMESPACE_STD
using ::signbit;
@@ -652,794 +323,130 @@ using ::isunordered;
using ::float_t;
using ::double_t;
-// abs
-
-#if defined(__sun__)
+#ifndef _AIX
using ::abs;
#endif
-#if !defined(_AIX) && !defined(__sun__)
-inline _LIBCPP_INLINE_VISIBILITY
-float
-abs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-double
-abs(double __lcpp_x) _NOEXCEPT {return fabs(__lcpp_x);}
-
-inline _LIBCPP_INLINE_VISIBILITY
-long double
-abs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);}
-#endif // !defined(_AIX)
-
#ifndef __sun__
-
-// acos
-
using ::acos;
using ::acosf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return acosf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return acosl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-acos(_A1 __lcpp_x) _NOEXCEPT {return acos((double)__lcpp_x);}
-
-// asin
-
using ::asin;
using ::asinf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return asinf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return asinl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-asin(_A1 __lcpp_x) _NOEXCEPT {return asin((double)__lcpp_x);}
-
-// atan
-
using ::atan;
using ::atanf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return atanf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return atanl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-atan(_A1 __lcpp_x) _NOEXCEPT {return atan((double)__lcpp_x);}
-
-// atan2
-
using ::atan2;
using ::atan2f;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return atan2f(__lcpp_y, __lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return atan2l(__lcpp_y, __lcpp_x);}
-#endif
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x);
-}
-
-// ceil
-
using ::ceil;
using ::ceilf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ceilf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ceill(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-ceil(_A1 __lcpp_x) _NOEXCEPT {return ceil((double)__lcpp_x);}
-
-// cos
-
using ::cos;
using ::cosf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return cosf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return cosl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-cos(_A1 __lcpp_x) _NOEXCEPT {return cos((double)__lcpp_x);}
-
-// cosh
-
using ::cosh;
using ::coshf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return coshf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return coshl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-cosh(_A1 __lcpp_x) _NOEXCEPT {return cosh((double)__lcpp_x);}
-
#endif // __sun__
-// exp
using ::exp;
using ::expf;
#ifndef __sun__
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return expf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return expl(__lcpp_x);}
-#endif
-
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-exp(_A1 __lcpp_x) _NOEXCEPT {return exp((double)__lcpp_x);}
-
-// fabs
-
using ::fabs;
using ::fabsf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-fabs(_A1 __lcpp_x) _NOEXCEPT {return fabs((double)__lcpp_x);}
-
-// floor
-
using ::floor;
using ::floorf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return floorf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return floorl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-floor(_A1 __lcpp_x) _NOEXCEPT {return floor((double)__lcpp_x);}
-
-// fmod
-
#endif //__sun__
+
using ::fmod;
using ::fmodf;
-#ifndef __sun__
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmodf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmodl(__lcpp_x, __lcpp_y);}
-#endif
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-
-// frexp
+#ifndef __sun__
using ::frexp;
using ::frexpf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpf(__lcpp_x, __lcpp_e);}
-inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpl(__lcpp_x, __lcpp_e);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexp((double)__lcpp_x, __lcpp_e);}
-
-// ldexp
-
using ::ldexp;
using ::ldexpf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpf(__lcpp_x, __lcpp_e);}
-inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpl(__lcpp_x, __lcpp_e);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexp((double)__lcpp_x, __lcpp_e);}
-
-// log
-
#endif // __sun__
+
using ::log;
using ::logf;
-#ifndef __sun__
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return logf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return logl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-log(_A1 __lcpp_x) _NOEXCEPT {return log((double)__lcpp_x);}
-
-
-// log10
+#ifndef __sun__
using ::log10;
using ::log10f;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return log10f(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return log10l(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-log10(_A1 __lcpp_x) _NOEXCEPT {return log10((double)__lcpp_x);}
-
-// modf
-
using ::modf;
using ::modff;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return modff(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return modfl(__lcpp_x, __lcpp_y);}
-#endif
-
-// pow
-
#endif // __sun__
+
using ::pow;
using ::powf;
#ifndef __sun__
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return powf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return powl(__lcpp_x, __lcpp_y);}
-#endif
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return pow((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-// sin
-
using ::sin;
using ::sinf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return sinf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return sinl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-sin(_A1 __lcpp_x) _NOEXCEPT {return sin((double)__lcpp_x);}
-
-// sinh
-
using ::sinh;
using ::sinhf;
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return sinhf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return sinhl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-sinh(_A1 __lcpp_x) _NOEXCEPT {return sinh((double)__lcpp_x);}
-
-// sqrt
-
#endif // __sun__
+
using ::sqrt;
using ::sqrtf;
-
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(__sun__) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return sqrtf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return sqrtl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-sqrt(_A1 __lcpp_x) _NOEXCEPT {return sqrt((double)__lcpp_x);}
-
-// tan
-
using ::tan;
using ::tanf;
-#ifndef __sun__
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return tanf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return tanl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-tan(_A1 __lcpp_x) _NOEXCEPT {return tan((double)__lcpp_x);}
-
-// tanh
+#ifndef __sun__
using ::tanh;
using ::tanhf;
-#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
-inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return tanhf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return tanhl(__lcpp_x);}
-#endif
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-tanh(_A1 __lcpp_x) _NOEXCEPT {return tanh((double)__lcpp_x);}
-
-// acosh
-
#ifndef _LIBCPP_MSVCRT
using ::acosh;
using ::acoshf;
-
-inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return acoshf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return acoshl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-acosh(_A1 __lcpp_x) _NOEXCEPT {return acosh((double)__lcpp_x);}
-#endif
-
-// asinh
-
-#ifndef _LIBCPP_MSVCRT
using ::asinh;
using ::asinhf;
-
-inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return asinhf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return asinhl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-asinh(_A1 __lcpp_x) _NOEXCEPT {return asinh((double)__lcpp_x);}
-#endif
-
-// atanh
-
-#ifndef _LIBCPP_MSVCRT
using ::atanh;
using ::atanhf;
-
-inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return atanhf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return atanhl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-atanh(_A1 __lcpp_x) _NOEXCEPT {return atanh((double)__lcpp_x);}
-#endif
-
-// cbrt
-
-#ifndef _LIBCPP_MSVCRT
using ::cbrt;
using ::cbrtf;
-
-inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return cbrtf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return cbrtl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-cbrt(_A1 __lcpp_x) _NOEXCEPT {return cbrt((double)__lcpp_x);}
#endif
-// copysign
-
using ::copysign;
using ::copysignf;
-#if !defined(_VC_CRT_MAJOR_VERSION) || (_VC_CRT_MAJOR_VERSION < 12)
-inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x,
- float __lcpp_y) _NOEXCEPT {
- return copysignf(__lcpp_x, __lcpp_y);
-}
-inline _LIBCPP_INLINE_VISIBILITY long double
-copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {
- return copysignl(__lcpp_x, __lcpp_y);
-}
-#endif
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
#ifndef _LIBCPP_MSVCRT
-
-// erf
-
using ::erf;
using ::erff;
-
-inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return erff(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return erfl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-erf(_A1 __lcpp_x) _NOEXCEPT {return erf((double)__lcpp_x);}
-
-// erfc
-
using ::erfc;
using ::erfcf;
-
-inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return erfcf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return erfcl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-erfc(_A1 __lcpp_x) _NOEXCEPT {return erfc((double)__lcpp_x);}
-
-// exp2
-
using ::exp2;
using ::exp2f;
-
-inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return exp2f(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return exp2l(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-exp2(_A1 __lcpp_x) _NOEXCEPT {return exp2((double)__lcpp_x);}
-
-// expm1
-
using ::expm1;
using ::expm1f;
-
-inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return expm1f(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return expm1l(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-expm1(_A1 __lcpp_x) _NOEXCEPT {return expm1((double)__lcpp_x);}
-
-// fdim
-
using ::fdim;
using ::fdimf;
-
-inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fdimf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fdiml(__lcpp_x, __lcpp_y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-// fma
-
using ::fmaf;
using ::fma;
-
-inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT {return fmaf(__lcpp_x, __lcpp_y, __lcpp_z);}
-inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT {return fmal(__lcpp_x, __lcpp_y, __lcpp_z);}
-
-template <class _A1, class _A2, class _A3>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value &&
- is_arithmetic<_A3>::value,
- __promote<_A1, _A2, _A3>
->::type
-fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2, _A3>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value &&
- is_same<_A3, __result_type>::value)), "");
- return fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
-}
-
-// fmax
-
using ::fmax;
using ::fmaxf;
-
-inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmaxf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmaxl(__lcpp_x, __lcpp_y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-// fmin
-
using ::fmin;
using ::fminf;
-
-inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fminf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fminl(__lcpp_x, __lcpp_y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-// hypot
-
using ::hypot;
using ::hypotf;
-
-inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return hypotf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return hypotl(__lcpp_x, __lcpp_y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-// ilogb
-
using ::ilogb;
using ::ilogbf;
-
-inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ilogbf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ilogbl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, int>::type
-ilogb(_A1 __lcpp_x) _NOEXCEPT {return ilogb((double)__lcpp_x);}
-
-// lgamma
-
using ::lgamma;
using ::lgammaf;
-
-inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return lgammaf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return lgammal(__lcpp_x);}
-
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-lgamma(_A1 __lcpp_x) _NOEXCEPT {return lgamma((double)__lcpp_x);}
-
-
-// llrint
-
using ::llrint;
using ::llrintf;
-
-inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT {return llrintf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT {return llrintl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long long>::type
-llrint(_A1 __lcpp_x) _NOEXCEPT {return llrint((double)__lcpp_x);}
-
-// llround
-
using ::llround;
using ::llroundf;
-
-inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT {return llroundf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT {return llroundl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long long>::type
-llround(_A1 __lcpp_x) _NOEXCEPT {return llround((double)__lcpp_x);}
-
-// log1p
-
using ::log1p;
using ::log1pf;
-
-inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return log1pf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return log1pl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-log1p(_A1 __lcpp_x) _NOEXCEPT {return log1p((double)__lcpp_x);}
-
-// log2
-
using ::log2;
using ::log2f;
-
-inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return log2f(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return log2l(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-log2(_A1 __lcpp_x) _NOEXCEPT {return log2((double)__lcpp_x);}
-
-// logb
-
using ::logb;
using ::logbf;
-
-inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return logbf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return logbl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-logb(_A1 __lcpp_x) _NOEXCEPT {return logb((double)__lcpp_x);}
-
-// lrint
-
using ::lrint;
using ::lrintf;
-
-inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT {return lrintf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT {return lrintl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long>::type
-lrint(_A1 __lcpp_x) _NOEXCEPT {return lrint((double)__lcpp_x);}
-
-// lround
-
using ::lround;
using ::lroundf;
-
-inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT {return lroundf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT {return lroundl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long>::type
-lround(_A1 __lcpp_x) _NOEXCEPT {return lround((double)__lcpp_x);}
-
#endif // _LIBCPP_MSVCRT
#endif // __sun__
-// nan
-
#ifndef _LIBCPP_MSVCRT
using ::nan;
using ::nanf;
@@ -1447,183 +454,28 @@ using ::nanf;
#ifndef __sun__
#ifndef _LIBCPP_MSVCRT
-
-// nearbyint
-
using ::nearbyint;
using ::nearbyintf;
-
-inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return nearbyintf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return nearbyintl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-nearbyint(_A1 __lcpp_x) _NOEXCEPT {return nearbyint((double)__lcpp_x);}
-
-// nextafter
-
using ::nextafter;
using ::nextafterf;
-
-inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return nextafterf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nextafterl(__lcpp_x, __lcpp_y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-// nexttoward
-
using ::nexttoward;
using ::nexttowardf;
-
-inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardl(__lcpp_x, __lcpp_y);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttoward((double)__lcpp_x, __lcpp_y);}
-
-// remainder
-
using ::remainder;
using ::remainderf;
-
-inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return remainderf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return remainderl(__lcpp_x, __lcpp_y);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y);
-}
-
-// remquo
-
using ::remquo;
using ::remquof;
-
-inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquof(__lcpp_x, __lcpp_y, __lcpp_z);}
-inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquol(__lcpp_x, __lcpp_y, __lcpp_z);}
-
-template <class _A1, class _A2>
-inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
-<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
->::type
-remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT
-{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
- return remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z);
-}
-
-// rint
-
using ::rint;
using ::rintf;
-
-inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT {return rintf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT {return rintl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-rint(_A1 __lcpp_x) _NOEXCEPT {return rint((double)__lcpp_x);}
-
-// round
-
using ::round;
using ::roundf;
-
-inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT {return roundf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT {return roundl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-round(_A1 __lcpp_x) _NOEXCEPT {return round((double)__lcpp_x);}
-
-// scalbln
-
using ::scalbln;
using ::scalblnf;
-
-inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnl(__lcpp_x, __lcpp_y);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalbln((double)__lcpp_x, __lcpp_y);}
-
-// scalbn
-
using ::scalbn;
using ::scalbnf;
-
-inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnf(__lcpp_x, __lcpp_y);}
-inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnl(__lcpp_x, __lcpp_y);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbn((double)__lcpp_x, __lcpp_y);}
-
-// tgamma
-
using ::tgamma;
using ::tgammaf;
-
-inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return tgammaf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return tgammal(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-tgamma(_A1 __lcpp_x) _NOEXCEPT {return tgamma((double)__lcpp_x);}
-
-// trunc
-
using ::trunc;
using ::truncf;
-
-inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT {return truncf(__lcpp_x);}
-inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT {return truncl(__lcpp_x);}
-
-template <class _A1>
-inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
-trunc(_A1 __lcpp_x) _NOEXCEPT {return trunc((double)__lcpp_x);}
-
#endif // !_LIBCPP_MSVCRT
using ::acosl;
@@ -1647,6 +499,7 @@ using ::sinl;
using ::sinhl;
using ::sqrtl;
using ::tanl;
+
#ifndef _LIBCPP_MSVCRT
using ::tanhl;
using ::acoshl;
@@ -1654,7 +507,9 @@ using ::asinhl;
using ::atanhl;
using ::cbrtl;
#endif // !_LIBCPP_MSVCRT
+
using ::copysignl;
+
#ifndef _LIBCPP_MSVCRT
using ::erfl;
using ::erfcl;
@@ -1692,6 +547,7 @@ using ::truncl;
using ::lgamma;
using ::lgammaf;
#endif // __sun__
+
_LIBCPP_END_NAMESPACE_STD
#endif // _LIBCPP_CMATH
Copied: libcxx/trunk/include/math.h (from r249736, libcxx/trunk/include/cmath)
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/math.h?p2=libcxx/trunk/include/math.h&p1=libcxx/trunk/include/cmath&r1=249736&r2=249742&rev=249742&view=diff
==============================================================================
--- libcxx/trunk/include/cmath (original)
+++ libcxx/trunk/include/math.h Thu Oct 8 15:40:34 2015
@@ -1,5 +1,5 @@
// -*- C++ -*-
-//===---------------------------- cmath -----------------------------------===//
+//===---------------------------- math.h ----------------------------------===//
//
// The LLVM Compiler Infrastructure
//
@@ -8,11 +8,11 @@
//
//===----------------------------------------------------------------------===//
-#ifndef _LIBCPP_CMATH
-#define _LIBCPP_CMATH
+#ifndef _LIBCPP_MATH_H
+#define _LIBCPP_MATH_H
/*
- cmath synopsis
+ math.h synopsis
Macros:
@@ -35,9 +35,6 @@ Macros:
MATH_ERREXCEPT // C99
math_errhandling // C99
-namespace std
-{
-
Types:
float_t // C99
@@ -293,22 +290,27 @@ floating_point trunc (arithmetic x);
float truncf(float x);
long double truncl(long double x);
-} // std
-
*/
#include <__config>
-#include <math.h>
+#include_next <math.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+#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>
#ifdef _LIBCPP_MSVCRT
#include "support/win32/math_win32.h"
#endif
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#pragma GCC system_header
-#endif
-
// signbit
#ifdef signbit
@@ -633,32 +635,11 @@ isunordered(_A1 __lcpp_x, _A2 __lcpp_y)
#endif // isunordered
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-using ::signbit;
-using ::fpclassify;
-using ::isfinite;
-using ::isinf;
-using ::isnan;
-using ::isnormal;
-using ::isgreater;
-using ::isgreaterequal;
-using ::isless;
-using ::islessequal;
-using ::islessgreater;
-using ::isunordered;
-using ::isunordered;
-
-using ::float_t;
-using ::double_t;
+#ifndef __sun__
// abs
-#if defined(__sun__)
-using ::abs;
-#endif
-
-#if !defined(_AIX) && !defined(__sun__)
+#if !defined(_AIX)
inline _LIBCPP_INLINE_VISIBILITY
float
abs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);}
@@ -672,13 +653,8 @@ long double
abs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);}
#endif // !defined(_AIX)
-#ifndef __sun__
-
// acos
-using ::acos;
-using ::acosf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float acos(float __lcpp_x) _NOEXCEPT {return acosf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return acosl(__lcpp_x);}
@@ -686,14 +662,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
acos(_A1 __lcpp_x) _NOEXCEPT {return acos((double)__lcpp_x);}
// asin
-using ::asin;
-using ::asinf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float asin(float __lcpp_x) _NOEXCEPT {return asinf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return asinl(__lcpp_x);}
@@ -701,14 +674,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
asin(_A1 __lcpp_x) _NOEXCEPT {return asin((double)__lcpp_x);}
// atan
-using ::atan;
-using ::atanf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float atan(float __lcpp_x) _NOEXCEPT {return atanf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return atanl(__lcpp_x);}
@@ -716,14 +686,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
atan(_A1 __lcpp_x) _NOEXCEPT {return atan((double)__lcpp_x);}
// atan2
-using ::atan2;
-using ::atan2f;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT {return atan2f(__lcpp_y, __lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return atan2l(__lcpp_y, __lcpp_x);}
@@ -731,25 +698,22 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
atan2(_A1 __lcpp_y, _A2 __lcpp_x) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return atan2((__result_type)__lcpp_y, (__result_type)__lcpp_x);
}
// ceil
-using ::ceil;
-using ::ceilf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float ceil(float __lcpp_x) _NOEXCEPT {return ceilf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ceill(__lcpp_x);}
@@ -757,14 +721,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
ceil(_A1 __lcpp_x) _NOEXCEPT {return ceil((double)__lcpp_x);}
// cos
-using ::cos;
-using ::cosf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float cos(float __lcpp_x) _NOEXCEPT {return cosf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return cosl(__lcpp_x);}
@@ -772,14 +733,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
cos(_A1 __lcpp_x) _NOEXCEPT {return cos((double)__lcpp_x);}
// cosh
-using ::cosh;
-using ::coshf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float cosh(float __lcpp_x) _NOEXCEPT {return coshf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return coshl(__lcpp_x);}
@@ -787,33 +745,23 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
cosh(_A1 __lcpp_x) _NOEXCEPT {return cosh((double)__lcpp_x);}
-#endif // __sun__
// exp
-using ::exp;
-using ::expf;
-
-#ifndef __sun__
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float exp(float __lcpp_x) _NOEXCEPT {return expf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return expl(__lcpp_x);}
#endif
-
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
exp(_A1 __lcpp_x) _NOEXCEPT {return exp((double)__lcpp_x);}
// fabs
-using ::fabs;
-using ::fabsf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float fabs(float __lcpp_x) _NOEXCEPT {return fabsf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return fabsl(__lcpp_x);}
@@ -821,14 +769,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
fabs(_A1 __lcpp_x) _NOEXCEPT {return fabs((double)__lcpp_x);}
// floor
-using ::floor;
-using ::floorf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float floor(float __lcpp_x) _NOEXCEPT {return floorf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return floorl(__lcpp_x);}
@@ -836,16 +781,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
floor(_A1 __lcpp_x) _NOEXCEPT {return floor((double)__lcpp_x);}
// fmod
-#endif //__sun__
-using ::fmod;
-using ::fmodf;
-#ifndef __sun__
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmodf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmodl(__lcpp_x, __lcpp_y);}
@@ -853,26 +793,22 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
fmod(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return fmod((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
-
// frexp
-using ::frexp;
-using ::frexpf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpf(__lcpp_x, __lcpp_e);}
inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexpl(__lcpp_x, __lcpp_e);}
@@ -880,14 +816,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
frexp(_A1 __lcpp_x, int* __lcpp_e) _NOEXCEPT {return frexp((double)__lcpp_x, __lcpp_e);}
// ldexp
-using ::ldexp;
-using ::ldexpf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpf(__lcpp_x, __lcpp_e);}
inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexpl(__lcpp_x, __lcpp_e);}
@@ -895,16 +828,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
ldexp(_A1 __lcpp_x, int __lcpp_e) _NOEXCEPT {return ldexp((double)__lcpp_x, __lcpp_e);}
// log
-#endif // __sun__
-using ::log;
-using ::logf;
-#ifndef __sun__
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float log(float __lcpp_x) _NOEXCEPT {return logf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return logl(__lcpp_x);}
@@ -912,15 +840,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
log(_A1 __lcpp_x) _NOEXCEPT {return log((double)__lcpp_x);}
-
// log10
-using ::log10;
-using ::log10f;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float log10(float __lcpp_x) _NOEXCEPT {return log10f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return log10l(__lcpp_x);}
@@ -928,14 +852,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
log10(_A1 __lcpp_x) _NOEXCEPT {return log10((double)__lcpp_x);}
// modf
-using ::modf;
-using ::modff;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT {return modff(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return modfl(__lcpp_x, __lcpp_y);}
@@ -943,12 +864,6 @@ inline _LIBCPP_INLINE_VISIBILITY long do
// pow
-#endif // __sun__
-using ::pow;
-using ::powf;
-
-#ifndef __sun__
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return powf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return powl(__lcpp_x, __lcpp_y);}
@@ -956,25 +871,22 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
pow(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return pow((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
// sin
-using ::sin;
-using ::sinf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float sin(float __lcpp_x) _NOEXCEPT {return sinf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return sinl(__lcpp_x);}
@@ -982,14 +894,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
sin(_A1 __lcpp_x) _NOEXCEPT {return sin((double)__lcpp_x);}
// sinh
-using ::sinh;
-using ::sinhf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float sinh(float __lcpp_x) _NOEXCEPT {return sinhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return sinhl(__lcpp_x);}
@@ -997,32 +906,25 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
sinh(_A1 __lcpp_x) _NOEXCEPT {return sinh((double)__lcpp_x);}
// sqrt
-#endif // __sun__
-using ::sqrt;
-using ::sqrtf;
-
-
-#if !(defined(_LIBCPP_MSVCRT) || defined(__sun__) || defined(_AIX))
+#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float sqrt(float __lcpp_x) _NOEXCEPT {return sqrtf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return sqrtl(__lcpp_x);}
#endif
+#endif // __sun__
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
sqrt(_A1 __lcpp_x) _NOEXCEPT {return sqrt((double)__lcpp_x);}
+#ifndef __sun__
// tan
-using ::tan;
-using ::tanf;
-#ifndef __sun__
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float tan(float __lcpp_x) _NOEXCEPT {return tanf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return tanl(__lcpp_x);}
@@ -1030,14 +932,11 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
tan(_A1 __lcpp_x) _NOEXCEPT {return tan((double)__lcpp_x);}
// tanh
-using ::tanh;
-using ::tanhf;
-
#if !(defined(_LIBCPP_MSVCRT) || defined(_AIX))
inline _LIBCPP_INLINE_VISIBILITY float tanh(float __lcpp_x) _NOEXCEPT {return tanhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return tanhl(__lcpp_x);}
@@ -1045,74 +944,59 @@ inline _LIBCPP_INLINE_VISIBILITY long do
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
tanh(_A1 __lcpp_x) _NOEXCEPT {return tanh((double)__lcpp_x);}
// acosh
#ifndef _LIBCPP_MSVCRT
-using ::acosh;
-using ::acoshf;
-
inline _LIBCPP_INLINE_VISIBILITY float acosh(float __lcpp_x) _NOEXCEPT {return acoshf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return acoshl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
acosh(_A1 __lcpp_x) _NOEXCEPT {return acosh((double)__lcpp_x);}
#endif
// asinh
#ifndef _LIBCPP_MSVCRT
-using ::asinh;
-using ::asinhf;
-
inline _LIBCPP_INLINE_VISIBILITY float asinh(float __lcpp_x) _NOEXCEPT {return asinhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return asinhl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
asinh(_A1 __lcpp_x) _NOEXCEPT {return asinh((double)__lcpp_x);}
#endif
// atanh
#ifndef _LIBCPP_MSVCRT
-using ::atanh;
-using ::atanhf;
-
inline _LIBCPP_INLINE_VISIBILITY float atanh(float __lcpp_x) _NOEXCEPT {return atanhf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return atanhl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
atanh(_A1 __lcpp_x) _NOEXCEPT {return atanh((double)__lcpp_x);}
#endif
// cbrt
#ifndef _LIBCPP_MSVCRT
-using ::cbrt;
-using ::cbrtf;
-
inline _LIBCPP_INLINE_VISIBILITY float cbrt(float __lcpp_x) _NOEXCEPT {return cbrtf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return cbrtl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
cbrt(_A1 __lcpp_x) _NOEXCEPT {return cbrt((double)__lcpp_x);}
#endif
// copysign
-using ::copysign;
-using ::copysignf;
-
#if !defined(_VC_CRT_MAJOR_VERSION) || (_VC_CRT_MAJOR_VERSION < 12)
inline _LIBCPP_INLINE_VISIBILITY float copysign(float __lcpp_x,
float __lcpp_y) _NOEXCEPT {
@@ -1126,17 +1010,17 @@ copysign(long double __lcpp_x, long doub
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return copysign((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
@@ -1144,554 +1028,391 @@ copysign(_A1 __lcpp_x, _A2 __lcpp_y) _NO
// erf
-using ::erf;
-using ::erff;
-
inline _LIBCPP_INLINE_VISIBILITY float erf(float __lcpp_x) _NOEXCEPT {return erff(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return erfl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
erf(_A1 __lcpp_x) _NOEXCEPT {return erf((double)__lcpp_x);}
// erfc
-using ::erfc;
-using ::erfcf;
-
inline _LIBCPP_INLINE_VISIBILITY float erfc(float __lcpp_x) _NOEXCEPT {return erfcf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return erfcl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
erfc(_A1 __lcpp_x) _NOEXCEPT {return erfc((double)__lcpp_x);}
// exp2
-using ::exp2;
-using ::exp2f;
-
inline _LIBCPP_INLINE_VISIBILITY float exp2(float __lcpp_x) _NOEXCEPT {return exp2f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return exp2l(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
exp2(_A1 __lcpp_x) _NOEXCEPT {return exp2((double)__lcpp_x);}
// expm1
-using ::expm1;
-using ::expm1f;
-
inline _LIBCPP_INLINE_VISIBILITY float expm1(float __lcpp_x) _NOEXCEPT {return expm1f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return expm1l(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
expm1(_A1 __lcpp_x) _NOEXCEPT {return expm1((double)__lcpp_x);}
// fdim
-using ::fdim;
-using ::fdimf;
-
inline _LIBCPP_INLINE_VISIBILITY float fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fdimf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fdiml(__lcpp_x, __lcpp_y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
fdim(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return fdim((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
// fma
-using ::fmaf;
-using ::fma;
-
inline _LIBCPP_INLINE_VISIBILITY float fma(float __lcpp_x, float __lcpp_y, float __lcpp_z) _NOEXCEPT {return fmaf(__lcpp_x, __lcpp_y, __lcpp_z);}
inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT {return fmal(__lcpp_x, __lcpp_y, __lcpp_z);}
template <class _A1, class _A2, class _A3>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value &&
- is_arithmetic<_A3>::value,
- __promote<_A1, _A2, _A3>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value &&
+ std::is_arithmetic<_A3>::value,
+ std::__promote<_A1, _A2, _A3>
>::type
fma(_A1 __lcpp_x, _A2 __lcpp_y, _A3 __lcpp_z) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2, _A3>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value &&
- is_same<_A3, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2, _A3>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value &&
+ std::is_same<_A3, __result_type>::value)), "");
return fma((__result_type)__lcpp_x, (__result_type)__lcpp_y, (__result_type)__lcpp_z);
}
// fmax
-using ::fmax;
-using ::fmaxf;
-
inline _LIBCPP_INLINE_VISIBILITY float fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fmaxf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fmaxl(__lcpp_x, __lcpp_y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
fmax(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return fmax((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
// fmin
-using ::fmin;
-using ::fminf;
-
inline _LIBCPP_INLINE_VISIBILITY float fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return fminf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return fminl(__lcpp_x, __lcpp_y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
fmin(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return fmin((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
// hypot
-using ::hypot;
-using ::hypotf;
-
inline _LIBCPP_INLINE_VISIBILITY float hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return hypotf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return hypotl(__lcpp_x, __lcpp_y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
hypot(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return hypot((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
// ilogb
-using ::ilogb;
-using ::ilogbf;
-
inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT {return ilogbf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ilogbl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, int>::type
+typename std::enable_if<std::is_integral<_A1>::value, int>::type
ilogb(_A1 __lcpp_x) _NOEXCEPT {return ilogb((double)__lcpp_x);}
// lgamma
-using ::lgamma;
-using ::lgammaf;
-
inline _LIBCPP_INLINE_VISIBILITY float lgamma(float __lcpp_x) _NOEXCEPT {return lgammaf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return lgammal(__lcpp_x);}
-
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
lgamma(_A1 __lcpp_x) _NOEXCEPT {return lgamma((double)__lcpp_x);}
-
// llrint
-using ::llrint;
-using ::llrintf;
-
inline _LIBCPP_INLINE_VISIBILITY long long llrint(float __lcpp_x) _NOEXCEPT {return llrintf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT {return llrintl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long long>::type
+typename std::enable_if<std::is_integral<_A1>::value, long long>::type
llrint(_A1 __lcpp_x) _NOEXCEPT {return llrint((double)__lcpp_x);}
// llround
-using ::llround;
-using ::llroundf;
-
inline _LIBCPP_INLINE_VISIBILITY long long llround(float __lcpp_x) _NOEXCEPT {return llroundf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT {return llroundl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long long>::type
+typename std::enable_if<std::is_integral<_A1>::value, long long>::type
llround(_A1 __lcpp_x) _NOEXCEPT {return llround((double)__lcpp_x);}
// log1p
-using ::log1p;
-using ::log1pf;
-
inline _LIBCPP_INLINE_VISIBILITY float log1p(float __lcpp_x) _NOEXCEPT {return log1pf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return log1pl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
log1p(_A1 __lcpp_x) _NOEXCEPT {return log1p((double)__lcpp_x);}
// log2
-using ::log2;
-using ::log2f;
-
inline _LIBCPP_INLINE_VISIBILITY float log2(float __lcpp_x) _NOEXCEPT {return log2f(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return log2l(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
log2(_A1 __lcpp_x) _NOEXCEPT {return log2((double)__lcpp_x);}
// logb
-using ::logb;
-using ::logbf;
-
inline _LIBCPP_INLINE_VISIBILITY float logb(float __lcpp_x) _NOEXCEPT {return logbf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return logbl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
logb(_A1 __lcpp_x) _NOEXCEPT {return logb((double)__lcpp_x);}
// lrint
-using ::lrint;
-using ::lrintf;
-
inline _LIBCPP_INLINE_VISIBILITY long lrint(float __lcpp_x) _NOEXCEPT {return lrintf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT {return lrintl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long>::type
+typename std::enable_if<std::is_integral<_A1>::value, long>::type
lrint(_A1 __lcpp_x) _NOEXCEPT {return lrint((double)__lcpp_x);}
// lround
-using ::lround;
-using ::lroundf;
-
inline _LIBCPP_INLINE_VISIBILITY long lround(float __lcpp_x) _NOEXCEPT {return lroundf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT {return lroundl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, long>::type
+typename std::enable_if<std::is_integral<_A1>::value, long>::type
lround(_A1 __lcpp_x) _NOEXCEPT {return lround((double)__lcpp_x);}
-#endif // _LIBCPP_MSVCRT
-#endif // __sun__
-
// nan
-#ifndef _LIBCPP_MSVCRT
-using ::nan;
-using ::nanf;
-#endif // _LIBCPP_MSVCRT
-
-#ifndef __sun__
-#ifndef _LIBCPP_MSVCRT
-
// nearbyint
-using ::nearbyint;
-using ::nearbyintf;
-
inline _LIBCPP_INLINE_VISIBILITY float nearbyint(float __lcpp_x) _NOEXCEPT {return nearbyintf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return nearbyintl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
nearbyint(_A1 __lcpp_x) _NOEXCEPT {return nearbyint((double)__lcpp_x);}
// nextafter
-using ::nextafter;
-using ::nextafterf;
-
inline _LIBCPP_INLINE_VISIBILITY float nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return nextafterf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nextafterl(__lcpp_x, __lcpp_y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
nextafter(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return nextafter((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
// nexttoward
-using ::nexttoward;
-using ::nexttowardf;
-
inline _LIBCPP_INLINE_VISIBILITY float nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttowardl(__lcpp_x, __lcpp_y);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return nexttoward((double)__lcpp_x, __lcpp_y);}
// remainder
-using ::remainder;
-using ::remainderf;
-
inline _LIBCPP_INLINE_VISIBILITY float remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT {return remainderf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return remainderl(__lcpp_x, __lcpp_y);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
remainder(_A1 __lcpp_x, _A2 __lcpp_y) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return remainder((__result_type)__lcpp_x, (__result_type)__lcpp_y);
}
// remquo
-using ::remquo;
-using ::remquof;
-
inline _LIBCPP_INLINE_VISIBILITY float remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquof(__lcpp_x, __lcpp_y, __lcpp_z);}
inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return remquol(__lcpp_x, __lcpp_y, __lcpp_z);}
template <class _A1, class _A2>
inline _LIBCPP_INLINE_VISIBILITY
-typename __lazy_enable_if
+typename std::__lazy_enable_if
<
- is_arithmetic<_A1>::value &&
- is_arithmetic<_A2>::value,
- __promote<_A1, _A2>
+ std::is_arithmetic<_A1>::value &&
+ std::is_arithmetic<_A2>::value,
+ std::__promote<_A1, _A2>
>::type
remquo(_A1 __lcpp_x, _A2 __lcpp_y, int* __lcpp_z) _NOEXCEPT
{
- typedef typename __promote<_A1, _A2>::type __result_type;
- static_assert((!(is_same<_A1, __result_type>::value &&
- is_same<_A2, __result_type>::value)), "");
+ typedef typename std::__promote<_A1, _A2>::type __result_type;
+ static_assert((!(std::is_same<_A1, __result_type>::value &&
+ std::is_same<_A2, __result_type>::value)), "");
return remquo((__result_type)__lcpp_x, (__result_type)__lcpp_y, __lcpp_z);
}
// rint
-using ::rint;
-using ::rintf;
-
inline _LIBCPP_INLINE_VISIBILITY float rint(float __lcpp_x) _NOEXCEPT {return rintf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT {return rintl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
rint(_A1 __lcpp_x) _NOEXCEPT {return rint((double)__lcpp_x);}
// round
-using ::round;
-using ::roundf;
-
inline _LIBCPP_INLINE_VISIBILITY float round(float __lcpp_x) _NOEXCEPT {return roundf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT {return roundl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
round(_A1 __lcpp_x) _NOEXCEPT {return round((double)__lcpp_x);}
// scalbln
-using ::scalbln;
-using ::scalblnf;
-
inline _LIBCPP_INLINE_VISIBILITY float scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalblnl(__lcpp_x, __lcpp_y);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
scalbln(_A1 __lcpp_x, long __lcpp_y) _NOEXCEPT {return scalbln((double)__lcpp_x, __lcpp_y);}
// scalbn
-using ::scalbn;
-using ::scalbnf;
-
inline _LIBCPP_INLINE_VISIBILITY float scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnf(__lcpp_x, __lcpp_y);}
inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbnl(__lcpp_x, __lcpp_y);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
scalbn(_A1 __lcpp_x, int __lcpp_y) _NOEXCEPT {return scalbn((double)__lcpp_x, __lcpp_y);}
// tgamma
-using ::tgamma;
-using ::tgammaf;
-
inline _LIBCPP_INLINE_VISIBILITY float tgamma(float __lcpp_x) _NOEXCEPT {return tgammaf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return tgammal(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
tgamma(_A1 __lcpp_x) _NOEXCEPT {return tgamma((double)__lcpp_x);}
// trunc
-using ::trunc;
-using ::truncf;
-
inline _LIBCPP_INLINE_VISIBILITY float trunc(float __lcpp_x) _NOEXCEPT {return truncf(__lcpp_x);}
inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT {return truncl(__lcpp_x);}
template <class _A1>
inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if<is_integral<_A1>::value, double>::type
+typename std::enable_if<std::is_integral<_A1>::value, double>::type
trunc(_A1 __lcpp_x) _NOEXCEPT {return trunc((double)__lcpp_x);}
#endif // !_LIBCPP_MSVCRT
+#endif // __sun__
-using ::acosl;
-using ::asinl;
-using ::atanl;
-using ::atan2l;
-using ::ceill;
-using ::cosl;
-using ::coshl;
-using ::expl;
-using ::fabsl;
-using ::floorl;
-using ::fmodl;
-using ::frexpl;
-using ::ldexpl;
-using ::logl;
-using ::log10l;
-using ::modfl;
-using ::powl;
-using ::sinl;
-using ::sinhl;
-using ::sqrtl;
-using ::tanl;
-#ifndef _LIBCPP_MSVCRT
-using ::tanhl;
-using ::acoshl;
-using ::asinhl;
-using ::atanhl;
-using ::cbrtl;
-#endif // !_LIBCPP_MSVCRT
-using ::copysignl;
-#ifndef _LIBCPP_MSVCRT
-using ::erfl;
-using ::erfcl;
-using ::exp2l;
-using ::expm1l;
-using ::fdiml;
-using ::fmal;
-using ::fmaxl;
-using ::fminl;
-using ::hypotl;
-using ::ilogbl;
-using ::lgammal;
-using ::llrintl;
-using ::llroundl;
-using ::log1pl;
-using ::log2l;
-using ::logbl;
-using ::lrintl;
-using ::lroundl;
-using ::nanl;
-using ::nearbyintl;
-using ::nextafterl;
-using ::nexttowardl;
-using ::remainderl;
-using ::remquol;
-using ::rintl;
-using ::roundl;
-using ::scalblnl;
-using ::scalbnl;
-using ::tgammal;
-using ::truncl;
-#endif // !_LIBCPP_MSVCRT
+} // extern "C++"
-#else
-using ::lgamma;
-using ::lgammaf;
-#endif // __sun__
-_LIBCPP_END_NAMESPACE_STD
+#endif // __cplusplus
-#endif // _LIBCPP_CMATH
+#endif // _LIBCPP_MATH_H
Modified: libcxx/trunk/test/std/depr/depr.c.headers/math_h.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/depr/depr.c.headers/math_h.pass.cpp?rev=249742&r1=249741&r2=249742&view=diff
==============================================================================
--- libcxx/trunk/test/std/depr/depr.c.headers/math_h.pass.cpp (original)
+++ libcxx/trunk/test/std/depr/depr.c.headers/math_h.pass.cpp Thu Oct 8 15:40:34 2015
@@ -9,7 +9,8 @@
// <math.h>
-// XFAIL: linux
+// NOTE: isinf and isnan are tested separately because they are expected to fail
+// on linux. We don't want their expected failure to hide other failures in this file.
#include <math.h>
#include <type_traits>
@@ -17,498 +18,1168 @@
#include "hexfloat.h"
+// convertible to int/float/double/etc
+template <class T, int N=0>
+struct Value {
+ operator T () { return T(N); }
+};
+
+// See PR21083
+// Ambiguous is a user-defined type that defines its own overloads of cmath
+// functions. When the std overloads are candidates too (by using or adl),
+// they should not interfere.
+struct Ambiguous : std::true_type { // ADL
+ operator float () { return 0.f; }
+ operator double () { return 0.; }
+};
+Ambiguous abs(Ambiguous){ return Ambiguous(); }
+Ambiguous acos(Ambiguous){ return Ambiguous(); }
+Ambiguous asin(Ambiguous){ return Ambiguous(); }
+Ambiguous atan(Ambiguous){ return Ambiguous(); }
+Ambiguous atan2(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous ceil(Ambiguous){ return Ambiguous(); }
+Ambiguous cos(Ambiguous){ return Ambiguous(); }
+Ambiguous cosh(Ambiguous){ return Ambiguous(); }
+Ambiguous exp(Ambiguous){ return Ambiguous(); }
+Ambiguous fabs(Ambiguous){ return Ambiguous(); }
+Ambiguous floor(Ambiguous){ return Ambiguous(); }
+Ambiguous fmod(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous frexp(Ambiguous, int*){ return Ambiguous(); }
+Ambiguous ldexp(Ambiguous, int){ return Ambiguous(); }
+Ambiguous log(Ambiguous){ return Ambiguous(); }
+Ambiguous log10(Ambiguous){ return Ambiguous(); }
+Ambiguous modf(Ambiguous, Ambiguous*){ return Ambiguous(); }
+Ambiguous pow(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous sin(Ambiguous){ return Ambiguous(); }
+Ambiguous sinh(Ambiguous){ return Ambiguous(); }
+Ambiguous sqrt(Ambiguous){ return Ambiguous(); }
+Ambiguous tan(Ambiguous){ return Ambiguous(); }
+Ambiguous tanh(Ambiguous){ return Ambiguous(); }
+Ambiguous signbit(Ambiguous){ return Ambiguous(); }
+Ambiguous fpclassify(Ambiguous){ return Ambiguous(); }
+Ambiguous isfinite(Ambiguous){ return Ambiguous(); }
+Ambiguous isnormal(Ambiguous){ return Ambiguous(); }
+Ambiguous isgreater(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous isgreaterequal(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous isless(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous islessequal(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous islessgreater(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous isunordered(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous acosh(Ambiguous){ return Ambiguous(); }
+Ambiguous asinh(Ambiguous){ return Ambiguous(); }
+Ambiguous atanh(Ambiguous){ return Ambiguous(); }
+Ambiguous cbrt(Ambiguous){ return Ambiguous(); }
+Ambiguous copysign(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous erf(Ambiguous){ return Ambiguous(); }
+Ambiguous erfc(Ambiguous){ return Ambiguous(); }
+Ambiguous exp2(Ambiguous){ return Ambiguous(); }
+Ambiguous expm1(Ambiguous){ return Ambiguous(); }
+Ambiguous fdim(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous fma(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous fmax(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous fmin(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous hypot(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous ilogb(Ambiguous){ return Ambiguous(); }
+Ambiguous lgamma(Ambiguous){ return Ambiguous(); }
+Ambiguous llrint(Ambiguous){ return Ambiguous(); }
+Ambiguous llround(Ambiguous){ return Ambiguous(); }
+Ambiguous log1p(Ambiguous){ return Ambiguous(); }
+Ambiguous log2(Ambiguous){ return Ambiguous(); }
+Ambiguous logb(Ambiguous){ return Ambiguous(); }
+Ambiguous lrint(Ambiguous){ return Ambiguous(); }
+Ambiguous lround(Ambiguous){ return Ambiguous(); }
+Ambiguous nearbyint(Ambiguous){ return Ambiguous(); }
+Ambiguous nextafter(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous nexttoward(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous remainder(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous remquo(Ambiguous, Ambiguous, int*){ return Ambiguous(); }
+Ambiguous rint(Ambiguous){ return Ambiguous(); }
+Ambiguous round(Ambiguous){ return Ambiguous(); }
+Ambiguous scalbln(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous scalbn(Ambiguous, Ambiguous){ return Ambiguous(); }
+Ambiguous tgamma(Ambiguous){ return Ambiguous(); }
+Ambiguous trunc(Ambiguous){ return Ambiguous(); }
+
+void test_abs()
+{
+ static_assert((std::is_same<decltype(abs((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(abs((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(abs((long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value), "");
+ assert(abs(-1.) == 1);
+}
+
void test_acos()
{
+ static_assert((std::is_same<decltype(acos((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(acos((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(acos((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acos((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(acosf(0)), float>::value), "");
static_assert((std::is_same<decltype(acosl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(acos(Ambiguous())), Ambiguous>::value), "");
assert(acos(1) == 0);
}
void test_asin()
{
+ static_assert((std::is_same<decltype(asin((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(asin((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(asin((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asin((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(asinf(0)), float>::value), "");
static_assert((std::is_same<decltype(asinl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(asin(Ambiguous())), Ambiguous>::value), "");
assert(asin(0) == 0);
}
void test_atan()
{
+ static_assert((std::is_same<decltype(atan((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(atan((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(atan((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(atanf(0)), float>::value), "");
static_assert((std::is_same<decltype(atanl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(atan(Ambiguous())), Ambiguous>::value), "");
assert(atan(0) == 0);
}
void test_atan2()
{
+ static_assert((std::is_same<decltype(atan2((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(atan2((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(atan2((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(atan2((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(atan2((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(atan2((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(atan2((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(atan2f(0,0)), float>::value), "");
static_assert((std::is_same<decltype(atan2l(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(atan2((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atan2(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(atan2(0,1) == 0);
}
void test_ceil()
{
+ static_assert((std::is_same<decltype(ceil((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(ceil((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(ceil((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(ceil((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(ceilf(0)), float>::value), "");
static_assert((std::is_same<decltype(ceill(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(ceil(Ambiguous())), Ambiguous>::value), "");
assert(ceil(0) == 0);
}
void test_cos()
{
+ static_assert((std::is_same<decltype(cos((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(cos((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(cos((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cos((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(cosf(0)), float>::value), "");
static_assert((std::is_same<decltype(cosl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(cos(Ambiguous())), Ambiguous>::value), "");
assert(cos(0) == 1);
}
void test_cosh()
{
+ static_assert((std::is_same<decltype(cosh((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(cosh((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(cosh((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cosh((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(coshf(0)), float>::value), "");
static_assert((std::is_same<decltype(coshl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(cosh(Ambiguous())), Ambiguous>::value), "");
assert(cosh(0) == 1);
}
void test_exp()
{
+ static_assert((std::is_same<decltype(exp((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(exp((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(exp((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(expf(0)), float>::value), "");
static_assert((std::is_same<decltype(expl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(exp(Ambiguous())), Ambiguous>::value), "");
assert(exp(0) == 1);
}
void test_fabs()
{
+ static_assert((std::is_same<decltype(fabs((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(fabs((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fabs((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fabs((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fabs((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fabs((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fabs((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fabs((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fabs((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(fabs((double)0)), double>::value), "");
- static_assert((std::is_same<decltype(fabsf(0.f)), float>::value), "");
- static_assert((std::is_same<decltype(fabsl(0.L)), long double>::value), "");
- assert(fabs(-1.f) == 1);
+ static_assert((std::is_same<decltype(fabs((long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fabsf(0.0f)), float>::value), "");
+ static_assert((std::is_same<decltype(fabsl(0.0L)), long double>::value), "");
+ static_assert((std::is_same<decltype(fabs(Ambiguous())), Ambiguous>::value), "");
+ assert(fabs(-1) == 1);
}
void test_floor()
{
+ static_assert((std::is_same<decltype(floor((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(floor((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(floor((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(floor((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(floorf(0)), float>::value), "");
static_assert((std::is_same<decltype(floorl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(floor(Ambiguous())), Ambiguous>::value), "");
assert(floor(1) == 1);
}
void test_fmod()
{
+ static_assert((std::is_same<decltype(fmod((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(fmod((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmod((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmod((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(fmod((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmod((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmod((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(fmodf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(fmodl(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmod((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmod(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(fmod(1.5,1) == .5);
}
void test_frexp()
{
int ip;
+ static_assert((std::is_same<decltype(frexp((float)0, &ip)), float>::value), "");
+ static_assert((std::is_same<decltype(frexp((bool)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((unsigned short)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((int)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((unsigned int)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((long)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((unsigned long)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((long long)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((unsigned long long)0, &ip)), double>::value), "");
static_assert((std::is_same<decltype(frexp((double)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(frexp((long double)0, &ip)), long double>::value), "");
static_assert((std::is_same<decltype(frexpf(0, &ip)), float>::value), "");
static_assert((std::is_same<decltype(frexpl(0, &ip)), long double>::value), "");
+ static_assert((std::is_same<decltype(frexp(Ambiguous(), &ip)), Ambiguous>::value), "");
assert(frexp(0, &ip) == 0);
}
void test_ldexp()
{
int ip = 1;
+ static_assert((std::is_same<decltype(ldexp((float)0, ip)), float>::value), "");
+ static_assert((std::is_same<decltype(ldexp((bool)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((unsigned short)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((int)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((unsigned int)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((long)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((unsigned long)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((long long)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((unsigned long long)0, ip)), double>::value), "");
static_assert((std::is_same<decltype(ldexp((double)0, ip)), double>::value), "");
+ static_assert((std::is_same<decltype(ldexp((long double)0, ip)), long double>::value), "");
static_assert((std::is_same<decltype(ldexpf(0, ip)), float>::value), "");
static_assert((std::is_same<decltype(ldexpl(0, ip)), long double>::value), "");
+ static_assert((std::is_same<decltype(ldexp(Ambiguous(), ip)), Ambiguous>::value), "");
assert(ldexp(1, ip) == 2);
}
void test_log()
{
+ static_assert((std::is_same<decltype(log((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(log((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(log((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(logf(0)), float>::value), "");
static_assert((std::is_same<decltype(logl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(log(Ambiguous())), Ambiguous>::value), "");
assert(log(1) == 0);
}
void test_log10()
{
+ static_assert((std::is_same<decltype(log10((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(log10((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(log10((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log10((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(log10f(0)), float>::value), "");
static_assert((std::is_same<decltype(log10l(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(log10(Ambiguous())), Ambiguous>::value), "");
assert(log10(1) == 0);
}
void test_modf()
{
+ static_assert((std::is_same<decltype(modf((float)0, (float*)0)), float>::value), "");
static_assert((std::is_same<decltype(modf((double)0, (double*)0)), double>::value), "");
+ static_assert((std::is_same<decltype(modf((long double)0, (long double*)0)), long double>::value), "");
static_assert((std::is_same<decltype(modff(0, (float*)0)), float>::value), "");
static_assert((std::is_same<decltype(modfl(0, (long double*)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous>::value), "");
double i;
assert(modf(1., &i) == 0);
}
void test_pow()
{
+ static_assert((std::is_same<decltype(pow((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(pow((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(pow((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(pow((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(pow((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(pow((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(pow((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(pow((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(pow((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(pow((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(pow((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(pow((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(pow((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(pow((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(powf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(powl(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(pow((int)0, (int)0)), double>::value), "");
+// static_assert((std::is_same<decltype(pow(Value<int>(), (int)0)), double>::value), "");
+// static_assert((std::is_same<decltype(pow(Value<long double>(), (float)0)), long double>::value), "");
+// static_assert((std::is_same<decltype(pow((float) 0, Value<float>())), float>::value), "");
+ static_assert((std::is_same<decltype(pow(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(pow(1,1) == 1);
+// assert(pow(Value<int,1>(), Value<float,1>()) == 1);
+// assert(pow(1.0f, Value<double,1>()) == 1);
+// assert(pow(1.0, Value<int,1>()) == 1);
+// assert(pow(Value<long double,1>(), 1LL) == 1);
}
void test_sin()
{
+ static_assert((std::is_same<decltype(sin((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(sin((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(sin((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sin((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(sinf(0)), float>::value), "");
static_assert((std::is_same<decltype(sinl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(sin(Ambiguous())), Ambiguous>::value), "");
assert(sin(0) == 0);
}
void test_sinh()
{
+ static_assert((std::is_same<decltype(sinh((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(sinh((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(sinh((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sinh((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(sinhf(0)), float>::value), "");
static_assert((std::is_same<decltype(sinhl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(sinh(Ambiguous())), Ambiguous>::value), "");
assert(sinh(0) == 0);
}
void test_sqrt()
{
+ static_assert((std::is_same<decltype(sqrt((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(sqrt((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(sqrt((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(sqrt((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(sqrtf(0)), float>::value), "");
static_assert((std::is_same<decltype(sqrtl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(sqrt(Ambiguous())), Ambiguous>::value), "");
assert(sqrt(4) == 2);
}
void test_tan()
{
+ static_assert((std::is_same<decltype(tan((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(tan((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(tan((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tan((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(tanf(0)), float>::value), "");
static_assert((std::is_same<decltype(tanl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(tan(Ambiguous())), Ambiguous>::value), "");
assert(tan(0) == 0);
}
void test_tanh()
{
+ static_assert((std::is_same<decltype(tanh((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(tanh((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(tanh((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tanh((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(tanhf(0)), float>::value), "");
static_assert((std::is_same<decltype(tanhl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(tanh(Ambiguous())), Ambiguous>::value), "");
assert(tanh(0) == 0);
}
void test_signbit()
{
+#ifdef signbit
+#error signbit defined
+#endif
static_assert((std::is_same<decltype(signbit((float)0)), bool>::value), "");
static_assert((std::is_same<decltype(signbit((double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(signbit(0)), bool>::value), "");
static_assert((std::is_same<decltype(signbit((long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(signbit(Ambiguous())), Ambiguous>::value), "");
assert(signbit(-1.0) == true);
}
void test_fpclassify()
{
+#ifdef fpclassify
+#error fpclassify defined
+#endif
static_assert((std::is_same<decltype(fpclassify((float)0)), int>::value), "");
static_assert((std::is_same<decltype(fpclassify((double)0)), int>::value), "");
+ static_assert((std::is_same<decltype(fpclassify(0)), int>::value), "");
static_assert((std::is_same<decltype(fpclassify((long double)0)), int>::value), "");
+ static_assert((std::is_same<decltype(fpclassify(Ambiguous())), Ambiguous>::value), "");
assert(fpclassify(-1.0) == FP_NORMAL);
}
void test_isfinite()
{
+#ifdef isfinite
+#error isfinite defined
+#endif
static_assert((std::is_same<decltype(isfinite((float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isfinite((double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isfinite(0)), bool>::value), "");
static_assert((std::is_same<decltype(isfinite((long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isfinite(Ambiguous())), Ambiguous>::value), "");
assert(isfinite(-1.0) == true);
}
-void test_isinf()
-{
- static_assert((std::is_same<decltype(isinf((float)0)), bool>::value), "");
- static_assert((std::is_same<decltype(isinf((double)0)), bool>::value), "");
- static_assert((std::is_same<decltype(isinf((long double)0)), bool>::value), "");
- assert(isinf(-1.0) == false);
-}
-
-void test_isnan()
-{
- static_assert((std::is_same<decltype(isnan((float)0)), bool>::value), "");
- static_assert((std::is_same<decltype(isnan((double)0)), bool>::value), "");
- static_assert((std::is_same<decltype(isnan((long double)0)), bool>::value), "");
- assert(isnan(-1.0) == false);
-}
-
void test_isnormal()
{
+#ifdef isnormal
+#error isnormal defined
+#endif
static_assert((std::is_same<decltype(isnormal((float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isnormal((double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isnormal(0)), bool>::value), "");
static_assert((std::is_same<decltype(isnormal((long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isnormal(Ambiguous())), Ambiguous>::value), "");
assert(isnormal(-1.0) == true);
}
void test_isgreater()
{
+#ifdef isgreater
+#error isgreater defined
+#endif
static_assert((std::is_same<decltype(isgreater((float)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((float)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((float)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((double)0, (double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isgreater(0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((double)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((long double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((long double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreater((long double)0, (long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(isgreater(-1.0, 0.F) == false);
}
void test_isgreaterequal()
{
+#ifdef isgreaterequal
+#error isgreaterequal defined
+#endif
static_assert((std::is_same<decltype(isgreaterequal((float)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((float)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((float)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((double)0, (double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isgreaterequal(0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((double)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((long double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((long double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isgreaterequal((long double)0, (long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isgreaterequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(isgreaterequal(-1.0, 0.F) == false);
}
void test_isless()
{
+#ifdef isless
+#error isless defined
+#endif
static_assert((std::is_same<decltype(isless((float)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((float)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((float)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((double)0, (double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isless(0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((double)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((long double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((long double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isless((long double)0, (long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isless(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(isless(-1.0, 0.F) == true);
}
void test_islessequal()
{
+#ifdef islessequal
+#error islessequal defined
+#endif
static_assert((std::is_same<decltype(islessequal((float)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((float)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((float)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((double)0, (double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(islessequal(0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((double)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((long double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((long double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessequal((long double)0, (long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(islessequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(islessequal(-1.0, 0.F) == true);
}
void test_islessgreater()
{
+#ifdef islessgreater
+#error islessgreater defined
+#endif
static_assert((std::is_same<decltype(islessgreater((float)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((float)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((float)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((double)0, (double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(islessgreater(0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((double)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((long double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((long double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(islessgreater((long double)0, (long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(islessgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(islessgreater(-1.0, 0.F) == true);
}
void test_isunordered()
{
+#ifdef isunordered
+#error isunordered defined
+#endif
static_assert((std::is_same<decltype(isunordered((float)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((float)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((float)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((double)0, (double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isunordered(0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((double)0, (long double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((long double)0, (float)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((long double)0, (double)0)), bool>::value), "");
static_assert((std::is_same<decltype(isunordered((long double)0, (long double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isunordered(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(isunordered(-1.0, 0.F) == false);
}
void test_acosh()
{
+ static_assert((std::is_same<decltype(acosh((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(acosh((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(acosh((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(acosh((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(acoshf(0)), float>::value), "");
static_assert((std::is_same<decltype(acoshl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(acosh(Ambiguous())), Ambiguous>::value), "");
assert(acosh(1) == 0);
}
void test_asinh()
{
+ static_assert((std::is_same<decltype(asinh((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(asinh((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(asinh((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(asinh((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(asinhf(0)), float>::value), "");
static_assert((std::is_same<decltype(asinhl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(asinh(Ambiguous())), Ambiguous>::value), "");
assert(asinh(0) == 0);
}
void test_atanh()
{
+ static_assert((std::is_same<decltype(atanh((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(atanh((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(atanh((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(atanh((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(atanhf(0)), float>::value), "");
static_assert((std::is_same<decltype(atanhl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(atanh(Ambiguous())), Ambiguous>::value), "");
assert(atanh(0) == 0);
}
void test_cbrt()
{
+ static_assert((std::is_same<decltype(cbrt((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(cbrt((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(cbrt((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(cbrt((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(cbrtf(0)), float>::value), "");
static_assert((std::is_same<decltype(cbrtl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value), "");
assert(cbrt(1) == 1);
}
void test_copysign()
{
+ static_assert((std::is_same<decltype(copysign((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(copysign((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(copysign((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(copysign((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(copysign((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(copysign((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(copysign((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(copysignf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(copysignl(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(copysign((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(copysign(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(copysign(1,1) == 1);
}
void test_erf()
{
+ static_assert((std::is_same<decltype(erf((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(erf((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(erf((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erf((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(erff(0)), float>::value), "");
static_assert((std::is_same<decltype(erfl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(erf(Ambiguous())), Ambiguous>::value), "");
assert(erf(0) == 0);
}
void test_erfc()
{
+ static_assert((std::is_same<decltype(erfc((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(erfc((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(erfc((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(erfc((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(erfcf(0)), float>::value), "");
static_assert((std::is_same<decltype(erfcl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(erfc(Ambiguous())), Ambiguous>::value), "");
assert(erfc(0) == 1);
}
void test_exp2()
{
+ static_assert((std::is_same<decltype(exp2((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(exp2((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(exp2((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(exp2((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(exp2f(0)), float>::value), "");
static_assert((std::is_same<decltype(exp2l(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(exp2(Ambiguous())), Ambiguous>::value), "");
assert(exp2(1) == 2);
}
void test_expm1()
{
+ static_assert((std::is_same<decltype(expm1((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(expm1((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(expm1((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(expm1((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(expm1f(0)), float>::value), "");
static_assert((std::is_same<decltype(expm1l(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(expm1(Ambiguous())), Ambiguous>::value), "");
assert(expm1(0) == 0);
}
void test_fdim()
{
+ static_assert((std::is_same<decltype(fdim((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(fdim((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fdim((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fdim((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(fdim((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fdim((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fdim((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(fdimf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(fdiml(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fdim((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fdim(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(fdim(1,0) == 1);
}
void test_fma()
{
+ static_assert((std::is_same<decltype(fma((bool)0, (float)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((char)0, (float)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((unsigned)0, (float)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((float)0, (int)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((float)0, (long)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((float)0, (float)0, (unsigned long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((float)0, (float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((float)0, (float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((float)0, (float)0, (float)0)), float>::value), "");
+
+ static_assert((std::is_same<decltype(fma((bool)0, (double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((char)0, (double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((unsigned)0, (double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((double)0, (int)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((double)0, (long)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((double)0, (double)0, (unsigned long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((double)0, (double)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fma((double)0, (double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(fma((double)0, (double)0, (double)0)), double>::value), "");
+
+ static_assert((std::is_same<decltype(fma((bool)0, (long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((char)0, (long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((unsigned)0, (long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((long double)0, (int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((long double)0, (long)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (unsigned long long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (float)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((double)0, (long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (long double)0)), long double>::value), "");
+
static_assert((std::is_same<decltype(fmaf(0,0,0)), float>::value), "");
static_assert((std::is_same<decltype(fmal(0,0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fma(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(fma(1,1,1) == 2);
}
void test_fmax()
{
+ static_assert((std::is_same<decltype(fmax((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(fmax((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmax((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmax((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(fmax((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmax((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmax((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(fmaxf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(fmaxl(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmax((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmax(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(fmax(1,0) == 1);
}
void test_fmin()
{
+ static_assert((std::is_same<decltype(fmin((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(fmin((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmin((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmin((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(fmin((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmin((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmin((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(fminf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(fminl(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(fmin((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(fmin(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(fmin(1,0) == 0);
}
void test_hypot()
{
+ static_assert((std::is_same<decltype(hypot((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(hypot((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(hypot((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(hypot((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(hypot((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(hypot((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(hypot((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(hypotf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(hypotl(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(hypot((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(hypot(3,4) == 5);
}
void test_ilogb()
{
+ static_assert((std::is_same<decltype(ilogb((float)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((bool)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((unsigned short)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((int)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((unsigned int)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((long)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((unsigned long)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((long long)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((unsigned long long)0)), int>::value), "");
static_assert((std::is_same<decltype(ilogb((double)0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb((long double)0)), int>::value), "");
static_assert((std::is_same<decltype(ilogbf(0)), int>::value), "");
static_assert((std::is_same<decltype(ilogbl(0)), int>::value), "");
+ static_assert((std::is_same<decltype(ilogb(Ambiguous())), Ambiguous>::value), "");
assert(ilogb(1) == 0);
}
void test_lgamma()
{
+ static_assert((std::is_same<decltype(lgamma((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(lgamma((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(lgamma((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(lgamma((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(lgammaf(0)), float>::value), "");
static_assert((std::is_same<decltype(lgammal(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(lgamma(Ambiguous())), Ambiguous>::value), "");
assert(lgamma(1) == 0);
}
void test_llrint()
{
+ static_assert((std::is_same<decltype(llrint((float)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((bool)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((unsigned short)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((int)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((unsigned int)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((long)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((unsigned long)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((long long)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((unsigned long long)0)), long long>::value), "");
static_assert((std::is_same<decltype(llrint((double)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint((long double)0)), long long>::value), "");
static_assert((std::is_same<decltype(llrintf(0)), long long>::value), "");
static_assert((std::is_same<decltype(llrintl(0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llrint(Ambiguous())), Ambiguous>::value), "");
assert(llrint(1) == 1LL);
}
void test_llround()
{
+ static_assert((std::is_same<decltype(llround((float)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((bool)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((unsigned short)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((int)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((unsigned int)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((long)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((unsigned long)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((long long)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((unsigned long long)0)), long long>::value), "");
static_assert((std::is_same<decltype(llround((double)0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround((long double)0)), long long>::value), "");
static_assert((std::is_same<decltype(llroundf(0)), long long>::value), "");
static_assert((std::is_same<decltype(llroundl(0)), long long>::value), "");
+ static_assert((std::is_same<decltype(llround(Ambiguous())), Ambiguous>::value), "");
assert(llround(1) == 1LL);
}
void test_log1p()
{
+ static_assert((std::is_same<decltype(log1p((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(log1p((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(log1p((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log1p((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(log1pf(0)), float>::value), "");
static_assert((std::is_same<decltype(log1pl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(log1p(Ambiguous())), Ambiguous>::value), "");
assert(log1p(0) == 0);
}
void test_log2()
{
+ static_assert((std::is_same<decltype(log2((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(log2((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(log2((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(log2((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(log2f(0)), float>::value), "");
static_assert((std::is_same<decltype(log2l(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(log2(Ambiguous())), Ambiguous>::value), "");
assert(log2(1) == 0);
}
void test_logb()
{
+ static_assert((std::is_same<decltype(logb((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(logb((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(logb((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(logb((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(logbf(0)), float>::value), "");
static_assert((std::is_same<decltype(logbl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(logb(Ambiguous())), Ambiguous>::value), "");
assert(logb(1) == 0);
}
void test_lrint()
{
+ static_assert((std::is_same<decltype(lrint((float)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((bool)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((unsigned short)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((int)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((unsigned int)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((long)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((unsigned long)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((long long)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((unsigned long long)0)), long>::value), "");
static_assert((std::is_same<decltype(lrint((double)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint((long double)0)), long>::value), "");
static_assert((std::is_same<decltype(lrintf(0)), long>::value), "");
static_assert((std::is_same<decltype(lrintl(0)), long>::value), "");
+ static_assert((std::is_same<decltype(lrint(Ambiguous())), Ambiguous>::value), "");
assert(lrint(1) == 1L);
}
void test_lround()
{
+ static_assert((std::is_same<decltype(lround((float)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((bool)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((unsigned short)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((int)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((unsigned int)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((long)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((unsigned long)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((long long)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((unsigned long long)0)), long>::value), "");
static_assert((std::is_same<decltype(lround((double)0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround((long double)0)), long>::value), "");
static_assert((std::is_same<decltype(lroundf(0)), long>::value), "");
static_assert((std::is_same<decltype(lroundl(0)), long>::value), "");
+ static_assert((std::is_same<decltype(lround(Ambiguous())), Ambiguous>::value), "");
assert(lround(1) == 1L);
}
@@ -521,96 +1192,229 @@ void test_nan()
void test_nearbyint()
{
+ static_assert((std::is_same<decltype(nearbyint((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(nearbyint((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(nearbyintf(0)), float>::value), "");
static_assert((std::is_same<decltype(nearbyintl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(nearbyint(Ambiguous())), Ambiguous>::value), "");
assert(nearbyint(1) == 1);
}
void test_nextafter()
{
+ static_assert((std::is_same<decltype(nextafter((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(nextafter((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(nextafter((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(nextafterf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(nextafterl(0,0)), long double>::value), "");
+ static_assert((std::is_same<decltype(nextafter((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nextafter(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(nextafter(0,1) == hexfloat<double>(0x1, 0, -1074));
}
void test_nexttoward()
{
+ static_assert((std::is_same<decltype(nexttoward((float)0, (long double)0)), float>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((bool)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((unsigned short)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((int)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((unsigned int)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((long)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((unsigned long)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((long long)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((unsigned long long)0, (long double)0)), double>::value), "");
static_assert((std::is_same<decltype(nexttoward((double)0, (long double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward((long double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(nexttowardf(0, (long double)0)), float>::value), "");
static_assert((std::is_same<decltype(nexttowardl(0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(nexttoward(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(nexttoward(0, 1) == hexfloat<double>(0x1, 0, -1074));
}
void test_remainder()
{
+ static_assert((std::is_same<decltype(remainder((float)0, (float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(remainder((bool)0, (float)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder((unsigned short)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder((int)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(remainder((float)0, (unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder((long double)0, (unsigned long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(remainder((int)0, (long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder((int)0, (unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(remainder((double)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder((long double)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(remainder((float)0, (double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder((float)0, (long double)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(remainder((double)0, (long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(remainderf(0,0)), float>::value), "");
static_assert((std::is_same<decltype(remainderl(0,0)), long double>::value), "");
static_assert((std::is_same<decltype(remainder((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(remainder(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(remainder(0.5,1) == 0.5);
}
void test_remquo()
{
int ip;
+ static_assert((std::is_same<decltype(remquo((float)0, (float)0, &ip)), float>::value), "");
+ static_assert((std::is_same<decltype(remquo((bool)0, (float)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo((unsigned short)0, (double)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo((int)0, (long double)0, &ip)), long double>::value), "");
+ static_assert((std::is_same<decltype(remquo((float)0, (unsigned int)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo((double)0, (long)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo((long double)0, (unsigned long)0, &ip)), long double>::value), "");
+ static_assert((std::is_same<decltype(remquo((int)0, (long long)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo((int)0, (unsigned long long)0, &ip)), double>::value), "");
static_assert((std::is_same<decltype(remquo((double)0, (double)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo((long double)0, (long double)0, &ip)), long double>::value), "");
+ static_assert((std::is_same<decltype(remquo((float)0, (double)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo((float)0, (long double)0, &ip)), long double>::value), "");
+ static_assert((std::is_same<decltype(remquo((double)0, (long double)0, &ip)), long double>::value), "");
static_assert((std::is_same<decltype(remquof(0,0, &ip)), float>::value), "");
static_assert((std::is_same<decltype(remquol(0,0, &ip)), long double>::value), "");
+ static_assert((std::is_same<decltype(remquo((int)0, (int)0, &ip)), double>::value), "");
+ static_assert((std::is_same<decltype(remquo(Ambiguous(), Ambiguous(), &ip)), Ambiguous>::value), "");
assert(remquo(0.5,1, &ip) == 0.5);
}
void test_rint()
{
+ static_assert((std::is_same<decltype(rint((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(rint((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(rint((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(rint((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(rintf(0)), float>::value), "");
static_assert((std::is_same<decltype(rintl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(rint(Ambiguous())), Ambiguous>::value), "");
assert(rint(1) == 1);
}
void test_round()
{
+ static_assert((std::is_same<decltype(round((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(round((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(round((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(round((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(roundf(0)), float>::value), "");
static_assert((std::is_same<decltype(roundl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(round(Ambiguous())), Ambiguous>::value), "");
assert(round(1) == 1);
}
void test_scalbln()
{
+ static_assert((std::is_same<decltype(scalbln((float)0, (long)0)), float>::value), "");
+ static_assert((std::is_same<decltype(scalbln((bool)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((unsigned short)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((int)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((unsigned int)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((long)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((unsigned long)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((long long)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((unsigned long long)0, (long)0)), double>::value), "");
static_assert((std::is_same<decltype(scalbln((double)0, (long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbln((long double)0, (long)0)), long double>::value), "");
static_assert((std::is_same<decltype(scalblnf(0, (long)0)), float>::value), "");
static_assert((std::is_same<decltype(scalblnl(0, (long)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(scalbln(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(scalbln(1, 1) == 2);
}
void test_scalbn()
{
+ static_assert((std::is_same<decltype(scalbn((float)0, (int)0)), float>::value), "");
+ static_assert((std::is_same<decltype(scalbn((bool)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((unsigned short)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((unsigned int)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((long)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((unsigned long)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((long long)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((unsigned long long)0, (int)0)), double>::value), "");
static_assert((std::is_same<decltype(scalbn((double)0, (int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(scalbn((long double)0, (int)0)), long double>::value), "");
static_assert((std::is_same<decltype(scalbnf(0, (int)0)), float>::value), "");
static_assert((std::is_same<decltype(scalbnl(0, (int)0)), long double>::value), "");
+ static_assert((std::is_same<decltype(scalbn(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
assert(scalbn(1, 1) == 2);
}
void test_tgamma()
{
+ static_assert((std::is_same<decltype(tgamma((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(tgamma((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(tgamma((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(tgamma((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(tgammaf(0)), float>::value), "");
static_assert((std::is_same<decltype(tgammal(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(tgamma(Ambiguous())), Ambiguous>::value), "");
assert(tgamma(1) == 1);
}
void test_trunc()
{
+ static_assert((std::is_same<decltype(trunc((float)0)), float>::value), "");
+ static_assert((std::is_same<decltype(trunc((bool)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((unsigned short)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((unsigned int)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((unsigned long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((long long)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((unsigned long long)0)), double>::value), "");
static_assert((std::is_same<decltype(trunc((double)0)), double>::value), "");
+ static_assert((std::is_same<decltype(trunc((long double)0)), long double>::value), "");
static_assert((std::is_same<decltype(truncf(0)), float>::value), "");
static_assert((std::is_same<decltype(truncl(0)), long double>::value), "");
+ static_assert((std::is_same<decltype(trunc(Ambiguous())), Ambiguous>::value), "");
assert(trunc(1) == 1);
}
int main()
{
+ test_abs();
test_acos();
test_asin();
test_atan();
@@ -636,8 +1440,6 @@ int main()
test_signbit();
test_fpclassify();
test_isfinite();
- test_isinf();
- test_isnan();
test_isnormal();
test_isgreater();
test_isgreaterequal();
Added: libcxx/trunk/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp?rev=249742&view=auto
==============================================================================
--- libcxx/trunk/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp (added)
+++ libcxx/trunk/test/std/depr/depr.c.headers/math_h_isinf.pass.cpp Thu Oct 8 15:40:34 2015
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <math.h>
+
+// isinf
+
+// XFAIL: linux
+
+#include <math.h>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+#ifdef isinf
+#error isinf defined
+#endif
+ static_assert((std::is_same<decltype(isinf((float)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isinf((double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isinf(0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isinf((long double)0)), bool>::value), "");
+ assert(isinf(-1.0) == false);
+}
Added: libcxx/trunk/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp?rev=249742&view=auto
==============================================================================
--- libcxx/trunk/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp (added)
+++ libcxx/trunk/test/std/depr/depr.c.headers/math_h_isnan.pass.cpp Thu Oct 8 15:40:34 2015
@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// <math.h>
+
+// isnan
+
+// XFAIL: linux
+
+#include <math.h>
+#include <type_traits>
+#include <cassert>
+
+int main()
+{
+#ifdef isnan
+#error isnan defined
+#endif
+ static_assert((std::is_same<decltype(isnan((float)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isnan((double)0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isnan(0)), bool>::value), "");
+ static_assert((std::is_same<decltype(isnan((long double)0)), bool>::value), "");
+ assert(isnan(-1.0) == false);
+}
More information about the cfe-commits
mailing list