* contained in the namespace @c std.
*/
-#ifndef _CPP_CMATH
-#define _CPP_CMATH 1
+#ifndef _GLIBCXX_CMATH
+#define _GLIBCXX_CMATH 1
#pragma GCC system_header
#undef tan
#undef tanh
-// ...and in the darkness bind them...
-namespace __gnu_cxx
-{
- namespace __c99_binding
- {
-#if _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_CHECK || \
- _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
- extern "C" float (acosf)(float);
- extern "C" float (asinf)(float);
- extern "C" float (atanf)(float);
- extern "C" float (atan2f)(float, float);
- extern "C" float (ceilf)(float);
- extern "C" float (coshf)(float);
- extern "C" float (expf)(float);
- extern "C" float (floorf)(float);
- extern "C" float (fmodf)(float, float);
- extern "C" float (frexpf)(float, int*);
- extern "C" float (ldexpf)(float, int);
- extern "C" float (logf)(float);
- extern "C" float (log10f)(float);
- extern "C" float (modff)(float, float*);
- extern "C" float (powf)(float, float);
- extern "C" float (sinhf)(float);
- extern "C" float (tanf)(float);
- extern "C" float (tanhf)(float);
-#endif
-#if !_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
-#if _GLIBCPP_HAVE_ACOSF
- using ::acosf;
-#endif
-#if _GLIBCPP_HAVE_ASINF
- using ::asinf;
-#endif
-#if _GLIBCPP_HAVE_ATANF
- using ::atanf;
-#endif
-#if _GLIBCPP_HAVE_ATAN2F
- using ::atan2f;
-#endif
-#if _GLIBCPP_HAVE_CEILF
- using ::ceilf;
-#endif
-#if _GLIBCPP_HAVE_COSHF
- using ::coshf;
-#endif
-#if _GLIBCPP_HAVE_EXPF
- using ::expf;
-#endif
-#if _GLIBCPP_HAVE_FLOORF
- using ::floorf;
-#endif
-#if _GLIBCPP_HAVE_FMODF
- using ::fmodf;
-#endif
-#if _GLIBCPP_HAVE_FREXPF
- using ::frexpf;
-#endif
-#if _GLIBCPP_HAVE_LDEXPF
- using ::ldexpf;
-#endif
-#if _GLIBCPP_HAVE_LOGF
- using ::logf;
-#endif
-#if _GLIBCPP_HAVE_LOG10F
- using ::log10f;
-#endif
-#if _GLIBCPP_HAVE_MODFF
- using ::modff;
-#endif
-#if _GLIBCPP_HAVE_POWF
- using ::powf;
-#endif
-#if _GLIBCPP_HAVE_SINHF
- using ::sinhf;
-#endif
-#if _GLIBCPP_HAVE_TANF
- using ::tanf;
-#endif
-#if _GLIBCPP_HAVE_TANHF
- using ::tanhf;
-#endif
-#endif /* _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */
- }
-}
-namespace std
+namespace std
{
// Forward declaration of a helper function. This really should be
// an `exported' forward declaration.
abs(long double __x)
{ return __builtin_fabsl(__x); }
-#if _GLIBCPP_HAVE_ACOSF
- inline float
- acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); }
-#else
- inline float
- acos(float __x) { return ::acos(static_cast<double>(__x)); }
-#endif
-
using ::acos;
-
-#if _GLIBCPP_HAVE_ACOSL
- inline long double
- acos(long double __x) { return ::acosl(__x); }
-#else
- inline long double
- acos(long double __x) { return ::acos(static_cast<double>(__x)); }
-#endif
+
+ inline float
+ acos(float __x)
+ { return __builtin_acosf(__x); }
+
+ inline long double
+ acos(long double __x)
+ { return __builtin_acosl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
acos(_Tp __x)
{
- return ::acos(static_cast<double>(__x));
+ return __builtin_acos(__x);
}
-
+
using ::asin;
-#if _GLIBCPP_HAVE_ASINF
- inline float
- asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); }
-#else
- inline float
- asin(float __x) { return ::asin(static_cast<double>(__x)); }
-#endif
+ inline float
+ asin(float __x)
+ { return __builtin_asinf(__x); }
-#if _GLIBCPP_HAVE_ASINL
- inline long double
- asin(long double __x) { return ::asinl(__x); }
-#else
- inline long double
- asin(long double __x) { return ::asin(static_cast<double>(__x)); }
-#endif
+ inline long double
+ asin(long double __x)
+ { return __builtin_asinl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
asin(_Tp __x)
- { return ::asin(static_cast<double>(__x)); }
+ { return __builtin_asin(__x); }
using ::atan;
-#if _GLIBCPP_HAVE_ATANF
- inline float
- atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); }
-#else
- inline float
- atan(float __x) { return ::atan(static_cast<double>(__x)); }
-#endif
+ inline float
+ atan(float __x)
+ { return __builtin_atanf(__x); }
-#if _GLIBCPP_HAVE_ATANL
- inline long double
- atan(long double __x) { return ::atanl(__x); }
-#else
- inline long double
- atan(long double __x) { return ::atan(static_cast<double>(__x)); }
-#endif
+ inline long double
+ atan(long double __x)
+ { return __builtin_atanl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
atan(_Tp __x)
- { return ::atan(static_cast<double>(__x)); }
-
+ { return __builtin_atan(__x); }
+
using ::atan2;
-#if _GLIBCPP_HAVE_ATAN2F
- inline float
- atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); }
-#else
- inline float
+ inline float
atan2(float __y, float __x)
- { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
-#endif
+ { return __builtin_atan2f(__y, __x); }
-#if _GLIBCPP_HAVE_ATAN2L
- inline long double
- atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
-#else
- inline long double
- atan2(long double __y, long double __x)
- { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
-#endif
+ inline long double
+ atan2(long double __y, long double __x)
+ { return __builtin_atan2l(__y, __x); }
template<typename _Tp, typename _Up>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type
&& __is_integer<_Up>::_M_type>::_M_type
- atan2(_Tp __x, _Up __y)
- { return ::atan2(static_cast<double>(__x), static_cast<double>(__y)); }
+ atan2(_Tp __y, _Up __x)
+ { return __builtin_atan2(__y, __x); }
using ::ceil;
-#if _GLIBCPP_HAVE_CEILF
- inline float
- ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); }
-#else
- inline float
- ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
-#endif
+ inline float
+ ceil(float __x)
+ { return __builtin_ceilf(__x); }
-#if _GLIBCPP_HAVE_CEILL
- inline long double
- ceil(long double __x) { return ::ceill(__x); }
-#else
- inline long double
- ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
-#endif
+ inline long double
+ ceil(long double __x)
+ { return __builtin_ceill(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
ceil(_Tp __x)
- { return ::ceil(static_cast<double>(__x)); }
-
+ { return __builtin_ceil(__x); }
+
using ::cos;
inline float
using ::cosh;
-#if _GLIBCPP_HAVE_COSHF
- inline float
- cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); }
-#else
- inline float
- cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
-#endif
+ inline float
+ cosh(float __x)
+ { return __builtin_coshf(__x); }
-#if _GLIBCPP_HAVE_COSHL
- inline long double
- cosh(long double __x) { return ::coshl(__x); }
-#else
- inline long double
- cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
-#endif
+ inline long double
+ cosh(long double __x)
+ { return __builtin_coshl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
cosh(_Tp __x)
- { return ::cosh(static_cast<double>(__x)); }
+ { return __builtin_cosh(__x); }
using ::exp;
-#if _GLIBCPP_HAVE_EXPF
- inline float
- exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); }
-#else
- inline float
- exp(float __x) { return ::exp(static_cast<double>(__x)); }
-#endif
+ inline float
+ exp(float __x)
+ { return __builtin_expf(__x); }
-#if _GLIBCPP_HAVE_EXPL
- inline long double
- exp(long double __x) { return ::expl(__x); }
-#else
- inline long double
- exp(long double __x) { return ::exp(static_cast<double>(__x)); }
-#endif
+ inline long double
+ exp(long double __x)
+ { return __builtin_expl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
exp(_Tp __x)
- { return ::exp(static_cast<double>(__x)); }
-
+ { return __builtin_exp(__x); }
+
using ::fabs;
inline float
using ::floor;
-#if _GLIBCPP_HAVE_FLOORF
- inline float
- floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); }
-#else
- inline float
- floor(float __x) { return ::floor(static_cast<double>(__x)); }
-#endif
+ inline float
+ floor(float __x)
+ { return __builtin_floorf(__x); }
-#if _GLIBCPP_HAVE_FLOORL
- inline long double
- floor(long double __x) { return ::floorl(__x); }
-#else
- inline long double
- floor(long double __x) { return ::floor(static_cast<double>(__x)); }
-#endif
+ inline long double
+ floor(long double __x)
+ { return __builtin_floorl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
floor(_Tp __x)
- { return ::floor(static_cast<double>(__x)); }
-
+ { return __builtin_floor(__x); }
+
using ::fmod;
-#if _GLIBCPP_HAVE_FMODF
- inline float
- fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); }
-#else
- inline float
+ inline float
fmod(float __x, float __y)
- { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
-#endif
+ { return __builtin_fmodf(__x, __y); }
-#if _GLIBCPP_HAVE_FMODL
- inline long double
- fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
-#else
- inline long double
- fmod(long double __x, long double __y)
- { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
-#endif
+ inline long double
+ fmod(long double __x, long double __y)
+ { return __builtin_fmodl(__x, __y); }
using ::frexp;
-#if _GLIBCPP_HAVE_FREXPF
- inline float
- frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); }
-#else
- inline float
- frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
-#endif
+ inline float
+ frexp(float __x, int* __exp)
+ { return __builtin_frexpf(__x, __exp); }
-#if _GLIBCPP_HAVE_FREXPL
- inline long double
- frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
-#else
- inline long double
- frexp(long double __x, int* __exp)
- { return ::frexp(static_cast<double>(__x), __exp); }
-#endif
+ inline long double
+ frexp(long double __x, int* __exp)
+ { return __builtin_frexpl(__x, __exp); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
frexp(_Tp __x, int* __exp)
- { return ::frexp(static_cast<double>(__x), __exp); }
-
+ { return __builtin_frexp(__x, __exp); }
+
using ::ldexp;
-#if _GLIBCPP_HAVE_LDEXPF
- inline float
- ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); }
-#else
- inline float
+ inline float
ldexp(float __x, int __exp)
- { return ::ldexp(static_cast<double>(__x), __exp); }
-#endif
+ { return __builtin_ldexpf(__x, __exp); }
-#if _GLIBCPP_HAVE_LDEXPL
- inline long double
- ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
-#else
- inline long double
- ldexp(long double __x, int __exp)
- { return ::ldexp(static_cast<double>(__x), __exp); }
-#endif
+ inline long double
+ ldexp(long double __x, int __exp)
+ { return __builtin_ldexpl(__x, __exp); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
ldexp(_Tp __x, int __exp)
- { return ::ldexp(static_cast<double>(__x), __exp); }
+ { return __builtin_ldexp(__x, __exp); }
using ::log;
-#if _GLIBCPP_HAVE_LOGF
- inline float
- log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); }
-#else
- inline float log(float __x)
- { return ::log(static_cast<double>(__x)); }
-#endif
+ inline float
+ log(float __x)
+ { return __builtin_logf(__x); }
-#if _GLIBCPP_HAVE_LOGL
- inline long double
- log(long double __x) { return ::logl(__x); }
-#else
- inline long double
- log(long double __x) { return ::log(static_cast<double>(__x)); }
-#endif
+ inline long double
+ log(long double __x)
+ { return __builtin_logl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
log(_Tp __x)
- { return ::log(static_cast<double>(__x)); }
-
+ { return __builtin_log(__x); }
+
using ::log10;
-#if _GLIBCPP_HAVE_LOG10F
- inline float
- log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); }
-#else
- inline float
- log10(float __x) { return ::log10(static_cast<double>(__x)); }
-#endif
+ inline float
+ log10(float __x)
+ { return __builtin_log10f(__x); }
-#if _GLIBCPP_HAVE_LOG10L
- inline long double
- log10(long double __x) { return ::log10l(__x); }
-#else
- inline long double
- log10(long double __x) { return ::log10(static_cast<double>(__x)); }
-#endif
+ inline long double
+ log10(long double __x)
+ { return __builtin_log10l(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
log10(_Tp __x)
- { return ::log10(static_cast<double>(__x)); }
-
+ { return __builtin_log10(__x); }
+
using ::modf;
-#if _GLIBCPP_HAVE_MODFF
- inline float
- modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); }
-#else
- inline float
+ inline float
modf(float __x, float* __iptr)
- {
- double __tmp;
- double __res = ::modf(static_cast<double>(__x), &__tmp);
- *__iptr = static_cast<float>(__tmp);
- return __res;
- }
-#endif
+ { return __builtin_modff(__x, __iptr); }
-#if _GLIBCPP_HAVE_MODFL
- inline long double
- modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
-#else
- inline long double
- modf(long double __x, long double* __iptr)
- {
- double __tmp;
- double __res = ::modf(static_cast<double>(__x), &__tmp);
- * __iptr = static_cast<long double>(__tmp);
- return __res;
- }
-#endif
+ inline long double
+ modf(long double __x, long double* __iptr)
+ { return __builtin_modfl(__x, __iptr); }
template<typename _Tp>
inline _Tp
using ::pow;
-#if _GLIBCPP_HAVE_POWF
- inline float
- pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); }
-#else
- inline float
+ inline float
pow(float __x, float __y)
- { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
-#endif
+ { return __builtin_powf(__x, __y); }
-#if _GLIBCPP_HAVE_POWL
- inline long double
- pow(long double __x, long double __y) { return ::powl(__x, __y); }
-#else
- inline long double
- pow(long double __x, long double __y)
- { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
-#endif
+ inline long double
+ pow(long double __x, long double __y)
+ { return __builtin_powl(__x, __y); }
- inline double
+ inline double
pow(double __x, int __i)
{ return __pow_helper(__x, __i); }
- inline float
+ inline float
pow(float __x, int __n)
{ return __pow_helper(__x, __n); }
- inline long double
+ inline long double
pow(long double __x, int __n)
{ return __pow_helper(__x, __n); }
using ::sinh;
-#if _GLIBCPP_HAVE_SINHF
- inline float
- sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); }
-#else
- inline float
- sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
-#endif
+ inline float
+ sinh(float __x)
+ { return __builtin_sinhf(__x); }
-#if _GLIBCPP_HAVE_SINHL
- inline long double
- sinh(long double __x) { return ::sinhl(__x); }
-#else
- inline long double
- sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
-#endif
+ inline long double
+ sinh(long double __x)
+ { return __builtin_sinhl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
sinh(_Tp __x)
- { return ::sinh(static_cast<_Tp>(__x)); }
-
+ { return __builtin_sinh(__x); }
+
using ::sqrt;
inline float
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
sqrt(_Tp __x)
{ return __builtin_sqrt(__x); }
-
+
using ::tan;
-#if _GLIBCPP_HAVE_TANF
- inline float
- tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); }
-#else
- inline float
- tan(float __x) { return ::tan(static_cast<double>(__x)); }
-#endif
+ inline float
+ tan(float __x)
+ { return __builtin_tanf(__x); }
-#if _GLIBCPP_HAVE_TANL
- inline long double
- tan(long double __x) { return ::tanl(__x); }
-#else
- inline long double
- tan(long double __x) { return ::tan(static_cast<double>(__x)); }
-#endif
+ inline long double
+ tan(long double __x)
+ { return __builtin_tanl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
tan(_Tp __x)
- { return ::tan(static_cast<double>(__x)); }
-
+ { return __builtin_tan(__x); }
+
using ::tanh;
-#if _GLIBCPP_HAVE_TANHF
- inline float
- tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); }
-#else
- inline float
- tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
-#endif
+ inline float
+ tanh(float __x)
+ { return __builtin_tanhf(__x); }
-#if _GLIBCPP_HAVE_TANHL
- inline long double
- tanh(long double __x) { return ::tanhl(__x); }
-#else
- inline long double
- tanh(long double __x) { return ::tanh(static_cast<double>(__x)); }
-#endif
+ inline long double
+ tanh(long double __x)
+ { return __builtin_tanhl(__x); }
template<typename _Tp>
inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
tanh(_Tp __x)
- { return ::tanh(static_cast<double>(__x)); }
-}
+ { return __builtin_tanh(__x); }
+}
-#if _GLIBCPP_USE_C99
-#if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC
+#if _GLIBCXX_USE_C99
+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
// These are possible macros imported from C99-land. For strict
// conformance, remove possible C99-injected names from the global
-// namespace, and sequester them in the __gnu_cxx extension namespace.
+// namespace, and sequester them in the __gnu_cxx extension namespace.
namespace __gnu_cxx
{
template<typename _Tp>
- int
+ int
__capture_fpclassify(_Tp __f) { return fpclassify(__f); }
template<typename _Tp>
- int
+ int
__capture_isfinite(_Tp __f) { return isfinite(__f); }
template<typename _Tp>
- int
+ int
__capture_isinf(_Tp __f) { return isinf(__f); }
template<typename _Tp>
- int
+ int
__capture_isnan(_Tp __f) { return isnan(__f); }
template<typename _Tp>
- int
+ int
__capture_isnormal(_Tp __f) { return isnormal(__f); }
template<typename _Tp>
- int
+ int
__capture_signbit(_Tp __f) { return signbit(__f); }
template<typename _Tp>
- int
+ int
__capture_isgreater(_Tp __f1, _Tp __f2)
{ return isgreater(__f1, __f2); }
template<typename _Tp>
- int
- __capture_isgreaterequal(_Tp __f1, _Tp __f2)
+ int
+ __capture_isgreaterequal(_Tp __f1, _Tp __f2)
{ return isgreaterequal(__f1, __f2); }
template<typename _Tp>
- int
+ int
__capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
template<typename _Tp>
- int
- __capture_islessequal(_Tp __f1, _Tp __f2)
+ int
+ __capture_islessequal(_Tp __f1, _Tp __f2)
{ return islessequal(__f1, __f2); }
template<typename _Tp>
- int
- __capture_islessgreater(_Tp __f1, _Tp __f2)
+ int
+ __capture_islessgreater(_Tp __f1, _Tp __f2)
{ return islessgreater(__f1, __f2); }
template<typename _Tp>
- int
- __capture_isunordered(_Tp __f1, _Tp __f2)
+ int
+ __capture_isunordered(_Tp __f1, _Tp __f2)
{ return isunordered(__f1, __f2); }
}
#undef islessequal
#undef islessgreater
#undef isunordered
-#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
+#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif
-#if _GLIBCPP_USE_C99
-#if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC
+#if _GLIBCXX_USE_C99
+#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
namespace __gnu_cxx
{
template<typename _Tp>
isfinite(_Tp __f) { return __capture_isfinite(__f); }
template<typename _Tp>
- int
+ int
isinf(_Tp __f) { return __capture_isinf(__f); }
template<typename _Tp>
- int
+ int
isnan(_Tp __f) { return __capture_isnan(__f); }
template<typename _Tp>
- int
+ int
isnormal(_Tp __f) { return __capture_isnormal(__f); }
template<typename _Tp>
- int
+ int
signbit(_Tp __f) { return __capture_signbit(__f); }
template<typename _Tp>
- int
+ int
isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
template<typename _Tp>
- int
- isgreaterequal(_Tp __f1, _Tp __f2)
+ int
+ isgreaterequal(_Tp __f1, _Tp __f2)
{ return __capture_isgreaterequal(__f1, __f2); }
template<typename _Tp>
- int
+ int
isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
template<typename _Tp>
- int
- islessequal(_Tp __f1, _Tp __f2)
+ int
+ islessequal(_Tp __f1, _Tp __f2)
{ return __capture_islessequal(__f1, __f2); }
template<typename _Tp>
- int
- islessgreater(_Tp __f1, _Tp __f2)
+ int
+ islessgreater(_Tp __f1, _Tp __f2)
{ return __capture_islessgreater(__f1, __f2); }
template<typename _Tp>
- int
- isunordered(_Tp __f1, _Tp __f2)
+ int
+ isunordered(_Tp __f1, _Tp __f2)
{ return __capture_isunordered(__f1, __f2); }
}
using __gnu_cxx::islessgreater;
using __gnu_cxx::isunordered;
}
-#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
+#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif
-
-#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
-# define export
-# include <bits/cmath.tcc>
+
+#ifndef _GLIBCXX_EXPORT_TEMPLATE
+# include <bits/cmath.tcc>
#endif
#endif
OSDN Git Service
