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