libstdc++
cmath
1 // -*- C++ -*- C forwarding header.
2 
3 // Copyright (C) 1997-2013 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/cmath
26  * This is a Standard C++ Library file. You should @c \#include this file
27  * in your programs, rather than any of the @a *.h implementation files.
28  *
29  * This is the C++ version of the Standard C Library header @c math.h,
30  * and its contents are (mostly) the same as that header, but are all
31  * contained in the namespace @c std (except for names which are defined
32  * as macros in C).
33  */
34 
35 //
36 // ISO C++ 14882: 26.5 C library
37 //
38 
39 #pragma GCC system_header
40 
41 #include <bits/c++config.h>
42 #include <bits/cpp_type_traits.h>
43 #include <ext/type_traits.h>
44 #include <math.h>
45 
46 #ifndef _GLIBCXX_CMATH
47 #define _GLIBCXX_CMATH 1
48 
49 // Get rid of those macros defined in <math.h> in lieu of real functions.
50 #undef abs
51 #undef div
52 #undef acos
53 #undef asin
54 #undef atan
55 #undef atan2
56 #undef ceil
57 #undef cos
58 #undef cosh
59 #undef exp
60 #undef fabs
61 #undef floor
62 #undef fmod
63 #undef frexp
64 #undef ldexp
65 #undef log
66 #undef log10
67 #undef modf
68 #undef pow
69 #undef sin
70 #undef sinh
71 #undef sqrt
72 #undef tan
73 #undef tanh
74 
75 namespace std _GLIBCXX_VISIBILITY(default)
76 {
77 _GLIBCXX_BEGIN_NAMESPACE_VERSION
78 
79 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
80  inline _GLIBCXX_CONSTEXPR double
81  abs(double __x)
82  { return __builtin_fabs(__x); }
83 #endif
84 
85 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
86  inline _GLIBCXX_CONSTEXPR float
87  abs(float __x)
88  { return __builtin_fabsf(__x); }
89 
90  inline _GLIBCXX_CONSTEXPR long double
91  abs(long double __x)
92  { return __builtin_fabsl(__x); }
93 #endif
94 
95  template<typename _Tp>
96  inline _GLIBCXX_CONSTEXPR
97  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
98  double>::__type
99  abs(_Tp __x)
100  { return __builtin_fabs(__x); }
101 
102  using ::acos;
103 
104 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
105  inline _GLIBCXX_CONSTEXPR float
106  acos(float __x)
107  { return __builtin_acosf(__x); }
108 
109  inline _GLIBCXX_CONSTEXPR long double
110  acos(long double __x)
111  { return __builtin_acosl(__x); }
112 #endif
113 
114  template<typename _Tp>
115  inline _GLIBCXX_CONSTEXPR
116  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
117  double>::__type
118  acos(_Tp __x)
119  { return __builtin_acos(__x); }
120 
121  using ::asin;
122 
123 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
124  inline _GLIBCXX_CONSTEXPR float
125  asin(float __x)
126  { return __builtin_asinf(__x); }
127 
128  inline _GLIBCXX_CONSTEXPR long double
129  asin(long double __x)
130  { return __builtin_asinl(__x); }
131 #endif
132 
133  template<typename _Tp>
134  inline _GLIBCXX_CONSTEXPR
135  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
136  double>::__type
137  asin(_Tp __x)
138  { return __builtin_asin(__x); }
139 
140  using ::atan;
141 
142 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
143  inline _GLIBCXX_CONSTEXPR float
144  atan(float __x)
145  { return __builtin_atanf(__x); }
146 
147  inline _GLIBCXX_CONSTEXPR long double
148  atan(long double __x)
149  { return __builtin_atanl(__x); }
150 #endif
151 
152  template<typename _Tp>
153  inline _GLIBCXX_CONSTEXPR
154  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
155  double>::__type
156  atan(_Tp __x)
157  { return __builtin_atan(__x); }
158 
159  using ::atan2;
160 
161 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
162  inline _GLIBCXX_CONSTEXPR float
163  atan2(float __y, float __x)
164  { return __builtin_atan2f(__y, __x); }
165 
166  inline _GLIBCXX_CONSTEXPR long double
167  atan2(long double __y, long double __x)
168  { return __builtin_atan2l(__y, __x); }
169 #endif
170 
171  template<typename _Tp, typename _Up>
172  inline _GLIBCXX_CONSTEXPR
173  typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
174  atan2(_Tp __y, _Up __x)
175  {
176  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
177  return atan2(__type(__y), __type(__x));
178  }
179 
180  using ::ceil;
181 
182 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
183  inline _GLIBCXX_CONSTEXPR float
184  ceil(float __x)
185  { return __builtin_ceilf(__x); }
186 
187  inline _GLIBCXX_CONSTEXPR long double
188  ceil(long double __x)
189  { return __builtin_ceill(__x); }
190 #endif
191 
192  template<typename _Tp>
193  inline _GLIBCXX_CONSTEXPR
194  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
195  double>::__type
196  ceil(_Tp __x)
197  { return __builtin_ceil(__x); }
198 
199  using ::cos;
200 
201 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
202  inline _GLIBCXX_CONSTEXPR float
203  cos(float __x)
204  { return __builtin_cosf(__x); }
205 
206  inline _GLIBCXX_CONSTEXPR long double
207  cos(long double __x)
208  { return __builtin_cosl(__x); }
209 #endif
210 
211  template<typename _Tp>
212  inline _GLIBCXX_CONSTEXPR
213  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
214  double>::__type
215  cos(_Tp __x)
216  { return __builtin_cos(__x); }
217 
218  using ::cosh;
219 
220 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
221  inline _GLIBCXX_CONSTEXPR float
222  cosh(float __x)
223  { return __builtin_coshf(__x); }
224 
225  inline _GLIBCXX_CONSTEXPR long double
226  cosh(long double __x)
227  { return __builtin_coshl(__x); }
228 #endif
229 
230  template<typename _Tp>
231  inline _GLIBCXX_CONSTEXPR
232  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
233  double>::__type
234  cosh(_Tp __x)
235  { return __builtin_cosh(__x); }
236 
237  using ::exp;
238 
239 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
240  inline _GLIBCXX_CONSTEXPR float
241  exp(float __x)
242  { return __builtin_expf(__x); }
243 
244  inline _GLIBCXX_CONSTEXPR long double
245  exp(long double __x)
246  { return __builtin_expl(__x); }
247 #endif
248 
249  template<typename _Tp>
250  inline _GLIBCXX_CONSTEXPR
251  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
252  double>::__type
253  exp(_Tp __x)
254  { return __builtin_exp(__x); }
255 
256  using ::fabs;
257 
258 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
259  inline _GLIBCXX_CONSTEXPR float
260  fabs(float __x)
261  { return __builtin_fabsf(__x); }
262 
263  inline _GLIBCXX_CONSTEXPR long double
264  fabs(long double __x)
265  { return __builtin_fabsl(__x); }
266 #endif
267 
268  template<typename _Tp>
269  inline _GLIBCXX_CONSTEXPR
270  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
271  double>::__type
272  fabs(_Tp __x)
273  { return __builtin_fabs(__x); }
274 
275  using ::floor;
276 
277 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
278  inline _GLIBCXX_CONSTEXPR float
279  floor(float __x)
280  { return __builtin_floorf(__x); }
281 
282  inline _GLIBCXX_CONSTEXPR long double
283  floor(long double __x)
284  { return __builtin_floorl(__x); }
285 #endif
286 
287  template<typename _Tp>
288  inline _GLIBCXX_CONSTEXPR
289  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
290  double>::__type
291  floor(_Tp __x)
292  { return __builtin_floor(__x); }
293 
294  using ::fmod;
295 
296 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
297  inline _GLIBCXX_CONSTEXPR float
298  fmod(float __x, float __y)
299  { return __builtin_fmodf(__x, __y); }
300 
301  inline _GLIBCXX_CONSTEXPR long double
302  fmod(long double __x, long double __y)
303  { return __builtin_fmodl(__x, __y); }
304 #endif
305 
306  template<typename _Tp, typename _Up>
307  inline _GLIBCXX_CONSTEXPR
308  typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
309  fmod(_Tp __x, _Up __y)
310  {
311  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
312  return fmod(__type(__x), __type(__y));
313  }
314 
315  using ::frexp;
316 
317 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
318  inline float
319  frexp(float __x, int* __exp)
320  { return __builtin_frexpf(__x, __exp); }
321 
322  inline long double
323  frexp(long double __x, int* __exp)
324  { return __builtin_frexpl(__x, __exp); }
325 #endif
326 
327  template<typename _Tp>
328  inline _GLIBCXX_CONSTEXPR
329  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
330  double>::__type
331  frexp(_Tp __x, int* __exp)
332  { return __builtin_frexp(__x, __exp); }
333 
334  using ::ldexp;
335 
336 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
337  inline _GLIBCXX_CONSTEXPR float
338  ldexp(float __x, int __exp)
339  { return __builtin_ldexpf(__x, __exp); }
340 
341  inline _GLIBCXX_CONSTEXPR long double
342  ldexp(long double __x, int __exp)
343  { return __builtin_ldexpl(__x, __exp); }
344 #endif
345 
346  template<typename _Tp>
347  inline _GLIBCXX_CONSTEXPR
348  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
349  double>::__type
350  ldexp(_Tp __x, int __exp)
351  { return __builtin_ldexp(__x, __exp); }
352 
353  using ::log;
354 
355 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
356  inline _GLIBCXX_CONSTEXPR float
357  log(float __x)
358  { return __builtin_logf(__x); }
359 
360  inline _GLIBCXX_CONSTEXPR long double
361  log(long double __x)
362  { return __builtin_logl(__x); }
363 #endif
364 
365  template<typename _Tp>
366  inline _GLIBCXX_CONSTEXPR
367  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
368  double>::__type
369  log(_Tp __x)
370  { return __builtin_log(__x); }
371 
372  using ::log10;
373 
374 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
375  inline _GLIBCXX_CONSTEXPR float
376  log10(float __x)
377  { return __builtin_log10f(__x); }
378 
379  inline _GLIBCXX_CONSTEXPR long double
380  log10(long double __x)
381  { return __builtin_log10l(__x); }
382 #endif
383 
384  template<typename _Tp>
385  inline _GLIBCXX_CONSTEXPR
386  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
387  double>::__type
388  log10(_Tp __x)
389  { return __builtin_log10(__x); }
390 
391  using ::modf;
392 
393 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
394  inline float
395  modf(float __x, float* __iptr)
396  { return __builtin_modff(__x, __iptr); }
397 
398  inline long double
399  modf(long double __x, long double* __iptr)
400  { return __builtin_modfl(__x, __iptr); }
401 #endif
402 
403  using ::pow;
404 
405 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
406  inline _GLIBCXX_CONSTEXPR float
407  pow(float __x, float __y)
408  { return __builtin_powf(__x, __y); }
409 
410  inline _GLIBCXX_CONSTEXPR long double
411  pow(long double __x, long double __y)
412  { return __builtin_powl(__x, __y); }
413 
414 #if __cplusplus < 201103L
415  // _GLIBCXX_RESOLVE_LIB_DEFECTS
416  // DR 550. What should the return type of pow(float,int) be?
417  inline double
418  pow(double __x, int __i)
419  { return __builtin_powi(__x, __i); }
420 
421  inline float
422  pow(float __x, int __n)
423  { return __builtin_powif(__x, __n); }
424 
425  inline long double
426  pow(long double __x, int __n)
427  { return __builtin_powil(__x, __n); }
428 #endif
429 #endif
430 
431  template<typename _Tp, typename _Up>
432  inline _GLIBCXX_CONSTEXPR
433  typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
434  pow(_Tp __x, _Up __y)
435  {
436  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
437  return pow(__type(__x), __type(__y));
438  }
439 
440  using ::sin;
441 
442 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
443  inline _GLIBCXX_CONSTEXPR float
444  sin(float __x)
445  { return __builtin_sinf(__x); }
446 
447  inline _GLIBCXX_CONSTEXPR long double
448  sin(long double __x)
449  { return __builtin_sinl(__x); }
450 #endif
451 
452  template<typename _Tp>
453  inline _GLIBCXX_CONSTEXPR
454  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
455  double>::__type
456  sin(_Tp __x)
457  { return __builtin_sin(__x); }
458 
459  using ::sinh;
460 
461 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
462  inline _GLIBCXX_CONSTEXPR float
463  sinh(float __x)
464  { return __builtin_sinhf(__x); }
465 
466  inline _GLIBCXX_CONSTEXPR long double
467  sinh(long double __x)
468  { return __builtin_sinhl(__x); }
469 #endif
470 
471  template<typename _Tp>
472  inline _GLIBCXX_CONSTEXPR
473  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
474  double>::__type
475  sinh(_Tp __x)
476  { return __builtin_sinh(__x); }
477 
478  using ::sqrt;
479 
480 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
481  inline _GLIBCXX_CONSTEXPR float
482  sqrt(float __x)
483  { return __builtin_sqrtf(__x); }
484 
485  inline _GLIBCXX_CONSTEXPR long double
486  sqrt(long double __x)
487  { return __builtin_sqrtl(__x); }
488 #endif
489 
490  template<typename _Tp>
491  inline _GLIBCXX_CONSTEXPR
492  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
493  double>::__type
494  sqrt(_Tp __x)
495  { return __builtin_sqrt(__x); }
496 
497  using ::tan;
498 
499 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
500  inline _GLIBCXX_CONSTEXPR float
501  tan(float __x)
502  { return __builtin_tanf(__x); }
503 
504  inline _GLIBCXX_CONSTEXPR long double
505  tan(long double __x)
506  { return __builtin_tanl(__x); }
507 #endif
508 
509  template<typename _Tp>
510  inline _GLIBCXX_CONSTEXPR
511  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
512  double>::__type
513  tan(_Tp __x)
514  { return __builtin_tan(__x); }
515 
516  using ::tanh;
517 
518 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
519  inline _GLIBCXX_CONSTEXPR float
520  tanh(float __x)
521  { return __builtin_tanhf(__x); }
522 
523  inline _GLIBCXX_CONSTEXPR long double
524  tanh(long double __x)
525  { return __builtin_tanhl(__x); }
526 #endif
527 
528  template<typename _Tp>
529  inline _GLIBCXX_CONSTEXPR
530  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
531  double>::__type
532  tanh(_Tp __x)
533  { return __builtin_tanh(__x); }
534 
535 _GLIBCXX_END_NAMESPACE_VERSION
536 } // namespace
537 
538 #if _GLIBCXX_USE_C99_MATH
539 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
540 
541 // These are possible macros imported from C99-land.
542 #undef fpclassify
543 #undef isfinite
544 #undef isinf
545 #undef isnan
546 #undef isnormal
547 #undef signbit
548 #undef isgreater
549 #undef isgreaterequal
550 #undef isless
551 #undef islessequal
552 #undef islessgreater
553 #undef isunordered
554 
555 namespace std _GLIBCXX_VISIBILITY(default)
556 {
557 _GLIBCXX_BEGIN_NAMESPACE_VERSION
558 
559 #if __cplusplus >= 201103L
560  constexpr int
561  fpclassify(float __x)
562  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
563  FP_SUBNORMAL, FP_ZERO, __x); }
564 
565  constexpr int
566  fpclassify(double __x)
567  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
568  FP_SUBNORMAL, FP_ZERO, __x); }
569 
570  constexpr int
571  fpclassify(long double __x)
572  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
573  FP_SUBNORMAL, FP_ZERO, __x); }
574 
575  template<typename _Tp>
576  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
577  int>::__type
578  fpclassify(_Tp __x)
579  { return __x != 0 ? FP_NORMAL : FP_ZERO; }
580 
581  constexpr bool
582  isfinite(float __x)
583  { return __builtin_isfinite(__x); }
584 
585  constexpr bool
586  isfinite(double __x)
587  { return __builtin_isfinite(__x); }
588 
589  constexpr bool
590  isfinite(long double __x)
591  { return __builtin_isfinite(__x); }
592 
593  template<typename _Tp>
594  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
595  bool>::__type
596  isfinite(_Tp __x)
597  { return true; }
598 
599  constexpr bool
600  isinf(float __x)
601  { return __builtin_isinf(__x); }
602 
603  constexpr bool
604  isinf(double __x)
605  { return __builtin_isinf(__x); }
606 
607  constexpr bool
608  isinf(long double __x)
609  { return __builtin_isinf(__x); }
610 
611  template<typename _Tp>
612  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
613  bool>::__type
614  isinf(_Tp __x)
615  { return false; }
616 
617  constexpr bool
618  isnan(float __x)
619  { return __builtin_isnan(__x); }
620 
621  constexpr bool
622  isnan(double __x)
623  { return __builtin_isnan(__x); }
624 
625  constexpr bool
626  isnan(long double __x)
627  { return __builtin_isnan(__x); }
628 
629  template<typename _Tp>
630  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
631  bool>::__type
632  isnan(_Tp __x)
633  { return false; }
634 
635  constexpr bool
636  isnormal(float __x)
637  { return __builtin_isnormal(__x); }
638 
639  constexpr bool
640  isnormal(double __x)
641  { return __builtin_isnormal(__x); }
642 
643  constexpr bool
644  isnormal(long double __x)
645  { return __builtin_isnormal(__x); }
646 
647  template<typename _Tp>
648  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
649  bool>::__type
650  isnormal(_Tp __x)
651  { return __x != 0 ? true : false; }
652 
653  constexpr bool
654  signbit(float __x)
655  { return __builtin_signbit(__x); }
656 
657  constexpr bool
658  signbit(double __x)
659  { return __builtin_signbit(__x); }
660 
661  constexpr bool
662  signbit(long double __x)
663  { return __builtin_signbit(__x); }
664 
665  template<typename _Tp>
666  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
667  bool>::__type
668  signbit(_Tp __x)
669  { return __x < 0 ? true : false; }
670 
671  constexpr bool
672  isgreater(float __x, float __y)
673  { return __builtin_isgreater(__x, __y); }
674 
675  constexpr bool
676  isgreater(double __x, double __y)
677  { return __builtin_isgreater(__x, __y); }
678 
679  constexpr bool
680  isgreater(long double __x, long double __y)
681  { return __builtin_isgreater(__x, __y); }
682 
683  template<typename _Tp, typename _Up>
684  constexpr typename
685  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
686  && __is_arithmetic<_Up>::__value), bool>::__type
687  isgreater(_Tp __x, _Up __y)
688  {
689  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
690  return __builtin_isgreater(__type(__x), __type(__y));
691  }
692 
693  constexpr bool
694  isgreaterequal(float __x, float __y)
695  { return __builtin_isgreaterequal(__x, __y); }
696 
697  constexpr bool
698  isgreaterequal(double __x, double __y)
699  { return __builtin_isgreaterequal(__x, __y); }
700 
701  constexpr bool
702  isgreaterequal(long double __x, long double __y)
703  { return __builtin_isgreaterequal(__x, __y); }
704 
705  template<typename _Tp, typename _Up>
706  constexpr typename
707  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
708  && __is_arithmetic<_Up>::__value), bool>::__type
709  isgreaterequal(_Tp __x, _Up __y)
710  {
711  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
712  return __builtin_isgreaterequal(__type(__x), __type(__y));
713  }
714 
715  constexpr bool
716  isless(float __x, float __y)
717  { return __builtin_isless(__x, __y); }
718 
719  constexpr bool
720  isless(double __x, double __y)
721  { return __builtin_isless(__x, __y); }
722 
723  constexpr bool
724  isless(long double __x, long double __y)
725  { return __builtin_isless(__x, __y); }
726 
727  template<typename _Tp, typename _Up>
728  constexpr typename
729  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
730  && __is_arithmetic<_Up>::__value), bool>::__type
731  isless(_Tp __x, _Up __y)
732  {
733  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
734  return __builtin_isless(__type(__x), __type(__y));
735  }
736 
737  constexpr bool
738  islessequal(float __x, float __y)
739  { return __builtin_islessequal(__x, __y); }
740 
741  constexpr bool
742  islessequal(double __x, double __y)
743  { return __builtin_islessequal(__x, __y); }
744 
745  constexpr bool
746  islessequal(long double __x, long double __y)
747  { return __builtin_islessequal(__x, __y); }
748 
749  template<typename _Tp, typename _Up>
750  constexpr typename
751  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
752  && __is_arithmetic<_Up>::__value), bool>::__type
753  islessequal(_Tp __x, _Up __y)
754  {
755  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
756  return __builtin_islessequal(__type(__x), __type(__y));
757  }
758 
759  constexpr bool
760  islessgreater(float __x, float __y)
761  { return __builtin_islessgreater(__x, __y); }
762 
763  constexpr bool
764  islessgreater(double __x, double __y)
765  { return __builtin_islessgreater(__x, __y); }
766 
767  constexpr bool
768  islessgreater(long double __x, long double __y)
769  { return __builtin_islessgreater(__x, __y); }
770 
771  template<typename _Tp, typename _Up>
772  constexpr typename
773  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
774  && __is_arithmetic<_Up>::__value), bool>::__type
775  islessgreater(_Tp __x, _Up __y)
776  {
777  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
778  return __builtin_islessgreater(__type(__x), __type(__y));
779  }
780 
781  constexpr bool
782  isunordered(float __x, float __y)
783  { return __builtin_isunordered(__x, __y); }
784 
785  constexpr bool
786  isunordered(double __x, double __y)
787  { return __builtin_isunordered(__x, __y); }
788 
789  constexpr bool
790  isunordered(long double __x, long double __y)
791  { return __builtin_isunordered(__x, __y); }
792 
793  template<typename _Tp, typename _Up>
794  constexpr typename
795  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
796  && __is_arithmetic<_Up>::__value), bool>::__type
797  isunordered(_Tp __x, _Up __y)
798  {
799  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
800  return __builtin_isunordered(__type(__x), __type(__y));
801  }
802 
803 #else
804 
805  template<typename _Tp>
806  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
807  int>::__type
808  fpclassify(_Tp __f)
809  {
810  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
811  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
812  FP_SUBNORMAL, FP_ZERO, __type(__f));
813  }
814 
815  template<typename _Tp>
816  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
817  int>::__type
818  isfinite(_Tp __f)
819  {
820  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
821  return __builtin_isfinite(__type(__f));
822  }
823 
824  template<typename _Tp>
825  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
826  int>::__type
827  isinf(_Tp __f)
828  {
829  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
830  return __builtin_isinf(__type(__f));
831  }
832 
833  template<typename _Tp>
834  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
835  int>::__type
836  isnan(_Tp __f)
837  {
838  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
839  return __builtin_isnan(__type(__f));
840  }
841 
842  template<typename _Tp>
843  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
844  int>::__type
845  isnormal(_Tp __f)
846  {
847  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
848  return __builtin_isnormal(__type(__f));
849  }
850 
851  template<typename _Tp>
852  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
853  int>::__type
854  signbit(_Tp __f)
855  {
856  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
857  return __builtin_signbit(__type(__f));
858  }
859 
860  template<typename _Tp>
861  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
862  int>::__type
863  isgreater(_Tp __f1, _Tp __f2)
864  {
865  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
866  return __builtin_isgreater(__type(__f1), __type(__f2));
867  }
868 
869  template<typename _Tp>
870  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
871  int>::__type
872  isgreaterequal(_Tp __f1, _Tp __f2)
873  {
874  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
875  return __builtin_isgreaterequal(__type(__f1), __type(__f2));
876  }
877 
878  template<typename _Tp>
879  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
880  int>::__type
881  isless(_Tp __f1, _Tp __f2)
882  {
883  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
884  return __builtin_isless(__type(__f1), __type(__f2));
885  }
886 
887  template<typename _Tp>
888  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
889  int>::__type
890  islessequal(_Tp __f1, _Tp __f2)
891  {
892  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
893  return __builtin_islessequal(__type(__f1), __type(__f2));
894  }
895 
896  template<typename _Tp>
897  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
898  int>::__type
899  islessgreater(_Tp __f1, _Tp __f2)
900  {
901  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
902  return __builtin_islessgreater(__type(__f1), __type(__f2));
903  }
904 
905  template<typename _Tp>
906  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
907  int>::__type
908  isunordered(_Tp __f1, _Tp __f2)
909  {
910  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
911  return __builtin_isunordered(__type(__f1), __type(__f2));
912  }
913 
914 #endif
915 
916 _GLIBCXX_END_NAMESPACE_VERSION
917 } // namespace
918 
919 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
920 #endif
921 
922 #if __cplusplus >= 201103L
923 
924 #ifdef _GLIBCXX_USE_C99_MATH_TR1
925 
926 #undef acosh
927 #undef acoshf
928 #undef acoshl
929 #undef asinh
930 #undef asinhf
931 #undef asinhl
932 #undef atanh
933 #undef atanhf
934 #undef atanhl
935 #undef cbrt
936 #undef cbrtf
937 #undef cbrtl
938 #undef copysign
939 #undef copysignf
940 #undef copysignl
941 #undef erf
942 #undef erff
943 #undef erfl
944 #undef erfc
945 #undef erfcf
946 #undef erfcl
947 #undef exp2
948 #undef exp2f
949 #undef exp2l
950 #undef expm1
951 #undef expm1f
952 #undef expm1l
953 #undef fdim
954 #undef fdimf
955 #undef fdiml
956 #undef fma
957 #undef fmaf
958 #undef fmal
959 #undef fmax
960 #undef fmaxf
961 #undef fmaxl
962 #undef fmin
963 #undef fminf
964 #undef fminl
965 #undef hypot
966 #undef hypotf
967 #undef hypotl
968 #undef ilogb
969 #undef ilogbf
970 #undef ilogbl
971 #undef lgamma
972 #undef lgammaf
973 #undef lgammal
974 #undef llrint
975 #undef llrintf
976 #undef llrintl
977 #undef llround
978 #undef llroundf
979 #undef llroundl
980 #undef log1p
981 #undef log1pf
982 #undef log1pl
983 #undef log2
984 #undef log2f
985 #undef log2l
986 #undef logb
987 #undef logbf
988 #undef logbl
989 #undef lrint
990 #undef lrintf
991 #undef lrintl
992 #undef lround
993 #undef lroundf
994 #undef lroundl
995 #undef nan
996 #undef nanf
997 #undef nanl
998 #undef nearbyint
999 #undef nearbyintf
1000 #undef nearbyintl
1001 #undef nextafter
1002 #undef nextafterf
1003 #undef nextafterl
1004 #undef nexttoward
1005 #undef nexttowardf
1006 #undef nexttowardl
1007 #undef remainder
1008 #undef remainderf
1009 #undef remainderl
1010 #undef remquo
1011 #undef remquof
1012 #undef remquol
1013 #undef rint
1014 #undef rintf
1015 #undef rintl
1016 #undef round
1017 #undef roundf
1018 #undef roundl
1019 #undef scalbln
1020 #undef scalblnf
1021 #undef scalblnl
1022 #undef scalbn
1023 #undef scalbnf
1024 #undef scalbnl
1025 #undef tgamma
1026 #undef tgammaf
1027 #undef tgammal
1028 #undef trunc
1029 #undef truncf
1030 #undef truncl
1031 
1032 namespace std _GLIBCXX_VISIBILITY(default)
1033 {
1034 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1035 
1036  // types
1037  using ::double_t;
1038  using ::float_t;
1039 
1040  // functions
1041  using ::acosh;
1042  using ::acoshf;
1043  using ::acoshl;
1044 
1045  using ::asinh;
1046  using ::asinhf;
1047  using ::asinhl;
1048 
1049  using ::atanh;
1050  using ::atanhf;
1051  using ::atanhl;
1052 
1053  using ::cbrt;
1054  using ::cbrtf;
1055  using ::cbrtl;
1056 
1057  using ::copysign;
1058  using ::copysignf;
1059  using ::copysignl;
1060 
1061  using ::erf;
1062  using ::erff;
1063  using ::erfl;
1064 
1065  using ::erfc;
1066  using ::erfcf;
1067  using ::erfcl;
1068 
1069  using ::exp2;
1070  using ::exp2f;
1071  using ::exp2l;
1072 
1073  using ::expm1;
1074  using ::expm1f;
1075  using ::expm1l;
1076 
1077  using ::fdim;
1078  using ::fdimf;
1079  using ::fdiml;
1080 
1081  using ::fma;
1082  using ::fmaf;
1083  using ::fmal;
1084 
1085  using ::fmax;
1086  using ::fmaxf;
1087  using ::fmaxl;
1088 
1089  using ::fmin;
1090  using ::fminf;
1091  using ::fminl;
1092 
1093  using ::hypot;
1094  using ::hypotf;
1095  using ::hypotl;
1096 
1097  using ::ilogb;
1098  using ::ilogbf;
1099  using ::ilogbl;
1100 
1101  using ::lgamma;
1102  using ::lgammaf;
1103  using ::lgammal;
1104 
1105  using ::llrint;
1106  using ::llrintf;
1107  using ::llrintl;
1108 
1109  using ::llround;
1110  using ::llroundf;
1111  using ::llroundl;
1112 
1113  using ::log1p;
1114  using ::log1pf;
1115  using ::log1pl;
1116 
1117  using ::log2;
1118  using ::log2f;
1119  using ::log2l;
1120 
1121  using ::logb;
1122  using ::logbf;
1123  using ::logbl;
1124 
1125  using ::lrint;
1126  using ::lrintf;
1127  using ::lrintl;
1128 
1129  using ::lround;
1130  using ::lroundf;
1131  using ::lroundl;
1132 
1133  using ::nan;
1134  using ::nanf;
1135  using ::nanl;
1136 
1137  using ::nearbyint;
1138  using ::nearbyintf;
1139  using ::nearbyintl;
1140 
1141  using ::nextafter;
1142  using ::nextafterf;
1143  using ::nextafterl;
1144 
1145  using ::nexttoward;
1146  using ::nexttowardf;
1147  using ::nexttowardl;
1148 
1149  using ::remainder;
1150  using ::remainderf;
1151  using ::remainderl;
1152 
1153  using ::remquo;
1154  using ::remquof;
1155  using ::remquol;
1156 
1157  using ::rint;
1158  using ::rintf;
1159  using ::rintl;
1160 
1161  using ::round;
1162  using ::roundf;
1163  using ::roundl;
1164 
1165  using ::scalbln;
1166  using ::scalblnf;
1167  using ::scalblnl;
1168 
1169  using ::scalbn;
1170  using ::scalbnf;
1171  using ::scalbnl;
1172 
1173  using ::tgamma;
1174  using ::tgammaf;
1175  using ::tgammal;
1176 
1177  using ::trunc;
1178  using ::truncf;
1179  using ::truncl;
1180 
1181  /// Additional overloads.
1182  constexpr float
1183  acosh(float __x)
1184  { return __builtin_acoshf(__x); }
1185 
1186  constexpr long double
1187  acosh(long double __x)
1188  { return __builtin_acoshl(__x); }
1189 
1190  template<typename _Tp>
1191  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1192  double>::__type
1193  acosh(_Tp __x)
1194  { return __builtin_acosh(__x); }
1195 
1196  constexpr float
1197  asinh(float __x)
1198  { return __builtin_asinhf(__x); }
1199 
1200  constexpr long double
1201  asinh(long double __x)
1202  { return __builtin_asinhl(__x); }
1203 
1204  template<typename _Tp>
1205  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1206  double>::__type
1207  asinh(_Tp __x)
1208  { return __builtin_asinh(__x); }
1209 
1210  constexpr float
1211  atanh(float __x)
1212  { return __builtin_atanhf(__x); }
1213 
1214  constexpr long double
1215  atanh(long double __x)
1216  { return __builtin_atanhl(__x); }
1217 
1218  template<typename _Tp>
1219  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1220  double>::__type
1221  atanh(_Tp __x)
1222  { return __builtin_atanh(__x); }
1223 
1224  constexpr float
1225  cbrt(float __x)
1226  { return __builtin_cbrtf(__x); }
1227 
1228  constexpr long double
1229  cbrt(long double __x)
1230  { return __builtin_cbrtl(__x); }
1231 
1232  template<typename _Tp>
1233  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1234  double>::__type
1235  cbrt(_Tp __x)
1236  { return __builtin_cbrt(__x); }
1237 
1238  constexpr float
1239  copysign(float __x, float __y)
1240  { return __builtin_copysignf(__x, __y); }
1241 
1242  constexpr long double
1243  copysign(long double __x, long double __y)
1244  { return __builtin_copysignl(__x, __y); }
1245 
1246  template<typename _Tp, typename _Up>
1247  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1248  copysign(_Tp __x, _Up __y)
1249  {
1250  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1251  return copysign(__type(__x), __type(__y));
1252  }
1253 
1254  constexpr float
1255  erf(float __x)
1256  { return __builtin_erff(__x); }
1257 
1258  constexpr long double
1259  erf(long double __x)
1260  { return __builtin_erfl(__x); }
1261 
1262  template<typename _Tp>
1263  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1264  double>::__type
1265  erf(_Tp __x)
1266  { return __builtin_erf(__x); }
1267 
1268  constexpr float
1269  erfc(float __x)
1270  { return __builtin_erfcf(__x); }
1271 
1272  constexpr long double
1273  erfc(long double __x)
1274  { return __builtin_erfcl(__x); }
1275 
1276  template<typename _Tp>
1277  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1278  double>::__type
1279  erfc(_Tp __x)
1280  { return __builtin_erfc(__x); }
1281 
1282  constexpr float
1283  exp2(float __x)
1284  { return __builtin_exp2f(__x); }
1285 
1286  constexpr long double
1287  exp2(long double __x)
1288  { return __builtin_exp2l(__x); }
1289 
1290  template<typename _Tp>
1291  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1292  double>::__type
1293  exp2(_Tp __x)
1294  { return __builtin_exp2(__x); }
1295 
1296  constexpr float
1297  expm1(float __x)
1298  { return __builtin_expm1f(__x); }
1299 
1300  constexpr long double
1301  expm1(long double __x)
1302  { return __builtin_expm1l(__x); }
1303 
1304  template<typename _Tp>
1305  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1306  double>::__type
1307  expm1(_Tp __x)
1308  { return __builtin_expm1(__x); }
1309 
1310  constexpr float
1311  fdim(float __x, float __y)
1312  { return __builtin_fdimf(__x, __y); }
1313 
1314  constexpr long double
1315  fdim(long double __x, long double __y)
1316  { return __builtin_fdiml(__x, __y); }
1317 
1318  template<typename _Tp, typename _Up>
1319  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1320  fdim(_Tp __x, _Up __y)
1321  {
1322  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1323  return fdim(__type(__x), __type(__y));
1324  }
1325 
1326  constexpr float
1327  fma(float __x, float __y, float __z)
1328  { return __builtin_fmaf(__x, __y, __z); }
1329 
1330  constexpr long double
1331  fma(long double __x, long double __y, long double __z)
1332  { return __builtin_fmal(__x, __y, __z); }
1333 
1334  template<typename _Tp, typename _Up, typename _Vp>
1335  constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1336  fma(_Tp __x, _Up __y, _Vp __z)
1337  {
1338  typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
1339  return fma(__type(__x), __type(__y), __type(__z));
1340  }
1341 
1342  constexpr float
1343  fmax(float __x, float __y)
1344  { return __builtin_fmaxf(__x, __y); }
1345 
1346  constexpr long double
1347  fmax(long double __x, long double __y)
1348  { return __builtin_fmaxl(__x, __y); }
1349 
1350  template<typename _Tp, typename _Up>
1351  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1352  fmax(_Tp __x, _Up __y)
1353  {
1354  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1355  return fmax(__type(__x), __type(__y));
1356  }
1357 
1358  constexpr float
1359  fmin(float __x, float __y)
1360  { return __builtin_fminf(__x, __y); }
1361 
1362  constexpr long double
1363  fmin(long double __x, long double __y)
1364  { return __builtin_fminl(__x, __y); }
1365 
1366  template<typename _Tp, typename _Up>
1367  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1368  fmin(_Tp __x, _Up __y)
1369  {
1370  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1371  return fmin(__type(__x), __type(__y));
1372  }
1373 
1374  constexpr float
1375  hypot(float __x, float __y)
1376  { return __builtin_hypotf(__x, __y); }
1377 
1378  constexpr long double
1379  hypot(long double __x, long double __y)
1380  { return __builtin_hypotl(__x, __y); }
1381 
1382  template<typename _Tp, typename _Up>
1383  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1384  hypot(_Tp __x, _Up __y)
1385  {
1386  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1387  return hypot(__type(__x), __type(__y));
1388  }
1389 
1390  constexpr int
1391  ilogb(float __x)
1392  { return __builtin_ilogbf(__x); }
1393 
1394  constexpr int
1395  ilogb(long double __x)
1396  { return __builtin_ilogbl(__x); }
1397 
1398  template<typename _Tp>
1399  constexpr
1400  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1401  int>::__type
1402  ilogb(_Tp __x)
1403  { return __builtin_ilogb(__x); }
1404 
1405  constexpr float
1406  lgamma(float __x)
1407  { return __builtin_lgammaf(__x); }
1408 
1409  constexpr long double
1410  lgamma(long double __x)
1411  { return __builtin_lgammal(__x); }
1412 
1413  template<typename _Tp>
1414  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1415  double>::__type
1416  lgamma(_Tp __x)
1417  { return __builtin_lgamma(__x); }
1418 
1419  constexpr long long
1420  llrint(float __x)
1421  { return __builtin_llrintf(__x); }
1422 
1423  constexpr long long
1424  llrint(long double __x)
1425  { return __builtin_llrintl(__x); }
1426 
1427  template<typename _Tp>
1428  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1429  long long>::__type
1430  llrint(_Tp __x)
1431  { return __builtin_llrint(__x); }
1432 
1433  constexpr long long
1434  llround(float __x)
1435  { return __builtin_llroundf(__x); }
1436 
1437  constexpr long long
1438  llround(long double __x)
1439  { return __builtin_llroundl(__x); }
1440 
1441  template<typename _Tp>
1442  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1443  long long>::__type
1444  llround(_Tp __x)
1445  { return __builtin_llround(__x); }
1446 
1447  constexpr float
1448  log1p(float __x)
1449  { return __builtin_log1pf(__x); }
1450 
1451  constexpr long double
1452  log1p(long double __x)
1453  { return __builtin_log1pl(__x); }
1454 
1455  template<typename _Tp>
1456  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1457  double>::__type
1458  log1p(_Tp __x)
1459  { return __builtin_log1p(__x); }
1460 
1461  // DR 568.
1462  constexpr float
1463  log2(float __x)
1464  { return __builtin_log2f(__x); }
1465 
1466  constexpr long double
1467  log2(long double __x)
1468  { return __builtin_log2l(__x); }
1469 
1470  template<typename _Tp>
1471  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1472  double>::__type
1473  log2(_Tp __x)
1474  { return __builtin_log2(__x); }
1475 
1476  constexpr float
1477  logb(float __x)
1478  { return __builtin_logbf(__x); }
1479 
1480  constexpr long double
1481  logb(long double __x)
1482  { return __builtin_logbl(__x); }
1483 
1484  template<typename _Tp>
1485  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1486  double>::__type
1487  logb(_Tp __x)
1488  { return __builtin_logb(__x); }
1489 
1490  constexpr long
1491  lrint(float __x)
1492  { return __builtin_lrintf(__x); }
1493 
1494  constexpr long
1495  lrint(long double __x)
1496  { return __builtin_lrintl(__x); }
1497 
1498  template<typename _Tp>
1499  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1500  long>::__type
1501  lrint(_Tp __x)
1502  { return __builtin_lrint(__x); }
1503 
1504  constexpr long
1505  lround(float __x)
1506  { return __builtin_lroundf(__x); }
1507 
1508  constexpr long
1509  lround(long double __x)
1510  { return __builtin_lroundl(__x); }
1511 
1512  template<typename _Tp>
1513  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1514  long>::__type
1515  lround(_Tp __x)
1516  { return __builtin_lround(__x); }
1517 
1518  constexpr float
1519  nearbyint(float __x)
1520  { return __builtin_nearbyintf(__x); }
1521 
1522  constexpr long double
1523  nearbyint(long double __x)
1524  { return __builtin_nearbyintl(__x); }
1525 
1526  template<typename _Tp>
1527  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1528  double>::__type
1529  nearbyint(_Tp __x)
1530  { return __builtin_nearbyint(__x); }
1531 
1532  constexpr float
1533  nextafter(float __x, float __y)
1534  { return __builtin_nextafterf(__x, __y); }
1535 
1536  constexpr long double
1537  nextafter(long double __x, long double __y)
1538  { return __builtin_nextafterl(__x, __y); }
1539 
1540  template<typename _Tp, typename _Up>
1541  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1542  nextafter(_Tp __x, _Up __y)
1543  {
1544  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1545  return nextafter(__type(__x), __type(__y));
1546  }
1547 
1548  constexpr float
1549  nexttoward(float __x, long double __y)
1550  { return __builtin_nexttowardf(__x, __y); }
1551 
1552  constexpr long double
1553  nexttoward(long double __x, long double __y)
1554  { return __builtin_nexttowardl(__x, __y); }
1555 
1556  template<typename _Tp>
1557  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1558  double>::__type
1559  nexttoward(_Tp __x, long double __y)
1560  { return __builtin_nexttoward(__x, __y); }
1561 
1562  constexpr float
1563  remainder(float __x, float __y)
1564  { return __builtin_remainderf(__x, __y); }
1565 
1566  constexpr long double
1567  remainder(long double __x, long double __y)
1568  { return __builtin_remainderl(__x, __y); }
1569 
1570  template<typename _Tp, typename _Up>
1571  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1572  remainder(_Tp __x, _Up __y)
1573  {
1574  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1575  return remainder(__type(__x), __type(__y));
1576  }
1577 
1578  inline float
1579  remquo(float __x, float __y, int* __pquo)
1580  { return __builtin_remquof(__x, __y, __pquo); }
1581 
1582  inline long double
1583  remquo(long double __x, long double __y, int* __pquo)
1584  { return __builtin_remquol(__x, __y, __pquo); }
1585 
1586  template<typename _Tp, typename _Up>
1587  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1588  remquo(_Tp __x, _Up __y, int* __pquo)
1589  {
1590  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1591  return remquo(__type(__x), __type(__y), __pquo);
1592  }
1593 
1594  constexpr float
1595  rint(float __x)
1596  { return __builtin_rintf(__x); }
1597 
1598  constexpr long double
1599  rint(long double __x)
1600  { return __builtin_rintl(__x); }
1601 
1602  template<typename _Tp>
1603  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1604  double>::__type
1605  rint(_Tp __x)
1606  { return __builtin_rint(__x); }
1607 
1608  constexpr float
1609  round(float __x)
1610  { return __builtin_roundf(__x); }
1611 
1612  constexpr long double
1613  round(long double __x)
1614  { return __builtin_roundl(__x); }
1615 
1616  template<typename _Tp>
1617  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1618  double>::__type
1619  round(_Tp __x)
1620  { return __builtin_round(__x); }
1621 
1622  constexpr float
1623  scalbln(float __x, long __ex)
1624  { return __builtin_scalblnf(__x, __ex); }
1625 
1626  constexpr long double
1627  scalbln(long double __x, long __ex)
1628  { return __builtin_scalblnl(__x, __ex); }
1629 
1630  template<typename _Tp>
1631  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1632  double>::__type
1633  scalbln(_Tp __x, long __ex)
1634  { return __builtin_scalbln(__x, __ex); }
1635 
1636  constexpr float
1637  scalbn(float __x, int __ex)
1638  { return __builtin_scalbnf(__x, __ex); }
1639 
1640  constexpr long double
1641  scalbn(long double __x, int __ex)
1642  { return __builtin_scalbnl(__x, __ex); }
1643 
1644  template<typename _Tp>
1645  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1646  double>::__type
1647  scalbn(_Tp __x, int __ex)
1648  { return __builtin_scalbn(__x, __ex); }
1649 
1650  constexpr float
1651  tgamma(float __x)
1652  { return __builtin_tgammaf(__x); }
1653 
1654  constexpr long double
1655  tgamma(long double __x)
1656  { return __builtin_tgammal(__x); }
1657 
1658  template<typename _Tp>
1659  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1660  double>::__type
1661  tgamma(_Tp __x)
1662  { return __builtin_tgamma(__x); }
1663 
1664  constexpr float
1665  trunc(float __x)
1666  { return __builtin_truncf(__x); }
1667 
1668  constexpr long double
1669  trunc(long double __x)
1670  { return __builtin_truncl(__x); }
1671 
1672  template<typename _Tp>
1673  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1674  double>::__type
1675  trunc(_Tp __x)
1676  { return __builtin_trunc(__x); }
1677 
1678 _GLIBCXX_END_NAMESPACE_VERSION
1679 } // namespace
1680 
1681 #endif // _GLIBCXX_USE_C99_MATH_TR1
1682 
1683 #endif // C++11
1684 
1685 #endif