#include <bits/c++config.h>
#include <cmath>
+#include <tr1/common.h>
#if _GLIBCXX_USE_C99_MATH_TR1
#endif
#endif
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+ /// @brief Additional overloads [8.16.4].
+ //
+ inline float
+ acosh(float __x)
+ { return __builtin_acoshf(__x); }
+
+ inline long double
+ acosh(long double __x)
+ { return __builtin_acoshl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ acosh(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return acosh(__type(__x));
+ }
+
+ inline float
+ asinh(float __x)
+ { return __builtin_asinhf(__x); }
+
+ inline long double
+ asinh(long double __x)
+ { return __builtin_asinhl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ asinh(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return asinh(__type(__x));
+ }
+
+ inline float
+ atanh(float __x)
+ { return __builtin_atanhf(__x); }
+
+ inline long double
+ atanh(long double __x)
+ { return __builtin_atanhl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ atanh(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return atanh(__type(__x));
+ }
+
+ inline float
+ cbrt(float __x)
+ { return __builtin_cbrtf(__x); }
+
+ inline long double
+ cbrt(long double __x)
+ { return __builtin_cbrtl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ cbrt(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return cbrt(__type(__x));
+ }
+
+ inline float
+ copysign(float __x, float __y)
+ { return __builtin_copysignf(__x, __y); }
+
+ inline long double
+ copysign(long double __x, long double __y)
+ { return __builtin_copysignl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ copysign(_Tp __x, _Up __y)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return copysign(__type(__x), __type(__y));
+ }
+
+ inline float
+ erf(float __x)
+ { return __builtin_erff(__x); }
+
+ inline long double
+ erf(long double __x)
+ { return __builtin_erfl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ erf(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return erf(__type(__x));
+ }
+
+ inline float
+ erfc(float __x)
+ { return __builtin_erfcf(__x); }
+
+ inline long double
+ erfc(long double __x)
+ { return __builtin_erfcl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ erfc(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return erfc(__type(__x));
+ }
+
+ inline float
+ exp2(float __x)
+ { return __builtin_exp2f(__x); }
+
+ inline long double
+ exp2(long double __x)
+ { return __builtin_exp2l(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ exp2(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return exp2(__type(__x));
+ }
+
+ inline float
+ expm1(float __x)
+ { return __builtin_expm1f(__x); }
+
+ inline long double
+ expm1(long double __x)
+ { return __builtin_expm1l(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ expm1(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return expm1(__type(__x));
+ }
+
+ inline float
+ fdim(float __x, float __y)
+ { return __builtin_fdimf(__x, __y); }
+
+ inline long double
+ fdim(long double __x, long double __y)
+ { return __builtin_fdiml(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ fdim(_Tp __x, _Up __y)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return fdim(__type(__x), __type(__y));
+ }
+
+ inline float
+ fma(float __x, float __y, float __z)
+ { return __builtin_fmaf(__x, __y, __z); }
+
+ inline long double
+ fma(long double __x, long double __y, long double __z)
+ { return __builtin_fmal(__x, __y, __z); }
+
+ template<typename _Tp, typename _Up, typename _Vp>
+ inline typename __promote_3<_Tp, _Up, _Vp>::__type
+ fma(_Tp __x, _Up __y, _Vp __z)
+ {
+ typedef typename __promote_3<_Tp, _Up, _Vp>::__type __type;
+ return fma(__type(__x), __type(__y), __type(__z));
+ }
+
+ inline float
+ fmax(float __x, float __y)
+ { return __builtin_fmaxf(__x, __y); }
+
+ inline long double
+ fmax(long double __x, long double __y)
+ { return __builtin_fmaxl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ fmax(_Tp __x, _Up __y)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return fmax(__type(__x), __type(__y));
+ }
+
+ inline float
+ fmin(float __x, float __y)
+ { return __builtin_fminf(__x, __y); }
+
+ inline long double
+ fmin(long double __x, long double __y)
+ { return __builtin_fminl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ fmin(_Tp __x, _Up __y)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return fmin(__type(__x), __type(__y));
+ }
+
+ inline float
+ hypot(float __x, float __y)
+ { return __builtin_hypotf(__x, __y); }
+
+ inline long double
+ hypot(long double __x, long double __y)
+ { return __builtin_hypotl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ hypot(_Tp __x, _Up __y)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return hypot(__type(__x), __type(__y));
+ }
+
+ inline int
+ ilogb(float __x)
+ { return __builtin_ilogbf(__x); }
+
+ inline int
+ ilogb(long double __x)
+ { return __builtin_ilogbl(__x); }
+
+ template<typename _Tp>
+ inline int
+ ilogb(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return ilogb(__type(__x));
+ }
+
+ inline float
+ lgamma(float __x)
+ { return __builtin_lgammaf(__x); }
+
+ inline long double
+ lgamma(long double __x)
+ { return __builtin_lgammal(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ lgamma(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return lgamma(__type(__x));
+ }
+
+ inline long long
+ llrint(float __x)
+ { return __builtin_llrintf(__x); }
+
+ inline long long
+ llrint(long double __x)
+ { return __builtin_llrintl(__x); }
+
+ template<typename _Tp>
+ inline long long
+ llrint(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return llrint(__type(__x));
+ }
+
+ inline long long
+ llround(float __x)
+ { return __builtin_llroundf(__x); }
+
+ inline long long
+ llround(long double __x)
+ { return __builtin_llroundl(__x); }
+
+ template<typename _Tp>
+ inline long long
+ llround(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return llround(__type(__x));
+ }
+
+ inline float
+ log1p(float __x)
+ { return __builtin_log1pf(__x); }
+
+ inline long double
+ log1p(long double __x)
+ { return __builtin_log1pl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ log1p(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return log1p(__type(__x));
+ }
+
+ inline float
+ log2(float __x)
+ { return __builtin_log2f(__x); }
+
+ inline long double
+ log2(long double __x)
+ { return __builtin_log2l(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ log2(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return log2(__type(__x));
+ }
+
+ inline float
+ logb(float __x)
+ { return __builtin_logbf(__x); }
+
+ inline long double
+ logb(long double __x)
+ { return __builtin_logbl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ logb(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return logb(__type(__x));
+ }
+
+ inline long
+ lrint(float __x)
+ { return __builtin_lrintf(__x); }
+
+ inline long
+ lrint(long double __x)
+ { return __builtin_lrintl(__x); }
+
+ template<typename _Tp>
+ inline long
+ lrint(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return lrint(__type(__x));
+ }
+
+ inline long
+ lround(float __x)
+ { return __builtin_lroundf(__x); }
+
+ inline long
+ lround(long double __x)
+ { return __builtin_lroundl(__x); }
+
+ template<typename _Tp>
+ inline long
+ lround(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return lround(__type(__x));
+ }
+
+ inline float
+ nearbyint(float __x)
+ { return __builtin_nearbyintf(__x); }
+
+ inline long double
+ nearbyint(long double __x)
+ { return __builtin_nearbyintl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ nearbyint(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return nearbyint(__type(__x));
+ }
+
+ inline float
+ nextafter(float __x, float __y)
+ { return __builtin_nextafterf(__x, __y); }
+
+ inline long double
+ nextafter(long double __x, long double __y)
+ { return __builtin_nextafterl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ nextafter(_Tp __x, _Up __y)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return nextafter(__type(__x), __type(__y));
+ }
+
+ inline float
+ nexttoward(float __x, long double __y)
+ { return __builtin_nexttowardf(__x, __y); }
+
+ inline long double
+ nexttoward(long double __x, long double __y)
+ { return __builtin_nexttowardl(__x, __y); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ nexttoward(_Tp __x, long double __y)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return nexttoward(__type(__x), __y);
+ }
+
+ inline float
+ remainder(float __x, float __y)
+ { return __builtin_remainderf(__x, __y); }
+
+ inline long double
+ remainder(long double __x, long double __y)
+ { return __builtin_remainderl(__x, __y); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ remainder(_Tp __x, _Up __y)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return remainder(__type(__x), __type(__y));
+ }
+
+ inline float
+ remquo(float __x, float __y, int* __pquo)
+ { return __builtin_remquof(__x, __y, __pquo); }
+
+ inline long double
+ remquo(long double __x, long double __y, int* __pquo)
+ { return __builtin_remquol(__x, __y, __pquo); }
+
+ template<typename _Tp, typename _Up>
+ inline typename __promote_2<_Tp, _Up>::__type
+ remquo(_Tp __x, _Up __y, int* __pquo)
+ {
+ typedef typename __promote_2<_Tp, _Up>::__type __type;
+ return remquo(__type(__x), __type(__y), __pquo);
+ }
+
+ inline float
+ rint(float __x)
+ { return __builtin_rintf(__x); }
+
+ inline long double
+ rint(long double __x)
+ { return __builtin_rintl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ rint(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return rint(__type(__x));
+ }
+
+ inline float
+ round(float __x)
+ { return __builtin_roundf(__x); }
+
+ inline long double
+ round(long double __x)
+ { return __builtin_roundl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ round(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return round(__type(__x));
+ }
+
+ inline float
+ scalbln(float __x, long __ex)
+ { return __builtin_scalblnf(__x, __ex); }
+
+ inline long double
+ scalbln(long double __x, long __ex)
+ { return __builtin_scalblnl(__x, __ex); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ scalbln(_Tp __x, long __ex)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return scalbln(__type(__x), __ex);
+ }
+
+ inline float
+ scalbn(float __x, int __ex)
+ { return __builtin_scalbnf(__x, __ex); }
+
+ inline long double
+ scalbn(long double __x, int __ex)
+ { return __builtin_scalbnl(__x, __ex); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ scalbn(_Tp __x, int __ex)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return scalbn(__type(__x), __ex);
+ }
+
+ inline float
+ tgamma(float __x)
+ { return __builtin_tgammaf(__x); }
+
+ inline long double
+ tgamma(long double __x)
+ { return __builtin_tgammal(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ tgamma(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return tgamma(__type(__x));
+ }
+
+ inline float
+ trunc(float __x)
+ { return __builtin_truncf(__x); }
+
+ inline long double
+ trunc(long double __x)
+ { return __builtin_truncl(__x); }
+
+ template<typename _Tp>
+ inline typename __promote<_Tp>::__type
+ trunc(_Tp __x)
+ {
+ typedef typename __promote<_Tp>::__type __type;
+ return trunc(__type(__x));
+ }
+
+#endif
+
_GLIBCXX_END_NAMESPACE
}
--- /dev/null
+// { dg-do compile }
+
+// 2006-03-07 Paolo Carlini <pcarlini@suse.de>
+//
+// Copyright (C) 2006 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library. This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 2, or (at your option)
+// any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING. If not, write to the Free
+// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
+// USA.
+
+// 8.16.4 Additional overloads
+
+#include <tr1/cmath>
+#include <testsuite_tr1.h>
+
+void test01()
+{
+#if _GLIBCXX_USE_C99_MATH_TR1
+
+ using namespace std::tr1;
+ using namespace __gnu_test;
+
+ double d0 = 0.0;
+ float f0 = 0.0f;
+ long double ld0 = 0.0l;
+ int i0 = 0;
+ int* pquo = 0;
+ long lex = 0l;
+ int ex = 0;
+
+ check_ret_type<double>(acosh(d0));
+ check_ret_type<float>(acosh(f0));
+ check_ret_type<long double>(acosh(ld0));
+ check_ret_type<double>(acosh(i0));
+
+ check_ret_type<double>(asinh(d0));
+ check_ret_type<float>(asinh(f0));
+ check_ret_type<long double>(asinh(ld0));
+ check_ret_type<double>(asinh(i0));
+
+ check_ret_type<double>(atanh(d0));
+ check_ret_type<float>(atanh(f0));
+ check_ret_type<long double>(atanh(ld0));
+ check_ret_type<double>(atanh(i0));
+
+ check_ret_type<double>(cbrt(d0));
+ check_ret_type<float>(cbrt(f0));
+ check_ret_type<long double>(cbrt(ld0));
+ check_ret_type<double>(cbrt(i0));
+
+ check_ret_type<double>(copysign(d0, d0));
+ check_ret_type<double>(copysign(d0, f0));
+ check_ret_type<float>(copysign(f0, f0));
+ check_ret_type<long double>(copysign(ld0, ld0));
+ check_ret_type<long double>(copysign(ld0, d0));
+ check_ret_type<double>(copysign(i0, i0));
+ check_ret_type<double>(copysign(d0, i0));
+
+ check_ret_type<double>(erf(d0));
+ check_ret_type<float>(erf(f0));
+ check_ret_type<long double>(erf(ld0));
+ check_ret_type<double>(erf(i0));
+
+ check_ret_type<double>(erfc(d0));
+ check_ret_type<float>(erfc(f0));
+ check_ret_type<long double>(erfc(ld0));
+ check_ret_type<double>(erfc(i0));
+
+ check_ret_type<double>(exp2(d0));
+ check_ret_type<float>(exp2(f0));
+ check_ret_type<long double>(exp2(ld0));
+ check_ret_type<double>(exp2(i0));
+
+ check_ret_type<double>(expm1(d0));
+ check_ret_type<float>(expm1(f0));
+ check_ret_type<long double>(expm1(ld0));
+ check_ret_type<double>(expm1(i0));
+
+ check_ret_type<double>(fdim(d0, d0));
+ check_ret_type<double>(fdim(d0, f0));
+ check_ret_type<float>(fdim(f0, f0));
+ check_ret_type<long double>(fdim(ld0, ld0));
+ check_ret_type<long double>(fdim(ld0, d0));
+ check_ret_type<double>(fdim(i0, i0));
+ check_ret_type<double>(fdim(d0, i0));
+
+ check_ret_type<double>(fma(d0, d0, d0));
+ check_ret_type<double>(fma(d0, f0, d0));
+ check_ret_type<float>(fma(f0, f0, f0));
+ check_ret_type<long double>(fma(ld0, ld0, ld0));
+ check_ret_type<long double>(fma(ld0, d0, f0));
+ check_ret_type<double>(fma(i0, i0, i0));
+ check_ret_type<double>(fma(d0, i0, f0));
+
+ check_ret_type<double>(fmax(d0, d0));
+ check_ret_type<double>(fmax(d0, f0));
+ check_ret_type<float>(fmax(f0, f0));
+ check_ret_type<long double>(fmax(ld0, ld0));
+ check_ret_type<long double>(fmax(ld0, d0));
+ check_ret_type<double>(fmax(i0, i0));
+ check_ret_type<double>(fmax(d0, i0));
+
+ check_ret_type<double>(fmin(d0, d0));
+ check_ret_type<double>(fmin(d0, f0));
+ check_ret_type<float>(fmin(f0, f0));
+ check_ret_type<long double>(fmin(ld0, ld0));
+ check_ret_type<long double>(fmin(ld0, d0));
+ check_ret_type<double>(fmin(i0, i0));
+ check_ret_type<double>(fmin(d0, i0));
+
+ check_ret_type<double>(hypot(d0, d0));
+ check_ret_type<double>(hypot(d0, f0));
+ check_ret_type<float>(hypot(f0, f0));
+ check_ret_type<long double>(hypot(ld0, ld0));
+ check_ret_type<long double>(hypot(ld0, d0));
+ check_ret_type<double>(hypot(i0, i0));
+ check_ret_type<double>(hypot(d0, i0));
+
+ check_ret_type<int>(ilogb(d0));
+ check_ret_type<int>(ilogb(f0));
+ check_ret_type<int>(ilogb(ld0));
+ check_ret_type<int>(ilogb(i0));
+
+ check_ret_type<double>(lgamma(d0));
+ check_ret_type<float>(lgamma(f0));
+ check_ret_type<long double>(lgamma(ld0));
+ check_ret_type<double>(lgamma(i0));
+
+ check_ret_type<long long>(llrint(d0));
+ check_ret_type<long long>(llrint(f0));
+ check_ret_type<long long>(llrint(ld0));
+ check_ret_type<long long>(llrint(i0));
+
+ check_ret_type<long long>(llround(d0));
+ check_ret_type<long long>(llround(f0));
+ check_ret_type<long long>(llround(ld0));
+ check_ret_type<long long>(llround(i0));
+
+ check_ret_type<double>(log1p(d0));
+ check_ret_type<float>(log1p(f0));
+ check_ret_type<long double>(log1p(ld0));
+ check_ret_type<double>(log1p(i0));
+
+ check_ret_type<double>(log2(d0));
+ check_ret_type<float>(log2(f0));
+ check_ret_type<long double>(log2(ld0));
+ check_ret_type<double>(log2(i0));
+
+ check_ret_type<double>(logb(d0));
+ check_ret_type<float>(logb(f0));
+ check_ret_type<long double>(logb(ld0));
+ check_ret_type<double>(logb(i0));
+
+ check_ret_type<long>(lrint(d0));
+ check_ret_type<long>(lrint(f0));
+ check_ret_type<long>(lrint(ld0));
+ check_ret_type<long>(lrint(i0));
+
+ check_ret_type<long>(lround(d0));
+ check_ret_type<long>(lround(f0));
+ check_ret_type<long>(lround(ld0));
+ check_ret_type<long>(lround(i0));
+
+ check_ret_type<double>(nearbyint(d0));
+ check_ret_type<float>(nearbyint(f0));
+ check_ret_type<long double>(nearbyint(ld0));
+ check_ret_type<double>(nearbyint(i0));
+
+ check_ret_type<double>(nextafter(d0, d0));
+ check_ret_type<double>(nextafter(d0, f0));
+ check_ret_type<float>(nextafter(f0, f0));
+ check_ret_type<long double>(nextafter(ld0, ld0));
+ check_ret_type<long double>(nextafter(ld0, d0));
+ check_ret_type<double>(nextafter(i0, i0));
+ check_ret_type<double>(nextafter(d0, i0));
+
+ check_ret_type<double>(nexttoward(d0, ld0));
+ check_ret_type<float>(nexttoward(f0, ld0));
+ check_ret_type<long double>(nexttoward(ld0, ld0));
+ check_ret_type<double>(nexttoward(i0, ld0));
+
+ check_ret_type<double>(remainder(d0, d0));
+ check_ret_type<double>(remainder(d0, f0));
+ check_ret_type<float>(remainder(f0, f0));
+ check_ret_type<long double>(remainder(ld0, ld0));
+ check_ret_type<long double>(remainder(ld0, d0));
+ check_ret_type<double>(remainder(i0, i0));
+ check_ret_type<double>(remainder(d0, i0));
+
+ check_ret_type<double>(remquo(d0, d0, pquo));
+ check_ret_type<double>(remquo(d0, f0, pquo));
+ check_ret_type<float>(remquo(f0, f0, pquo));
+ check_ret_type<long double>(remquo(ld0, ld0, pquo));
+ check_ret_type<long double>(remquo(ld0, d0, pquo));
+ check_ret_type<double>(remquo(i0, i0, pquo));
+ check_ret_type<double>(remquo(d0, i0, pquo));
+
+ check_ret_type<double>(rint(d0));
+ check_ret_type<float>(rint(f0));
+ check_ret_type<long double>(rint(ld0));
+ check_ret_type<double>(rint(i0));
+
+ check_ret_type<double>(round(d0));
+ check_ret_type<float>(round(f0));
+ check_ret_type<long double>(round(ld0));
+ check_ret_type<double>(round(i0));
+
+ check_ret_type<double>(scalbln(d0, lex));
+ check_ret_type<float>(scalbln(f0, lex));
+ check_ret_type<long double>(scalbln(ld0, lex));
+ check_ret_type<double>(scalbln(i0, lex));
+
+ check_ret_type<double>(scalbn(d0, ex));
+ check_ret_type<float>(scalbn(f0, ex));
+ check_ret_type<long double>(scalbn(ld0, ex));
+ check_ret_type<double>(scalbn(i0, ex));
+
+ check_ret_type<double>(tgamma(d0));
+ check_ret_type<float>(tgamma(f0));
+ check_ret_type<long double>(tgamma(ld0));
+ check_ret_type<double>(tgamma(i0));
+
+ check_ret_type<double>(trunc(d0));
+ check_ret_type<float>(trunc(f0));
+ check_ret_type<long double>(trunc(ld0));
+ check_ret_type<double>(trunc(i0));
+
+#endif
+}
projects / thirdparty / gcc.git / commitdiff
