URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [include/] [c_std/] [cmath] - Blame information for rev 866

Go to most recent revision | Details | Compare with Previous | View Log


// -*- C++ -*- C forwarding header.
 
// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
// 2006, 2007, 2008, 2009, 2010
// 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
// .
 
/** @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
//
 
#ifndef _GLIBCXX_CMATH
#define _GLIBCXX_CMATH 1
 
#pragma GCC system_header
 
#include 
#include 
#include 
 
#include 
 
// Get rid of those macros defined in  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
    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
    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
    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
    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
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
                                           && __is_integer<_Up>::__value,
                                           double>::__type
    atan2(_Tp __y, _Up __x)
    { return __builtin_atan2(__y, __x); }
 
  using ::ceil;
 
  inline float
  ceil(float __x)
  { return __builtin_ceilf(__x); }
 
  inline long double
  ceil(long double __x)
  { return __builtin_ceill(__x); }
 
  template
    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
    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
    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
    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
    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
    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); }
 
  template
    inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
                                           && __is_integer<_Up>::__value,
                                           double>::__type
    fmod(_Tp __x, _Up __y)
    { return __builtin_fmod(__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
    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
    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
    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
    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); }
 
  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); }
 
  using ::sin;
 
  inline float
  sin(float __x)
  { return __builtin_sinf(__x); }
 
  inline long double
  sin(long double __x)
  { return __builtin_sinl(__x); }
 
  template
    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
    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
    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
    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
    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
 
  template
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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
    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));
    }
 
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
 
#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
#endif
 
#endif

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [include/] [c_std/] [cmath] - Blame information for rev 866

Line No.	Rev	Author	Line
1	742	jeremybenn	`// -- C++ -- C forwarding header.`
2
3			`// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,`
4			`// 2006, 2007, 2008, 2009, 2010`
5			`// Free Software Foundation, Inc.`
6			`//`
7			`// This file is part of the GNU ISO C++ Library. This library is free`
8			`// software; you can redistribute it and/or modify it under the`
9			`// terms of the GNU General Public License as published by the`
10			`// Free Software Foundation; either version 3, or (at your option)`
11			`// any later version.`
12
13			`// This library is distributed in the hope that it will be useful,`
14			`// but WITHOUT ANY WARRANTY; without even the implied warranty of`
15			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
16			`// GNU General Public License for more details.`
17
18			`// Under Section 7 of GPL version 3, you are granted additional`
19			`// permissions described in the GCC Runtime Library Exception, version`
20			`// 3.1, as published by the Free Software Foundation.`
21
22			`// You should have received a copy of the GNU General Public License and`
23			`// a copy of the GCC Runtime Library Exception along with this program;`
24			`// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see`
25			`// .`
26
27			`/** @file include/cmath`
28			`* This is a Standard C++ Library file. You should @c #include this file`
29			`* in your programs, rather than any of the @a *.h implementation files.`
30			`*`
31			`* This is the C++ version of the Standard C Library header @c math.h,`
32			`* and its contents are (mostly) the same as that header, but are all`
33			`* contained in the namespace @c std (except for names which are defined`
34			`* as macros in C).`
35			`*/`
36
37			`//`
38			`// ISO C++ 14882: 26.5 C library`
39			`//`
40
41			`#ifndef _GLIBCXX_CMATH`
42			`#define _GLIBCXX_CMATH 1`
43
44			`#pragma GCC system_header`
45
46			`#include`
47			`#include`
48			`#include`
49
50			`#include`
51
52			`// Get rid of those macros defined in in lieu of real functions.`
53			`#undef abs`
54			`#undef div`
55			`#undef acos`
56			`#undef asin`
57			`#undef atan`
58			`#undef atan2`
59			`#undef ceil`
60			`#undef cos`
61			`#undef cosh`
62			`#undef exp`
63			`#undef fabs`
64			`#undef floor`
65			`#undef fmod`
66			`#undef frexp`
67			`#undef ldexp`
68			`#undef log`
69			`#undef log10`
70			`#undef modf`
71			`#undef pow`
72			`#undef sin`
73			`#undef sinh`
74			`#undef sqrt`
75			`#undef tan`
76			`#undef tanh`
77
78			`namespace std _GLIBCXX_VISIBILITY(default)`
79			`{`
80			`_GLIBCXX_BEGIN_NAMESPACE_VERSION`
81
82			`inline double`
83			`abs(double __x)`
84			`{ return __builtin_fabs(__x); }`
85
86			`inline float`
87			`abs(float __x)`
88			`{ return __builtin_fabsf(__x); }`
89
90			`inline long double`
91			`abs(long double __x)`
92			`{ return __builtin_fabsl(__x); }`
93
94			`template`
95			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
96			`double>::__type`
97			`abs(_Tp __x)`
98			`{ return __builtin_fabs(__x); }`
99
100			`using ::acos;`
101
102			`inline float`
103			`acos(float __x)`
104			`{ return __builtin_acosf(__x); }`
105
106			`inline long double`
107			`acos(long double __x)`
108			`{ return __builtin_acosl(__x); }`
109
110			`template`
111			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
112			`double>::__type`
113			`acos(_Tp __x)`
114			`{ return __builtin_acos(__x); }`
115
116			`using ::asin;`
117
118			`inline float`
119			`asin(float __x)`
120			`{ return __builtin_asinf(__x); }`
121
122			`inline long double`
123			`asin(long double __x)`
124			`{ return __builtin_asinl(__x); }`
125
126			`template`
127			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
128			`double>::__type`
129			`asin(_Tp __x)`
130			`{ return __builtin_asin(__x); }`
131
132			`using ::atan;`
133
134			`inline float`
135			`atan(float __x)`
136			`{ return __builtin_atanf(__x); }`
137
138			`inline long double`
139			`atan(long double __x)`
140			`{ return __builtin_atanl(__x); }`
141
142			`template`
143			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
144			`double>::__type`
145			`atan(_Tp __x)`
146			`{ return __builtin_atan(__x); }`
147
148			`using ::atan2;`
149
150			`inline float`
151			`atan2(float __y, float __x)`
152			`{ return __builtin_atan2f(__y, __x); }`
153
154			`inline long double`
155			`atan2(long double __y, long double __x)`
156			`{ return __builtin_atan2l(__y, __x); }`
157
158			`template`
159			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value`
160			`&& __is_integer<_Up>::__value,`
161			`double>::__type`
162			`atan2(_Tp __y, _Up __x)`
163			`{ return __builtin_atan2(__y, __x); }`
164
165			`using ::ceil;`
166
167			`inline float`
168			`ceil(float __x)`
169			`{ return __builtin_ceilf(__x); }`
170
171			`inline long double`
172			`ceil(long double __x)`
173			`{ return __builtin_ceill(__x); }`
174
175			`template`
176			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
177			`double>::__type`
178			`ceil(_Tp __x)`
179			`{ return __builtin_ceil(__x); }`
180
181			`using ::cos;`
182
183			`inline float`
184			`cos(float __x)`
185			`{ return __builtin_cosf(__x); }`
186
187			`inline long double`
188			`cos(long double __x)`
189			`{ return __builtin_cosl(__x); }`
190
191			`template`
192			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
193			`double>::__type`
194			`cos(_Tp __x)`
195			`{ return __builtin_cos(__x); }`
196
197			`using ::cosh;`
198
199			`inline float`
200			`cosh(float __x)`
201			`{ return __builtin_coshf(__x); }`
202
203			`inline long double`
204			`cosh(long double __x)`
205			`{ return __builtin_coshl(__x); }`
206
207			`template`
208			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
209			`double>::__type`
210			`cosh(_Tp __x)`
211			`{ return __builtin_cosh(__x); }`
212
213			`using ::exp;`
214
215			`inline float`
216			`exp(float __x)`
217			`{ return __builtin_expf(__x); }`
218
219			`inline long double`
220			`exp(long double __x)`
221			`{ return __builtin_expl(__x); }`
222
223			`template`
224			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
225			`double>::__type`
226			`exp(_Tp __x)`
227			`{ return __builtin_exp(__x); }`
228
229			`using ::fabs;`
230
231			`inline float`
232			`fabs(float __x)`
233			`{ return __builtin_fabsf(__x); }`
234
235			`inline long double`
236			`fabs(long double __x)`
237			`{ return __builtin_fabsl(__x); }`
238
239			`template`
240			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
241			`double>::__type`
242			`fabs(_Tp __x)`
243			`{ return __builtin_fabs(__x); }`
244
245			`using ::floor;`
246
247			`inline float`
248			`floor(float __x)`
249			`{ return __builtin_floorf(__x); }`
250
251			`inline long double`
252			`floor(long double __x)`
253			`{ return __builtin_floorl(__x); }`
254
255			`template`
256			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
257			`double>::__type`
258			`floor(_Tp __x)`
259			`{ return __builtin_floor(__x); }`
260
261			`using ::fmod;`
262
263			`inline float`
264			`fmod(float __x, float __y)`
265			`{ return __builtin_fmodf(__x, __y); }`
266
267			`inline long double`
268			`fmod(long double __x, long double __y)`
269			`{ return __builtin_fmodl(__x, __y); }`
270
271			`template`
272			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value`
273			`&& __is_integer<_Up>::__value,`
274			`double>::__type`
275			`fmod(_Tp __x, _Up __y)`
276			`{ return __builtin_fmod(__x, __y); }`
277
278			`using ::frexp;`
279
280			`inline float`
281			`frexp(float __x, int* __exp)`
282			`{ return __builtin_frexpf(__x, __exp); }`
283
284			`inline long double`
285			`frexp(long double __x, int* __exp)`
286			`{ return __builtin_frexpl(__x, __exp); }`
287
288			`template`
289			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
290			`double>::__type`
291			`frexp(_Tp __x, int* __exp)`
292			`{ return __builtin_frexp(__x, __exp); }`
293
294			`using ::ldexp;`
295
296			`inline float`
297			`ldexp(float __x, int __exp)`
298			`{ return __builtin_ldexpf(__x, __exp); }`
299
300			`inline long double`
301			`ldexp(long double __x, int __exp)`
302			`{ return __builtin_ldexpl(__x, __exp); }`
303
304			`template`
305			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
306			`double>::__type`
307			`ldexp(_Tp __x, int __exp)`
308			`{ return __builtin_ldexp(__x, __exp); }`
309
310			`using ::log;`
311
312			`inline float`
313			`log(float __x)`
314			`{ return __builtin_logf(__x); }`
315
316			`inline long double`
317			`log(long double __x)`
318			`{ return __builtin_logl(__x); }`
319
320			`template`
321			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
322			`double>::__type`
323			`log(_Tp __x)`
324			`{ return __builtin_log(__x); }`
325
326			`using ::log10;`
327
328			`inline float`
329			`log10(float __x)`
330			`{ return __builtin_log10f(__x); }`
331
332			`inline long double`
333			`log10(long double __x)`
334			`{ return __builtin_log10l(__x); }`
335
336			`template`
337			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
338			`double>::__type`
339			`log10(_Tp __x)`
340			`{ return __builtin_log10(__x); }`
341
342			`using ::modf;`
343
344			`inline float`
345			`modf(float __x, float* __iptr)`
346			`{ return __builtin_modff(__x, __iptr); }`
347
348			`inline long double`
349			`modf(long double __x, long double* __iptr)`
350			`{ return __builtin_modfl(__x, __iptr); }`
351
352			`using ::pow;`
353
354			`inline float`
355			`pow(float __x, float __y)`
356			`{ return __builtin_powf(__x, __y); }`
357
358			`inline long double`
359			`pow(long double __x, long double __y)`
360			`{ return __builtin_powl(__x, __y); }`
361
362			`inline double`
363			`pow(double __x, int __i)`
364			`{ return __builtin_powi(__x, __i); }`
365
366			`inline float`
367			`pow(float __x, int __n)`
368			`{ return __builtin_powif(__x, __n); }`
369
370			`inline long double`
371			`pow(long double __x, int __n)`
372			`{ return __builtin_powil(__x, __n); }`
373
374			`using ::sin;`
375
376			`inline float`
377			`sin(float __x)`
378			`{ return __builtin_sinf(__x); }`
379
380			`inline long double`
381			`sin(long double __x)`
382			`{ return __builtin_sinl(__x); }`
383
384			`template`
385			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
386			`double>::__type`
387			`sin(_Tp __x)`
388			`{ return __builtin_sin(__x); }`
389
390			`using ::sinh;`
391
392			`inline float`
393			`sinh(float __x)`
394			`{ return __builtin_sinhf(__x); }`
395
396			`inline long double`
397			`sinh(long double __x)`
398			`{ return __builtin_sinhl(__x); }`
399
400			`template`
401			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
402			`double>::__type`
403			`sinh(_Tp __x)`
404			`{ return __builtin_sinh(__x); }`
405
406			`using ::sqrt;`
407
408			`inline float`
409			`sqrt(float __x)`
410			`{ return __builtin_sqrtf(__x); }`
411
412			`inline long double`
413			`sqrt(long double __x)`
414			`{ return __builtin_sqrtl(__x); }`
415
416			`template`
417			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
418			`double>::__type`
419			`sqrt(_Tp __x)`
420			`{ return __builtin_sqrt(__x); }`
421
422			`using ::tan;`
423
424			`inline float`
425			`tan(float __x)`
426			`{ return __builtin_tanf(__x); }`
427
428			`inline long double`
429			`tan(long double __x)`
430			`{ return __builtin_tanl(__x); }`
431
432			`template`
433			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
434			`double>::__type`
435			`tan(_Tp __x)`
436			`{ return __builtin_tan(__x); }`
437
438			`using ::tanh;`
439
440			`inline float`
441			`tanh(float __x)`
442			`{ return __builtin_tanhf(__x); }`
443
444			`inline long double`
445			`tanh(long double __x)`
446			`{ return __builtin_tanhl(__x); }`
447
448			`template`
449			`inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,`
450			`double>::__type`
451			`tanh(_Tp __x)`
452			`{ return __builtin_tanh(__x); }`
453
454			`_GLIBCXX_END_NAMESPACE_VERSION`
455			`} // namespace`
456
457			`#if _GLIBCXX_USE_C99_MATH`
458			`#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC`
459
460			`// These are possible macros imported from C99-land.`
461			`#undef fpclassify`
462			`#undef isfinite`
463			`#undef isinf`
464			`#undef isnan`
465			`#undef isnormal`
466			`#undef signbit`
467			`#undef isgreater`
468			`#undef isgreaterequal`
469			`#undef isless`
470			`#undef islessequal`
471			`#undef islessgreater`
472			`#undef isunordered`
473
474			`namespace std _GLIBCXX_VISIBILITY(default)`
475			`{`
476			`_GLIBCXX_BEGIN_NAMESPACE_VERSION`
477
478			`template`
479			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
480			`int>::__type`
481			`fpclassify(_Tp __f)`
482			`{`
483			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
484			`return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,`
485			`FP_SUBNORMAL, FP_ZERO, __type(__f));`
486			`}`
487
488			`template`
489			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
490			`int>::__type`
491			`isfinite(_Tp __f)`
492			`{`
493			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
494			`return __builtin_isfinite(__type(__f));`
495			`}`
496
497			`template`
498			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
499			`int>::__type`
500			`isinf(_Tp __f)`
501			`{`
502			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
503			`return __builtin_isinf(__type(__f));`
504			`}`
505
506			`template`
507			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
508			`int>::__type`
509			`isnan(_Tp __f)`
510			`{`
511			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
512			`return __builtin_isnan(__type(__f));`
513			`}`
514
515			`template`
516			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
517			`int>::__type`
518			`isnormal(_Tp __f)`
519			`{`
520			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
521			`return __builtin_isnormal(__type(__f));`
522			`}`
523
524			`template`
525			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
526			`int>::__type`
527			`signbit(_Tp __f)`
528			`{`
529			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
530			`return __builtin_signbit(__type(__f));`
531			`}`
532
533			`template`
534			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
535			`int>::__type`
536			`isgreater(_Tp __f1, _Tp __f2)`
537			`{`
538			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
539			`return __builtin_isgreater(__type(__f1), __type(__f2));`
540			`}`
541
542			`template`
543			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
544			`int>::__type`
545			`isgreaterequal(_Tp __f1, _Tp __f2)`
546			`{`
547			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
548			`return __builtin_isgreaterequal(__type(__f1), __type(__f2));`
549			`}`
550
551			`template`
552			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
553			`int>::__type`
554			`isless(_Tp __f1, _Tp __f2)`
555			`{`
556			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
557			`return __builtin_isless(__type(__f1), __type(__f2));`
558			`}`
559
560			`template`
561			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
562			`int>::__type`
563			`islessequal(_Tp __f1, _Tp __f2)`
564			`{`
565			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
566			`return __builtin_islessequal(__type(__f1), __type(__f2));`
567			`}`
568
569			`template`
570			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
571			`int>::__type`
572			`islessgreater(_Tp __f1, _Tp __f2)`
573			`{`
574			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
575			`return __builtin_islessgreater(__type(__f1), __type(__f2));`
576			`}`
577
578			`template`
579			`inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,`
580			`int>::__type`
581			`isunordered(_Tp __f1, _Tp __f2)`
582			`{`
583			`typedef typename __gnu_cxx::__promote<_Tp>::__type __type;`
584			`return __builtin_isunordered(__type(__f1), __type(__f2));`
585			`}`
586
587			`_GLIBCXX_END_NAMESPACE_VERSION`
588			`} // namespace std`
589
590			`#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */`
591			`#endif`
592
593			`#endif`