libstdc++
cmath
Go to the documentation of this file.
1 // -*- C++ -*- C forwarding header.
2 
3 // Copyright (C) 1997-2020 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 #if _GLIBCXX_USE_C99_MATH
517 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
518 
519 // These are possible macros imported from C99-land.
520 #undef fpclassify
521 #undef isfinite
522 #undef isinf
523 #undef isnan
524 #undef isnormal
525 #undef signbit
526 #undef isgreater
527 #undef isgreaterequal
528 #undef isless
529 #undef islessequal
530 #undef islessgreater
531 #undef isunordered
532 
533 #if __cplusplus >= 201103L
534 
535 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
536  constexpr int
537  fpclassify(float __x)
538  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
539  FP_SUBNORMAL, FP_ZERO, __x); }
540 
541  constexpr int
542  fpclassify(double __x)
543  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
544  FP_SUBNORMAL, FP_ZERO, __x); }
545 
546  constexpr int
547  fpclassify(long double __x)
548  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
549  FP_SUBNORMAL, FP_ZERO, __x); }
550 #endif
551 
552 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
553  template<typename _Tp>
554  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
555  int>::__type
556  fpclassify(_Tp __x)
557  { return __x != 0 ? FP_NORMAL : FP_ZERO; }
558 #endif
559 
560 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
561  constexpr bool
562  isfinite(float __x)
563  { return __builtin_isfinite(__x); }
564 
565  constexpr bool
566  isfinite(double __x)
567  { return __builtin_isfinite(__x); }
568 
569  constexpr bool
570  isfinite(long double __x)
571  { return __builtin_isfinite(__x); }
572 #endif
573 
574 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
575  template<typename _Tp>
576  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
577  bool>::__type
578  isfinite(_Tp __x)
579  { return true; }
580 #endif
581 
582 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
583  constexpr bool
584  isinf(float __x)
585  { return __builtin_isinf(__x); }
586 
587 #if _GLIBCXX_HAVE_OBSOLETE_ISINF \
588  && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
589  using ::isinf;
590 #else
591  constexpr bool
592  isinf(double __x)
593  { return __builtin_isinf(__x); }
594 #endif
595 
596  constexpr bool
597  isinf(long double __x)
598  { return __builtin_isinf(__x); }
599 #endif
600 
601 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
602  template<typename _Tp>
603  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
604  bool>::__type
605  isinf(_Tp __x)
606  { return false; }
607 #endif
608 
609 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
610  constexpr bool
611  isnan(float __x)
612  { return __builtin_isnan(__x); }
613 
614 #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
615  && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
616  using ::isnan;
617 #else
618  constexpr bool
619  isnan(double __x)
620  { return __builtin_isnan(__x); }
621 #endif
622 
623  constexpr bool
624  isnan(long double __x)
625  { return __builtin_isnan(__x); }
626 #endif
627 
628 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
629  template<typename _Tp>
630  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
631  bool>::__type
632  isnan(_Tp __x)
633  { return false; }
634 #endif
635 
636 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
637  constexpr bool
638  isnormal(float __x)
639  { return __builtin_isnormal(__x); }
640 
641  constexpr bool
642  isnormal(double __x)
643  { return __builtin_isnormal(__x); }
644 
645  constexpr bool
646  isnormal(long double __x)
647  { return __builtin_isnormal(__x); }
648 #endif
649 
650 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
651  template<typename _Tp>
652  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
653  bool>::__type
654  isnormal(_Tp __x)
655  { return __x != 0 ? true : false; }
656 #endif
657 
658 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
659  // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.
660  constexpr bool
661  signbit(float __x)
662  { return __builtin_signbit(__x); }
663 
664  constexpr bool
665  signbit(double __x)
666  { return __builtin_signbit(__x); }
667 
668  constexpr bool
669  signbit(long double __x)
670  { return __builtin_signbit(__x); }
671 #endif
672 
673 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
674  template<typename _Tp>
675  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
676  bool>::__type
677  signbit(_Tp __x)
678  { return __x < 0 ? true : false; }
679 #endif
680 
681 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
682  constexpr bool
683  isgreater(float __x, float __y)
684  { return __builtin_isgreater(__x, __y); }
685 
686  constexpr bool
687  isgreater(double __x, double __y)
688  { return __builtin_isgreater(__x, __y); }
689 
690  constexpr bool
691  isgreater(long double __x, long double __y)
692  { return __builtin_isgreater(__x, __y); }
693 #endif
694 
695 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
696  template<typename _Tp, typename _Up>
697  constexpr typename
698  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
699  && __is_arithmetic<_Up>::__value), bool>::__type
700  isgreater(_Tp __x, _Up __y)
701  {
702  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
703  return __builtin_isgreater(__type(__x), __type(__y));
704  }
705 #endif
706 
707 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
708  constexpr bool
709  isgreaterequal(float __x, float __y)
710  { return __builtin_isgreaterequal(__x, __y); }
711 
712  constexpr bool
713  isgreaterequal(double __x, double __y)
714  { return __builtin_isgreaterequal(__x, __y); }
715 
716  constexpr bool
717  isgreaterequal(long double __x, long double __y)
718  { return __builtin_isgreaterequal(__x, __y); }
719 #endif
720 
721 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
722  template<typename _Tp, typename _Up>
723  constexpr typename
724  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
725  && __is_arithmetic<_Up>::__value), bool>::__type
726  isgreaterequal(_Tp __x, _Up __y)
727  {
728  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
729  return __builtin_isgreaterequal(__type(__x), __type(__y));
730  }
731 #endif
732 
733 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
734  constexpr bool
735  isless(float __x, float __y)
736  { return __builtin_isless(__x, __y); }
737 
738  constexpr bool
739  isless(double __x, double __y)
740  { return __builtin_isless(__x, __y); }
741 
742  constexpr bool
743  isless(long double __x, long double __y)
744  { return __builtin_isless(__x, __y); }
745 #endif
746 
747 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
748  template<typename _Tp, typename _Up>
749  constexpr typename
750  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
751  && __is_arithmetic<_Up>::__value), bool>::__type
752  isless(_Tp __x, _Up __y)
753  {
754  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
755  return __builtin_isless(__type(__x), __type(__y));
756  }
757 #endif
758 
759 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
760  constexpr bool
761  islessequal(float __x, float __y)
762  { return __builtin_islessequal(__x, __y); }
763 
764  constexpr bool
765  islessequal(double __x, double __y)
766  { return __builtin_islessequal(__x, __y); }
767 
768  constexpr bool
769  islessequal(long double __x, long double __y)
770  { return __builtin_islessequal(__x, __y); }
771 #endif
772 
773 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
774  template<typename _Tp, typename _Up>
775  constexpr typename
776  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
777  && __is_arithmetic<_Up>::__value), bool>::__type
778  islessequal(_Tp __x, _Up __y)
779  {
780  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
781  return __builtin_islessequal(__type(__x), __type(__y));
782  }
783 #endif
784 
785 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
786  constexpr bool
787  islessgreater(float __x, float __y)
788  { return __builtin_islessgreater(__x, __y); }
789 
790  constexpr bool
791  islessgreater(double __x, double __y)
792  { return __builtin_islessgreater(__x, __y); }
793 
794  constexpr bool
795  islessgreater(long double __x, long double __y)
796  { return __builtin_islessgreater(__x, __y); }
797 #endif
798 
799 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
800  template<typename _Tp, typename _Up>
801  constexpr typename
802  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
803  && __is_arithmetic<_Up>::__value), bool>::__type
804  islessgreater(_Tp __x, _Up __y)
805  {
806  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
807  return __builtin_islessgreater(__type(__x), __type(__y));
808  }
809 #endif
810 
811 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
812  constexpr bool
813  isunordered(float __x, float __y)
814  { return __builtin_isunordered(__x, __y); }
815 
816  constexpr bool
817  isunordered(double __x, double __y)
818  { return __builtin_isunordered(__x, __y); }
819 
820  constexpr bool
821  isunordered(long double __x, long double __y)
822  { return __builtin_isunordered(__x, __y); }
823 #endif
824 
825 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
826  template<typename _Tp, typename _Up>
827  constexpr typename
828  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
829  && __is_arithmetic<_Up>::__value), bool>::__type
830  isunordered(_Tp __x, _Up __y)
831  {
832  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
833  return __builtin_isunordered(__type(__x), __type(__y));
834  }
835 #endif
836 
837 #else
838 
839  template<typename _Tp>
840  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
841  int>::__type
842  fpclassify(_Tp __f)
843  {
844  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
845  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
846  FP_SUBNORMAL, FP_ZERO, __type(__f));
847  }
848 
849  template<typename _Tp>
850  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
851  int>::__type
852  isfinite(_Tp __f)
853  {
854  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
855  return __builtin_isfinite(__type(__f));
856  }
857 
858  template<typename _Tp>
859  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
860  int>::__type
861  isinf(_Tp __f)
862  {
863  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
864  return __builtin_isinf(__type(__f));
865  }
866 
867  template<typename _Tp>
868  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
869  int>::__type
870  isnan(_Tp __f)
871  {
872  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
873  return __builtin_isnan(__type(__f));
874  }
875 
876  template<typename _Tp>
877  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
878  int>::__type
879  isnormal(_Tp __f)
880  {
881  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
882  return __builtin_isnormal(__type(__f));
883  }
884 
885  template<typename _Tp>
886  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
887  int>::__type
888  signbit(_Tp __f)
889  {
890  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
891  return __builtin_signbit(__type(__f));
892  }
893 
894  template<typename _Tp>
895  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
896  int>::__type
897  isgreater(_Tp __f1, _Tp __f2)
898  {
899  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
900  return __builtin_isgreater(__type(__f1), __type(__f2));
901  }
902 
903  template<typename _Tp>
904  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
905  int>::__type
906  isgreaterequal(_Tp __f1, _Tp __f2)
907  {
908  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
909  return __builtin_isgreaterequal(__type(__f1), __type(__f2));
910  }
911 
912  template<typename _Tp>
913  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
914  int>::__type
915  isless(_Tp __f1, _Tp __f2)
916  {
917  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
918  return __builtin_isless(__type(__f1), __type(__f2));
919  }
920 
921  template<typename _Tp>
922  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
923  int>::__type
924  islessequal(_Tp __f1, _Tp __f2)
925  {
926  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
927  return __builtin_islessequal(__type(__f1), __type(__f2));
928  }
929 
930  template<typename _Tp>
931  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
932  int>::__type
933  islessgreater(_Tp __f1, _Tp __f2)
934  {
935  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
936  return __builtin_islessgreater(__type(__f1), __type(__f2));
937  }
938 
939  template<typename _Tp>
940  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
941  int>::__type
942  isunordered(_Tp __f1, _Tp __f2)
943  {
944  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
945  return __builtin_isunordered(__type(__f1), __type(__f2));
946  }
947 
948 #endif // C++11
949 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
950 #endif /* _GLIBCXX_USE_C99_MATH */
951 
952 #if __cplusplus >= 201103L
953 
954 #ifdef _GLIBCXX_USE_C99_MATH_TR1
955 
956 #undef acosh
957 #undef acoshf
958 #undef acoshl
959 #undef asinh
960 #undef asinhf
961 #undef asinhl
962 #undef atanh
963 #undef atanhf
964 #undef atanhl
965 #undef cbrt
966 #undef cbrtf
967 #undef cbrtl
968 #undef copysign
969 #undef copysignf
970 #undef copysignl
971 #undef erf
972 #undef erff
973 #undef erfl
974 #undef erfc
975 #undef erfcf
976 #undef erfcl
977 #undef exp2
978 #undef exp2f
979 #undef exp2l
980 #undef expm1
981 #undef expm1f
982 #undef expm1l
983 #undef fdim
984 #undef fdimf
985 #undef fdiml
986 #undef fma
987 #undef fmaf
988 #undef fmal
989 #undef fmax
990 #undef fmaxf
991 #undef fmaxl
992 #undef fmin
993 #undef fminf
994 #undef fminl
995 #undef hypot
996 #undef hypotf
997 #undef hypotl
998 #undef ilogb
999 #undef ilogbf
1000 #undef ilogbl
1001 #undef lgamma
1002 #undef lgammaf
1003 #undef lgammal
1004 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1005 #undef llrint
1006 #undef llrintf
1007 #undef llrintl
1008 #undef llround
1009 #undef llroundf
1010 #undef llroundl
1011 #endif
1012 #undef log1p
1013 #undef log1pf
1014 #undef log1pl
1015 #undef log2
1016 #undef log2f
1017 #undef log2l
1018 #undef logb
1019 #undef logbf
1020 #undef logbl
1021 #undef lrint
1022 #undef lrintf
1023 #undef lrintl
1024 #undef lround
1025 #undef lroundf
1026 #undef lroundl
1027 #undef nan
1028 #undef nanf
1029 #undef nanl
1030 #undef nearbyint
1031 #undef nearbyintf
1032 #undef nearbyintl
1033 #undef nextafter
1034 #undef nextafterf
1035 #undef nextafterl
1036 #undef nexttoward
1037 #undef nexttowardf
1038 #undef nexttowardl
1039 #undef remainder
1040 #undef remainderf
1041 #undef remainderl
1042 #undef remquo
1043 #undef remquof
1044 #undef remquol
1045 #undef rint
1046 #undef rintf
1047 #undef rintl
1048 #undef round
1049 #undef roundf
1050 #undef roundl
1051 #undef scalbln
1052 #undef scalblnf
1053 #undef scalblnl
1054 #undef scalbn
1055 #undef scalbnf
1056 #undef scalbnl
1057 #undef tgamma
1058 #undef tgammaf
1059 #undef tgammal
1060 #undef trunc
1061 #undef truncf
1062 #undef truncl
1063 
1064  // types
1065  using ::double_t;
1066  using ::float_t;
1067 
1068  // functions
1069  using ::acosh;
1070  using ::acoshf;
1071  using ::acoshl;
1072 
1073  using ::asinh;
1074  using ::asinhf;
1075  using ::asinhl;
1076 
1077  using ::atanh;
1078  using ::atanhf;
1079  using ::atanhl;
1080 
1081  using ::cbrt;
1082  using ::cbrtf;
1083  using ::cbrtl;
1084 
1085  using ::copysign;
1086  using ::copysignf;
1087  using ::copysignl;
1088 
1089  using ::erf;
1090  using ::erff;
1091  using ::erfl;
1092 
1093  using ::erfc;
1094  using ::erfcf;
1095  using ::erfcl;
1096 
1097  using ::exp2;
1098  using ::exp2f;
1099  using ::exp2l;
1100 
1101  using ::expm1;
1102  using ::expm1f;
1103  using ::expm1l;
1104 
1105  using ::fdim;
1106  using ::fdimf;
1107  using ::fdiml;
1108 
1109  using ::fma;
1110  using ::fmaf;
1111  using ::fmal;
1112 
1113  using ::fmax;
1114  using ::fmaxf;
1115  using ::fmaxl;
1116 
1117  using ::fmin;
1118  using ::fminf;
1119  using ::fminl;
1120 
1121  using ::hypot;
1122  using ::hypotf;
1123  using ::hypotl;
1124 
1125  using ::ilogb;
1126  using ::ilogbf;
1127  using ::ilogbl;
1128 
1129  using ::lgamma;
1130  using ::lgammaf;
1131  using ::lgammal;
1132 
1133 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1134  using ::llrint;
1135  using ::llrintf;
1136  using ::llrintl;
1137 
1138  using ::llround;
1139  using ::llroundf;
1140  using ::llroundl;
1141 #endif
1142 
1143  using ::log1p;
1144  using ::log1pf;
1145  using ::log1pl;
1146 
1147  using ::log2;
1148  using ::log2f;
1149  using ::log2l;
1150 
1151  using ::logb;
1152  using ::logbf;
1153  using ::logbl;
1154 
1155  using ::lrint;
1156  using ::lrintf;
1157  using ::lrintl;
1158 
1159  using ::lround;
1160  using ::lroundf;
1161  using ::lroundl;
1162 
1163  using ::nan;
1164  using ::nanf;
1165  using ::nanl;
1166 
1167  using ::nearbyint;
1168  using ::nearbyintf;
1169  using ::nearbyintl;
1170 
1171  using ::nextafter;
1172  using ::nextafterf;
1173  using ::nextafterl;
1174 
1175  using ::nexttoward;
1176  using ::nexttowardf;
1177  using ::nexttowardl;
1178 
1179  using ::remainder;
1180  using ::remainderf;
1181  using ::remainderl;
1182 
1183  using ::remquo;
1184  using ::remquof;
1185  using ::remquol;
1186 
1187  using ::rint;
1188  using ::rintf;
1189  using ::rintl;
1190 
1191  using ::round;
1192  using ::roundf;
1193  using ::roundl;
1194 
1195  using ::scalbln;
1196  using ::scalblnf;
1197  using ::scalblnl;
1198 
1199  using ::scalbn;
1200  using ::scalbnf;
1201  using ::scalbnl;
1202 
1203  using ::tgamma;
1204  using ::tgammaf;
1205  using ::tgammal;
1206 
1207  using ::trunc;
1208  using ::truncf;
1209  using ::truncl;
1210 
1211  /// Additional overloads.
1212 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1213  constexpr float
1214  acosh(float __x)
1215  { return __builtin_acoshf(__x); }
1216 
1217  constexpr long double
1218  acosh(long double __x)
1219  { return __builtin_acoshl(__x); }
1220 #endif
1221 
1222 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1223  template<typename _Tp>
1224  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1225  double>::__type
1226  acosh(_Tp __x)
1227  { return __builtin_acosh(__x); }
1228 #endif
1229 
1230 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1231  constexpr float
1232  asinh(float __x)
1233  { return __builtin_asinhf(__x); }
1234 
1235  constexpr long double
1236  asinh(long double __x)
1237  { return __builtin_asinhl(__x); }
1238 #endif
1239 
1240 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1241  template<typename _Tp>
1242  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1243  double>::__type
1244  asinh(_Tp __x)
1245  { return __builtin_asinh(__x); }
1246 #endif
1247 
1248 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1249  constexpr float
1250  atanh(float __x)
1251  { return __builtin_atanhf(__x); }
1252 
1253  constexpr long double
1254  atanh(long double __x)
1255  { return __builtin_atanhl(__x); }
1256 #endif
1257 
1258 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1259  template<typename _Tp>
1260  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1261  double>::__type
1262  atanh(_Tp __x)
1263  { return __builtin_atanh(__x); }
1264 #endif
1265 
1266 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1267  constexpr float
1268  cbrt(float __x)
1269  { return __builtin_cbrtf(__x); }
1270 
1271  constexpr long double
1272  cbrt(long double __x)
1273  { return __builtin_cbrtl(__x); }
1274 #endif
1275 
1276 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1277  template<typename _Tp>
1278  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1279  double>::__type
1280  cbrt(_Tp __x)
1281  { return __builtin_cbrt(__x); }
1282 #endif
1283 
1284 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1285  constexpr float
1286  copysign(float __x, float __y)
1287  { return __builtin_copysignf(__x, __y); }
1288 
1289  constexpr long double
1290  copysign(long double __x, long double __y)
1291  { return __builtin_copysignl(__x, __y); }
1292 #endif
1293 
1294 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1295  template<typename _Tp, typename _Up>
1296  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1297  copysign(_Tp __x, _Up __y)
1298  {
1299  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1300  return copysign(__type(__x), __type(__y));
1301  }
1302 #endif
1303 
1304 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
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 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1315  template<typename _Tp>
1316  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1317  double>::__type
1318  erf(_Tp __x)
1319  { return __builtin_erf(__x); }
1320 #endif
1321 
1322 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1323  constexpr float
1324  erfc(float __x)
1325  { return __builtin_erfcf(__x); }
1326 
1327  constexpr long double
1328  erfc(long double __x)
1329  { return __builtin_erfcl(__x); }
1330 #endif
1331 
1332 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1333  template<typename _Tp>
1334  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1335  double>::__type
1336  erfc(_Tp __x)
1337  { return __builtin_erfc(__x); }
1338 #endif
1339 
1340 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1341  constexpr float
1342  exp2(float __x)
1343  { return __builtin_exp2f(__x); }
1344 
1345  constexpr long double
1346  exp2(long double __x)
1347  { return __builtin_exp2l(__x); }
1348 #endif
1349 
1350 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1351  template<typename _Tp>
1352  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1353  double>::__type
1354  exp2(_Tp __x)
1355  { return __builtin_exp2(__x); }
1356 #endif
1357 
1358 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1359  constexpr float
1360  expm1(float __x)
1361  { return __builtin_expm1f(__x); }
1362 
1363  constexpr long double
1364  expm1(long double __x)
1365  { return __builtin_expm1l(__x); }
1366 #endif
1367 
1368 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1369  template<typename _Tp>
1370  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1371  double>::__type
1372  expm1(_Tp __x)
1373  { return __builtin_expm1(__x); }
1374 #endif
1375 
1376 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1377  constexpr float
1378  fdim(float __x, float __y)
1379  { return __builtin_fdimf(__x, __y); }
1380 
1381  constexpr long double
1382  fdim(long double __x, long double __y)
1383  { return __builtin_fdiml(__x, __y); }
1384 #endif
1385 
1386 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1387  template<typename _Tp, typename _Up>
1388  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1389  fdim(_Tp __x, _Up __y)
1390  {
1391  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1392  return fdim(__type(__x), __type(__y));
1393  }
1394 #endif
1395 
1396 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1397  constexpr float
1398  fma(float __x, float __y, float __z)
1399  { return __builtin_fmaf(__x, __y, __z); }
1400 
1401  constexpr long double
1402  fma(long double __x, long double __y, long double __z)
1403  { return __builtin_fmal(__x, __y, __z); }
1404 #endif
1405 
1406 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1407  template<typename _Tp, typename _Up, typename _Vp>
1408  constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1409  fma(_Tp __x, _Up __y, _Vp __z)
1410  {
1411  typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
1412  return fma(__type(__x), __type(__y), __type(__z));
1413  }
1414 #endif
1415 
1416 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1417  constexpr float
1418  fmax(float __x, float __y)
1419  { return __builtin_fmaxf(__x, __y); }
1420 
1421  constexpr long double
1422  fmax(long double __x, long double __y)
1423  { return __builtin_fmaxl(__x, __y); }
1424 #endif
1425 
1426 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1427  template<typename _Tp, typename _Up>
1428  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1429  fmax(_Tp __x, _Up __y)
1430  {
1431  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1432  return fmax(__type(__x), __type(__y));
1433  }
1434 #endif
1435 
1436 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1437  constexpr float
1438  fmin(float __x, float __y)
1439  { return __builtin_fminf(__x, __y); }
1440 
1441  constexpr long double
1442  fmin(long double __x, long double __y)
1443  { return __builtin_fminl(__x, __y); }
1444 #endif
1445 
1446 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1447  template<typename _Tp, typename _Up>
1448  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1449  fmin(_Tp __x, _Up __y)
1450  {
1451  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1452  return fmin(__type(__x), __type(__y));
1453  }
1454 #endif
1455 
1456 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1457  constexpr float
1458  hypot(float __x, float __y)
1459  { return __builtin_hypotf(__x, __y); }
1460 
1461  constexpr long double
1462  hypot(long double __x, long double __y)
1463  { return __builtin_hypotl(__x, __y); }
1464 #endif
1465 
1466 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1467  template<typename _Tp, typename _Up>
1468  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1469  hypot(_Tp __x, _Up __y)
1470  {
1471  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1472  return hypot(__type(__x), __type(__y));
1473  }
1474 #endif
1475 
1476 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1477  constexpr int
1478  ilogb(float __x)
1479  { return __builtin_ilogbf(__x); }
1480 
1481  constexpr int
1482  ilogb(long double __x)
1483  { return __builtin_ilogbl(__x); }
1484 #endif
1485 
1486 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1487  template<typename _Tp>
1488  constexpr
1489  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1490  int>::__type
1491  ilogb(_Tp __x)
1492  { return __builtin_ilogb(__x); }
1493 #endif
1494 
1495 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1496  constexpr float
1497  lgamma(float __x)
1498  { return __builtin_lgammaf(__x); }
1499 
1500  constexpr long double
1501  lgamma(long double __x)
1502  { return __builtin_lgammal(__x); }
1503 #endif
1504 
1505 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1506  template<typename _Tp>
1507  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1508  double>::__type
1509  lgamma(_Tp __x)
1510  { return __builtin_lgamma(__x); }
1511 #endif
1512 
1513 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1514  constexpr long long
1515  llrint(float __x)
1516  { return __builtin_llrintf(__x); }
1517 
1518  constexpr long long
1519  llrint(long double __x)
1520  { return __builtin_llrintl(__x); }
1521 #endif
1522 
1523 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1524  template<typename _Tp>
1525  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1526  long long>::__type
1527  llrint(_Tp __x)
1528  { return __builtin_llrint(__x); }
1529 #endif
1530 
1531 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1532  constexpr long long
1533  llround(float __x)
1534  { return __builtin_llroundf(__x); }
1535 
1536  constexpr long long
1537  llround(long double __x)
1538  { return __builtin_llroundl(__x); }
1539 #endif
1540 
1541 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1542  template<typename _Tp>
1543  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1544  long long>::__type
1545  llround(_Tp __x)
1546  { return __builtin_llround(__x); }
1547 #endif
1548 
1549 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1550  constexpr float
1551  log1p(float __x)
1552  { return __builtin_log1pf(__x); }
1553 
1554  constexpr long double
1555  log1p(long double __x)
1556  { return __builtin_log1pl(__x); }
1557 #endif
1558 
1559 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1560  template<typename _Tp>
1561  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1562  double>::__type
1563  log1p(_Tp __x)
1564  { return __builtin_log1p(__x); }
1565 #endif
1566 
1567 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1568  // DR 568.
1569  constexpr float
1570  log2(float __x)
1571  { return __builtin_log2f(__x); }
1572 
1573  constexpr long double
1574  log2(long double __x)
1575  { return __builtin_log2l(__x); }
1576 #endif
1577 
1578 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1579  template<typename _Tp>
1580  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1581  double>::__type
1582  log2(_Tp __x)
1583  { return __builtin_log2(__x); }
1584 #endif
1585 
1586 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1587  constexpr float
1588  logb(float __x)
1589  { return __builtin_logbf(__x); }
1590 
1591  constexpr long double
1592  logb(long double __x)
1593  { return __builtin_logbl(__x); }
1594 #endif
1595 
1596 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1597  template<typename _Tp>
1598  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1599  double>::__type
1600  logb(_Tp __x)
1601  { return __builtin_logb(__x); }
1602 #endif
1603 
1604 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1605  constexpr long
1606  lrint(float __x)
1607  { return __builtin_lrintf(__x); }
1608 
1609  constexpr long
1610  lrint(long double __x)
1611  { return __builtin_lrintl(__x); }
1612 #endif
1613 
1614 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1615  template<typename _Tp>
1616  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1617  long>::__type
1618  lrint(_Tp __x)
1619  { return __builtin_lrint(__x); }
1620 #endif
1621 
1622 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1623  constexpr long
1624  lround(float __x)
1625  { return __builtin_lroundf(__x); }
1626 
1627  constexpr long
1628  lround(long double __x)
1629  { return __builtin_lroundl(__x); }
1630 #endif
1631 
1632 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1633  template<typename _Tp>
1634  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1635  long>::__type
1636  lround(_Tp __x)
1637  { return __builtin_lround(__x); }
1638 #endif
1639 
1640 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1641  constexpr float
1642  nearbyint(float __x)
1643  { return __builtin_nearbyintf(__x); }
1644 
1645  constexpr long double
1646  nearbyint(long double __x)
1647  { return __builtin_nearbyintl(__x); }
1648 #endif
1649 
1650 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1651  template<typename _Tp>
1652  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1653  double>::__type
1654  nearbyint(_Tp __x)
1655  { return __builtin_nearbyint(__x); }
1656 #endif
1657 
1658 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1659  constexpr float
1660  nextafter(float __x, float __y)
1661  { return __builtin_nextafterf(__x, __y); }
1662 
1663  constexpr long double
1664  nextafter(long double __x, long double __y)
1665  { return __builtin_nextafterl(__x, __y); }
1666 #endif
1667 
1668 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1669  template<typename _Tp, typename _Up>
1670  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1671  nextafter(_Tp __x, _Up __y)
1672  {
1673  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1674  return nextafter(__type(__x), __type(__y));
1675  }
1676 #endif
1677 
1678 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1679  constexpr float
1680  nexttoward(float __x, long double __y)
1681  { return __builtin_nexttowardf(__x, __y); }
1682 
1683  constexpr long double
1684  nexttoward(long double __x, long double __y)
1685  { return __builtin_nexttowardl(__x, __y); }
1686 #endif
1687 
1688 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1689  template<typename _Tp>
1690  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1691  double>::__type
1692  nexttoward(_Tp __x, long double __y)
1693  { return __builtin_nexttoward(__x, __y); }
1694 #endif
1695 
1696 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1697  constexpr float
1698  remainder(float __x, float __y)
1699  { return __builtin_remainderf(__x, __y); }
1700 
1701  constexpr long double
1702  remainder(long double __x, long double __y)
1703  { return __builtin_remainderl(__x, __y); }
1704 #endif
1705 
1706 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1707  template<typename _Tp, typename _Up>
1708  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1709  remainder(_Tp __x, _Up __y)
1710  {
1711  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1712  return remainder(__type(__x), __type(__y));
1713  }
1714 #endif
1715 
1716 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1717  inline float
1718  remquo(float __x, float __y, int* __pquo)
1719  { return __builtin_remquof(__x, __y, __pquo); }
1720 
1721  inline long double
1722  remquo(long double __x, long double __y, int* __pquo)
1723  { return __builtin_remquol(__x, __y, __pquo); }
1724 #endif
1725 
1726 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1727  template<typename _Tp, typename _Up>
1728  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1729  remquo(_Tp __x, _Up __y, int* __pquo)
1730  {
1731  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1732  return remquo(__type(__x), __type(__y), __pquo);
1733  }
1734 #endif
1735 
1736 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1737  constexpr float
1738  rint(float __x)
1739  { return __builtin_rintf(__x); }
1740 
1741  constexpr long double
1742  rint(long double __x)
1743  { return __builtin_rintl(__x); }
1744 #endif
1745 
1746 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1747  template<typename _Tp>
1748  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1749  double>::__type
1750  rint(_Tp __x)
1751  { return __builtin_rint(__x); }
1752 #endif
1753 
1754 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1755  constexpr float
1756  round(float __x)
1757  { return __builtin_roundf(__x); }
1758 
1759  constexpr long double
1760  round(long double __x)
1761  { return __builtin_roundl(__x); }
1762 #endif
1763 
1764 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1765  template<typename _Tp>
1766  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1767  double>::__type
1768  round(_Tp __x)
1769  { return __builtin_round(__x); }
1770 #endif
1771 
1772 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1773  constexpr float
1774  scalbln(float __x, long __ex)
1775  { return __builtin_scalblnf(__x, __ex); }
1776 
1777  constexpr long double
1778  scalbln(long double __x, long __ex)
1779  { return __builtin_scalblnl(__x, __ex); }
1780 #endif
1781 
1782 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1783  template<typename _Tp>
1784  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1785  double>::__type
1786  scalbln(_Tp __x, long __ex)
1787  { return __builtin_scalbln(__x, __ex); }
1788 #endif
1789 
1790 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1791  constexpr float
1792  scalbn(float __x, int __ex)
1793  { return __builtin_scalbnf(__x, __ex); }
1794 
1795  constexpr long double
1796  scalbn(long double __x, int __ex)
1797  { return __builtin_scalbnl(__x, __ex); }
1798 #endif
1799 
1800 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1801  template<typename _Tp>
1802  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1803  double>::__type
1804  scalbn(_Tp __x, int __ex)
1805  { return __builtin_scalbn(__x, __ex); }
1806 #endif
1807 
1808 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1809  constexpr float
1810  tgamma(float __x)
1811  { return __builtin_tgammaf(__x); }
1812 
1813  constexpr long double
1814  tgamma(long double __x)
1815  { return __builtin_tgammal(__x); }
1816 #endif
1817 
1818 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1819  template<typename _Tp>
1820  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1821  double>::__type
1822  tgamma(_Tp __x)
1823  { return __builtin_tgamma(__x); }
1824 #endif
1825 
1826 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1827  constexpr float
1828  trunc(float __x)
1829  { return __builtin_truncf(__x); }
1830 
1831  constexpr long double
1832  trunc(long double __x)
1833  { return __builtin_truncl(__x); }
1834 #endif
1835 
1836 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1837  template<typename _Tp>
1838  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1839  double>::__type
1840  trunc(_Tp __x)
1841  { return __builtin_trunc(__x); }
1842 #endif
1843 
1844 #endif // _GLIBCXX_USE_C99_MATH_TR1
1845 #endif // C++11
1846 
1847 #if __cplusplus >= 201703L
1848 
1849  // [c.math.hypot3], three-dimensional hypotenuse
1850 #define __cpp_lib_hypot 201603
1851 
1852  template<typename _Tp>
1853  inline _Tp
1854  __hypot3(_Tp __x, _Tp __y, _Tp __z)
1855  {
1856  __x = std::abs(__x);
1857  __y = std::abs(__y);
1858  __z = std::abs(__z);
1859  if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
1860  return __a * std::sqrt((__x / __a) * (__x / __a)
1861  + (__y / __a) * (__y / __a)
1862  + (__z / __a) * (__z / __a));
1863  else
1864  return {};
1865  }
1866 
1867  inline float
1868  hypot(float __x, float __y, float __z)
1869  { return std::__hypot3<float>(__x, __y, __z); }
1870 
1871  inline double
1872  hypot(double __x, double __y, double __z)
1873  { return std::__hypot3<double>(__x, __y, __z); }
1874 
1875  inline long double
1876  hypot(long double __x, long double __y, long double __z)
1877  { return std::__hypot3<long double>(__x, __y, __z); }
1878 
1879  template<typename _Tp, typename _Up, typename _Vp>
1880  __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
1881  hypot(_Tp __x, _Up __y, _Vp __z)
1882  {
1883  using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
1884  return std::__hypot3<__type>(__x, __y, __z);
1885  }
1886 #endif // C++17
1887 
1888 #if __cplusplus > 201703L
1889  // linear interpolation
1890 # define __cpp_lib_interpolate 201902L
1891 
1892  template<typename _Fp>
1893  constexpr _Fp
1894  __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
1895  {
1896  if (__a <= 0 && __b >= 0 || __a >= 0 && __b <= 0)
1897  return __t * __b + (1 - __t) * __a;
1898 
1899  if (__t == 1)
1900  return __b; // exact
1901 
1902  // Exact at __t=0, monotonic except near __t=1,
1903  // bounded, determinate, and consistent:
1904  const _Fp __x = __a + __t * (__b - __a);
1905  return __t > 1 == __b > __a
1906  ? (__b < __x ? __x : __b)
1907  : (__b > __x ? __x : __b); // monotonic near __t=1
1908  }
1909 
1910  constexpr float
1911  lerp(float __a, float __b, float __t) noexcept
1912  { return std::__lerp(__a, __b, __t); }
1913 
1914  constexpr double
1915  lerp(double __a, double __b, double __t) noexcept
1916  { return std::__lerp(__a, __b, __t); }
1917 
1918  constexpr long double
1919  lerp(long double __a, long double __b, long double __t) noexcept
1920  { return std::__lerp(__a, __b, __t); }
1921 
1922  template<typename _Tp, typename _Up, typename _Vp>
1923  constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
1924  lerp(_Tp __x, _Up __y, _Vp __z) noexcept
1925  {
1926  using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
1927  return std::__lerp<__type>(__x, __y, __z);
1928  }
1929 #endif // C++20
1930 
1931 _GLIBCXX_END_NAMESPACE_VERSION
1932 } // namespace
1933 
1934 #if _GLIBCXX_USE_STD_SPEC_FUNCS
1935 # include <bits/specfun.h>
1936 #endif
1937 
1938 } // extern "C++"
1939 
1940 #endif