imported in <cinttypes> in namespace std in C++11.])
fi
- # Check for the existence of <math.h> functions used if C99 is enabled.
- AC_CACHE_CHECK([for ISO C99 support in <math.h> for C++11],
+ # Check for the existence of <math.h> generic macros used if C99 is enabled.
+ AC_CACHE_CHECK([for ISO C99 generic macro support in <math.h> for C++11],
glibcxx_cv_c99_math_cxx11, [
GCC_TRY_COMPILE_OR_LINK(
[#include <math.h>
])
if test x"$glibcxx_cv_c99_math_cxx11" = x"yes"; then
AC_DEFINE(_GLIBCXX11_USE_C99_MATH, 1,
- [Define if C99 functions or macros in <math.h> should be imported
+ [Define if C99 generic macros in <math.h> should be imported
in <cmath> in namespace std for C++11.])
fi
+ # Check for the existence of <math.h> functions.
+ AC_CACHE_CHECK([for ISO C99 function support for C++11 in <math.h>],
+ glibcxx_cv_c99_math_funcs, [
+ AC_TRY_COMPILE([#include <math.h>],
+ [// Types
+ typedef double_t my_double_t;
+ typedef float_t my_float_t;
+ // Hyperbolic
+ acosh(0.0);
+ acoshf(0.0f);
+ acoshl(0.0l);
+ asinh(0.0);
+ asinhf(0.0f);
+ asinhl(0.0l);
+ atanh(0.0);
+ atanhf(0.0f);
+ atanhl(0.0l);
+ // Exponential and logarithmic
+ exp2(0.0);
+ exp2f(0.0f);
+ exp2l(0.0l);
+ expm1(0.0);
+ expm1f(0.0f);
+ expm1l(0.0l);
+ ilogb(0.0);
+ ilogbf(0.0f);
+ ilogbl(0.0l);
+ log1p(0.0);
+ log1pf(0.0f);
+ log1pl(0.0l);
+ log2(0.0);
+ log2f(0.0f);
+ log2l(0.0l);
+ logb(0.0);
+ logbf(0.0f);
+ logbl(0.0l);
+ scalbln(0.0, 0l);
+ scalblnf(0.0f, 0l);
+ scalblnl(0.0l, 0l);
+ scalbn(0.0, 0);
+ scalbnf(0.0f, 0);
+ scalbnl(0.0l, 0);
+ // Power and absolute-value
+ cbrt(0.0);
+ cbrtf(0.0f);
+ cbrtl(0.0l);
+ hypot(0.0, 0.0);
+ hypotf(0.0f, 0.0f);
+ hypotl(0.0l, 0.0l);
+ // Error and gamma
+ erf(0.0);
+ erff(0.0f);
+ erfl(0.0l);
+ erfc(0.0);
+ erfcf(0.0f);
+ erfcl(0.0l);
+ lgamma(0.0);
+ lgammaf(0.0f);
+ lgammal(0.0l);
+ tgamma(0.0);
+ tgammaf(0.0f);
+ tgammal(0.0l);
+ // Nearest integer
+ nearbyint(0.0);
+ nearbyintf(0.0f);
+ nearbyintl(0.0l);
+ rint(0.0);
+ rintf(0.0f);
+ rintl(0.0l);
+ round(0.0);
+ roundf(0.0f);
+ roundl(0.0l);
+ lrint(0.0);
+ lrintf(0.0f);
+ lrintl(0.0l);
+ lround(0.0);
+ lroundf(0.0f);
+ lroundl(0.0l);
+ #ifndef __APPLE__ /* see below */
+ llrint(0.0);
+ llrintf(0.0f);
+ llrintl(0.0l);
+ llround(0.0);
+ llroundf(0.0f);
+ llroundl(0.0l);
+ #endif
+ trunc(0.0);
+ truncf(0.0f);
+ truncl(0.0l);
+ // Remainder
+ remainder(0.0, 0.0);
+ remainderf(0.0f, 0.0f);
+ remainderl(0.0l, 0.0l);
+ remquo(0.0, 0.0, 0);
+ remquof(0.0f, 0.0f, 0);
+ remquol(0.0l, 0.0l, 0);
+ // Manipulation
+ copysign(0.0, 0.0);
+ copysignf(0.0f, 0.0f);
+ copysignl(0.0l, 0.0l);
+ nan("");
+ nanf("");
+ nanl("");
+ nextafter(0.0, 0.0);
+ nextafterf(0.0f, 0.0f);
+ nextafterl(0.0l, 0.0l);
+ nexttoward(0.0, 0.0);
+ nexttowardf(0.0f, 0.0f);
+ nexttowardl(0.0l, 0.0l);
+ // Max, min, positive difference
+ fdim(0.0, 0.0);
+ fdimf(0.0f, 0.0f);
+ fdiml(0.0l, 0.0l);
+ fmax(0.0, 0.0);
+ fmaxf(0.0f, 0.0f);
+ fmaxl(0.0l, 0.0l);
+ fmin(0.0, 0.0);
+ fminf(0.0f, 0.0f);
+ fminl(0.0l, 0.0l);
+ // FP Multiply-add
+ fma(0.0, 0.0, 0.0);
+ fmaf(0.0f, 0.0f, 0.0f);
+ fmal(0.0l, 0.0l, 0.0l);
+ ],
+ [glibcxx_cv_c99_math_funcs=yes],
+ [glibcxx_cv_c99_math_funcs=no])
+ ])
+ if test x"$glibcxx_cv_c99_math_funcs" = x"yes"; then
+ AC_DEFINE(_GLIBCXX_USE_C99_MATH_FUNCS, 1,
+ [Define if C99 functions in <math.h> should be imported
+ in <cmath> in namespace std for C++11.])
+
+ case "${target_os}" in
+ darwin*)
+ AC_CACHE_CHECK([for ISO C99 rounding functions in <math.h>],
+ glibcxx_cv_c99_math_llround, [
+ AC_TRY_COMPILE([#include <math.h>],
+ [llrint(0.0);
+ llrintf(0.0f);
+ llrintl(0.0l);
+ llround(0.0);
+ llroundf(0.0f);
+ llroundl(0.0l);
+ ],
+ [glibcxx_cv_c99_math_llround=yes],
+ [glibcxx_cv_c99_math_llround=no])
+ ])
+ ;;
+ esac
+ if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
+ AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
+ [Define if C99 llrint and llround functions are missing from <math.h>.])
+ fi
+ fi
+
# Check for the existence of <complex.h> complex math functions.
# This is necessary even though libstdc++ uses the builtin versions
# of these functions, because if the builtin cannot be used, a reference
AC_DEFINE(_GLIBCXX_USE_C99_MATH_TR1, 1,
[Define if C99 functions or macros in <math.h> should be imported
in <tr1/cmath> in namespace std::tr1.])
-
- case "${target_os}" in
- darwin*)
- AC_CACHE_CHECK([for ISO C99 rounding functions in <math.h>],
- glibcxx_cv_c99_math_llround, [
- AC_TRY_COMPILE([#include <math.h>],
- [llrint(0.0);
- llrintf(0.0f);
- llrintl(0.0l);
- llround(0.0);
- llroundf(0.0f);
- llroundl(0.0l);
- ],
- [glibcxx_cv_c99_math_llround=yes],
- [glibcxx_cv_c99_math_llround=no])
- ])
- ;;
- esac
- if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
- AC_DEFINE(_GLIBCXX_NO_C99_ROUNDING_FUNCS, 1,
- [Define if C99 llrint and llround functions are missing from <math.h>.])
- fi
fi
# Check for the existence of <inttypes.h> functions (NB: doesn't make
C99 library functions to be present. */
#undef _GLIBCXX11_USE_C99_COMPLEX
-/* Define if C99 functions or macros in <math.h> should be imported in <cmath>
- in namespace std for C++11. */
+/* Define if C99 generic macros in <math.h> should be imported in <cmath> in
+ namespace std for C++11. */
#undef _GLIBCXX11_USE_C99_MATH
/* Define if C99 functions or macros in <stdio.h> should be imported in
<tr1/cinttypes> in namespace std::tr1. */
#undef _GLIBCXX_USE_C99_INTTYPES_WCHAR_T_TR1
+/* Define if C99 functions in <math.h> should be imported in <cmath> in
+ namespace std for C++11. */
+#undef _GLIBCXX_USE_C99_MATH_FUNCS
+
/* Define if C99 functions or macros in <math.h> should be imported in
<tr1/cmath> in namespace std::tr1. */
#undef _GLIBCXX_USE_C99_MATH_TR1
fi
- # Check for the existence of <math.h> functions used if C99 is enabled.
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ISO C99 support in <math.h> for C++11" >&5
-$as_echo_n "checking for ISO C99 support in <math.h> for C++11... " >&6; }
+ # Check for the existence of <math.h> generic macros used if C99 is enabled.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ISO C99 generic macro support in <math.h> for C++11" >&5
+$as_echo_n "checking for ISO C99 generic macro support in <math.h> for C++11... " >&6; }
if ${glibcxx_cv_c99_math_cxx11+:} false; then :
$as_echo_n "(cached) " >&6
else
fi
+ # Check for the existence of <math.h> functions.
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ISO C99 function support for C++11 in <math.h>" >&5
+$as_echo_n "checking for ISO C99 function support for C++11 in <math.h>... " >&6; }
+if ${glibcxx_cv_c99_math_funcs+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#include <math.h>
+int
+main ()
+{
+// Types
+ typedef double_t my_double_t;
+ typedef float_t my_float_t;
+ // Hyperbolic
+ acosh(0.0);
+ acoshf(0.0f);
+ acoshl(0.0l);
+ asinh(0.0);
+ asinhf(0.0f);
+ asinhl(0.0l);
+ atanh(0.0);
+ atanhf(0.0f);
+ atanhl(0.0l);
+ // Exponential and logarithmic
+ exp2(0.0);
+ exp2f(0.0f);
+ exp2l(0.0l);
+ expm1(0.0);
+ expm1f(0.0f);
+ expm1l(0.0l);
+ ilogb(0.0);
+ ilogbf(0.0f);
+ ilogbl(0.0l);
+ log1p(0.0);
+ log1pf(0.0f);
+ log1pl(0.0l);
+ log2(0.0);
+ log2f(0.0f);
+ log2l(0.0l);
+ logb(0.0);
+ logbf(0.0f);
+ logbl(0.0l);
+ scalbln(0.0, 0l);
+ scalblnf(0.0f, 0l);
+ scalblnl(0.0l, 0l);
+ scalbn(0.0, 0);
+ scalbnf(0.0f, 0);
+ scalbnl(0.0l, 0);
+ // Power and absolute-value
+ cbrt(0.0);
+ cbrtf(0.0f);
+ cbrtl(0.0l);
+ hypot(0.0, 0.0);
+ hypotf(0.0f, 0.0f);
+ hypotl(0.0l, 0.0l);
+ // Error and gamma
+ erf(0.0);
+ erff(0.0f);
+ erfl(0.0l);
+ erfc(0.0);
+ erfcf(0.0f);
+ erfcl(0.0l);
+ lgamma(0.0);
+ lgammaf(0.0f);
+ lgammal(0.0l);
+ tgamma(0.0);
+ tgammaf(0.0f);
+ tgammal(0.0l);
+ // Nearest integer
+ nearbyint(0.0);
+ nearbyintf(0.0f);
+ nearbyintl(0.0l);
+ rint(0.0);
+ rintf(0.0f);
+ rintl(0.0l);
+ round(0.0);
+ roundf(0.0f);
+ roundl(0.0l);
+ lrint(0.0);
+ lrintf(0.0f);
+ lrintl(0.0l);
+ lround(0.0);
+ lroundf(0.0f);
+ lroundl(0.0l);
+ #ifndef __APPLE__ /* see below */
+ llrint(0.0);
+ llrintf(0.0f);
+ llrintl(0.0l);
+ llround(0.0);
+ llroundf(0.0f);
+ llroundl(0.0l);
+ #endif
+ trunc(0.0);
+ truncf(0.0f);
+ truncl(0.0l);
+ // Remainder
+ remainder(0.0, 0.0);
+ remainderf(0.0f, 0.0f);
+ remainderl(0.0l, 0.0l);
+ remquo(0.0, 0.0, 0);
+ remquof(0.0f, 0.0f, 0);
+ remquol(0.0l, 0.0l, 0);
+ // Manipulation
+ copysign(0.0, 0.0);
+ copysignf(0.0f, 0.0f);
+ copysignl(0.0l, 0.0l);
+ nan("");
+ nanf("");
+ nanl("");
+ nextafter(0.0, 0.0);
+ nextafterf(0.0f, 0.0f);
+ nextafterl(0.0l, 0.0l);
+ nexttoward(0.0, 0.0);
+ nexttowardf(0.0f, 0.0f);
+ nexttowardl(0.0l, 0.0l);
+ // Max, min, positive difference
+ fdim(0.0, 0.0);
+ fdimf(0.0f, 0.0f);
+ fdiml(0.0l, 0.0l);
+ fmax(0.0, 0.0);
+ fmaxf(0.0f, 0.0f);
+ fmaxl(0.0l, 0.0l);
+ fmin(0.0, 0.0);
+ fminf(0.0f, 0.0f);
+ fminl(0.0l, 0.0l);
+ // FP Multiply-add
+ fma(0.0, 0.0, 0.0);
+ fmaf(0.0f, 0.0f, 0.0f);
+ fmal(0.0l, 0.0l, 0.0l);
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+ glibcxx_cv_c99_math_funcs=yes
+else
+ glibcxx_cv_c99_math_funcs=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_c99_math_funcs" >&5
+$as_echo "$glibcxx_cv_c99_math_funcs" >&6; }
+ if test x"$glibcxx_cv_c99_math_funcs" = x"yes"; then
+
+$as_echo "#define _GLIBCXX_USE_C99_MATH_FUNCS 1" >>confdefs.h
+
+
+ case "${target_os}" in
+ darwin*)
+ { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ISO C99 rounding functions in <math.h>" >&5
+$as_echo_n "checking for ISO C99 rounding functions in <math.h>... " >&6; }
+if ${glibcxx_cv_c99_math_llround+:} false; then :
+ $as_echo_n "(cached) " >&6
+else
+
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h. */
+#include <math.h>
+int
+main ()
+{
+llrint(0.0);
+ llrintf(0.0f);
+ llrintl(0.0l);
+ llround(0.0);
+ llroundf(0.0f);
+ llroundl(0.0l);
+
+ ;
+ return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+ glibcxx_cv_c99_math_llround=yes
+else
+ glibcxx_cv_c99_math_llround=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_c99_math_llround" >&5
+$as_echo "$glibcxx_cv_c99_math_llround" >&6; }
+ ;;
+ esac
+ if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
+
+$as_echo "#define _GLIBCXX_NO_C99_ROUNDING_FUNCS 1" >>confdefs.h
+
+ fi
+ fi
+
# Check for the existence of <complex.h> complex math functions.
# This is necessary even though libstdc++ uses the builtin versions
# of these functions, because if the builtin cannot be used, a reference
$as_echo "#define _GLIBCXX_USE_C99_MATH_TR1 1" >>confdefs.h
-
- case "${target_os}" in
- darwin*)
- { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ISO C99 rounding functions in <math.h>" >&5
-$as_echo_n "checking for ISO C99 rounding functions in <math.h>... " >&6; }
-if ${glibcxx_cv_c99_math_llround+:} false; then :
- $as_echo_n "(cached) " >&6
-else
-
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h. */
-#include <math.h>
-int
-main ()
-{
-llrint(0.0);
- llrintf(0.0f);
- llrintl(0.0l);
- llround(0.0);
- llroundf(0.0f);
- llroundl(0.0l);
-
- ;
- return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
- glibcxx_cv_c99_math_llround=yes
-else
- glibcxx_cv_c99_math_llround=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $glibcxx_cv_c99_math_llround" >&5
-$as_echo "$glibcxx_cv_c99_math_llround" >&6; }
- ;;
- esac
- if test x"$glibcxx_cv_c99_math_llround" = x"no"; then
-
-$as_echo "#define _GLIBCXX_NO_C99_ROUNDING_FUNCS 1" >>confdefs.h
-
- fi
fi
# Check for the existence of <inttypes.h> functions (NB: doesn't make
double _M_p;
double _M_q;
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
_M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
#endif
friend bool
operator==(const binomial_distribution& __d1,
const binomial_distribution& __d2)
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
{ return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
#else
{ return __d1._M_param == __d2._M_param; }
param_type _M_param;
- // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+ // NB: Unused when _GLIBCXX_USE_C99_MATH_FUNCS is undefined.
std::normal_distribution<double> _M_nd;
};
double _M_mean;
double _M_lm_thr;
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
#endif
};
friend bool
operator==(const poisson_distribution& __d1,
const poisson_distribution& __d2)
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
{ return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
#else
{ return __d1._M_param == __d2._M_param; }
param_type _M_param;
- // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
+ // NB: Unused when _GLIBCXX_USE_C99_MATH_FUNCS is undefined.
std::normal_distribution<double> _M_nd;
};
poisson_distribution<_IntType>::param_type::
_M_initialize()
{
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
if (_M_mean >= 12)
{
const double __m = std::floor(_M_mean);
/**
* A rejection algorithm when mean >= 12 and a simple method based
* upon the multiplication of uniform random variates otherwise.
- * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
+ * NB: The former is available only if _GLIBCXX_USE_C99_MATH_FUNCS
* is defined.
*
* Reference:
{
__detail::_Adaptor<_UniformRandomNumberGenerator, double>
__aurng(__urng);
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
if (__param.mean() >= 12)
{
double __x;
_M_easy = true;
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
if (_M_t * __p12 >= 8)
{
_M_easy = false;
/**
* A rejection algorithm when t * p >= 8 and a simple waiting time
* method - the second in the referenced book - otherwise.
- * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
+ * NB: The former is available only if _GLIBCXX_USE_C99_MATH_FUNCS
* is defined.
*
* Reference:
__detail::_Adaptor<_UniformRandomNumberGenerator, double>
__aurng(__urng);
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
if (!__param._M_easy)
{
double __x;
__ret = __sum / __tmp;
if (__builtin_expect(__ret >= _RealType(1), 0))
{
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
__ret = std::nextafter(_RealType(1), _RealType(0));
#else
__ret = _RealType(1)
using std::isunordered;
#endif
-#if __cplusplus >= 201103L && defined(_GLIBCXX_USE_C99_MATH_TR1)
+#if __cplusplus >= 201103L && defined(_GLIBCXX_USE_C99_MATH_FUNCS)
using std::acosh;
using std::asinh;
using std::atanh;
using std::scalbn;
using std::tgamma;
using std::trunc;
-#endif // C++11 && _GLIBCXX_USE_C99_MATH_TR1
+#endif // C++11 && _GLIBCXX_USE_C99_MATH_FUNCS
// The mathematical special functions are only added to the global namespace
// by IS 29124, but not by C++17.
#if __cplusplus >= 201103L
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
#undef acosh
#undef acoshf
}
#endif
-#endif // _GLIBCXX_USE_C99_MATH_TR1
+#endif // _GLIBCXX_USE_C99_MATH_FUNCS
#endif // C++11
#if __cplusplus >= 201703L
{
result_type __x = this->_M_ndx(__urng);
result_type __y = this->_M_ndy(__urng);
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
return std::hypot(__x, __y);
#else
return std::sqrt(__x * __x + __y * __y);
__px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());
result_type __x = this->_M_ndx(__px, __urng);
result_type __y = this->_M_ndy(__py, __urng);
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
return std::hypot(__x, __y);
#else
return std::sqrt(__x * __x + __y * __y);
__px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());
result_type __x = this->_M_ndx(__px, __urng);
result_type __y = this->_M_ndy(__py, __urng);
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
*__f++ = std::hypot(__x, __y);
#else
*__f++ = std::sqrt(__x * __x + __y * __y);
}
result_type __res = std::acos(__f);
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
__res = std::copysign(__res, __aurng() - result_type(0.5));
#else
if (__aurng() < result_type(0.5))
}
while (__sq == _RealType(0) || __sq > _RealType(1));
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
// Yes, we do not just use sqrt(__sq) because hypot() is more
// accurate.
auto __norm = std::hypot(__ret[0], __ret[1]);
{ return __complex_proj(__z.__rep()); }
#endif
-#elif defined _GLIBCXX_USE_C99_MATH_TR1
+#elif defined _GLIBCXX_USE_C99_MATH_FUNCS
inline complex<float>
__complex_proj(const complex<float>& __z)
{
if (Float_limits::is_iec559 && Float_limits::digits < UInt_limits::digits)
{
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
std::printf("Testing %d-bit float, using %zu-bit integer\n",
Float_limits::digits + (int)std::log2(Float_limits::max_exponent) + 1,
sizeof(UIntT) * __CHAR_BIT__);
if (Float_limits::is_iec559 && Float_limits::digits < UInt_limits::digits)
{
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
std::printf("Testing %d-bit float, using %zu-bit integer\n",
Float_limits::digits + (int)std::log2(Float_limits::max_exponent) + 1,
sizeof(UIntT) * __CHAR_BIT__);
namespace test
{
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
using std::copysign;
#else
bool copysign(float x, float y)
normal ways to skip tests may not work: we don't have a test for
C99_COMPLEX, and these macros may vary depending on -std=*, but
macro tests wouldn't take them into account. */
-#if ! (_GLIBCXX_USE_C99_COMPLEX || _GLIBCXX_USE_C99_MATH_TR1)
+#if ! (_GLIBCXX_USE_C99_COMPLEX || _GLIBCXX_USE_C99_MATH_FUNCS)
if (true)
return 0;
#endif
F<float(float)>abs = ::abs;
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
F<float(float)> acosh = ::acosh;
F<float(float)> asinh = ::asinh;
F<float(float)> atanh = ::atanh;
void test01()
{
-#if _GLIBCXX_USE_C99_MATH_TR1
+#if _GLIBCXX_USE_C99_MATH_FUNCS
typedef std::double_t my_double_t;
typedef std::float_t my_float_t;
# Return 1 if the C99 math facilities are available, 0 otherwise.
proc check_v3_target_cmath { } {
return [check_v3_target_prop_cached et_c99_math {
- set cond "defined _GLIBCXX_USE_C99_MATH_TR1"
+ set cond "defined _GLIBCXX_USE_C99_MATH_FUNCS"
return [v3_check_preprocessor_condition cmath $cond]
}]
}
return 0.0;
}
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
inline double
binomial_pdf(int k, int n, double p)
{
return p * std::pow(1 - p, k);
}
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
inline double
negative_binomial_pdf(int k, int n, double p)
{
return 1.0 / (b - a + 1.0);
}
-#ifdef _GLIBCXX_USE_C99_MATH_TR1
+#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
inline double
lbincoef(int n, int k)
{
projects / thirdparty / gcc.git / commitdiff
