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