libstdc++
cmath
Go to the documentation of this file.
1 // -*- C++ -*- C forwarding header.
2 
3 // Copyright (C) 1997-2014 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  // The front-end doesn't provide a type generic builtin (libstdc++/58625).
654  constexpr bool
655  signbit(float __x)
656  { return __builtin_signbitf(__x); }
657 
658  constexpr bool
659  signbit(double __x)
660  { return __builtin_signbit(__x); }
661 
662  constexpr bool
663  signbit(long double __x)
664  { return __builtin_signbitl(__x); }
665 
666  template<typename _Tp>
667  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
668  bool>::__type
669  signbit(_Tp __x)
670  { return __x < 0 ? true : false; }
671 
672  constexpr bool
673  isgreater(float __x, float __y)
674  { return __builtin_isgreater(__x, __y); }
675 
676  constexpr bool
677  isgreater(double __x, double __y)
678  { return __builtin_isgreater(__x, __y); }
679 
680  constexpr bool
681  isgreater(long double __x, long double __y)
682  { return __builtin_isgreater(__x, __y); }
683 
684  template<typename _Tp, typename _Up>
685  constexpr typename
686  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
687  && __is_arithmetic<_Up>::__value), bool>::__type
688  isgreater(_Tp __x, _Up __y)
689  {
690  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
691  return __builtin_isgreater(__type(__x), __type(__y));
692  }
693 
694  constexpr bool
695  isgreaterequal(float __x, float __y)
696  { return __builtin_isgreaterequal(__x, __y); }
697 
698  constexpr bool
699  isgreaterequal(double __x, double __y)
700  { return __builtin_isgreaterequal(__x, __y); }
701 
702  constexpr bool
703  isgreaterequal(long double __x, long double __y)
704  { return __builtin_isgreaterequal(__x, __y); }
705 
706  template<typename _Tp, typename _Up>
707  constexpr typename
708  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
709  && __is_arithmetic<_Up>::__value), bool>::__type
710  isgreaterequal(_Tp __x, _Up __y)
711  {
712  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
713  return __builtin_isgreaterequal(__type(__x), __type(__y));
714  }
715 
716  constexpr bool
717  isless(float __x, float __y)
718  { return __builtin_isless(__x, __y); }
719 
720  constexpr bool
721  isless(double __x, double __y)
722  { return __builtin_isless(__x, __y); }
723 
724  constexpr bool
725  isless(long double __x, long double __y)
726  { return __builtin_isless(__x, __y); }
727 
728  template<typename _Tp, typename _Up>
729  constexpr typename
730  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
731  && __is_arithmetic<_Up>::__value), bool>::__type
732  isless(_Tp __x, _Up __y)
733  {
734  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
735  return __builtin_isless(__type(__x), __type(__y));
736  }
737 
738  constexpr bool
739  islessequal(float __x, float __y)
740  { return __builtin_islessequal(__x, __y); }
741 
742  constexpr bool
743  islessequal(double __x, double __y)
744  { return __builtin_islessequal(__x, __y); }
745 
746  constexpr bool
747  islessequal(long double __x, long double __y)
748  { return __builtin_islessequal(__x, __y); }
749 
750  template<typename _Tp, typename _Up>
751  constexpr typename
752  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
753  && __is_arithmetic<_Up>::__value), bool>::__type
754  islessequal(_Tp __x, _Up __y)
755  {
756  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
757  return __builtin_islessequal(__type(__x), __type(__y));
758  }
759 
760  constexpr bool
761  islessgreater(float __x, float __y)
762  { return __builtin_islessgreater(__x, __y); }
763 
764  constexpr bool
765  islessgreater(double __x, double __y)
766  { return __builtin_islessgreater(__x, __y); }
767 
768  constexpr bool
769  islessgreater(long double __x, long double __y)
770  { return __builtin_islessgreater(__x, __y); }
771 
772  template<typename _Tp, typename _Up>
773  constexpr typename
774  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
775  && __is_arithmetic<_Up>::__value), bool>::__type
776  islessgreater(_Tp __x, _Up __y)
777  {
778  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
779  return __builtin_islessgreater(__type(__x), __type(__y));
780  }
781 
782  constexpr bool
783  isunordered(float __x, float __y)
784  { return __builtin_isunordered(__x, __y); }
785 
786  constexpr bool
787  isunordered(double __x, double __y)
788  { return __builtin_isunordered(__x, __y); }
789 
790  constexpr bool
791  isunordered(long double __x, long double __y)
792  { return __builtin_isunordered(__x, __y); }
793 
794  template<typename _Tp, typename _Up>
795  constexpr typename
796  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
797  && __is_arithmetic<_Up>::__value), bool>::__type
798  isunordered(_Tp __x, _Up __y)
799  {
800  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
801  return __builtin_isunordered(__type(__x), __type(__y));
802  }
803 
804 #else
805 
806  template<typename _Tp>
807  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
808  int>::__type
809  fpclassify(_Tp __f)
810  {
811  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
812  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
813  FP_SUBNORMAL, FP_ZERO, __type(__f));
814  }
815 
816  template<typename _Tp>
817  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
818  int>::__type
819  isfinite(_Tp __f)
820  {
821  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
822  return __builtin_isfinite(__type(__f));
823  }
824 
825  template<typename _Tp>
826  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
827  int>::__type
828  isinf(_Tp __f)
829  {
830  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
831  return __builtin_isinf(__type(__f));
832  }
833 
834  template<typename _Tp>
835  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
836  int>::__type
837  isnan(_Tp __f)
838  {
839  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
840  return __builtin_isnan(__type(__f));
841  }
842 
843  template<typename _Tp>
844  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
845  int>::__type
846  isnormal(_Tp __f)
847  {
848  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
849  return __builtin_isnormal(__type(__f));
850  }
851 
852  template<typename _Tp>
853  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
854  int>::__type
855  signbit(_Tp __f)
856  {
857  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
858  return __builtin_signbit(__type(__f));
859  }
860 
861  template<typename _Tp>
862  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
863  int>::__type
864  isgreater(_Tp __f1, _Tp __f2)
865  {
866  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
867  return __builtin_isgreater(__type(__f1), __type(__f2));
868  }
869 
870  template<typename _Tp>
871  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
872  int>::__type
873  isgreaterequal(_Tp __f1, _Tp __f2)
874  {
875  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
876  return __builtin_isgreaterequal(__type(__f1), __type(__f2));
877  }
878 
879  template<typename _Tp>
880  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
881  int>::__type
882  isless(_Tp __f1, _Tp __f2)
883  {
884  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
885  return __builtin_isless(__type(__f1), __type(__f2));
886  }
887 
888  template<typename _Tp>
889  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
890  int>::__type
891  islessequal(_Tp __f1, _Tp __f2)
892  {
893  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
894  return __builtin_islessequal(__type(__f1), __type(__f2));
895  }
896 
897  template<typename _Tp>
898  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
899  int>::__type
900  islessgreater(_Tp __f1, _Tp __f2)
901  {
902  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
903  return __builtin_islessgreater(__type(__f1), __type(__f2));
904  }
905 
906  template<typename _Tp>
907  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
908  int>::__type
909  isunordered(_Tp __f1, _Tp __f2)
910  {
911  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
912  return __builtin_isunordered(__type(__f1), __type(__f2));
913  }
914 
915 #endif
916 
917 _GLIBCXX_END_NAMESPACE_VERSION
918 } // namespace
919 
920 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
921 #endif
922 
923 #if __cplusplus >= 201103L
924 
925 #ifdef _GLIBCXX_USE_C99_MATH_TR1
926 
927 #undef acosh
928 #undef acoshf
929 #undef acoshl
930 #undef asinh
931 #undef asinhf
932 #undef asinhl
933 #undef atanh
934 #undef atanhf
935 #undef atanhl
936 #undef cbrt
937 #undef cbrtf
938 #undef cbrtl
939 #undef copysign
940 #undef copysignf
941 #undef copysignl
942 #undef erf
943 #undef erff
944 #undef erfl
945 #undef erfc
946 #undef erfcf
947 #undef erfcl
948 #undef exp2
949 #undef exp2f
950 #undef exp2l
951 #undef expm1
952 #undef expm1f
953 #undef expm1l
954 #undef fdim
955 #undef fdimf
956 #undef fdiml
957 #undef fma
958 #undef fmaf
959 #undef fmal
960 #undef fmax
961 #undef fmaxf
962 #undef fmaxl
963 #undef fmin
964 #undef fminf
965 #undef fminl
966 #undef hypot
967 #undef hypotf
968 #undef hypotl
969 #undef ilogb
970 #undef ilogbf
971 #undef ilogbl
972 #undef lgamma
973 #undef lgammaf
974 #undef lgammal
975 #undef llrint
976 #undef llrintf
977 #undef llrintl
978 #undef llround
979 #undef llroundf
980 #undef llroundl
981 #undef log1p
982 #undef log1pf
983 #undef log1pl
984 #undef log2
985 #undef log2f
986 #undef log2l
987 #undef logb
988 #undef logbf
989 #undef logbl
990 #undef lrint
991 #undef lrintf
992 #undef lrintl
993 #undef lround
994 #undef lroundf
995 #undef lroundl
996 #undef nan
997 #undef nanf
998 #undef nanl
999 #undef nearbyint
1000 #undef nearbyintf
1001 #undef nearbyintl
1002 #undef nextafter
1003 #undef nextafterf
1004 #undef nextafterl
1005 #undef nexttoward
1006 #undef nexttowardf
1007 #undef nexttowardl
1008 #undef remainder
1009 #undef remainderf
1010 #undef remainderl
1011 #undef remquo
1012 #undef remquof
1013 #undef remquol
1014 #undef rint
1015 #undef rintf
1016 #undef rintl
1017 #undef round
1018 #undef roundf
1019 #undef roundl
1020 #undef scalbln
1021 #undef scalblnf
1022 #undef scalblnl
1023 #undef scalbn
1024 #undef scalbnf
1025 #undef scalbnl
1026 #undef tgamma
1027 #undef tgammaf
1028 #undef tgammal
1029 #undef trunc
1030 #undef truncf
1031 #undef truncl
1032 
1033 namespace std _GLIBCXX_VISIBILITY(default)
1034 {
1035 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1036 
1037  // types
1038  using ::double_t;
1039  using ::float_t;
1040 
1041  // functions
1042  using ::acosh;
1043  using ::acoshf;
1044  using ::acoshl;
1045 
1046  using ::asinh;
1047  using ::asinhf;
1048  using ::asinhl;
1049 
1050  using ::atanh;
1051  using ::atanhf;
1052  using ::atanhl;
1053 
1054  using ::cbrt;
1055  using ::cbrtf;
1056  using ::cbrtl;
1057 
1058  using ::copysign;
1059  using ::copysignf;
1060  using ::copysignl;
1061 
1062  using ::erf;
1063  using ::erff;
1064  using ::erfl;
1065 
1066  using ::erfc;
1067  using ::erfcf;
1068  using ::erfcl;
1069 
1070  using ::exp2;
1071  using ::exp2f;
1072  using ::exp2l;
1073 
1074  using ::expm1;
1075  using ::expm1f;
1076  using ::expm1l;
1077 
1078  using ::fdim;
1079  using ::fdimf;
1080  using ::fdiml;
1081 
1082  using ::fma;
1083  using ::fmaf;
1084  using ::fmal;
1085 
1086  using ::fmax;
1087  using ::fmaxf;
1088  using ::fmaxl;
1089 
1090  using ::fmin;
1091  using ::fminf;
1092  using ::fminl;
1093 
1094  using ::hypot;
1095  using ::hypotf;
1096  using ::hypotl;
1097 
1098  using ::ilogb;
1099  using ::ilogbf;
1100  using ::ilogbl;
1101 
1102  using ::lgamma;
1103  using ::lgammaf;
1104  using ::lgammal;
1105 
1106  using ::llrint;
1107  using ::llrintf;
1108  using ::llrintl;
1109 
1110  using ::llround;
1111  using ::llroundf;
1112  using ::llroundl;
1113 
1114  using ::log1p;
1115  using ::log1pf;
1116  using ::log1pl;
1117 
1118  using ::log2;
1119  using ::log2f;
1120  using ::log2l;
1121 
1122  using ::logb;
1123  using ::logbf;
1124  using ::logbl;
1125 
1126  using ::lrint;
1127  using ::lrintf;
1128  using ::lrintl;
1129 
1130  using ::lround;
1131  using ::lroundf;
1132  using ::lroundl;
1133 
1134  using ::nan;
1135  using ::nanf;
1136  using ::nanl;
1137 
1138  using ::nearbyint;
1139  using ::nearbyintf;
1140  using ::nearbyintl;
1141 
1142  using ::nextafter;
1143  using ::nextafterf;
1144  using ::nextafterl;
1145 
1146  using ::nexttoward;
1147  using ::nexttowardf;
1148  using ::nexttowardl;
1149 
1150  using ::remainder;
1151  using ::remainderf;
1152  using ::remainderl;
1153 
1154  using ::remquo;
1155  using ::remquof;
1156  using ::remquol;
1157 
1158  using ::rint;
1159  using ::rintf;
1160  using ::rintl;
1161 
1162  using ::round;
1163  using ::roundf;
1164  using ::roundl;
1165 
1166  using ::scalbln;
1167  using ::scalblnf;
1168  using ::scalblnl;
1169 
1170  using ::scalbn;
1171  using ::scalbnf;
1172  using ::scalbnl;
1173 
1174  using ::tgamma;
1175  using ::tgammaf;
1176  using ::tgammal;
1177 
1178  using ::trunc;
1179  using ::truncf;
1180  using ::truncl;
1181 
1182  /// Additional overloads.
1183  constexpr float
1184  acosh(float __x)
1185  { return __builtin_acoshf(__x); }
1186 
1187  constexpr long double
1188  acosh(long double __x)
1189  { return __builtin_acoshl(__x); }
1190 
1191  template<typename _Tp>
1192  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1193  double>::__type
1194  acosh(_Tp __x)
1195  { return __builtin_acosh(__x); }
1196 
1197  constexpr float
1198  asinh(float __x)
1199  { return __builtin_asinhf(__x); }
1200 
1201  constexpr long double
1202  asinh(long double __x)
1203  { return __builtin_asinhl(__x); }
1204 
1205  template<typename _Tp>
1206  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1207  double>::__type
1208  asinh(_Tp __x)
1209  { return __builtin_asinh(__x); }
1210 
1211  constexpr float
1212  atanh(float __x)
1213  { return __builtin_atanhf(__x); }
1214 
1215  constexpr long double
1216  atanh(long double __x)
1217  { return __builtin_atanhl(__x); }
1218 
1219  template<typename _Tp>
1220  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1221  double>::__type
1222  atanh(_Tp __x)
1223  { return __builtin_atanh(__x); }
1224 
1225  constexpr float
1226  cbrt(float __x)
1227  { return __builtin_cbrtf(__x); }
1228 
1229  constexpr long double
1230  cbrt(long double __x)
1231  { return __builtin_cbrtl(__x); }
1232 
1233  template<typename _Tp>
1234  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1235  double>::__type
1236  cbrt(_Tp __x)
1237  { return __builtin_cbrt(__x); }
1238 
1239  constexpr float
1240  copysign(float __x, float __y)
1241  { return __builtin_copysignf(__x, __y); }
1242 
1243  constexpr long double
1244  copysign(long double __x, long double __y)
1245  { return __builtin_copysignl(__x, __y); }
1246 
1247  template<typename _Tp, typename _Up>
1248  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1249  copysign(_Tp __x, _Up __y)
1250  {
1251  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1252  return copysign(__type(__x), __type(__y));
1253  }
1254 
1255  constexpr float
1256  erf(float __x)
1257  { return __builtin_erff(__x); }
1258 
1259  constexpr long double
1260  erf(long double __x)
1261  { return __builtin_erfl(__x); }
1262 
1263  template<typename _Tp>
1264  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1265  double>::__type
1266  erf(_Tp __x)
1267  { return __builtin_erf(__x); }
1268 
1269  constexpr float
1270  erfc(float __x)
1271  { return __builtin_erfcf(__x); }
1272 
1273  constexpr long double
1274  erfc(long double __x)
1275  { return __builtin_erfcl(__x); }
1276 
1277  template<typename _Tp>
1278  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1279  double>::__type
1280  erfc(_Tp __x)
1281  { return __builtin_erfc(__x); }
1282 
1283  constexpr float
1284  exp2(float __x)
1285  { return __builtin_exp2f(__x); }
1286 
1287  constexpr long double
1288  exp2(long double __x)
1289  { return __builtin_exp2l(__x); }
1290 
1291  template<typename _Tp>
1292  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1293  double>::__type
1294  exp2(_Tp __x)
1295  { return __builtin_exp2(__x); }
1296 
1297  constexpr float
1298  expm1(float __x)
1299  { return __builtin_expm1f(__x); }
1300 
1301  constexpr long double
1302  expm1(long double __x)
1303  { return __builtin_expm1l(__x); }
1304 
1305  template<typename _Tp>
1306  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1307  double>::__type
1308  expm1(_Tp __x)
1309  { return __builtin_expm1(__x); }
1310 
1311  constexpr float
1312  fdim(float __x, float __y)
1313  { return __builtin_fdimf(__x, __y); }
1314 
1315  constexpr long double
1316  fdim(long double __x, long double __y)
1317  { return __builtin_fdiml(__x, __y); }
1318 
1319  template<typename _Tp, typename _Up>
1320  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1321  fdim(_Tp __x, _Up __y)
1322  {
1323  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1324  return fdim(__type(__x), __type(__y));
1325  }
1326 
1327  constexpr float
1328  fma(float __x, float __y, float __z)
1329  { return __builtin_fmaf(__x, __y, __z); }
1330 
1331  constexpr long double
1332  fma(long double __x, long double __y, long double __z)
1333  { return __builtin_fmal(__x, __y, __z); }
1334 
1335  template<typename _Tp, typename _Up, typename _Vp>
1336  constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1337  fma(_Tp __x, _Up __y, _Vp __z)
1338  {
1339  typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
1340  return fma(__type(__x), __type(__y), __type(__z));
1341  }
1342 
1343  constexpr float
1344  fmax(float __x, float __y)
1345  { return __builtin_fmaxf(__x, __y); }
1346 
1347  constexpr long double
1348  fmax(long double __x, long double __y)
1349  { return __builtin_fmaxl(__x, __y); }
1350 
1351  template<typename _Tp, typename _Up>
1352  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1353  fmax(_Tp __x, _Up __y)
1354  {
1355  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1356  return fmax(__type(__x), __type(__y));
1357  }
1358 
1359  constexpr float
1360  fmin(float __x, float __y)
1361  { return __builtin_fminf(__x, __y); }
1362 
1363  constexpr long double
1364  fmin(long double __x, long double __y)
1365  { return __builtin_fminl(__x, __y); }
1366 
1367  template<typename _Tp, typename _Up>
1368  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1369  fmin(_Tp __x, _Up __y)
1370  {
1371  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1372  return fmin(__type(__x), __type(__y));
1373  }
1374 
1375  constexpr float
1376  hypot(float __x, float __y)
1377  { return __builtin_hypotf(__x, __y); }
1378 
1379  constexpr long double
1380  hypot(long double __x, long double __y)
1381  { return __builtin_hypotl(__x, __y); }
1382 
1383  template<typename _Tp, typename _Up>
1384  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1385  hypot(_Tp __x, _Up __y)
1386  {
1387  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1388  return hypot(__type(__x), __type(__y));
1389  }
1390 
1391  constexpr int
1392  ilogb(float __x)
1393  { return __builtin_ilogbf(__x); }
1394 
1395  constexpr int
1396  ilogb(long double __x)
1397  { return __builtin_ilogbl(__x); }
1398 
1399  template<typename _Tp>
1400  constexpr
1401  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1402  int>::__type
1403  ilogb(_Tp __x)
1404  { return __builtin_ilogb(__x); }
1405 
1406  constexpr float
1407  lgamma(float __x)
1408  { return __builtin_lgammaf(__x); }
1409 
1410  constexpr long double
1411  lgamma(long double __x)
1412  { return __builtin_lgammal(__x); }
1413 
1414  template<typename _Tp>
1415  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1416  double>::__type
1417  lgamma(_Tp __x)
1418  { return __builtin_lgamma(__x); }
1419 
1420  constexpr long long
1421  llrint(float __x)
1422  { return __builtin_llrintf(__x); }
1423 
1424  constexpr long long
1425  llrint(long double __x)
1426  { return __builtin_llrintl(__x); }
1427 
1428  template<typename _Tp>
1429  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1430  long long>::__type
1431  llrint(_Tp __x)
1432  { return __builtin_llrint(__x); }
1433 
1434  constexpr long long
1435  llround(float __x)
1436  { return __builtin_llroundf(__x); }
1437 
1438  constexpr long long
1439  llround(long double __x)
1440  { return __builtin_llroundl(__x); }
1441 
1442  template<typename _Tp>
1443  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1444  long long>::__type
1445  llround(_Tp __x)
1446  { return __builtin_llround(__x); }
1447 
1448  constexpr float
1449  log1p(float __x)
1450  { return __builtin_log1pf(__x); }
1451 
1452  constexpr long double
1453  log1p(long double __x)
1454  { return __builtin_log1pl(__x); }
1455 
1456  template<typename _Tp>
1457  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1458  double>::__type
1459  log1p(_Tp __x)
1460  { return __builtin_log1p(__x); }
1461 
1462  // DR 568.
1463  constexpr float
1464  log2(float __x)
1465  { return __builtin_log2f(__x); }
1466 
1467  constexpr long double
1468  log2(long double __x)
1469  { return __builtin_log2l(__x); }
1470 
1471  template<typename _Tp>
1472  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1473  double>::__type
1474  log2(_Tp __x)
1475  { return __builtin_log2(__x); }
1476 
1477  constexpr float
1478  logb(float __x)
1479  { return __builtin_logbf(__x); }
1480 
1481  constexpr long double
1482  logb(long double __x)
1483  { return __builtin_logbl(__x); }
1484 
1485  template<typename _Tp>
1486  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1487  double>::__type
1488  logb(_Tp __x)
1489  { return __builtin_logb(__x); }
1490 
1491  constexpr long
1492  lrint(float __x)
1493  { return __builtin_lrintf(__x); }
1494 
1495  constexpr long
1496  lrint(long double __x)
1497  { return __builtin_lrintl(__x); }
1498 
1499  template<typename _Tp>
1500  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1501  long>::__type
1502  lrint(_Tp __x)
1503  { return __builtin_lrint(__x); }
1504 
1505  constexpr long
1506  lround(float __x)
1507  { return __builtin_lroundf(__x); }
1508 
1509  constexpr long
1510  lround(long double __x)
1511  { return __builtin_lroundl(__x); }
1512 
1513  template<typename _Tp>
1514  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1515  long>::__type
1516  lround(_Tp __x)
1517  { return __builtin_lround(__x); }
1518 
1519  constexpr float
1520  nearbyint(float __x)
1521  { return __builtin_nearbyintf(__x); }
1522 
1523  constexpr long double
1524  nearbyint(long double __x)
1525  { return __builtin_nearbyintl(__x); }
1526 
1527  template<typename _Tp>
1528  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1529  double>::__type
1530  nearbyint(_Tp __x)
1531  { return __builtin_nearbyint(__x); }
1532 
1533  constexpr float
1534  nextafter(float __x, float __y)
1535  { return __builtin_nextafterf(__x, __y); }
1536 
1537  constexpr long double
1538  nextafter(long double __x, long double __y)
1539  { return __builtin_nextafterl(__x, __y); }
1540 
1541  template<typename _Tp, typename _Up>
1542  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1543  nextafter(_Tp __x, _Up __y)
1544  {
1545  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1546  return nextafter(__type(__x), __type(__y));
1547  }
1548 
1549  constexpr float
1550  nexttoward(float __x, long double __y)
1551  { return __builtin_nexttowardf(__x, __y); }
1552 
1553  constexpr long double
1554  nexttoward(long double __x, long double __y)
1555  { return __builtin_nexttowardl(__x, __y); }
1556 
1557  template<typename _Tp>
1558  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1559  double>::__type
1560  nexttoward(_Tp __x, long double __y)
1561  { return __builtin_nexttoward(__x, __y); }
1562 
1563  constexpr float
1564  remainder(float __x, float __y)
1565  { return __builtin_remainderf(__x, __y); }
1566 
1567  constexpr long double
1568  remainder(long double __x, long double __y)
1569  { return __builtin_remainderl(__x, __y); }
1570 
1571  template<typename _Tp, typename _Up>
1572  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1573  remainder(_Tp __x, _Up __y)
1574  {
1575  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1576  return remainder(__type(__x), __type(__y));
1577  }
1578 
1579  inline float
1580  remquo(float __x, float __y, int* __pquo)
1581  { return __builtin_remquof(__x, __y, __pquo); }
1582 
1583  inline long double
1584  remquo(long double __x, long double __y, int* __pquo)
1585  { return __builtin_remquol(__x, __y, __pquo); }
1586 
1587  template<typename _Tp, typename _Up>
1588  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1589  remquo(_Tp __x, _Up __y, int* __pquo)
1590  {
1591  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1592  return remquo(__type(__x), __type(__y), __pquo);
1593  }
1594 
1595  constexpr float
1596  rint(float __x)
1597  { return __builtin_rintf(__x); }
1598 
1599  constexpr long double
1600  rint(long double __x)
1601  { return __builtin_rintl(__x); }
1602 
1603  template<typename _Tp>
1604  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1605  double>::__type
1606  rint(_Tp __x)
1607  { return __builtin_rint(__x); }
1608 
1609  constexpr float
1610  round(float __x)
1611  { return __builtin_roundf(__x); }
1612 
1613  constexpr long double
1614  round(long double __x)
1615  { return __builtin_roundl(__x); }
1616 
1617  template<typename _Tp>
1618  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1619  double>::__type
1620  round(_Tp __x)
1621  { return __builtin_round(__x); }
1622 
1623  constexpr float
1624  scalbln(float __x, long __ex)
1625  { return __builtin_scalblnf(__x, __ex); }
1626 
1627  constexpr long double
1628  scalbln(long double __x, long __ex)
1629  { return __builtin_scalblnl(__x, __ex); }
1630 
1631  template<typename _Tp>
1632  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1633  double>::__type
1634  scalbln(_Tp __x, long __ex)
1635  { return __builtin_scalbln(__x, __ex); }
1636 
1637  constexpr float
1638  scalbn(float __x, int __ex)
1639  { return __builtin_scalbnf(__x, __ex); }
1640 
1641  constexpr long double
1642  scalbn(long double __x, int __ex)
1643  { return __builtin_scalbnl(__x, __ex); }
1644 
1645  template<typename _Tp>
1646  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1647  double>::__type
1648  scalbn(_Tp __x, int __ex)
1649  { return __builtin_scalbn(__x, __ex); }
1650 
1651  constexpr float
1652  tgamma(float __x)
1653  { return __builtin_tgammaf(__x); }
1654 
1655  constexpr long double
1656  tgamma(long double __x)
1657  { return __builtin_tgammal(__x); }
1658 
1659  template<typename _Tp>
1660  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1661  double>::__type
1662  tgamma(_Tp __x)
1663  { return __builtin_tgamma(__x); }
1664 
1665  constexpr float
1666  trunc(float __x)
1667  { return __builtin_truncf(__x); }
1668 
1669  constexpr long double
1670  trunc(long double __x)
1671  { return __builtin_truncl(__x); }
1672 
1673  template<typename _Tp>
1674  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1675  double>::__type
1676  trunc(_Tp __x)
1677  { return __builtin_trunc(__x); }
1678 
1679 _GLIBCXX_END_NAMESPACE_VERSION
1680 } // namespace
1681 
1682 #endif // _GLIBCXX_USE_C99_MATH_TR1
1683 
1684 #endif // C++11
1685 
1686 #endif
std::asin
std::complex< _Tp > asin(const std::complex< _Tp > &)
asin(__z) [8.1.3].
Definition: complex:1645
std::sin
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
Definition: complex:819
std::exp
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
Definition: complex:757
std::sqrt
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition: complex:893
std::cosh
complex< _Tp > cosh(const complex< _Tp > &)
Return complex hyperbolic cosine of z.
Definition: complex:731
std::pow
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y&#39;th power.
Definition: complex:979
std::atanh
std::complex< _Tp > atanh(const std::complex< _Tp > &)
atanh(__z) [8.1.7].
Definition: complex:1808
std::asinh
std::complex< _Tp > asinh(const std::complex< _Tp > &)
asinh(__z) [8.1.6].
Definition: complex:1764
std::sinh
complex< _Tp > sinh(const complex< _Tp > &)
Return complex hyperbolic sine of z.
Definition: complex:849
std::acosh
std::complex< _Tp > acosh(const std::complex< _Tp > &)
acosh(__z) [8.1.5].
Definition: complex:1725
std::acos
std::complex< _Tp > acos(const std::complex< _Tp > &)
acos(__z) [8.1.2].
Definition: complex:1609
std::abs
_Tp abs(const complex< _Tp > &)
Return magnitude of z.
Definition: complex:596
std::tan
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
Definition: complex:920
std::log10
complex< _Tp > log10(const complex< _Tp > &)
Return complex base 10 logarithm of z.
Definition: complex:789
std::tanh
complex< _Tp > tanh(const complex< _Tp > &)
Return complex hyperbolic tangent of z.
Definition: complex:948
std::cos
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
Definition: complex:701
std::atan
std::complex< _Tp > atan(const std::complex< _Tp > &)
atan(__z) [8.1.4].
Definition: complex:1689
std::log
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
Definition: complex:784
std::fabs
_Tp fabs(const std::complex< _Tp > &)
fabs(__z) [8.1.8].
Definition: complex:1817