0,0 → 1,1783 |
// -*- C++ -*- C forwarding header. |
|
// Copyright (C) 1997-2015 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 |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR double |
abs(double __x) |
{ return __builtin_fabs(__x); } |
#endif |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
abs(float __x) |
{ return __builtin_fabsf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
abs(long double __x) |
{ return __builtin_fabsl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
abs(_Tp __x) |
{ return __builtin_fabs(__x); } |
|
using ::acos; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
acos(float __x) |
{ return __builtin_acosf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
acos(long double __x) |
{ return __builtin_acosl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
acos(_Tp __x) |
{ return __builtin_acos(__x); } |
|
using ::asin; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
asin(float __x) |
{ return __builtin_asinf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
asin(long double __x) |
{ return __builtin_asinl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
asin(_Tp __x) |
{ return __builtin_asin(__x); } |
|
using ::atan; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
atan(float __x) |
{ return __builtin_atanf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
atan(long double __x) |
{ return __builtin_atanl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
atan(_Tp __x) |
{ return __builtin_atan(__x); } |
|
using ::atan2; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
atan2(float __y, float __x) |
{ return __builtin_atan2f(__y, __x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
atan2(long double __y, long double __x) |
{ return __builtin_atan2l(__y, __x); } |
#endif |
|
template<typename _Tp, typename _Up> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__promote_2<_Tp, _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; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
ceil(float __x) |
{ return __builtin_ceilf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
ceil(long double __x) |
{ return __builtin_ceill(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
ceil(_Tp __x) |
{ return __builtin_ceil(__x); } |
|
using ::cos; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
cos(float __x) |
{ return __builtin_cosf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
cos(long double __x) |
{ return __builtin_cosl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
cos(_Tp __x) |
{ return __builtin_cos(__x); } |
|
using ::cosh; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
cosh(float __x) |
{ return __builtin_coshf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
cosh(long double __x) |
{ return __builtin_coshl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
cosh(_Tp __x) |
{ return __builtin_cosh(__x); } |
|
using ::exp; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
exp(float __x) |
{ return __builtin_expf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
exp(long double __x) |
{ return __builtin_expl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
exp(_Tp __x) |
{ return __builtin_exp(__x); } |
|
using ::fabs; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
fabs(float __x) |
{ return __builtin_fabsf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
fabs(long double __x) |
{ return __builtin_fabsl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
fabs(_Tp __x) |
{ return __builtin_fabs(__x); } |
|
using ::floor; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
floor(float __x) |
{ return __builtin_floorf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
floor(long double __x) |
{ return __builtin_floorl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
floor(_Tp __x) |
{ return __builtin_floor(__x); } |
|
using ::fmod; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
fmod(float __x, float __y) |
{ return __builtin_fmodf(__x, __y); } |
|
inline _GLIBCXX_CONSTEXPR long double |
fmod(long double __x, long double __y) |
{ return __builtin_fmodl(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
fmod(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return fmod(__type(__x), __type(__y)); |
} |
|
using ::frexp; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
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); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
frexp(_Tp __x, int* __exp) |
{ return __builtin_frexp(__x, __exp); } |
|
using ::ldexp; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
ldexp(float __x, int __exp) |
{ return __builtin_ldexpf(__x, __exp); } |
|
inline _GLIBCXX_CONSTEXPR long double |
ldexp(long double __x, int __exp) |
{ return __builtin_ldexpl(__x, __exp); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
ldexp(_Tp __x, int __exp) |
{ return __builtin_ldexp(__x, __exp); } |
|
using ::log; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
log(float __x) |
{ return __builtin_logf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
log(long double __x) |
{ return __builtin_logl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
log(_Tp __x) |
{ return __builtin_log(__x); } |
|
using ::log10; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
log10(float __x) |
{ return __builtin_log10f(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
log10(long double __x) |
{ return __builtin_log10l(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
log10(_Tp __x) |
{ return __builtin_log10(__x); } |
|
using ::modf; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
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); } |
#endif |
|
using ::pow; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
pow(float __x, float __y) |
{ return __builtin_powf(__x, __y); } |
|
inline _GLIBCXX_CONSTEXPR long double |
pow(long double __x, long double __y) |
{ return __builtin_powl(__x, __y); } |
|
#if __cplusplus < 201103L |
// _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 |
#endif |
|
template<typename _Tp, typename _Up> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__promote_2<_Tp, _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; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
sin(float __x) |
{ return __builtin_sinf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
sin(long double __x) |
{ return __builtin_sinl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
sin(_Tp __x) |
{ return __builtin_sin(__x); } |
|
using ::sinh; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
sinh(float __x) |
{ return __builtin_sinhf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
sinh(long double __x) |
{ return __builtin_sinhl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
sinh(_Tp __x) |
{ return __builtin_sinh(__x); } |
|
using ::sqrt; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
sqrt(float __x) |
{ return __builtin_sqrtf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
sqrt(long double __x) |
{ return __builtin_sqrtl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
sqrt(_Tp __x) |
{ return __builtin_sqrt(__x); } |
|
using ::tan; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
tan(float __x) |
{ return __builtin_tanf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
tan(long double __x) |
{ return __builtin_tanl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
tan(_Tp __x) |
{ return __builtin_tan(__x); } |
|
using ::tanh; |
|
#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO |
inline _GLIBCXX_CONSTEXPR float |
tanh(float __x) |
{ return __builtin_tanhf(__x); } |
|
inline _GLIBCXX_CONSTEXPR long double |
tanh(long double __x) |
{ return __builtin_tanhl(__x); } |
#endif |
|
template<typename _Tp> |
inline _GLIBCXX_CONSTEXPR |
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 |
|
#if __cplusplus >= 201103L |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr int |
fpclassify(float __x) |
{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
FP_SUBNORMAL, FP_ZERO, __x); } |
|
constexpr int |
fpclassify(double __x) |
{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
FP_SUBNORMAL, FP_ZERO, __x); } |
|
constexpr int |
fpclassify(long double __x) |
{ return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
FP_SUBNORMAL, FP_ZERO, __x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
int>::__type |
fpclassify(_Tp __x) |
{ return __x != 0 ? FP_NORMAL : FP_ZERO; } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isfinite(float __x) |
{ return __builtin_isfinite(__x); } |
|
constexpr bool |
isfinite(double __x) |
{ return __builtin_isfinite(__x); } |
|
constexpr bool |
isfinite(long double __x) |
{ return __builtin_isfinite(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
bool>::__type |
isfinite(_Tp __x) |
{ return true; } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isinf(float __x) |
{ return __builtin_isinf(__x); } |
|
constexpr bool |
isinf(double __x) |
{ return __builtin_isinf(__x); } |
|
constexpr bool |
isinf(long double __x) |
{ return __builtin_isinf(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
bool>::__type |
isinf(_Tp __x) |
{ return false; } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isnan(float __x) |
{ return __builtin_isnan(__x); } |
|
constexpr bool |
isnan(double __x) |
{ return __builtin_isnan(__x); } |
|
constexpr bool |
isnan(long double __x) |
{ return __builtin_isnan(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
bool>::__type |
isnan(_Tp __x) |
{ return false; } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isnormal(float __x) |
{ return __builtin_isnormal(__x); } |
|
constexpr bool |
isnormal(double __x) |
{ return __builtin_isnormal(__x); } |
|
constexpr bool |
isnormal(long double __x) |
{ return __builtin_isnormal(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
bool>::__type |
isnormal(_Tp __x) |
{ return __x != 0 ? true : false; } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
// The front-end doesn't provide a type generic builtin (libstdc++/58625). |
constexpr bool |
signbit(float __x) |
{ return __builtin_signbitf(__x); } |
|
constexpr bool |
signbit(double __x) |
{ return __builtin_signbit(__x); } |
|
constexpr bool |
signbit(long double __x) |
{ return __builtin_signbitl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
bool>::__type |
signbit(_Tp __x) |
{ return __x < 0 ? true : false; } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isgreater(float __x, float __y) |
{ return __builtin_isgreater(__x, __y); } |
|
constexpr bool |
isgreater(double __x, double __y) |
{ return __builtin_isgreater(__x, __y); } |
|
constexpr bool |
isgreater(long double __x, long double __y) |
{ return __builtin_isgreater(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr 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)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isgreaterequal(float __x, float __y) |
{ return __builtin_isgreaterequal(__x, __y); } |
|
constexpr bool |
isgreaterequal(double __x, double __y) |
{ return __builtin_isgreaterequal(__x, __y); } |
|
constexpr bool |
isgreaterequal(long double __x, long double __y) |
{ return __builtin_isgreaterequal(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr 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)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isless(float __x, float __y) |
{ return __builtin_isless(__x, __y); } |
|
constexpr bool |
isless(double __x, double __y) |
{ return __builtin_isless(__x, __y); } |
|
constexpr bool |
isless(long double __x, long double __y) |
{ return __builtin_isless(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr 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)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
islessequal(float __x, float __y) |
{ return __builtin_islessequal(__x, __y); } |
|
constexpr bool |
islessequal(double __x, double __y) |
{ return __builtin_islessequal(__x, __y); } |
|
constexpr bool |
islessequal(long double __x, long double __y) |
{ return __builtin_islessequal(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr 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)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
islessgreater(float __x, float __y) |
{ return __builtin_islessgreater(__x, __y); } |
|
constexpr bool |
islessgreater(double __x, double __y) |
{ return __builtin_islessgreater(__x, __y); } |
|
constexpr bool |
islessgreater(long double __x, long double __y) |
{ return __builtin_islessgreater(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr 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)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr bool |
isunordered(float __x, float __y) |
{ return __builtin_isunordered(__x, __y); } |
|
constexpr bool |
isunordered(double __x, double __y) |
{ return __builtin_isunordered(__x, __y); } |
|
constexpr bool |
isunordered(long double __x, long double __y) |
{ return __builtin_isunordered(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr 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 sizeof(__type) == sizeof(float) |
? __builtin_signbitf(__type(__f)) |
: sizeof(__type) == sizeof(double) |
? __builtin_signbit(__type(__f)) |
: __builtin_signbitl(__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 |
|
#if __cplusplus >= 201103L |
|
#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. |
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
acosh(float __x) |
{ return __builtin_acoshf(__x); } |
|
constexpr long double |
acosh(long double __x) |
{ return __builtin_acoshl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
acosh(_Tp __x) |
{ return __builtin_acosh(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
asinh(float __x) |
{ return __builtin_asinhf(__x); } |
|
constexpr long double |
asinh(long double __x) |
{ return __builtin_asinhl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
asinh(_Tp __x) |
{ return __builtin_asinh(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
atanh(float __x) |
{ return __builtin_atanhf(__x); } |
|
constexpr long double |
atanh(long double __x) |
{ return __builtin_atanhl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
atanh(_Tp __x) |
{ return __builtin_atanh(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
cbrt(float __x) |
{ return __builtin_cbrtf(__x); } |
|
constexpr long double |
cbrt(long double __x) |
{ return __builtin_cbrtl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
cbrt(_Tp __x) |
{ return __builtin_cbrt(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
copysign(float __x, float __y) |
{ return __builtin_copysignf(__x, __y); } |
|
constexpr long double |
copysign(long double __x, long double __y) |
{ return __builtin_copysignl(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
copysign(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return copysign(__type(__x), __type(__y)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
erf(float __x) |
{ return __builtin_erff(__x); } |
|
constexpr long double |
erf(long double __x) |
{ return __builtin_erfl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
erf(_Tp __x) |
{ return __builtin_erf(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
erfc(float __x) |
{ return __builtin_erfcf(__x); } |
|
constexpr long double |
erfc(long double __x) |
{ return __builtin_erfcl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
erfc(_Tp __x) |
{ return __builtin_erfc(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
exp2(float __x) |
{ return __builtin_exp2f(__x); } |
|
constexpr long double |
exp2(long double __x) |
{ return __builtin_exp2l(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
exp2(_Tp __x) |
{ return __builtin_exp2(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
expm1(float __x) |
{ return __builtin_expm1f(__x); } |
|
constexpr long double |
expm1(long double __x) |
{ return __builtin_expm1l(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
expm1(_Tp __x) |
{ return __builtin_expm1(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
fdim(float __x, float __y) |
{ return __builtin_fdimf(__x, __y); } |
|
constexpr long double |
fdim(long double __x, long double __y) |
{ return __builtin_fdiml(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
fdim(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return fdim(__type(__x), __type(__y)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
fma(float __x, float __y, float __z) |
{ return __builtin_fmaf(__x, __y, __z); } |
|
constexpr long double |
fma(long double __x, long double __y, long double __z) |
{ return __builtin_fmal(__x, __y, __z); } |
#endif |
|
template<typename _Tp, typename _Up, typename _Vp> |
constexpr typename __gnu_cxx::__promote_3<_Tp, _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)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
fmax(float __x, float __y) |
{ return __builtin_fmaxf(__x, __y); } |
|
constexpr long double |
fmax(long double __x, long double __y) |
{ return __builtin_fmaxl(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
fmax(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return fmax(__type(__x), __type(__y)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
fmin(float __x, float __y) |
{ return __builtin_fminf(__x, __y); } |
|
constexpr long double |
fmin(long double __x, long double __y) |
{ return __builtin_fminl(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
fmin(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return fmin(__type(__x), __type(__y)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
hypot(float __x, float __y) |
{ return __builtin_hypotf(__x, __y); } |
|
constexpr long double |
hypot(long double __x, long double __y) |
{ return __builtin_hypotl(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
hypot(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return hypot(__type(__x), __type(__y)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr int |
ilogb(float __x) |
{ return __builtin_ilogbf(__x); } |
|
constexpr int |
ilogb(long double __x) |
{ return __builtin_ilogbl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr |
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
int>::__type |
ilogb(_Tp __x) |
{ return __builtin_ilogb(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
lgamma(float __x) |
{ return __builtin_lgammaf(__x); } |
|
constexpr long double |
lgamma(long double __x) |
{ return __builtin_lgammal(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
lgamma(_Tp __x) |
{ return __builtin_lgamma(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr long long |
llrint(float __x) |
{ return __builtin_llrintf(__x); } |
|
constexpr long long |
llrint(long double __x) |
{ return __builtin_llrintl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
long long>::__type |
llrint(_Tp __x) |
{ return __builtin_llrint(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr long long |
llround(float __x) |
{ return __builtin_llroundf(__x); } |
|
constexpr long long |
llround(long double __x) |
{ return __builtin_llroundl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
long long>::__type |
llround(_Tp __x) |
{ return __builtin_llround(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
log1p(float __x) |
{ return __builtin_log1pf(__x); } |
|
constexpr long double |
log1p(long double __x) |
{ return __builtin_log1pl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
log1p(_Tp __x) |
{ return __builtin_log1p(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
// DR 568. |
constexpr float |
log2(float __x) |
{ return __builtin_log2f(__x); } |
|
constexpr long double |
log2(long double __x) |
{ return __builtin_log2l(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
log2(_Tp __x) |
{ return __builtin_log2(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
logb(float __x) |
{ return __builtin_logbf(__x); } |
|
constexpr long double |
logb(long double __x) |
{ return __builtin_logbl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
logb(_Tp __x) |
{ return __builtin_logb(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr long |
lrint(float __x) |
{ return __builtin_lrintf(__x); } |
|
constexpr long |
lrint(long double __x) |
{ return __builtin_lrintl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
long>::__type |
lrint(_Tp __x) |
{ return __builtin_lrint(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr long |
lround(float __x) |
{ return __builtin_lroundf(__x); } |
|
constexpr long |
lround(long double __x) |
{ return __builtin_lroundl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
long>::__type |
lround(_Tp __x) |
{ return __builtin_lround(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
nearbyint(float __x) |
{ return __builtin_nearbyintf(__x); } |
|
constexpr long double |
nearbyint(long double __x) |
{ return __builtin_nearbyintl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
nearbyint(_Tp __x) |
{ return __builtin_nearbyint(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
nextafter(float __x, float __y) |
{ return __builtin_nextafterf(__x, __y); } |
|
constexpr long double |
nextafter(long double __x, long double __y) |
{ return __builtin_nextafterl(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
nextafter(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return nextafter(__type(__x), __type(__y)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
nexttoward(float __x, long double __y) |
{ return __builtin_nexttowardf(__x, __y); } |
|
constexpr long double |
nexttoward(long double __x, long double __y) |
{ return __builtin_nexttowardl(__x, __y); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
nexttoward(_Tp __x, long double __y) |
{ return __builtin_nexttoward(__x, __y); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
remainder(float __x, float __y) |
{ return __builtin_remainderf(__x, __y); } |
|
constexpr long double |
remainder(long double __x, long double __y) |
{ return __builtin_remainderl(__x, __y); } |
#endif |
|
template<typename _Tp, typename _Up> |
constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
remainder(_Tp __x, _Up __y) |
{ |
typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
return remainder(__type(__x), __type(__y)); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
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); } |
#endif |
|
template<typename _Tp, typename _Up> |
inline typename __gnu_cxx::__promote_2<_Tp, _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); |
} |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
rint(float __x) |
{ return __builtin_rintf(__x); } |
|
constexpr long double |
rint(long double __x) |
{ return __builtin_rintl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
rint(_Tp __x) |
{ return __builtin_rint(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
round(float __x) |
{ return __builtin_roundf(__x); } |
|
constexpr long double |
round(long double __x) |
{ return __builtin_roundl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
round(_Tp __x) |
{ return __builtin_round(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
scalbln(float __x, long __ex) |
{ return __builtin_scalblnf(__x, __ex); } |
|
constexpr long double |
scalbln(long double __x, long __ex) |
{ return __builtin_scalblnl(__x, __ex); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
scalbln(_Tp __x, long __ex) |
{ return __builtin_scalbln(__x, __ex); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
scalbn(float __x, int __ex) |
{ return __builtin_scalbnf(__x, __ex); } |
|
constexpr long double |
scalbn(long double __x, int __ex) |
{ return __builtin_scalbnl(__x, __ex); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
scalbn(_Tp __x, int __ex) |
{ return __builtin_scalbn(__x, __ex); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
tgamma(float __x) |
{ return __builtin_tgammaf(__x); } |
|
constexpr long double |
tgamma(long double __x) |
{ return __builtin_tgammal(__x); } |
#endif |
|
template<typename _Tp> |
constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
double>::__type |
tgamma(_Tp __x) |
{ return __builtin_tgamma(__x); } |
|
#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO |
constexpr float |
trunc(float __x) |
{ return __builtin_truncf(__x); } |
|
constexpr long double |
trunc(long double __x) |
{ return __builtin_truncl(__x); } |
#endif |
|
template<typename _Tp> |
constexpr 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 // C++11 |
|
#endif |