b04fa73811
2011-05-09 Paolo Carlini <paolo.carlini@oracle.com> PR libstdc++/48933 * include/c_global/cmath (acosh, asinh, atanh, cbrt, copysign, erf, erfc, exp2, expm1, fdim, fma, fmax, hypot, ilogb, lgamma, llrint, llround, log1p, log2, logb, lrint, lround, nearbyint, nextafter, nexttoward, remainder, remquo, rint, round, scalbln, scalbn, tgamma, trunc): Use __enable_if on the return type. * include/tr1/cmath: Likewise. * testsuite/26_numerics/headers/cmath/overloads_c++0x_neg.cc: New. * testsuite/tr1/8_c_compatibility/cmath/overloads_neg.cc: Likewise. From-SVN: r173574
1654 lines
38 KiB
C++
1654 lines
38 KiB
C++
// -*- C++ -*- C forwarding header.
|
|
|
|
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
|
|
// 2006, 2007, 2008, 2009, 2010, 2011
|
|
// 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 3, 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.
|
|
|
|
// Under Section 7 of GPL version 3, you are granted additional
|
|
// permissions described in the GCC Runtime Library Exception, version
|
|
// 3.1, as published by the Free Software Foundation.
|
|
|
|
// You should have received a copy of the GNU General Public License and
|
|
// a copy of the GCC Runtime Library Exception along with this program;
|
|
// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
// <http://www.gnu.org/licenses/>.
|
|
|
|
/** @file include/cmath
|
|
* This is a Standard C++ Library file. You should @c \#include this file
|
|
* in your programs, rather than any of the @a *.h implementation files.
|
|
*
|
|
* This is the C++ version of the Standard C Library header @c math.h,
|
|
* and its contents are (mostly) the same as that header, but are all
|
|
* contained in the namespace @c std (except for names which are defined
|
|
* as macros in C).
|
|
*/
|
|
|
|
//
|
|
// ISO C++ 14882: 26.5 C library
|
|
//
|
|
|
|
#pragma GCC system_header
|
|
|
|
#include <bits/c++config.h>
|
|
#include <bits/cpp_type_traits.h>
|
|
#include <ext/type_traits.h>
|
|
#include <math.h>
|
|
|
|
#ifndef _GLIBCXX_CMATH
|
|
#define _GLIBCXX_CMATH 1
|
|
|
|
// Get rid of those macros defined in <math.h> in lieu of real functions.
|
|
#undef abs
|
|
#undef div
|
|
#undef acos
|
|
#undef asin
|
|
#undef atan
|
|
#undef atan2
|
|
#undef ceil
|
|
#undef cos
|
|
#undef cosh
|
|
#undef exp
|
|
#undef fabs
|
|
#undef floor
|
|
#undef fmod
|
|
#undef frexp
|
|
#undef ldexp
|
|
#undef log
|
|
#undef log10
|
|
#undef modf
|
|
#undef pow
|
|
#undef sin
|
|
#undef sinh
|
|
#undef sqrt
|
|
#undef tan
|
|
#undef tanh
|
|
|
|
namespace std _GLIBCXX_VISIBILITY(default)
|
|
{
|
|
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
|
inline double
|
|
abs(double __x)
|
|
{ return __builtin_fabs(__x); }
|
|
|
|
inline float
|
|
abs(float __x)
|
|
{ return __builtin_fabsf(__x); }
|
|
|
|
inline long double
|
|
abs(long double __x)
|
|
{ return __builtin_fabsl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
abs(_Tp __x)
|
|
{ return __builtin_fabs(__x); }
|
|
|
|
using ::acos;
|
|
|
|
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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
acos(_Tp __x)
|
|
{ return __builtin_acos(__x); }
|
|
|
|
using ::asin;
|
|
|
|
inline float
|
|
asin(float __x)
|
|
{ return __builtin_asinf(__x); }
|
|
|
|
inline long double
|
|
asin(long double __x)
|
|
{ return __builtin_asinl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
asin(_Tp __x)
|
|
{ return __builtin_asin(__x); }
|
|
|
|
using ::atan;
|
|
|
|
inline float
|
|
atan(float __x)
|
|
{ return __builtin_atanf(__x); }
|
|
|
|
inline long double
|
|
atan(long double __x)
|
|
{ return __builtin_atanl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
atan(_Tp __x)
|
|
{ return __builtin_atan(__x); }
|
|
|
|
using ::atan2;
|
|
|
|
inline float
|
|
atan2(float __y, float __x)
|
|
{ return __builtin_atan2f(__y, __x); }
|
|
|
|
inline long double
|
|
atan2(long double __y, long double __x)
|
|
{ return __builtin_atan2l(__y, __x); }
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline
|
|
typename __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
atan2(_Tp __y, _Up __x)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return atan2(__type(__y), __type(__x));
|
|
}
|
|
|
|
using ::ceil;
|
|
|
|
inline float
|
|
ceil(float __x)
|
|
{ return __builtin_ceilf(__x); }
|
|
|
|
inline long double
|
|
ceil(long double __x)
|
|
{ return __builtin_ceill(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
ceil(_Tp __x)
|
|
{ return __builtin_ceil(__x); }
|
|
|
|
using ::cos;
|
|
|
|
inline float
|
|
cos(float __x)
|
|
{ return __builtin_cosf(__x); }
|
|
|
|
inline long double
|
|
cos(long double __x)
|
|
{ return __builtin_cosl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
cos(_Tp __x)
|
|
{ return __builtin_cos(__x); }
|
|
|
|
using ::cosh;
|
|
|
|
inline float
|
|
cosh(float __x)
|
|
{ return __builtin_coshf(__x); }
|
|
|
|
inline long double
|
|
cosh(long double __x)
|
|
{ return __builtin_coshl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
cosh(_Tp __x)
|
|
{ return __builtin_cosh(__x); }
|
|
|
|
using ::exp;
|
|
|
|
inline float
|
|
exp(float __x)
|
|
{ return __builtin_expf(__x); }
|
|
|
|
inline long double
|
|
exp(long double __x)
|
|
{ return __builtin_expl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
exp(_Tp __x)
|
|
{ return __builtin_exp(__x); }
|
|
|
|
using ::fabs;
|
|
|
|
inline float
|
|
fabs(float __x)
|
|
{ return __builtin_fabsf(__x); }
|
|
|
|
inline long double
|
|
fabs(long double __x)
|
|
{ return __builtin_fabsl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
fabs(_Tp __x)
|
|
{ return __builtin_fabs(__x); }
|
|
|
|
using ::floor;
|
|
|
|
inline float
|
|
floor(float __x)
|
|
{ return __builtin_floorf(__x); }
|
|
|
|
inline long double
|
|
floor(long double __x)
|
|
{ return __builtin_floorl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
floor(_Tp __x)
|
|
{ return __builtin_floor(__x); }
|
|
|
|
using ::fmod;
|
|
|
|
inline float
|
|
fmod(float __x, float __y)
|
|
{ return __builtin_fmodf(__x, __y); }
|
|
|
|
inline long double
|
|
fmod(long double __x, long double __y)
|
|
{ return __builtin_fmodl(__x, __y); }
|
|
|
|
using ::frexp;
|
|
|
|
inline float
|
|
frexp(float __x, int* __exp)
|
|
{ return __builtin_frexpf(__x, __exp); }
|
|
|
|
inline long double
|
|
frexp(long double __x, int* __exp)
|
|
{ return __builtin_frexpl(__x, __exp); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
frexp(_Tp __x, int* __exp)
|
|
{ return __builtin_frexp(__x, __exp); }
|
|
|
|
using ::ldexp;
|
|
|
|
inline float
|
|
ldexp(float __x, int __exp)
|
|
{ return __builtin_ldexpf(__x, __exp); }
|
|
|
|
inline long double
|
|
ldexp(long double __x, int __exp)
|
|
{ return __builtin_ldexpl(__x, __exp); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
ldexp(_Tp __x, int __exp)
|
|
{ return __builtin_ldexp(__x, __exp); }
|
|
|
|
using ::log;
|
|
|
|
inline float
|
|
log(float __x)
|
|
{ return __builtin_logf(__x); }
|
|
|
|
inline long double
|
|
log(long double __x)
|
|
{ return __builtin_logl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
log(_Tp __x)
|
|
{ return __builtin_log(__x); }
|
|
|
|
using ::log10;
|
|
|
|
inline float
|
|
log10(float __x)
|
|
{ return __builtin_log10f(__x); }
|
|
|
|
inline long double
|
|
log10(long double __x)
|
|
{ return __builtin_log10l(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
log10(_Tp __x)
|
|
{ return __builtin_log10(__x); }
|
|
|
|
using ::modf;
|
|
|
|
inline float
|
|
modf(float __x, float* __iptr)
|
|
{ return __builtin_modff(__x, __iptr); }
|
|
|
|
inline long double
|
|
modf(long double __x, long double* __iptr)
|
|
{ return __builtin_modfl(__x, __iptr); }
|
|
|
|
using ::pow;
|
|
|
|
inline float
|
|
pow(float __x, float __y)
|
|
{ return __builtin_powf(__x, __y); }
|
|
|
|
inline long double
|
|
pow(long double __x, long double __y)
|
|
{ return __builtin_powl(__x, __y); }
|
|
|
|
#ifndef __GXX_EXPERIMENTAL_CXX0X__
|
|
// _GLIBCXX_RESOLVE_LIB_DEFECTS
|
|
// DR 550. What should the return type of pow(float,int) be?
|
|
inline double
|
|
pow(double __x, int __i)
|
|
{ return __builtin_powi(__x, __i); }
|
|
|
|
inline float
|
|
pow(float __x, int __n)
|
|
{ return __builtin_powif(__x, __n); }
|
|
|
|
inline long double
|
|
pow(long double __x, int __n)
|
|
{ return __builtin_powil(__x, __n); }
|
|
#endif
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline
|
|
typename __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
pow(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return pow(__type(__x), __type(__y));
|
|
}
|
|
|
|
using ::sin;
|
|
|
|
inline float
|
|
sin(float __x)
|
|
{ return __builtin_sinf(__x); }
|
|
|
|
inline long double
|
|
sin(long double __x)
|
|
{ return __builtin_sinl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
sin(_Tp __x)
|
|
{ return __builtin_sin(__x); }
|
|
|
|
using ::sinh;
|
|
|
|
inline float
|
|
sinh(float __x)
|
|
{ return __builtin_sinhf(__x); }
|
|
|
|
inline long double
|
|
sinh(long double __x)
|
|
{ return __builtin_sinhl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
sinh(_Tp __x)
|
|
{ return __builtin_sinh(__x); }
|
|
|
|
using ::sqrt;
|
|
|
|
inline float
|
|
sqrt(float __x)
|
|
{ return __builtin_sqrtf(__x); }
|
|
|
|
inline long double
|
|
sqrt(long double __x)
|
|
{ return __builtin_sqrtl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
sqrt(_Tp __x)
|
|
{ return __builtin_sqrt(__x); }
|
|
|
|
using ::tan;
|
|
|
|
inline float
|
|
tan(float __x)
|
|
{ return __builtin_tanf(__x); }
|
|
|
|
inline long double
|
|
tan(long double __x)
|
|
{ return __builtin_tanl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
tan(_Tp __x)
|
|
{ return __builtin_tan(__x); }
|
|
|
|
using ::tanh;
|
|
|
|
inline float
|
|
tanh(float __x)
|
|
{ return __builtin_tanhf(__x); }
|
|
|
|
inline long double
|
|
tanh(long double __x)
|
|
{ return __builtin_tanhl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
tanh(_Tp __x)
|
|
{ return __builtin_tanh(__x); }
|
|
|
|
_GLIBCXX_END_NAMESPACE_VERSION
|
|
} // namespace
|
|
|
|
#if _GLIBCXX_USE_C99_MATH
|
|
#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
|
|
|
|
// These are possible macros imported from C99-land.
|
|
#undef fpclassify
|
|
#undef isfinite
|
|
#undef isinf
|
|
#undef isnan
|
|
#undef isnormal
|
|
#undef signbit
|
|
#undef isgreater
|
|
#undef isgreaterequal
|
|
#undef isless
|
|
#undef islessequal
|
|
#undef islessgreater
|
|
#undef isunordered
|
|
|
|
namespace std _GLIBCXX_VISIBILITY(default)
|
|
{
|
|
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
|
inline int
|
|
fpclassify(float __x)
|
|
{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
|
|
FP_SUBNORMAL, FP_ZERO, __x); }
|
|
|
|
inline int
|
|
fpclassify(double __x)
|
|
{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
|
|
FP_SUBNORMAL, FP_ZERO, __x); }
|
|
|
|
inline int
|
|
fpclassify(long double __x)
|
|
{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
|
|
FP_SUBNORMAL, FP_ZERO, __x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
int>::__type
|
|
fpclassify(_Tp __x)
|
|
{ return __x != 0 ? FP_NORMAL : FP_ZERO; }
|
|
|
|
inline bool
|
|
isfinite(float __x)
|
|
{ return __builtin_isfinite(__x); }
|
|
|
|
inline bool
|
|
isfinite(double __x)
|
|
{ return __builtin_isfinite(__x); }
|
|
|
|
inline bool
|
|
isfinite(long double __x)
|
|
{ return __builtin_isfinite(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
bool>::__type
|
|
isfinite(_Tp __x)
|
|
{ return true; }
|
|
|
|
inline bool
|
|
isinf(float __x)
|
|
{ return __builtin_isinf(__x); }
|
|
|
|
inline bool
|
|
isinf(double __x)
|
|
{ return __builtin_isinf(__x); }
|
|
|
|
inline bool
|
|
isinf(long double __x)
|
|
{ return __builtin_isinf(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
bool>::__type
|
|
isinf(_Tp __x)
|
|
{ return false; }
|
|
|
|
inline bool
|
|
isnan(float __x)
|
|
{ return __builtin_isnan(__x); }
|
|
|
|
inline bool
|
|
isnan(double __x)
|
|
{ return __builtin_isnan(__x); }
|
|
|
|
inline bool
|
|
isnan(long double __x)
|
|
{ return __builtin_isnan(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
bool>::__type
|
|
isnan(_Tp __x)
|
|
{ return false; }
|
|
|
|
inline bool
|
|
isnormal(float __x)
|
|
{ return __builtin_isnormal(__x); }
|
|
|
|
inline bool
|
|
isnormal(double __x)
|
|
{ return __builtin_isnormal(__x); }
|
|
|
|
inline bool
|
|
isnormal(long double __x)
|
|
{ return __builtin_isnormal(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
bool>::__type
|
|
isnormal(_Tp __x)
|
|
{ return __x != 0 ? true : false; }
|
|
|
|
inline bool
|
|
signbit(float __x)
|
|
{ return __builtin_signbit(__x); }
|
|
|
|
inline bool
|
|
signbit(double __x)
|
|
{ return __builtin_signbit(__x); }
|
|
|
|
inline bool
|
|
signbit(long double __x)
|
|
{ return __builtin_signbit(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
bool>::__type
|
|
signbit(_Tp __x)
|
|
{ return __x < 0 ? true : false; }
|
|
|
|
inline bool
|
|
isgreater(float __x, float __y)
|
|
{ return __builtin_isgreater(__x, __y); }
|
|
|
|
inline bool
|
|
isgreater(double __x, double __y)
|
|
{ return __builtin_isgreater(__x, __y); }
|
|
|
|
inline bool
|
|
isgreater(long double __x, long double __y)
|
|
{ return __builtin_isgreater(__x, __y); }
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value), bool>::__type
|
|
isgreater(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return __builtin_isgreater(__type(__x), __type(__y));
|
|
}
|
|
|
|
inline bool
|
|
isgreaterequal(float __x, float __y)
|
|
{ return __builtin_isgreaterequal(__x, __y); }
|
|
|
|
inline bool
|
|
isgreaterequal(double __x, double __y)
|
|
{ return __builtin_isgreaterequal(__x, __y); }
|
|
|
|
inline bool
|
|
isgreaterequal(long double __x, long double __y)
|
|
{ return __builtin_isgreaterequal(__x, __y); }
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value), bool>::__type
|
|
isgreaterequal(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return __builtin_isgreaterequal(__type(__x), __type(__y));
|
|
}
|
|
|
|
inline bool
|
|
isless(float __x, float __y)
|
|
{ return __builtin_isless(__x, __y); }
|
|
|
|
inline bool
|
|
isless(double __x, double __y)
|
|
{ return __builtin_isless(__x, __y); }
|
|
|
|
inline bool
|
|
isless(long double __x, long double __y)
|
|
{ return __builtin_isless(__x, __y); }
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value), bool>::__type
|
|
isless(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return __builtin_isless(__type(__x), __type(__y));
|
|
}
|
|
|
|
inline bool
|
|
islessequal(float __x, float __y)
|
|
{ return __builtin_islessequal(__x, __y); }
|
|
|
|
inline bool
|
|
islessequal(double __x, double __y)
|
|
{ return __builtin_islessequal(__x, __y); }
|
|
|
|
inline bool
|
|
islessequal(long double __x, long double __y)
|
|
{ return __builtin_islessequal(__x, __y); }
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value), bool>::__type
|
|
islessequal(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return __builtin_islessequal(__type(__x), __type(__y));
|
|
}
|
|
|
|
inline bool
|
|
islessgreater(float __x, float __y)
|
|
{ return __builtin_islessgreater(__x, __y); }
|
|
|
|
inline bool
|
|
islessgreater(double __x, double __y)
|
|
{ return __builtin_islessgreater(__x, __y); }
|
|
|
|
inline bool
|
|
islessgreater(long double __x, long double __y)
|
|
{ return __builtin_islessgreater(__x, __y); }
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value), bool>::__type
|
|
islessgreater(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return __builtin_islessgreater(__type(__x), __type(__y));
|
|
}
|
|
|
|
inline bool
|
|
isunordered(float __x, float __y)
|
|
{ return __builtin_isunordered(__x, __y); }
|
|
|
|
inline bool
|
|
isunordered(double __x, double __y)
|
|
{ return __builtin_isunordered(__x, __y); }
|
|
|
|
inline bool
|
|
isunordered(long double __x, long double __y)
|
|
{ return __builtin_isunordered(__x, __y); }
|
|
|
|
template<typename _Tp, typename _Up>
|
|
inline typename
|
|
__gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value), bool>::__type
|
|
isunordered(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
|
|
return __builtin_isunordered(__type(__x), __type(__y));
|
|
}
|
|
|
|
#else
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
fpclassify(_Tp __f)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
|
|
FP_SUBNORMAL, FP_ZERO, __type(__f));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isfinite(_Tp __f)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isfinite(__type(__f));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isinf(_Tp __f)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isinf(__type(__f));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isnan(_Tp __f)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isnan(__type(__f));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isnormal(_Tp __f)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isnormal(__type(__f));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
signbit(_Tp __f)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_signbit(__type(__f));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isgreater(_Tp __f1, _Tp __f2)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isgreater(__type(__f1), __type(__f2));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isgreaterequal(_Tp __f1, _Tp __f2)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isgreaterequal(__type(__f1), __type(__f2));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isless(_Tp __f1, _Tp __f2)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isless(__type(__f1), __type(__f2));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
islessequal(_Tp __f1, _Tp __f2)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_islessequal(__type(__f1), __type(__f2));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
islessgreater(_Tp __f1, _Tp __f2)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_islessgreater(__type(__f1), __type(__f2));
|
|
}
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
|
|
int>::__type
|
|
isunordered(_Tp __f1, _Tp __f2)
|
|
{
|
|
typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
|
|
return __builtin_isunordered(__type(__f1), __type(__f2));
|
|
}
|
|
|
|
#endif
|
|
|
|
_GLIBCXX_END_NAMESPACE_VERSION
|
|
} // namespace
|
|
|
|
#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
|
|
#endif
|
|
|
|
#ifdef __GXX_EXPERIMENTAL_CXX0X__
|
|
|
|
#ifdef _GLIBCXX_USE_C99_MATH_TR1
|
|
|
|
#undef acosh
|
|
#undef acoshf
|
|
#undef acoshl
|
|
#undef asinh
|
|
#undef asinhf
|
|
#undef asinhl
|
|
#undef atanh
|
|
#undef atanhf
|
|
#undef atanhl
|
|
#undef cbrt
|
|
#undef cbrtf
|
|
#undef cbrtl
|
|
#undef copysign
|
|
#undef copysignf
|
|
#undef copysignl
|
|
#undef erf
|
|
#undef erff
|
|
#undef erfl
|
|
#undef erfc
|
|
#undef erfcf
|
|
#undef erfcl
|
|
#undef exp2
|
|
#undef exp2f
|
|
#undef exp2l
|
|
#undef expm1
|
|
#undef expm1f
|
|
#undef expm1l
|
|
#undef fdim
|
|
#undef fdimf
|
|
#undef fdiml
|
|
#undef fma
|
|
#undef fmaf
|
|
#undef fmal
|
|
#undef fmax
|
|
#undef fmaxf
|
|
#undef fmaxl
|
|
#undef fmin
|
|
#undef fminf
|
|
#undef fminl
|
|
#undef hypot
|
|
#undef hypotf
|
|
#undef hypotl
|
|
#undef ilogb
|
|
#undef ilogbf
|
|
#undef ilogbl
|
|
#undef lgamma
|
|
#undef lgammaf
|
|
#undef lgammal
|
|
#undef llrint
|
|
#undef llrintf
|
|
#undef llrintl
|
|
#undef llround
|
|
#undef llroundf
|
|
#undef llroundl
|
|
#undef log1p
|
|
#undef log1pf
|
|
#undef log1pl
|
|
#undef log2
|
|
#undef log2f
|
|
#undef log2l
|
|
#undef logb
|
|
#undef logbf
|
|
#undef logbl
|
|
#undef lrint
|
|
#undef lrintf
|
|
#undef lrintl
|
|
#undef lround
|
|
#undef lroundf
|
|
#undef lroundl
|
|
#undef nan
|
|
#undef nanf
|
|
#undef nanl
|
|
#undef nearbyint
|
|
#undef nearbyintf
|
|
#undef nearbyintl
|
|
#undef nextafter
|
|
#undef nextafterf
|
|
#undef nextafterl
|
|
#undef nexttoward
|
|
#undef nexttowardf
|
|
#undef nexttowardl
|
|
#undef remainder
|
|
#undef remainderf
|
|
#undef remainderl
|
|
#undef remquo
|
|
#undef remquof
|
|
#undef remquol
|
|
#undef rint
|
|
#undef rintf
|
|
#undef rintl
|
|
#undef round
|
|
#undef roundf
|
|
#undef roundl
|
|
#undef scalbln
|
|
#undef scalblnf
|
|
#undef scalblnl
|
|
#undef scalbn
|
|
#undef scalbnf
|
|
#undef scalbnl
|
|
#undef tgamma
|
|
#undef tgammaf
|
|
#undef tgammal
|
|
#undef trunc
|
|
#undef truncf
|
|
#undef truncl
|
|
|
|
namespace std _GLIBCXX_VISIBILITY(default)
|
|
{
|
|
_GLIBCXX_BEGIN_NAMESPACE_VERSION
|
|
|
|
// types
|
|
using ::double_t;
|
|
using ::float_t;
|
|
|
|
// functions
|
|
using ::acosh;
|
|
using ::acoshf;
|
|
using ::acoshl;
|
|
|
|
using ::asinh;
|
|
using ::asinhf;
|
|
using ::asinhl;
|
|
|
|
using ::atanh;
|
|
using ::atanhf;
|
|
using ::atanhl;
|
|
|
|
using ::cbrt;
|
|
using ::cbrtf;
|
|
using ::cbrtl;
|
|
|
|
using ::copysign;
|
|
using ::copysignf;
|
|
using ::copysignl;
|
|
|
|
using ::erf;
|
|
using ::erff;
|
|
using ::erfl;
|
|
|
|
using ::erfc;
|
|
using ::erfcf;
|
|
using ::erfcl;
|
|
|
|
using ::exp2;
|
|
using ::exp2f;
|
|
using ::exp2l;
|
|
|
|
using ::expm1;
|
|
using ::expm1f;
|
|
using ::expm1l;
|
|
|
|
using ::fdim;
|
|
using ::fdimf;
|
|
using ::fdiml;
|
|
|
|
using ::fma;
|
|
using ::fmaf;
|
|
using ::fmal;
|
|
|
|
using ::fmax;
|
|
using ::fmaxf;
|
|
using ::fmaxl;
|
|
|
|
using ::fmin;
|
|
using ::fminf;
|
|
using ::fminl;
|
|
|
|
using ::hypot;
|
|
using ::hypotf;
|
|
using ::hypotl;
|
|
|
|
using ::ilogb;
|
|
using ::ilogbf;
|
|
using ::ilogbl;
|
|
|
|
using ::lgamma;
|
|
using ::lgammaf;
|
|
using ::lgammal;
|
|
|
|
using ::llrint;
|
|
using ::llrintf;
|
|
using ::llrintl;
|
|
|
|
using ::llround;
|
|
using ::llroundf;
|
|
using ::llroundl;
|
|
|
|
using ::log1p;
|
|
using ::log1pf;
|
|
using ::log1pl;
|
|
|
|
using ::log2;
|
|
using ::log2f;
|
|
using ::log2l;
|
|
|
|
using ::logb;
|
|
using ::logbf;
|
|
using ::logbl;
|
|
|
|
using ::lrint;
|
|
using ::lrintf;
|
|
using ::lrintl;
|
|
|
|
using ::lround;
|
|
using ::lroundf;
|
|
using ::lroundl;
|
|
|
|
using ::nan;
|
|
using ::nanf;
|
|
using ::nanl;
|
|
|
|
using ::nearbyint;
|
|
using ::nearbyintf;
|
|
using ::nearbyintl;
|
|
|
|
using ::nextafter;
|
|
using ::nextafterf;
|
|
using ::nextafterl;
|
|
|
|
using ::nexttoward;
|
|
using ::nexttowardf;
|
|
using ::nexttowardl;
|
|
|
|
using ::remainder;
|
|
using ::remainderf;
|
|
using ::remainderl;
|
|
|
|
using ::remquo;
|
|
using ::remquof;
|
|
using ::remquol;
|
|
|
|
using ::rint;
|
|
using ::rintf;
|
|
using ::rintl;
|
|
|
|
using ::round;
|
|
using ::roundf;
|
|
using ::roundl;
|
|
|
|
using ::scalbln;
|
|
using ::scalblnf;
|
|
using ::scalblnl;
|
|
|
|
using ::scalbn;
|
|
using ::scalbnf;
|
|
using ::scalbnl;
|
|
|
|
using ::tgamma;
|
|
using ::tgammaf;
|
|
using ::tgammal;
|
|
|
|
using ::trunc;
|
|
using ::truncf;
|
|
using ::truncl;
|
|
|
|
/// Additional overloads.
|
|
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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
acosh(_Tp __x)
|
|
{ return __builtin_acosh(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
asinh(_Tp __x)
|
|
{ return __builtin_asinh(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
atanh(_Tp __x)
|
|
{ return __builtin_atanh(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
cbrt(_Tp __x)
|
|
{ return __builtin_cbrt(__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
copysign(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
erf(_Tp __x)
|
|
{ return __builtin_erf(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
erfc(_Tp __x)
|
|
{ return __builtin_erfc(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
exp2(_Tp __x)
|
|
{ return __builtin_exp2(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
expm1(_Tp __x)
|
|
{ return __builtin_expm1(__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
fdim(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__promote_3<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value
|
|
&& __is_arithmetic<_Vp>::__value,
|
|
_Tp>::__type, _Up, _Vp>::__type
|
|
fma(_Tp __x, _Up __y, _Vp __z)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
fmax(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
fmin(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
hypot(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__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 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
int>::__type
|
|
ilogb(_Tp __x)
|
|
{ return __builtin_ilogb(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
lgamma(_Tp __x)
|
|
{ return __builtin_lgamma(__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 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
long long>::__type
|
|
llrint(_Tp __x)
|
|
{ return __builtin_llrint(__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 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
long long>::__type
|
|
llround(_Tp __x)
|
|
{ return __builtin_llround(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
log1p(_Tp __x)
|
|
{ return __builtin_log1p(__x); }
|
|
|
|
// DR 568.
|
|
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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
log2(_Tp __x)
|
|
{ return __builtin_log2(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
logb(_Tp __x)
|
|
{ return __builtin_logb(__x); }
|
|
|
|
inline long
|
|
lrint(float __x)
|
|
{ return __builtin_lrintf(__x); }
|
|
|
|
inline long
|
|
lrint(long double __x)
|
|
{ return __builtin_lrintl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
long>::__type
|
|
lrint(_Tp __x)
|
|
{ return __builtin_lrint(__x); }
|
|
|
|
inline long
|
|
lround(float __x)
|
|
{ return __builtin_lroundf(__x); }
|
|
|
|
inline long
|
|
lround(long double __x)
|
|
{ return __builtin_lroundl(__x); }
|
|
|
|
template<typename _Tp>
|
|
inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
long>::__type
|
|
lround(_Tp __x)
|
|
{ return __builtin_lround(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
nearbyint(_Tp __x)
|
|
{ return __builtin_nearbyint(__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
nextafter(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
nexttoward(_Tp __x, long double __y)
|
|
{ return __builtin_nexttoward(__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
remainder(_Tp __x, _Up __y)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__promote_2<
|
|
typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
|
|
&& __is_arithmetic<_Up>::__value,
|
|
_Tp>::__type, _Up>::__type
|
|
remquo(_Tp __x, _Up __y, int* __pquo)
|
|
{
|
|
typedef typename __gnu_cxx::__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
rint(_Tp __x)
|
|
{ return __builtin_rint(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
round(_Tp __x)
|
|
{ return __builtin_round(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
scalbln(_Tp __x, long __ex)
|
|
{ return __builtin_scalbln(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
scalbn(_Tp __x, int __ex)
|
|
{ return __builtin_scalbn(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
tgamma(_Tp __x)
|
|
{ return __builtin_tgamma(__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 __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
|
|
double>::__type
|
|
trunc(_Tp __x)
|
|
{ return __builtin_trunc(__x); }
|
|
|
|
_GLIBCXX_END_NAMESPACE_VERSION
|
|
} // namespace
|
|
|
|
#endif // _GLIBCXX_USE_C99_MATH_TR1
|
|
|
|
#endif // __GXX_EXPERIMENTAL_CXX0X__
|
|
|
|
#endif
|