libstdc++
cmath
Go to the documentation of this file.
1 // -*- C++ -*- C forwarding header.
2 
3 // Copyright (C) 1997-2025 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 #ifndef _GLIBCXX_CMATH
40 #define _GLIBCXX_CMATH 1
41 
42 #ifdef _GLIBCXX_SYSHDR
43 #pragma GCC system_header
44 #endif
45 
46 #include <bits/requires_hosted.h>
47 
48 #include <bits/c++config.h>
49 #include <bits/cpp_type_traits.h>
50 #include <ext/type_traits.h>
51 
52 #pragma GCC diagnostic push
53 #pragma GCC diagnostic ignored "-Wpedantic" // include_next
54 #define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
55 #include_next <math.h>
56 #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
57 #pragma GCC diagnostic pop
58 
59 #include <bits/std_abs.h>
60 
61 #define __glibcxx_want_hypot
62 #define __glibcxx_want_interpolate
63 #include <bits/version.h>
64 
65 // Get rid of those macros defined in <math.h> in lieu of real functions.
66 #undef div
67 #undef acos
68 #undef asin
69 #undef atan
70 #undef atan2
71 #undef ceil
72 #undef cos
73 #undef cosh
74 #undef exp
75 #undef fabs
76 #undef floor
77 #undef fmod
78 #undef frexp
79 #undef ldexp
80 #undef log
81 #undef log10
82 #undef modf
83 #undef pow
84 #undef sin
85 #undef sinh
86 #undef sqrt
87 #undef tan
88 #undef tanh
89 
90 extern "C++"
91 {
92 namespace std _GLIBCXX_VISIBILITY(default)
93 {
94 _GLIBCXX_BEGIN_NAMESPACE_VERSION
95 
96  using ::acos;
97 
98 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
99  inline _GLIBCXX_CONSTEXPR float
100  acos(float __x)
101  { return __builtin_acosf(__x); }
102 
103  inline _GLIBCXX_CONSTEXPR long double
104  acos(long double __x)
105  { return __builtin_acosl(__x); }
106 #endif
107 
108  template<typename _Tp>
109  inline _GLIBCXX_CONSTEXPR
110  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
111  double>::__type
112  acos(_Tp __x)
113  { return __builtin_acos(__x); }
114 
115  using ::asin;
116 
117 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
118  inline _GLIBCXX_CONSTEXPR float
119  asin(float __x)
120  { return __builtin_asinf(__x); }
121 
122  inline _GLIBCXX_CONSTEXPR long double
123  asin(long double __x)
124  { return __builtin_asinl(__x); }
125 #endif
126 
127  template<typename _Tp>
128  inline _GLIBCXX_CONSTEXPR
129  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
130  double>::__type
131  asin(_Tp __x)
132  { return __builtin_asin(__x); }
133 
134  using ::atan;
135 
136 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
137  inline _GLIBCXX_CONSTEXPR float
138  atan(float __x)
139  { return __builtin_atanf(__x); }
140 
141  inline _GLIBCXX_CONSTEXPR long double
142  atan(long double __x)
143  { return __builtin_atanl(__x); }
144 #endif
145 
146  template<typename _Tp>
147  inline _GLIBCXX_CONSTEXPR
148  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
149  double>::__type
150  atan(_Tp __x)
151  { return __builtin_atan(__x); }
152 
153  using ::atan2;
154 
155 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
156  inline _GLIBCXX_CONSTEXPR float
157  atan2(float __y, float __x)
158  { return __builtin_atan2f(__y, __x); }
159 
160  inline _GLIBCXX_CONSTEXPR long double
161  atan2(long double __y, long double __x)
162  { return __builtin_atan2l(__y, __x); }
163 #endif
164 
165  using ::ceil;
166 
167 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
168  inline _GLIBCXX_CONSTEXPR float
169  ceil(float __x)
170  { return __builtin_ceilf(__x); }
171 
172  inline _GLIBCXX_CONSTEXPR long double
173  ceil(long double __x)
174  { return __builtin_ceill(__x); }
175 #endif
176 
177  template<typename _Tp>
178  inline _GLIBCXX_CONSTEXPR
179  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
180  double>::__type
181  ceil(_Tp __x)
182  { return __builtin_ceil(__x); }
183 
184  using ::cos;
185 
186 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
187  inline _GLIBCXX_CONSTEXPR float
188  cos(float __x)
189  { return __builtin_cosf(__x); }
190 
191  inline _GLIBCXX_CONSTEXPR long double
192  cos(long double __x)
193  { return __builtin_cosl(__x); }
194 #endif
195 
196  template<typename _Tp>
197  inline _GLIBCXX_CONSTEXPR
198  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
199  double>::__type
200  cos(_Tp __x)
201  { return __builtin_cos(__x); }
202 
203  using ::cosh;
204 
205 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
206  inline _GLIBCXX_CONSTEXPR float
207  cosh(float __x)
208  { return __builtin_coshf(__x); }
209 
210  inline _GLIBCXX_CONSTEXPR long double
211  cosh(long double __x)
212  { return __builtin_coshl(__x); }
213 #endif
214 
215  template<typename _Tp>
216  inline _GLIBCXX_CONSTEXPR
217  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
218  double>::__type
219  cosh(_Tp __x)
220  { return __builtin_cosh(__x); }
221 
222  using ::exp;
223 
224 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
225  inline _GLIBCXX_CONSTEXPR float
226  exp(float __x)
227  { return __builtin_expf(__x); }
228 
229  inline _GLIBCXX_CONSTEXPR long double
230  exp(long double __x)
231  { return __builtin_expl(__x); }
232 #endif
233 
234  template<typename _Tp>
235  inline _GLIBCXX_CONSTEXPR
236  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
237  double>::__type
238  exp(_Tp __x)
239  { return __builtin_exp(__x); }
240 
241  using ::fabs;
242 
243 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
244  inline _GLIBCXX_CONSTEXPR float
245  fabs(float __x)
246  { return __builtin_fabsf(__x); }
247 
248  inline _GLIBCXX_CONSTEXPR long double
249  fabs(long double __x)
250  { return __builtin_fabsl(__x); }
251 #endif
252 
253  template<typename _Tp>
254  inline _GLIBCXX_CONSTEXPR
255  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
256  double>::__type
257  fabs(_Tp __x)
258  { return __builtin_fabs(__x); }
259 
260  using ::floor;
261 
262 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
263  inline _GLIBCXX_CONSTEXPR float
264  floor(float __x)
265  { return __builtin_floorf(__x); }
266 
267  inline _GLIBCXX_CONSTEXPR long double
268  floor(long double __x)
269  { return __builtin_floorl(__x); }
270 #endif
271 
272  template<typename _Tp>
273  inline _GLIBCXX_CONSTEXPR
274  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
275  double>::__type
276  floor(_Tp __x)
277  { return __builtin_floor(__x); }
278 
279  using ::fmod;
280 
281 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
282  inline _GLIBCXX_CONSTEXPR float
283  fmod(float __x, float __y)
284  { return __builtin_fmodf(__x, __y); }
285 
286  inline _GLIBCXX_CONSTEXPR long double
287  fmod(long double __x, long double __y)
288  { return __builtin_fmodl(__x, __y); }
289 #endif
290 
291  using ::frexp;
292 
293 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
294  inline float
295  frexp(float __x, int* __exp)
296  { return __builtin_frexpf(__x, __exp); }
297 
298  inline long double
299  frexp(long double __x, int* __exp)
300  { return __builtin_frexpl(__x, __exp); }
301 #endif
302 
303  template<typename _Tp>
304  inline _GLIBCXX_CONSTEXPR
305  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
306  double>::__type
307  frexp(_Tp __x, int* __exp)
308  { return __builtin_frexp(__x, __exp); }
309 
310  using ::ldexp;
311 
312 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
313  inline _GLIBCXX_CONSTEXPR float
314  ldexp(float __x, int __exp)
315  { return __builtin_ldexpf(__x, __exp); }
316 
317  inline _GLIBCXX_CONSTEXPR long double
318  ldexp(long double __x, int __exp)
319  { return __builtin_ldexpl(__x, __exp); }
320 #endif
321 
322  template<typename _Tp>
323  inline _GLIBCXX_CONSTEXPR
324  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
325  double>::__type
326  ldexp(_Tp __x, int __exp)
327  { return __builtin_ldexp(__x, __exp); }
328 
329  using ::log;
330 
331 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
332  inline _GLIBCXX_CONSTEXPR float
333  log(float __x)
334  { return __builtin_logf(__x); }
335 
336  inline _GLIBCXX_CONSTEXPR long double
337  log(long double __x)
338  { return __builtin_logl(__x); }
339 #endif
340 
341  template<typename _Tp>
342  inline _GLIBCXX_CONSTEXPR
343  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
344  double>::__type
345  log(_Tp __x)
346  { return __builtin_log(__x); }
347 
348  using ::log10;
349 
350 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
351  inline _GLIBCXX_CONSTEXPR float
352  log10(float __x)
353  { return __builtin_log10f(__x); }
354 
355  inline _GLIBCXX_CONSTEXPR long double
356  log10(long double __x)
357  { return __builtin_log10l(__x); }
358 #endif
359 
360  template<typename _Tp>
361  inline _GLIBCXX_CONSTEXPR
362  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
363  double>::__type
364  log10(_Tp __x)
365  { return __builtin_log10(__x); }
366 
367  using ::modf;
368 
369 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
370  inline float
371  modf(float __x, float* __iptr)
372  { return __builtin_modff(__x, __iptr); }
373 
374  inline long double
375  modf(long double __x, long double* __iptr)
376  { return __builtin_modfl(__x, __iptr); }
377 #endif
378 
379  using ::pow;
380 
381 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
382  inline _GLIBCXX_CONSTEXPR float
383  pow(float __x, float __y)
384  { return __builtin_powf(__x, __y); }
385 
386  inline _GLIBCXX_CONSTEXPR long double
387  pow(long double __x, long double __y)
388  { return __builtin_powl(__x, __y); }
389 
390 #if __cplusplus < 201103L
391  // _GLIBCXX_RESOLVE_LIB_DEFECTS
392  // DR 550. What should the return type of pow(float,int) be?
393  inline double
394  pow(double __x, int __i)
395  { return __builtin_powi(__x, __i); }
396 
397  inline float
398  pow(float __x, int __n)
399  { return __builtin_powif(__x, __n); }
400 
401  inline long double
402  pow(long double __x, int __n)
403  { return __builtin_powil(__x, __n); }
404 #endif
405 #endif
406 
407  using ::sin;
408 
409 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
410  inline _GLIBCXX_CONSTEXPR float
411  sin(float __x)
412  { return __builtin_sinf(__x); }
413 
414  inline _GLIBCXX_CONSTEXPR long double
415  sin(long double __x)
416  { return __builtin_sinl(__x); }
417 #endif
418 
419  template<typename _Tp>
420  inline _GLIBCXX_CONSTEXPR
421  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
422  double>::__type
423  sin(_Tp __x)
424  { return __builtin_sin(__x); }
425 
426  using ::sinh;
427 
428 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
429  inline _GLIBCXX_CONSTEXPR float
430  sinh(float __x)
431  { return __builtin_sinhf(__x); }
432 
433  inline _GLIBCXX_CONSTEXPR long double
434  sinh(long double __x)
435  { return __builtin_sinhl(__x); }
436 #endif
437 
438  template<typename _Tp>
439  inline _GLIBCXX_CONSTEXPR
440  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
441  double>::__type
442  sinh(_Tp __x)
443  { return __builtin_sinh(__x); }
444 
445  using ::sqrt;
446 
447 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
448  inline _GLIBCXX_CONSTEXPR float
449  sqrt(float __x)
450  { return __builtin_sqrtf(__x); }
451 
452  inline _GLIBCXX_CONSTEXPR long double
453  sqrt(long double __x)
454  { return __builtin_sqrtl(__x); }
455 #endif
456 
457  template<typename _Tp>
458  inline _GLIBCXX_CONSTEXPR
459  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
460  double>::__type
461  sqrt(_Tp __x)
462  { return __builtin_sqrt(__x); }
463 
464  using ::tan;
465 
466 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
467  inline _GLIBCXX_CONSTEXPR float
468  tan(float __x)
469  { return __builtin_tanf(__x); }
470 
471  inline _GLIBCXX_CONSTEXPR long double
472  tan(long double __x)
473  { return __builtin_tanl(__x); }
474 #endif
475 
476  template<typename _Tp>
477  inline _GLIBCXX_CONSTEXPR
478  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
479  double>::__type
480  tan(_Tp __x)
481  { return __builtin_tan(__x); }
482 
483  using ::tanh;
484 
485 #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
486  inline _GLIBCXX_CONSTEXPR float
487  tanh(float __x)
488  { return __builtin_tanhf(__x); }
489 
490  inline _GLIBCXX_CONSTEXPR long double
491  tanh(long double __x)
492  { return __builtin_tanhl(__x); }
493 #endif
494 
495  template<typename _Tp>
496  inline _GLIBCXX_CONSTEXPR
497  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
498  double>::__type
499  tanh(_Tp __x)
500  { return __builtin_tanh(__x); }
501 
502 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
503  constexpr _Float16
504  acos(_Float16 __x)
505  { return _Float16(__builtin_acosf(__x)); }
506 
507  constexpr _Float16
508  asin(_Float16 __x)
509  { return _Float16(__builtin_asinf(__x)); }
510 
511  constexpr _Float16
512  atan(_Float16 __x)
513  { return _Float16(__builtin_atanf(__x)); }
514 
515  constexpr _Float16
516  atan2(_Float16 __y, _Float16 __x)
517  { return _Float16(__builtin_atan2f(__y, __x)); }
518 
519  constexpr _Float16
520  ceil(_Float16 __x)
521  { return _Float16(__builtin_ceilf(__x)); }
522 
523  constexpr _Float16
524  cos(_Float16 __x)
525  { return _Float16(__builtin_cosf(__x)); }
526 
527  constexpr _Float16
528  cosh(_Float16 __x)
529  { return _Float16(__builtin_coshf(__x)); }
530 
531  constexpr _Float16
532  exp(_Float16 __x)
533  { return _Float16(__builtin_expf(__x)); }
534 
535  constexpr _Float16
536  fabs(_Float16 __x)
537  { return _Float16(__builtin_fabsf(__x)); }
538 
539  constexpr _Float16
540  floor(_Float16 __x)
541  { return _Float16(__builtin_floorf(__x)); }
542 
543  constexpr _Float16
544  fmod(_Float16 __x, _Float16 __y)
545  { return _Float16(__builtin_fmodf(__x, __y)); }
546 
547  inline _Float16
548  frexp(_Float16 __x, int* __exp)
549  { return _Float16(__builtin_frexpf(__x, __exp)); }
550 
551  constexpr _Float16
552  ldexp(_Float16 __x, int __exp)
553  { return _Float16(__builtin_ldexpf(__x, __exp)); }
554 
555  constexpr _Float16
556  log(_Float16 __x)
557  { return _Float16(__builtin_logf(__x)); }
558 
559  constexpr _Float16
560  log10(_Float16 __x)
561  { return _Float16(__builtin_log10f(__x)); }
562 
563  inline _Float16
564  modf(_Float16 __x, _Float16* __iptr)
565  {
566  float __i, __ret = __builtin_modff(__x, &__i);
567  *__iptr = _Float16(__i);
568  return _Float16(__ret);
569  }
570 
571  constexpr _Float16
572  pow(_Float16 __x, _Float16 __y)
573  { return _Float16(__builtin_powf(__x, __y)); }
574 
575  constexpr _Float16
576  sin(_Float16 __x)
577  { return _Float16(__builtin_sinf(__x)); }
578 
579  constexpr _Float16
580  sinh(_Float16 __x)
581  { return _Float16(__builtin_sinhf(__x)); }
582 
583  constexpr _Float16
584  sqrt(_Float16 __x)
585  { return _Float16(__builtin_sqrtf(__x)); }
586 
587  constexpr _Float16
588  tan(_Float16 __x)
589  { return _Float16(__builtin_tanf(__x)); }
590 
591  constexpr _Float16
592  tanh(_Float16 __x)
593  { return _Float16(__builtin_tanhf(__x)); }
594 #endif
595 
596 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
597  constexpr _Float32
598  acos(_Float32 __x)
599  { return __builtin_acosf(__x); }
600 
601  constexpr _Float32
602  asin(_Float32 __x)
603  { return __builtin_asinf(__x); }
604 
605  constexpr _Float32
606  atan(_Float32 __x)
607  { return __builtin_atanf(__x); }
608 
609  constexpr _Float32
610  atan2(_Float32 __y, _Float32 __x)
611  { return __builtin_atan2f(__y, __x); }
612 
613  constexpr _Float32
614  ceil(_Float32 __x)
615  { return __builtin_ceilf(__x); }
616 
617  constexpr _Float32
618  cos(_Float32 __x)
619  { return __builtin_cosf(__x); }
620 
621  constexpr _Float32
622  cosh(_Float32 __x)
623  { return __builtin_coshf(__x); }
624 
625  constexpr _Float32
626  exp(_Float32 __x)
627  { return __builtin_expf(__x); }
628 
629  constexpr _Float32
630  fabs(_Float32 __x)
631  { return __builtin_fabsf(__x); }
632 
633  constexpr _Float32
634  floor(_Float32 __x)
635  { return __builtin_floorf(__x); }
636 
637  constexpr _Float32
638  fmod(_Float32 __x, _Float32 __y)
639  { return __builtin_fmodf(__x, __y); }
640 
641  inline _Float32
642  frexp(_Float32 __x, int* __exp)
643  { return __builtin_frexpf(__x, __exp); }
644 
645  constexpr _Float32
646  ldexp(_Float32 __x, int __exp)
647  { return __builtin_ldexpf(__x, __exp); }
648 
649  constexpr _Float32
650  log(_Float32 __x)
651  { return __builtin_logf(__x); }
652 
653  constexpr _Float32
654  log10(_Float32 __x)
655  { return __builtin_log10f(__x); }
656 
657  inline _Float32
658  modf(_Float32 __x, _Float32* __iptr)
659  {
660  float __i, __ret = __builtin_modff(__x, &__i);
661  *__iptr = __i;
662  return __ret;
663  }
664 
665  constexpr _Float32
666  pow(_Float32 __x, _Float32 __y)
667  { return __builtin_powf(__x, __y); }
668 
669  constexpr _Float32
670  sin(_Float32 __x)
671  { return __builtin_sinf(__x); }
672 
673  constexpr _Float32
674  sinh(_Float32 __x)
675  { return __builtin_sinhf(__x); }
676 
677  constexpr _Float32
678  sqrt(_Float32 __x)
679  { return __builtin_sqrtf(__x); }
680 
681  constexpr _Float32
682  tan(_Float32 __x)
683  { return __builtin_tanf(__x); }
684 
685  constexpr _Float32
686  tanh(_Float32 __x)
687  { return __builtin_tanhf(__x); }
688 #endif
689 
690 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
691  constexpr _Float64
692  acos(_Float64 __x)
693  { return __builtin_acos(__x); }
694 
695  constexpr _Float64
696  asin(_Float64 __x)
697  { return __builtin_asin(__x); }
698 
699  constexpr _Float64
700  atan(_Float64 __x)
701  { return __builtin_atan(__x); }
702 
703  constexpr _Float64
704  atan2(_Float64 __y, _Float64 __x)
705  { return __builtin_atan2(__y, __x); }
706 
707  constexpr _Float64
708  ceil(_Float64 __x)
709  { return __builtin_ceil(__x); }
710 
711  constexpr _Float64
712  cos(_Float64 __x)
713  { return __builtin_cos(__x); }
714 
715  constexpr _Float64
716  cosh(_Float64 __x)
717  { return __builtin_cosh(__x); }
718 
719  constexpr _Float64
720  exp(_Float64 __x)
721  { return __builtin_exp(__x); }
722 
723  constexpr _Float64
724  fabs(_Float64 __x)
725  { return __builtin_fabs(__x); }
726 
727  constexpr _Float64
728  floor(_Float64 __x)
729  { return __builtin_floor(__x); }
730 
731  constexpr _Float64
732  fmod(_Float64 __x, _Float64 __y)
733  { return __builtin_fmod(__x, __y); }
734 
735  inline _Float64
736  frexp(_Float64 __x, int* __exp)
737  { return __builtin_frexp(__x, __exp); }
738 
739  constexpr _Float64
740  ldexp(_Float64 __x, int __exp)
741  { return __builtin_ldexp(__x, __exp); }
742 
743  constexpr _Float64
744  log(_Float64 __x)
745  { return __builtin_log(__x); }
746 
747  constexpr _Float64
748  log10(_Float64 __x)
749  { return __builtin_log10(__x); }
750 
751  inline _Float64
752  modf(_Float64 __x, _Float64* __iptr)
753  {
754  double __i, __ret = __builtin_modf(__x, &__i);
755  *__iptr = __i;
756  return __ret;
757  }
758 
759  constexpr _Float64
760  pow(_Float64 __x, _Float64 __y)
761  { return __builtin_pow(__x, __y); }
762 
763  constexpr _Float64
764  sin(_Float64 __x)
765  { return __builtin_sin(__x); }
766 
767  constexpr _Float64
768  sinh(_Float64 __x)
769  { return __builtin_sinh(__x); }
770 
771  constexpr _Float64
772  sqrt(_Float64 __x)
773  { return __builtin_sqrt(__x); }
774 
775  constexpr _Float64
776  tan(_Float64 __x)
777  { return __builtin_tan(__x); }
778 
779  constexpr _Float64
780  tanh(_Float64 __x)
781  { return __builtin_tanh(__x); }
782 #endif
783 
784 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
785  constexpr _Float128
786  acos(_Float128 __x)
787  { return __builtin_acosl(__x); }
788 
789  constexpr _Float128
790  asin(_Float128 __x)
791  { return __builtin_asinl(__x); }
792 
793  constexpr _Float128
794  atan(_Float128 __x)
795  { return __builtin_atanl(__x); }
796 
797  constexpr _Float128
798  atan2(_Float128 __y, _Float128 __x)
799  { return __builtin_atan2l(__y, __x); }
800 
801  constexpr _Float128
802  ceil(_Float128 __x)
803  { return __builtin_ceill(__x); }
804 
805  constexpr _Float128
806  cos(_Float128 __x)
807  { return __builtin_cosl(__x); }
808 
809  constexpr _Float128
810  cosh(_Float128 __x)
811  { return __builtin_coshl(__x); }
812 
813  constexpr _Float128
814  exp(_Float128 __x)
815  { return __builtin_expl(__x); }
816 
817  constexpr _Float128
818  fabs(_Float128 __x)
819  { return __builtin_fabsl(__x); }
820 
821  constexpr _Float128
822  floor(_Float128 __x)
823  { return __builtin_floorl(__x); }
824 
825  constexpr _Float128
826  fmod(_Float128 __x, _Float128 __y)
827  { return __builtin_fmodl(__x, __y); }
828 
829  inline _Float128
830  frexp(_Float128 __x, int* __exp)
831  { return __builtin_frexpl(__x, __exp); }
832 
833  constexpr _Float128
834  ldexp(_Float128 __x, int __exp)
835  { return __builtin_ldexpl(__x, __exp); }
836 
837  constexpr _Float128
838  log(_Float128 __x)
839  { return __builtin_logl(__x); }
840 
841  constexpr _Float128
842  log10(_Float128 __x)
843  { return __builtin_log10l(__x); }
844 
845  inline _Float128
846  modf(_Float128 __x, _Float128* __iptr)
847  {
848  long double __i, __ret = __builtin_modfl(__x, &__i);
849  *__iptr = __i;
850  return __ret;
851  }
852 
853  constexpr _Float128
854  pow(_Float128 __x, _Float128 __y)
855  { return __builtin_powl(__x, __y); }
856 
857  constexpr _Float128
858  sin(_Float128 __x)
859  { return __builtin_sinl(__x); }
860 
861  constexpr _Float128
862  sinh(_Float128 __x)
863  { return __builtin_sinhl(__x); }
864 
865  constexpr _Float128
866  sqrt(_Float128 __x)
867  { return __builtin_sqrtl(__x); }
868 
869  constexpr _Float128
870  tan(_Float128 __x)
871  { return __builtin_tanl(__x); }
872 
873  constexpr _Float128
874  tanh(_Float128 __x)
875  { return __builtin_tanhl(__x); }
876 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
877  constexpr _Float128
878  acos(_Float128 __x)
879  { return __builtin_acosf128(__x); }
880 
881  constexpr _Float128
882  asin(_Float128 __x)
883  { return __builtin_asinf128(__x); }
884 
885  constexpr _Float128
886  atan(_Float128 __x)
887  { return __builtin_atanf128(__x); }
888 
889  constexpr _Float128
890  atan2(_Float128 __y, _Float128 __x)
891  { return __builtin_atan2f128(__y, __x); }
892 
893  constexpr _Float128
894  ceil(_Float128 __x)
895  { return __builtin_ceilf128(__x); }
896 
897  constexpr _Float128
898  cos(_Float128 __x)
899  { return __builtin_cosf128(__x); }
900 
901  constexpr _Float128
902  cosh(_Float128 __x)
903  { return __builtin_coshf128(__x); }
904 
905  constexpr _Float128
906  exp(_Float128 __x)
907  { return __builtin_expf128(__x); }
908 
909  constexpr _Float128
910  fabs(_Float128 __x)
911  { return __builtin_fabsf128(__x); }
912 
913  constexpr _Float128
914  floor(_Float128 __x)
915  { return __builtin_floorf128(__x); }
916 
917  constexpr _Float128
918  fmod(_Float128 __x, _Float128 __y)
919  { return __builtin_fmodf128(__x, __y); }
920 
921  inline _Float128
922  frexp(_Float128 __x, int* __exp)
923  { return __builtin_frexpf128(__x, __exp); }
924 
925  constexpr _Float128
926  ldexp(_Float128 __x, int __exp)
927  { return __builtin_ldexpf128(__x, __exp); }
928 
929  constexpr _Float128
930  log(_Float128 __x)
931  { return __builtin_logf128(__x); }
932 
933  constexpr _Float128
934  log10(_Float128 __x)
935  { return __builtin_log10f128(__x); }
936 
937  inline _Float128
938  modf(_Float128 __x, _Float128* __iptr)
939  { return __builtin_modff128(__x, __iptr); }
940 
941  constexpr _Float128
942  pow(_Float128 __x, _Float128 __y)
943  { return __builtin_powf128(__x, __y); }
944 
945  constexpr _Float128
946  sin(_Float128 __x)
947  { return __builtin_sinf128(__x); }
948 
949  constexpr _Float128
950  sinh(_Float128 __x)
951  { return __builtin_sinhf128(__x); }
952 
953  constexpr _Float128
954  sqrt(_Float128 __x)
955  { return __builtin_sqrtf128(__x); }
956 
957  constexpr _Float128
958  tan(_Float128 __x)
959  { return __builtin_tanf128(__x); }
960 
961  constexpr _Float128
962  tanh(_Float128 __x)
963  { return __builtin_tanhf128(__x); }
964 #endif
965 
966 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
967  constexpr __gnu_cxx::__bfloat16_t
968  acos(__gnu_cxx::__bfloat16_t __x)
969  { return __gnu_cxx::__bfloat16_t(__builtin_acosf(__x)); }
970 
971  constexpr __gnu_cxx::__bfloat16_t
972  asin(__gnu_cxx::__bfloat16_t __x)
973  { return __gnu_cxx::__bfloat16_t(__builtin_asinf(__x)); }
974 
975  constexpr __gnu_cxx::__bfloat16_t
976  atan(__gnu_cxx::__bfloat16_t __x)
977  { return __gnu_cxx::__bfloat16_t(__builtin_atanf(__x)); }
978 
979  constexpr __gnu_cxx::__bfloat16_t
980  atan2(__gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __x)
981  { return __gnu_cxx::__bfloat16_t(__builtin_atan2f(__y, __x)); }
982 
983  constexpr __gnu_cxx::__bfloat16_t
984  ceil(__gnu_cxx::__bfloat16_t __x)
985  { return __gnu_cxx::__bfloat16_t(__builtin_ceilf(__x)); }
986 
987  constexpr __gnu_cxx::__bfloat16_t
988  cos(__gnu_cxx::__bfloat16_t __x)
989  { return __gnu_cxx::__bfloat16_t(__builtin_cosf(__x)); }
990 
991  constexpr __gnu_cxx::__bfloat16_t
992  cosh(__gnu_cxx::__bfloat16_t __x)
993  { return __gnu_cxx::__bfloat16_t(__builtin_coshf(__x)); }
994 
995  constexpr __gnu_cxx::__bfloat16_t
996  exp(__gnu_cxx::__bfloat16_t __x)
997  { return __gnu_cxx::__bfloat16_t(__builtin_expf(__x)); }
998 
999  constexpr __gnu_cxx::__bfloat16_t
1000  fabs(__gnu_cxx::__bfloat16_t __x)
1001  { return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); }
1002 
1003  constexpr __gnu_cxx::__bfloat16_t
1004  floor(__gnu_cxx::__bfloat16_t __x)
1005  { return __gnu_cxx::__bfloat16_t(__builtin_floorf(__x)); }
1006 
1007  constexpr __gnu_cxx::__bfloat16_t
1008  fmod(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1009  { return __gnu_cxx::__bfloat16_t(__builtin_fmodf(__x, __y)); }
1010 
1011  inline __gnu_cxx::__bfloat16_t
1012  frexp(__gnu_cxx::__bfloat16_t __x, int* __exp)
1013  { return __gnu_cxx::__bfloat16_t(__builtin_frexpf(__x, __exp)); }
1014 
1015  constexpr __gnu_cxx::__bfloat16_t
1016  ldexp(__gnu_cxx::__bfloat16_t __x, int __exp)
1017  { return __gnu_cxx::__bfloat16_t(__builtin_ldexpf(__x, __exp)); }
1018 
1019  constexpr __gnu_cxx::__bfloat16_t
1020  log(__gnu_cxx::__bfloat16_t __x)
1021  { return __gnu_cxx::__bfloat16_t(__builtin_logf(__x)); }
1022 
1023  constexpr __gnu_cxx::__bfloat16_t
1024  log10(__gnu_cxx::__bfloat16_t __x)
1025  { return __gnu_cxx::__bfloat16_t(__builtin_log10f(__x)); }
1026 
1027  inline __gnu_cxx::__bfloat16_t
1028  modf(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t* __iptr)
1029  {
1030  float __i, __ret = __builtin_modff(__x, &__i);
1031  *__iptr = __gnu_cxx::__bfloat16_t(__i);
1032  return __gnu_cxx::__bfloat16_t(__ret);
1033  }
1034 
1035  constexpr __gnu_cxx::__bfloat16_t
1036  pow(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1037  { return __gnu_cxx::__bfloat16_t(__builtin_powf(__x, __y)); }
1038 
1039  constexpr __gnu_cxx::__bfloat16_t
1040  sin(__gnu_cxx::__bfloat16_t __x)
1041  { return __gnu_cxx::__bfloat16_t(__builtin_sinf(__x)); }
1042 
1043  constexpr __gnu_cxx::__bfloat16_t
1044  sinh(__gnu_cxx::__bfloat16_t __x)
1045  { return __gnu_cxx::__bfloat16_t(__builtin_sinhf(__x)); }
1046 
1047  constexpr __gnu_cxx::__bfloat16_t
1048  sqrt(__gnu_cxx::__bfloat16_t __x)
1049  { return __gnu_cxx::__bfloat16_t(__builtin_sqrtf(__x)); }
1050 
1051  constexpr __gnu_cxx::__bfloat16_t
1052  tan(__gnu_cxx::__bfloat16_t __x)
1053  { return __gnu_cxx::__bfloat16_t(__builtin_tanf(__x)); }
1054 
1055  constexpr __gnu_cxx::__bfloat16_t
1056  tanh(__gnu_cxx::__bfloat16_t __x)
1057  { return __gnu_cxx::__bfloat16_t(__builtin_tanhf(__x)); }
1058 #endif
1059 
1060  template<typename _Tp, typename _Up>
1061  inline _GLIBCXX_CONSTEXPR
1062  typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1063  atan2(_Tp __y, _Up __x)
1064  {
1065  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1066  return atan2(__type(__y), __type(__x));
1067  }
1068 
1069  template<typename _Tp, typename _Up>
1070  inline _GLIBCXX_CONSTEXPR
1071  typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1072  fmod(_Tp __x, _Up __y)
1073  {
1074  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1075  return fmod(__type(__x), __type(__y));
1076  }
1077 
1078  template<typename _Tp, typename _Up>
1079  inline _GLIBCXX_CONSTEXPR
1080  typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1081  pow(_Tp __x, _Up __y)
1082  {
1083  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1084  return pow(__type(__x), __type(__y));
1085  }
1086 
1087 #if _GLIBCXX_USE_C99_MATH
1088 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
1089 
1090 // These are possible macros imported from C99-land.
1091 #undef fpclassify
1092 #undef isfinite
1093 #undef isinf
1094 #undef isnan
1095 #undef isnormal
1096 #undef signbit
1097 #undef isgreater
1098 #undef isgreaterequal
1099 #undef isless
1100 #undef islessequal
1101 #undef islessgreater
1102 #undef isunordered
1103 
1104 #if __cplusplus >= 201103L
1105 
1106 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1107  constexpr int
1108  fpclassify(float __x)
1109  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1110  FP_SUBNORMAL, FP_ZERO, __x); }
1111 
1112  constexpr int
1113  fpclassify(double __x)
1114  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1115  FP_SUBNORMAL, FP_ZERO, __x); }
1116 
1117  constexpr int
1118  fpclassify(long double __x)
1119  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1120  FP_SUBNORMAL, FP_ZERO, __x); }
1121 #endif
1122 
1123 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1124  template<typename _Tp>
1125  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1126  int>::__type
1127  fpclassify(_Tp __x)
1128  { return __x != 0 ? FP_NORMAL : FP_ZERO; }
1129 #endif
1130 
1131 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1132  constexpr bool
1133  isfinite(float __x)
1134  { return __builtin_isfinite(__x); }
1135 
1136  constexpr bool
1137  isfinite(double __x)
1138  { return __builtin_isfinite(__x); }
1139 
1140  constexpr bool
1141  isfinite(long double __x)
1142  { return __builtin_isfinite(__x); }
1143 #endif
1144 
1145 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1146  template<typename _Tp>
1147  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1148  bool>::__type
1149  isfinite(_Tp)
1150  { return true; }
1151 #endif
1152 
1153 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1154  constexpr bool
1155  isinf(float __x)
1156  { return __builtin_isinf(__x); }
1157 
1158 #if _GLIBCXX_HAVE_OBSOLETE_ISINF \
1159  && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1160  using ::isinf;
1161 #else
1162  constexpr bool
1163  isinf(double __x)
1164  { return __builtin_isinf(__x); }
1165 #endif
1166 
1167  constexpr bool
1168  isinf(long double __x)
1169  { return __builtin_isinf(__x); }
1170 #endif
1171 
1172 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1173  template<typename _Tp>
1174  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1175  bool>::__type
1176  isinf(_Tp)
1177  { return false; }
1178 #endif
1179 
1180 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1181  constexpr bool
1182  isnan(float __x)
1183  { return __builtin_isnan(__x); }
1184 
1185 #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
1186  && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1187  using ::isnan;
1188 #else
1189  constexpr bool
1190  isnan(double __x)
1191  { return __builtin_isnan(__x); }
1192 #endif
1193 
1194  constexpr bool
1195  isnan(long double __x)
1196  { return __builtin_isnan(__x); }
1197 #endif
1198 
1199 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1200  template<typename _Tp>
1201  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1202  bool>::__type
1203  isnan(_Tp)
1204  { return false; }
1205 #endif
1206 
1207 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1208  constexpr bool
1209  isnormal(float __x)
1210  { return __builtin_isnormal(__x); }
1211 
1212  constexpr bool
1213  isnormal(double __x)
1214  { return __builtin_isnormal(__x); }
1215 
1216  constexpr bool
1217  isnormal(long double __x)
1218  { return __builtin_isnormal(__x); }
1219 #endif
1220 
1221 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1222  template<typename _Tp>
1223  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1224  bool>::__type
1225  isnormal(_Tp __x)
1226  { return __x != 0 ? true : false; }
1227 #endif
1228 
1229 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1230  // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.
1231  constexpr bool
1232  signbit(float __x)
1233  { return __builtin_signbit(__x); }
1234 
1235  constexpr bool
1236  signbit(double __x)
1237  { return __builtin_signbit(__x); }
1238 
1239  constexpr bool
1240  signbit(long double __x)
1241  { return __builtin_signbit(__x); }
1242 #endif
1243 
1244 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1245  template<typename _Tp>
1246  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1247  bool>::__type
1248  signbit(_Tp __x)
1249  { return __x < 0 ? true : false; }
1250 #endif
1251 
1252 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1253  constexpr bool
1254  isgreater(float __x, float __y)
1255  { return __builtin_isgreater(__x, __y); }
1256 
1257  constexpr bool
1258  isgreater(double __x, double __y)
1259  { return __builtin_isgreater(__x, __y); }
1260 
1261  constexpr bool
1262  isgreater(long double __x, long double __y)
1263  { return __builtin_isgreater(__x, __y); }
1264 #endif
1265 
1266 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1267  template<typename _Tp, typename _Up>
1268  constexpr typename
1269  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1270  && __is_arithmetic<_Up>::__value), bool>::__type
1271  isgreater(_Tp __x, _Up __y)
1272  {
1273  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1274  return __builtin_isgreater(__type(__x), __type(__y));
1275  }
1276 #endif
1277 
1278 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1279  constexpr bool
1280  isgreaterequal(float __x, float __y)
1281  { return __builtin_isgreaterequal(__x, __y); }
1282 
1283  constexpr bool
1284  isgreaterequal(double __x, double __y)
1285  { return __builtin_isgreaterequal(__x, __y); }
1286 
1287  constexpr bool
1288  isgreaterequal(long double __x, long double __y)
1289  { return __builtin_isgreaterequal(__x, __y); }
1290 #endif
1291 
1292 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1293  template<typename _Tp, typename _Up>
1294  constexpr typename
1295  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1296  && __is_arithmetic<_Up>::__value), bool>::__type
1297  isgreaterequal(_Tp __x, _Up __y)
1298  {
1299  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1300  return __builtin_isgreaterequal(__type(__x), __type(__y));
1301  }
1302 #endif
1303 
1304 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1305  constexpr bool
1306  isless(float __x, float __y)
1307  { return __builtin_isless(__x, __y); }
1308 
1309  constexpr bool
1310  isless(double __x, double __y)
1311  { return __builtin_isless(__x, __y); }
1312 
1313  constexpr bool
1314  isless(long double __x, long double __y)
1315  { return __builtin_isless(__x, __y); }
1316 #endif
1317 
1318 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1319  template<typename _Tp, typename _Up>
1320  constexpr typename
1321  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1322  && __is_arithmetic<_Up>::__value), bool>::__type
1323  isless(_Tp __x, _Up __y)
1324  {
1325  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1326  return __builtin_isless(__type(__x), __type(__y));
1327  }
1328 #endif
1329 
1330 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1331  constexpr bool
1332  islessequal(float __x, float __y)
1333  { return __builtin_islessequal(__x, __y); }
1334 
1335  constexpr bool
1336  islessequal(double __x, double __y)
1337  { return __builtin_islessequal(__x, __y); }
1338 
1339  constexpr bool
1340  islessequal(long double __x, long double __y)
1341  { return __builtin_islessequal(__x, __y); }
1342 #endif
1343 
1344 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1345  template<typename _Tp, typename _Up>
1346  constexpr typename
1347  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1348  && __is_arithmetic<_Up>::__value), bool>::__type
1349  islessequal(_Tp __x, _Up __y)
1350  {
1351  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1352  return __builtin_islessequal(__type(__x), __type(__y));
1353  }
1354 #endif
1355 
1356 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1357  constexpr bool
1358  islessgreater(float __x, float __y)
1359  { return __builtin_islessgreater(__x, __y); }
1360 
1361  constexpr bool
1362  islessgreater(double __x, double __y)
1363  { return __builtin_islessgreater(__x, __y); }
1364 
1365  constexpr bool
1366  islessgreater(long double __x, long double __y)
1367  { return __builtin_islessgreater(__x, __y); }
1368 #endif
1369 
1370 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1371  template<typename _Tp, typename _Up>
1372  constexpr typename
1373  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1374  && __is_arithmetic<_Up>::__value), bool>::__type
1375  islessgreater(_Tp __x, _Up __y)
1376  {
1377  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1378  return __builtin_islessgreater(__type(__x), __type(__y));
1379  }
1380 #endif
1381 
1382 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1383  constexpr bool
1384  isunordered(float __x, float __y)
1385  { return __builtin_isunordered(__x, __y); }
1386 
1387  constexpr bool
1388  isunordered(double __x, double __y)
1389  { return __builtin_isunordered(__x, __y); }
1390 
1391  constexpr bool
1392  isunordered(long double __x, long double __y)
1393  { return __builtin_isunordered(__x, __y); }
1394 #endif
1395 
1396 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1397  template<typename _Tp, typename _Up>
1398  constexpr typename
1399  __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1400  && __is_arithmetic<_Up>::__value), bool>::__type
1401  isunordered(_Tp __x, _Up __y)
1402  {
1403  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1404  return __builtin_isunordered(__type(__x), __type(__y));
1405  }
1406 #endif
1407 
1408 #else
1409 
1410  template<typename _Tp>
1411  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1412  int>::__type
1413  fpclassify(_Tp __f)
1414  {
1415  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1416  return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1417  FP_SUBNORMAL, FP_ZERO, __type(__f));
1418  }
1419 
1420  template<typename _Tp>
1421  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1422  int>::__type
1423  isfinite(_Tp __f)
1424  {
1425  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1426  return __builtin_isfinite(__type(__f));
1427  }
1428 
1429  template<typename _Tp>
1430  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1431  int>::__type
1432  isinf(_Tp __f)
1433  {
1434  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1435  return __builtin_isinf(__type(__f));
1436  }
1437 
1438  template<typename _Tp>
1439  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1440  int>::__type
1441  isnan(_Tp __f)
1442  {
1443  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1444  return __builtin_isnan(__type(__f));
1445  }
1446 
1447  template<typename _Tp>
1448  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1449  int>::__type
1450  isnormal(_Tp __f)
1451  {
1452  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1453  return __builtin_isnormal(__type(__f));
1454  }
1455 
1456  template<typename _Tp>
1457  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1458  int>::__type
1459  signbit(_Tp __f)
1460  {
1461  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1462  return __builtin_signbit(__type(__f));
1463  }
1464 
1465  template<typename _Tp>
1466  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1467  int>::__type
1468  isgreater(_Tp __f1, _Tp __f2)
1469  {
1470  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1471  return __builtin_isgreater(__type(__f1), __type(__f2));
1472  }
1473 
1474  template<typename _Tp>
1475  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1476  int>::__type
1477  isgreaterequal(_Tp __f1, _Tp __f2)
1478  {
1479  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1480  return __builtin_isgreaterequal(__type(__f1), __type(__f2));
1481  }
1482 
1483  template<typename _Tp>
1484  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1485  int>::__type
1486  isless(_Tp __f1, _Tp __f2)
1487  {
1488  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1489  return __builtin_isless(__type(__f1), __type(__f2));
1490  }
1491 
1492  template<typename _Tp>
1493  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1494  int>::__type
1495  islessequal(_Tp __f1, _Tp __f2)
1496  {
1497  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1498  return __builtin_islessequal(__type(__f1), __type(__f2));
1499  }
1500 
1501  template<typename _Tp>
1502  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1503  int>::__type
1504  islessgreater(_Tp __f1, _Tp __f2)
1505  {
1506  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1507  return __builtin_islessgreater(__type(__f1), __type(__f2));
1508  }
1509 
1510  template<typename _Tp>
1511  inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1512  int>::__type
1513  isunordered(_Tp __f1, _Tp __f2)
1514  {
1515  typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1516  return __builtin_isunordered(__type(__f1), __type(__f2));
1517  }
1518 
1519 #endif // C++11
1520 
1521 #ifdef __STDCPP_FLOAT16_T__
1522  constexpr int
1523  fpclassify(_Float16 __x)
1524  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1525  FP_SUBNORMAL, FP_ZERO, __x); }
1526 
1527  constexpr bool
1528  isfinite(_Float16 __x)
1529  { return __builtin_isfinite(__x); }
1530 
1531  constexpr bool
1532  isinf(_Float16 __x)
1533  { return __builtin_isinf(__x); }
1534 
1535  constexpr bool
1536  isnan(_Float16 __x)
1537  { return __builtin_isnan(__x); }
1538 
1539  constexpr bool
1540  isnormal(_Float16 __x)
1541  { return __builtin_isnormal(__x); }
1542 
1543  constexpr bool
1544  signbit(_Float16 __x)
1545  { return __builtin_signbit(__x); }
1546 
1547  constexpr bool
1548  isgreater(_Float16 __x, _Float16 __y)
1549  { return __builtin_isgreater(__x, __y); }
1550 
1551  constexpr bool
1552  isgreaterequal(_Float16 __x, _Float16 __y)
1553  { return __builtin_isgreaterequal(__x, __y); }
1554 
1555  constexpr bool
1556  isless(_Float16 __x, _Float16 __y)
1557  { return __builtin_isless(__x, __y); }
1558 
1559  constexpr bool
1560  islessequal(_Float16 __x, _Float16 __y)
1561  { return __builtin_islessequal(__x, __y); }
1562 
1563  constexpr bool
1564  islessgreater(_Float16 __x, _Float16 __y)
1565  { return __builtin_islessgreater(__x, __y); }
1566 
1567  constexpr bool
1568  isunordered(_Float16 __x, _Float16 __y)
1569  { return __builtin_isunordered(__x, __y); }
1570 #endif
1571 
1572 #ifdef __STDCPP_FLOAT32_T__
1573  constexpr int
1574  fpclassify(_Float32 __x)
1575  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1576  FP_SUBNORMAL, FP_ZERO, __x); }
1577 
1578  constexpr bool
1579  isfinite(_Float32 __x)
1580  { return __builtin_isfinite(__x); }
1581 
1582  constexpr bool
1583  isinf(_Float32 __x)
1584  { return __builtin_isinf(__x); }
1585 
1586  constexpr bool
1587  isnan(_Float32 __x)
1588  { return __builtin_isnan(__x); }
1589 
1590  constexpr bool
1591  isnormal(_Float32 __x)
1592  { return __builtin_isnormal(__x); }
1593 
1594  constexpr bool
1595  signbit(_Float32 __x)
1596  { return __builtin_signbit(__x); }
1597 
1598  constexpr bool
1599  isgreater(_Float32 __x, _Float32 __y)
1600  { return __builtin_isgreater(__x, __y); }
1601 
1602  constexpr bool
1603  isgreaterequal(_Float32 __x, _Float32 __y)
1604  { return __builtin_isgreaterequal(__x, __y); }
1605 
1606  constexpr bool
1607  isless(_Float32 __x, _Float32 __y)
1608  { return __builtin_isless(__x, __y); }
1609 
1610  constexpr bool
1611  islessequal(_Float32 __x, _Float32 __y)
1612  { return __builtin_islessequal(__x, __y); }
1613 
1614  constexpr bool
1615  islessgreater(_Float32 __x, _Float32 __y)
1616  { return __builtin_islessgreater(__x, __y); }
1617 
1618  constexpr bool
1619  isunordered(_Float32 __x, _Float32 __y)
1620  { return __builtin_isunordered(__x, __y); }
1621 #endif
1622 
1623 #ifdef __STDCPP_FLOAT64_T__
1624  constexpr int
1625  fpclassify(_Float64 __x)
1626  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1627  FP_SUBNORMAL, FP_ZERO, __x); }
1628 
1629  constexpr bool
1630  isfinite(_Float64 __x)
1631  { return __builtin_isfinite(__x); }
1632 
1633  constexpr bool
1634  isinf(_Float64 __x)
1635  { return __builtin_isinf(__x); }
1636 
1637  constexpr bool
1638  isnan(_Float64 __x)
1639  { return __builtin_isnan(__x); }
1640 
1641  constexpr bool
1642  isnormal(_Float64 __x)
1643  { return __builtin_isnormal(__x); }
1644 
1645  constexpr bool
1646  signbit(_Float64 __x)
1647  { return __builtin_signbit(__x); }
1648 
1649  constexpr bool
1650  isgreater(_Float64 __x, _Float64 __y)
1651  { return __builtin_isgreater(__x, __y); }
1652 
1653  constexpr bool
1654  isgreaterequal(_Float64 __x, _Float64 __y)
1655  { return __builtin_isgreaterequal(__x, __y); }
1656 
1657  constexpr bool
1658  isless(_Float64 __x, _Float64 __y)
1659  { return __builtin_isless(__x, __y); }
1660 
1661  constexpr bool
1662  islessequal(_Float64 __x, _Float64 __y)
1663  { return __builtin_islessequal(__x, __y); }
1664 
1665  constexpr bool
1666  islessgreater(_Float64 __x, _Float64 __y)
1667  { return __builtin_islessgreater(__x, __y); }
1668 
1669  constexpr bool
1670  isunordered(_Float64 __x, _Float64 __y)
1671  { return __builtin_isunordered(__x, __y); }
1672 #endif
1673 
1674 #ifdef __STDCPP_FLOAT128_T__
1675  constexpr int
1676  fpclassify(_Float128 __x)
1677  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1678  FP_SUBNORMAL, FP_ZERO, __x); }
1679 
1680  constexpr bool
1681  isfinite(_Float128 __x)
1682  { return __builtin_isfinite(__x); }
1683 
1684  constexpr bool
1685  isinf(_Float128 __x)
1686  { return __builtin_isinf(__x); }
1687 
1688  constexpr bool
1689  isnan(_Float128 __x)
1690  { return __builtin_isnan(__x); }
1691 
1692  constexpr bool
1693  isnormal(_Float128 __x)
1694  { return __builtin_isnormal(__x); }
1695 
1696  constexpr bool
1697  signbit(_Float128 __x)
1698  { return __builtin_signbit(__x); }
1699 
1700  constexpr bool
1701  isgreater(_Float128 __x, _Float128 __y)
1702  { return __builtin_isgreater(__x, __y); }
1703 
1704  constexpr bool
1705  isgreaterequal(_Float128 __x, _Float128 __y)
1706  { return __builtin_isgreaterequal(__x, __y); }
1707 
1708  constexpr bool
1709  isless(_Float128 __x, _Float128 __y)
1710  { return __builtin_isless(__x, __y); }
1711 
1712  constexpr bool
1713  islessequal(_Float128 __x, _Float128 __y)
1714  { return __builtin_islessequal(__x, __y); }
1715 
1716  constexpr bool
1717  islessgreater(_Float128 __x, _Float128 __y)
1718  { return __builtin_islessgreater(__x, __y); }
1719 
1720  constexpr bool
1721  isunordered(_Float128 __x, _Float128 __y)
1722  { return __builtin_isunordered(__x, __y); }
1723 #endif
1724 
1725 #ifdef __STDCPP_BFLOAT16_T__
1726  constexpr int
1727  fpclassify(__gnu_cxx::__bfloat16_t __x)
1728  { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1729  FP_SUBNORMAL, FP_ZERO, __x); }
1730 
1731  constexpr bool
1732  isfinite(__gnu_cxx::__bfloat16_t __x)
1733  { return __builtin_isfinite(__x); }
1734 
1735  constexpr bool
1736  isinf(__gnu_cxx::__bfloat16_t __x)
1737  { return __builtin_isinf(__x); }
1738 
1739  constexpr bool
1740  isnan(__gnu_cxx::__bfloat16_t __x)
1741  { return __builtin_isnan(__x); }
1742 
1743  constexpr bool
1744  isnormal(__gnu_cxx::__bfloat16_t __x)
1745  { return __builtin_isnormal(__x); }
1746 
1747  constexpr bool
1748  signbit(__gnu_cxx::__bfloat16_t __x)
1749  { return __builtin_signbit(__x); }
1750 
1751  constexpr bool
1752  isgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1753  { return __builtin_isgreater(__x, __y); }
1754 
1755  constexpr bool
1756  isgreaterequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1757  { return __builtin_isgreaterequal(__x, __y); }
1758 
1759  constexpr bool
1760  isless(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1761  { return __builtin_isless(__x, __y); }
1762 
1763  constexpr bool
1764  islessequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1765  { return __builtin_islessequal(__x, __y); }
1766 
1767  constexpr bool
1768  islessgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1769  { return __builtin_islessgreater(__x, __y); }
1770 
1771  constexpr bool
1772  isunordered(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1773  { return __builtin_isunordered(__x, __y); }
1774 #endif
1775 
1776 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
1777 #endif /* _GLIBCXX_USE_C99_MATH */
1778 
1779 #if __cplusplus >= 201103L
1780 
1781 #undef acosf
1782 #undef acosl
1783 #undef asinf
1784 #undef asinl
1785 #undef atanf
1786 #undef atanl
1787 #undef atan2f
1788 #undef atan2l
1789 #undef ceilf
1790 #undef ceill
1791 #undef cosf
1792 #undef cosl
1793 #undef coshf
1794 #undef coshl
1795 #undef expf
1796 #undef expl
1797 #undef fabsf
1798 #undef fabsl
1799 #undef floorf
1800 #undef floorl
1801 #undef fmodf
1802 #undef fmodl
1803 #undef frexpf
1804 #undef frexpl
1805 #undef ldexpf
1806 #undef ldexpl
1807 #undef logf
1808 #undef logl
1809 #undef log10f
1810 #undef log10l
1811 #undef modff
1812 #undef modfl
1813 #undef powf
1814 #undef powl
1815 #undef sinf
1816 #undef sinl
1817 #undef sinhf
1818 #undef sinhl
1819 #undef sqrtf
1820 #undef sqrtl
1821 #undef tanf
1822 #undef tanl
1823 #undef tanhf
1824 #undef tanhl
1825 
1826 #ifdef _GLIBCXX_HAVE_ACOSF
1827  using ::acosf;
1828 #endif
1829 #ifdef _GLIBCXX_HAVE_ACOSL
1830  using ::acosl;
1831 #endif
1832 
1833 #ifdef _GLIBCXX_HAVE_ASINF
1834  using ::asinf;
1835 #endif
1836 #ifdef _GLIBCXX_HAVE_ASINL
1837  using ::asinl;
1838 #endif
1839 
1840 #ifdef _GLIBCXX_HAVE_ATANF
1841  using ::atanf;
1842 #endif
1843 #ifdef _GLIBCXX_HAVE_ATANL
1844  using ::atanl;
1845 #endif
1846 
1847 #ifdef _GLIBCXX_HAVE_ATAN2F
1848  using ::atan2f;
1849 #endif
1850 #ifdef _GLIBCXX_HAVE_ATAN2L
1851  using ::atan2l;
1852 #endif
1853 
1854 #ifdef _GLIBCXX_HAVE_CEILF
1855  using ::ceilf;
1856 #endif
1857 #ifdef _GLIBCXX_HAVE_CEILL
1858  using ::ceill;
1859 #endif
1860 
1861 #ifdef _GLIBCXX_HAVE_COSF
1862  using ::cosf;
1863 #endif
1864 #ifdef _GLIBCXX_HAVE_COSL
1865  using ::cosl;
1866 #endif
1867 
1868 #ifdef _GLIBCXX_HAVE_COSHF
1869  using ::coshf;
1870 #endif
1871 #ifdef _GLIBCXX_HAVE_COSHL
1872  using ::coshl;
1873 #endif
1874 
1875 #ifdef _GLIBCXX_HAVE_EXPF
1876  using ::expf;
1877 #endif
1878 #ifdef _GLIBCXX_HAVE_EXPL
1879  using ::expl;
1880 #endif
1881 
1882 #ifdef _GLIBCXX_HAVE_FABSF
1883  using ::fabsf;
1884 #endif
1885 #ifdef _GLIBCXX_HAVE_FABSL
1886  using ::fabsl;
1887 #endif
1888 
1889 #ifdef _GLIBCXX_HAVE_FLOORF
1890  using ::floorf;
1891 #endif
1892 #ifdef _GLIBCXX_HAVE_FLOORL
1893  using ::floorl;
1894 #endif
1895 
1896 #ifdef _GLIBCXX_HAVE_FMODF
1897  using ::fmodf;
1898 #endif
1899 #ifdef _GLIBCXX_HAVE_FMODL
1900  using ::fmodl;
1901 #endif
1902 
1903 #ifdef _GLIBCXX_HAVE_FREXPF
1904  using ::frexpf;
1905 #endif
1906 #ifdef _GLIBCXX_HAVE_FREXPL
1907  using ::frexpl;
1908 #endif
1909 
1910 #ifdef _GLIBCXX_HAVE_LDEXPF
1911  using ::ldexpf;
1912 #endif
1913 #ifdef _GLIBCXX_HAVE_LDEXPL
1914  using ::ldexpl;
1915 #endif
1916 
1917 #ifdef _GLIBCXX_HAVE_LOGF
1918  using ::logf;
1919 #endif
1920 #ifdef _GLIBCXX_HAVE_LOGL
1921  using ::logl;
1922 #endif
1923 
1924 #ifdef _GLIBCXX_HAVE_LOG10F
1925  using ::log10f;
1926 #endif
1927 #ifdef _GLIBCXX_HAVE_LOG10L
1928  using ::log10l;
1929 #endif
1930 
1931 #ifdef _GLIBCXX_HAVE_MODFF
1932  using ::modff;
1933 #endif
1934 #ifdef _GLIBCXX_HAVE_MODFL
1935  using ::modfl;
1936 #endif
1937 
1938 #ifdef _GLIBCXX_HAVE_POWF
1939  using ::powf;
1940 #endif
1941 #ifdef _GLIBCXX_HAVE_POWL
1942  using ::powl;
1943 #endif
1944 
1945 #ifdef _GLIBCXX_HAVE_SINF
1946  using ::sinf;
1947 #endif
1948 #ifdef _GLIBCXX_HAVE_SINL
1949  using ::sinl;
1950 #endif
1951 
1952 #ifdef _GLIBCXX_HAVE_SINHF
1953  using ::sinhf;
1954 #endif
1955 #ifdef _GLIBCXX_HAVE_SINHL
1956  using ::sinhl;
1957 #endif
1958 
1959 #ifdef _GLIBCXX_HAVE_SQRTF
1960  using ::sqrtf;
1961 #endif
1962 #ifdef _GLIBCXX_HAVE_SQRTL
1963  using ::sqrtl;
1964 #endif
1965 
1966 #ifdef _GLIBCXX_HAVE_TANF
1967  using ::tanf;
1968 #endif
1969 #ifdef _GLIBCXX_HAVE_TANL
1970  using ::tanl;
1971 #endif
1972 
1973 #ifdef _GLIBCXX_HAVE_TANHF
1974  using ::tanhf;
1975 #endif
1976 #ifdef _GLIBCXX_HAVE_TANHL
1977  using ::tanhl;
1978 #endif
1979 
1980 #ifdef _GLIBCXX_USE_C99_MATH_FUNCS
1981 
1982 #undef acosh
1983 #undef acoshf
1984 #undef acoshl
1985 #undef asinh
1986 #undef asinhf
1987 #undef asinhl
1988 #undef atanh
1989 #undef atanhf
1990 #undef atanhl
1991 #undef cbrt
1992 #undef cbrtf
1993 #undef cbrtl
1994 #undef copysign
1995 #undef copysignf
1996 #undef copysignl
1997 #undef erf
1998 #undef erff
1999 #undef erfl
2000 #undef erfc
2001 #undef erfcf
2002 #undef erfcl
2003 #undef exp2
2004 #undef exp2f
2005 #undef exp2l
2006 #undef expm1
2007 #undef expm1f
2008 #undef expm1l
2009 #undef fdim
2010 #undef fdimf
2011 #undef fdiml
2012 #undef fma
2013 #undef fmaf
2014 #undef fmal
2015 #undef fmax
2016 #undef fmaxf
2017 #undef fmaxl
2018 #undef fmin
2019 #undef fminf
2020 #undef fminl
2021 #undef hypot
2022 #undef hypotf
2023 #undef hypotl
2024 #undef ilogb
2025 #undef ilogbf
2026 #undef ilogbl
2027 #undef lgamma
2028 #undef lgammaf
2029 #undef lgammal
2030 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
2031 #undef llrint
2032 #undef llrintf
2033 #undef llrintl
2034 #undef llround
2035 #undef llroundf
2036 #undef llroundl
2037 #endif
2038 #undef log1p
2039 #undef log1pf
2040 #undef log1pl
2041 #undef log2
2042 #undef log2f
2043 #undef log2l
2044 #undef logb
2045 #undef logbf
2046 #undef logbl
2047 #undef lrint
2048 #undef lrintf
2049 #undef lrintl
2050 #undef lround
2051 #undef lroundf
2052 #undef lroundl
2053 #undef nan
2054 #undef nanf
2055 #undef nanl
2056 #undef nearbyint
2057 #undef nearbyintf
2058 #undef nearbyintl
2059 #undef nextafter
2060 #undef nextafterf
2061 #undef nextafterl
2062 #undef nexttoward
2063 #undef nexttowardf
2064 #undef nexttowardl
2065 #undef remainder
2066 #undef remainderf
2067 #undef remainderl
2068 #undef remquo
2069 #undef remquof
2070 #undef remquol
2071 #undef rint
2072 #undef rintf
2073 #undef rintl
2074 #undef round
2075 #undef roundf
2076 #undef roundl
2077 #undef scalbln
2078 #undef scalblnf
2079 #undef scalblnl
2080 #undef scalbn
2081 #undef scalbnf
2082 #undef scalbnl
2083 #undef tgamma
2084 #undef tgammaf
2085 #undef tgammal
2086 #undef trunc
2087 #undef truncf
2088 #undef truncl
2089 
2090 #ifdef _GLIBCXX_HAVE_C99_FLT_EVAL_TYPES
2091  // types
2092  using ::double_t;
2093  using ::float_t;
2094 #endif
2095 
2096  // functions
2097  using ::acosh;
2098  using ::acoshf;
2099  using ::acoshl;
2100 
2101  using ::asinh;
2102  using ::asinhf;
2103  using ::asinhl;
2104 
2105  using ::atanh;
2106  using ::atanhf;
2107  using ::atanhl;
2108 
2109  using ::cbrt;
2110  using ::cbrtf;
2111  using ::cbrtl;
2112 
2113  using ::copysign;
2114  using ::copysignf;
2115  using ::copysignl;
2116 
2117  using ::erf;
2118  using ::erff;
2119  using ::erfl;
2120 
2121  using ::erfc;
2122  using ::erfcf;
2123  using ::erfcl;
2124 
2125  using ::exp2;
2126  using ::exp2f;
2127  using ::exp2l;
2128 
2129  using ::expm1;
2130  using ::expm1f;
2131  using ::expm1l;
2132 
2133  using ::fdim;
2134  using ::fdimf;
2135  using ::fdiml;
2136 
2137  using ::fma;
2138  using ::fmaf;
2139  using ::fmal;
2140 
2141  using ::fmax;
2142  using ::fmaxf;
2143  using ::fmaxl;
2144 
2145  using ::fmin;
2146  using ::fminf;
2147  using ::fminl;
2148 
2149  using ::hypot;
2150  using ::hypotf;
2151  using ::hypotl;
2152 
2153  using ::ilogb;
2154  using ::ilogbf;
2155  using ::ilogbl;
2156 
2157  using ::lgamma;
2158  using ::lgammaf;
2159  using ::lgammal;
2160 
2161 #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
2162  using ::llrint;
2163  using ::llrintf;
2164  using ::llrintl;
2165 
2166  using ::llround;
2167  using ::llroundf;
2168  using ::llroundl;
2169 #endif
2170 
2171  using ::log1p;
2172  using ::log1pf;
2173  using ::log1pl;
2174 
2175  using ::log2;
2176  using ::log2f;
2177  using ::log2l;
2178 
2179  using ::logb;
2180  using ::logbf;
2181  using ::logbl;
2182 
2183  using ::lrint;
2184  using ::lrintf;
2185  using ::lrintl;
2186 
2187  using ::lround;
2188  using ::lroundf;
2189  using ::lroundl;
2190 
2191  using ::nan;
2192  using ::nanf;
2193  using ::nanl;
2194 
2195  using ::nearbyint;
2196  using ::nearbyintf;
2197  using ::nearbyintl;
2198 
2199  using ::nextafter;
2200  using ::nextafterf;
2201  using ::nextafterl;
2202 
2203  using ::nexttoward;
2204  using ::nexttowardf;
2205  using ::nexttowardl;
2206 
2207  using ::remainder;
2208  using ::remainderf;
2209  using ::remainderl;
2210 
2211  using ::remquo;
2212  using ::remquof;
2213  using ::remquol;
2214 
2215  using ::rint;
2216  using ::rintf;
2217  using ::rintl;
2218 
2219  using ::round;
2220  using ::roundf;
2221  using ::roundl;
2222 
2223  using ::scalbln;
2224  using ::scalblnf;
2225  using ::scalblnl;
2226 
2227  using ::scalbn;
2228  using ::scalbnf;
2229  using ::scalbnl;
2230 
2231  using ::tgamma;
2232  using ::tgammaf;
2233  using ::tgammal;
2234 
2235  using ::trunc;
2236  using ::truncf;
2237  using ::truncl;
2238 
2239  /// Additional overloads.
2240 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2241  constexpr float
2242  acosh(float __x)
2243  { return __builtin_acoshf(__x); }
2244 
2245  constexpr long double
2246  acosh(long double __x)
2247  { return __builtin_acoshl(__x); }
2248 #endif
2249 
2250 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2251  template<typename _Tp>
2252  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2253  double>::__type
2254  acosh(_Tp __x)
2255  { return __builtin_acosh(__x); }
2256 #endif
2257 
2258 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2259  constexpr float
2260  asinh(float __x)
2261  { return __builtin_asinhf(__x); }
2262 
2263  constexpr long double
2264  asinh(long double __x)
2265  { return __builtin_asinhl(__x); }
2266 #endif
2267 
2268 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2269  template<typename _Tp>
2270  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2271  double>::__type
2272  asinh(_Tp __x)
2273  { return __builtin_asinh(__x); }
2274 #endif
2275 
2276 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2277  constexpr float
2278  atanh(float __x)
2279  { return __builtin_atanhf(__x); }
2280 
2281  constexpr long double
2282  atanh(long double __x)
2283  { return __builtin_atanhl(__x); }
2284 #endif
2285 
2286 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2287  template<typename _Tp>
2288  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2289  double>::__type
2290  atanh(_Tp __x)
2291  { return __builtin_atanh(__x); }
2292 #endif
2293 
2294 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2295  constexpr float
2296  cbrt(float __x)
2297  { return __builtin_cbrtf(__x); }
2298 
2299  constexpr long double
2300  cbrt(long double __x)
2301  { return __builtin_cbrtl(__x); }
2302 #endif
2303 
2304 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2305  template<typename _Tp>
2306  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2307  double>::__type
2308  cbrt(_Tp __x)
2309  { return __builtin_cbrt(__x); }
2310 #endif
2311 
2312 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2313  constexpr float
2314  copysign(float __x, float __y)
2315  { return __builtin_copysignf(__x, __y); }
2316 
2317  constexpr long double
2318  copysign(long double __x, long double __y)
2319  { return __builtin_copysignl(__x, __y); }
2320 #endif
2321 
2322 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2323  constexpr float
2324  erf(float __x)
2325  { return __builtin_erff(__x); }
2326 
2327  constexpr long double
2328  erf(long double __x)
2329  { return __builtin_erfl(__x); }
2330 #endif
2331 
2332 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2333  template<typename _Tp>
2334  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2335  double>::__type
2336  erf(_Tp __x)
2337  { return __builtin_erf(__x); }
2338 #endif
2339 
2340 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2341  constexpr float
2342  erfc(float __x)
2343  { return __builtin_erfcf(__x); }
2344 
2345  constexpr long double
2346  erfc(long double __x)
2347  { return __builtin_erfcl(__x); }
2348 #endif
2349 
2350 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2351  template<typename _Tp>
2352  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2353  double>::__type
2354  erfc(_Tp __x)
2355  { return __builtin_erfc(__x); }
2356 #endif
2357 
2358 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2359  constexpr float
2360  exp2(float __x)
2361  { return __builtin_exp2f(__x); }
2362 
2363  constexpr long double
2364  exp2(long double __x)
2365  { return __builtin_exp2l(__x); }
2366 #endif
2367 
2368 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2369  template<typename _Tp>
2370  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2371  double>::__type
2372  exp2(_Tp __x)
2373  { return __builtin_exp2(__x); }
2374 #endif
2375 
2376 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2377  constexpr float
2378  expm1(float __x)
2379  { return __builtin_expm1f(__x); }
2380 
2381  constexpr long double
2382  expm1(long double __x)
2383  { return __builtin_expm1l(__x); }
2384 #endif
2385 
2386 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2387  template<typename _Tp>
2388  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2389  double>::__type
2390  expm1(_Tp __x)
2391  { return __builtin_expm1(__x); }
2392 #endif
2393 
2394 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2395  constexpr float
2396  fdim(float __x, float __y)
2397  { return __builtin_fdimf(__x, __y); }
2398 
2399  constexpr long double
2400  fdim(long double __x, long double __y)
2401  { return __builtin_fdiml(__x, __y); }
2402 #endif
2403 
2404 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2405  constexpr float
2406  fma(float __x, float __y, float __z)
2407  { return __builtin_fmaf(__x, __y, __z); }
2408 
2409  constexpr long double
2410  fma(long double __x, long double __y, long double __z)
2411  { return __builtin_fmal(__x, __y, __z); }
2412 #endif
2413 
2414 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2415  constexpr float
2416  fmax(float __x, float __y)
2417  { return __builtin_fmaxf(__x, __y); }
2418 
2419  constexpr long double
2420  fmax(long double __x, long double __y)
2421  { return __builtin_fmaxl(__x, __y); }
2422 #endif
2423 
2424 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2425  constexpr float
2426  fmin(float __x, float __y)
2427  { return __builtin_fminf(__x, __y); }
2428 
2429  constexpr long double
2430  fmin(long double __x, long double __y)
2431  { return __builtin_fminl(__x, __y); }
2432 #endif
2433 
2434 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2435  constexpr float
2436  hypot(float __x, float __y)
2437  { return __builtin_hypotf(__x, __y); }
2438 
2439  constexpr long double
2440  hypot(long double __x, long double __y)
2441  { return __builtin_hypotl(__x, __y); }
2442 #endif
2443 
2444 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2445  constexpr int
2446  ilogb(float __x)
2447  { return __builtin_ilogbf(__x); }
2448 
2449  constexpr int
2450  ilogb(long double __x)
2451  { return __builtin_ilogbl(__x); }
2452 #endif
2453 
2454 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2455  template<typename _Tp>
2456  constexpr
2457  typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2458  int>::__type
2459  ilogb(_Tp __x)
2460  { return __builtin_ilogb(__x); }
2461 #endif
2462 
2463 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2464  constexpr float
2465  lgamma(float __x)
2466  { return __builtin_lgammaf(__x); }
2467 
2468  constexpr long double
2469  lgamma(long double __x)
2470  { return __builtin_lgammal(__x); }
2471 #endif
2472 
2473 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2474  template<typename _Tp>
2475  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2476  double>::__type
2477  lgamma(_Tp __x)
2478  { return __builtin_lgamma(__x); }
2479 #endif
2480 
2481 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2482  constexpr long long
2483  llrint(float __x)
2484  { return __builtin_llrintf(__x); }
2485 
2486  constexpr long long
2487  llrint(long double __x)
2488  { return __builtin_llrintl(__x); }
2489 #endif
2490 
2491 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2492  template<typename _Tp>
2493  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2494  long long>::__type
2495  llrint(_Tp __x)
2496  { return __builtin_llrint(__x); }
2497 #endif
2498 
2499 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2500  constexpr long long
2501  llround(float __x)
2502  { return __builtin_llroundf(__x); }
2503 
2504  constexpr long long
2505  llround(long double __x)
2506  { return __builtin_llroundl(__x); }
2507 #endif
2508 
2509 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2510  template<typename _Tp>
2511  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2512  long long>::__type
2513  llround(_Tp __x)
2514  { return __builtin_llround(__x); }
2515 #endif
2516 
2517 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2518  constexpr float
2519  log1p(float __x)
2520  { return __builtin_log1pf(__x); }
2521 
2522  constexpr long double
2523  log1p(long double __x)
2524  { return __builtin_log1pl(__x); }
2525 #endif
2526 
2527 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2528  template<typename _Tp>
2529  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2530  double>::__type
2531  log1p(_Tp __x)
2532  { return __builtin_log1p(__x); }
2533 #endif
2534 
2535 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2536  // DR 568.
2537  constexpr float
2538  log2(float __x)
2539  { return __builtin_log2f(__x); }
2540 
2541  constexpr long double
2542  log2(long double __x)
2543  { return __builtin_log2l(__x); }
2544 #endif
2545 
2546 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2547  template<typename _Tp>
2548  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2549  double>::__type
2550  log2(_Tp __x)
2551  { return __builtin_log2(__x); }
2552 #endif
2553 
2554 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2555  constexpr float
2556  logb(float __x)
2557  { return __builtin_logbf(__x); }
2558 
2559  constexpr long double
2560  logb(long double __x)
2561  { return __builtin_logbl(__x); }
2562 #endif
2563 
2564 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2565  template<typename _Tp>
2566  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2567  double>::__type
2568  logb(_Tp __x)
2569  { return __builtin_logb(__x); }
2570 #endif
2571 
2572 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2573  constexpr long
2574  lrint(float __x)
2575  { return __builtin_lrintf(__x); }
2576 
2577  constexpr long
2578  lrint(long double __x)
2579  { return __builtin_lrintl(__x); }
2580 #endif
2581 
2582 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2583  template<typename _Tp>
2584  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2585  long>::__type
2586  lrint(_Tp __x)
2587  { return __builtin_lrint(__x); }
2588 #endif
2589 
2590 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2591  constexpr long
2592  lround(float __x)
2593  { return __builtin_lroundf(__x); }
2594 
2595  constexpr long
2596  lround(long double __x)
2597  { return __builtin_lroundl(__x); }
2598 #endif
2599 
2600 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2601  template<typename _Tp>
2602  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2603  long>::__type
2604  lround(_Tp __x)
2605  { return __builtin_lround(__x); }
2606 #endif
2607 
2608 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2609  constexpr float
2610  nearbyint(float __x)
2611  { return __builtin_nearbyintf(__x); }
2612 
2613  constexpr long double
2614  nearbyint(long double __x)
2615  { return __builtin_nearbyintl(__x); }
2616 #endif
2617 
2618 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2619  template<typename _Tp>
2620  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2621  double>::__type
2622  nearbyint(_Tp __x)
2623  { return __builtin_nearbyint(__x); }
2624 #endif
2625 
2626 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2627  constexpr float
2628  nextafter(float __x, float __y)
2629  { return __builtin_nextafterf(__x, __y); }
2630 
2631  constexpr long double
2632  nextafter(long double __x, long double __y)
2633  { return __builtin_nextafterl(__x, __y); }
2634 #endif
2635 
2636 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2637  constexpr float
2638  nexttoward(float __x, long double __y)
2639  { return __builtin_nexttowardf(__x, __y); }
2640 
2641  constexpr long double
2642  nexttoward(long double __x, long double __y)
2643  { return __builtin_nexttowardl(__x, __y); }
2644 #endif
2645 
2646 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2647  template<typename _Tp>
2648  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2649  double>::__type
2650  nexttoward(_Tp __x, long double __y)
2651  { return __builtin_nexttoward(__x, __y); }
2652 #endif
2653 
2654 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2655  constexpr float
2656  remainder(float __x, float __y)
2657  { return __builtin_remainderf(__x, __y); }
2658 
2659  constexpr long double
2660  remainder(long double __x, long double __y)
2661  { return __builtin_remainderl(__x, __y); }
2662 #endif
2663 
2664 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2665  inline float
2666  remquo(float __x, float __y, int* __pquo)
2667  { return __builtin_remquof(__x, __y, __pquo); }
2668 
2669  inline long double
2670  remquo(long double __x, long double __y, int* __pquo)
2671  { return __builtin_remquol(__x, __y, __pquo); }
2672 #endif
2673 
2674 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2675  constexpr float
2676  rint(float __x)
2677  { return __builtin_rintf(__x); }
2678 
2679  constexpr long double
2680  rint(long double __x)
2681  { return __builtin_rintl(__x); }
2682 #endif
2683 
2684 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2685  template<typename _Tp>
2686  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2687  double>::__type
2688  rint(_Tp __x)
2689  { return __builtin_rint(__x); }
2690 #endif
2691 
2692 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2693  constexpr float
2694  round(float __x)
2695  { return __builtin_roundf(__x); }
2696 
2697  constexpr long double
2698  round(long double __x)
2699  { return __builtin_roundl(__x); }
2700 #endif
2701 
2702 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2703  template<typename _Tp>
2704  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2705  double>::__type
2706  round(_Tp __x)
2707  { return __builtin_round(__x); }
2708 #endif
2709 
2710 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2711  constexpr float
2712  scalbln(float __x, long __ex)
2713  { return __builtin_scalblnf(__x, __ex); }
2714 
2715  constexpr long double
2716  scalbln(long double __x, long __ex)
2717  { return __builtin_scalblnl(__x, __ex); }
2718 #endif
2719 
2720 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2721  template<typename _Tp>
2722  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2723  double>::__type
2724  scalbln(_Tp __x, long __ex)
2725  { return __builtin_scalbln(__x, __ex); }
2726 #endif
2727 
2728 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2729  constexpr float
2730  scalbn(float __x, int __ex)
2731  { return __builtin_scalbnf(__x, __ex); }
2732 
2733  constexpr long double
2734  scalbn(long double __x, int __ex)
2735  { return __builtin_scalbnl(__x, __ex); }
2736 #endif
2737 
2738 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2739  template<typename _Tp>
2740  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2741  double>::__type
2742  scalbn(_Tp __x, int __ex)
2743  { return __builtin_scalbn(__x, __ex); }
2744 #endif
2745 
2746 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2747  constexpr float
2748  tgamma(float __x)
2749  { return __builtin_tgammaf(__x); }
2750 
2751  constexpr long double
2752  tgamma(long double __x)
2753  { return __builtin_tgammal(__x); }
2754 #endif
2755 
2756 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2757  template<typename _Tp>
2758  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2759  double>::__type
2760  tgamma(_Tp __x)
2761  { return __builtin_tgamma(__x); }
2762 #endif
2763 
2764 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2765  constexpr float
2766  trunc(float __x)
2767  { return __builtin_truncf(__x); }
2768 
2769  constexpr long double
2770  trunc(long double __x)
2771  { return __builtin_truncl(__x); }
2772 #endif
2773 
2774 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2775  template<typename _Tp>
2776  constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2777  double>::__type
2778  trunc(_Tp __x)
2779  { return __builtin_trunc(__x); }
2780 #endif
2781 
2782 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2783  constexpr _Float16
2784  acosh(_Float16 __x)
2785  { return _Float16(__builtin_acoshf(__x)); }
2786 
2787  constexpr _Float16
2788  asinh(_Float16 __x)
2789  { return _Float16(__builtin_asinhf(__x)); }
2790 
2791  constexpr _Float16
2792  atanh(_Float16 __x)
2793  { return _Float16(__builtin_atanhf(__x)); }
2794 
2795  constexpr _Float16
2796  cbrt(_Float16 __x)
2797  { return _Float16(__builtin_cbrtf(__x)); }
2798 
2799  constexpr _Float16
2800  copysign(_Float16 __x, _Float16 __y)
2801  { return __builtin_copysignf16(__x, __y); }
2802 
2803  constexpr _Float16
2804  erf(_Float16 __x)
2805  { return _Float16(__builtin_erff(__x)); }
2806 
2807  constexpr _Float16
2808  erfc(_Float16 __x)
2809  { return _Float16(__builtin_erfcf(__x)); }
2810 
2811  constexpr _Float16
2812  exp2(_Float16 __x)
2813  { return _Float16(__builtin_exp2f(__x)); }
2814 
2815  constexpr _Float16
2816  expm1(_Float16 __x)
2817  { return _Float16(__builtin_expm1f(__x)); }
2818 
2819  constexpr _Float16
2820  fdim(_Float16 __x, _Float16 __y)
2821  { return _Float16(__builtin_fdimf(__x, __y)); }
2822 
2823  constexpr _Float16
2824  fma(_Float16 __x, _Float16 __y, _Float16 __z)
2825  { return _Float16(__builtin_fmaf(__x, __y, __z)); }
2826 
2827  constexpr _Float16
2828  fmax(_Float16 __x, _Float16 __y)
2829  { return _Float16(__builtin_fmaxf(__x, __y)); }
2830 
2831  constexpr _Float16
2832  fmin(_Float16 __x, _Float16 __y)
2833  { return _Float16(__builtin_fminf(__x, __y)); }
2834 
2835  constexpr _Float16
2836  hypot(_Float16 __x, _Float16 __y)
2837  { return _Float16(__builtin_hypotf(__x, __y)); }
2838 
2839  constexpr int
2840  ilogb(_Float16 __x)
2841  { return __builtin_ilogbf(__x); }
2842 
2843  constexpr _Float16
2844  lgamma(_Float16 __x)
2845  { return _Float16(__builtin_lgammaf(__x)); }
2846 
2847  constexpr long long
2848  llrint(_Float16 __x)
2849  { return __builtin_llrintf(__x); }
2850 
2851  constexpr long long
2852  llround(_Float16 __x)
2853  { return __builtin_llroundf(__x); }
2854 
2855  constexpr _Float16
2856  log1p(_Float16 __x)
2857  { return _Float16(__builtin_log1pf(__x)); }
2858 
2859  // DR 568.
2860  constexpr _Float16
2861  log2(_Float16 __x)
2862  { return _Float16(__builtin_log2f(__x)); }
2863 
2864  constexpr _Float16
2865  logb(_Float16 __x)
2866  { return _Float16(__builtin_logbf(__x)); }
2867 
2868  constexpr long
2869  lrint(_Float16 __x)
2870  { return __builtin_lrintf(__x); }
2871 
2872  constexpr long
2873  lround(_Float16 __x)
2874  { return __builtin_lroundf(__x); }
2875 
2876  constexpr _Float16
2877  nearbyint(_Float16 __x)
2878  { return _Float16(__builtin_nearbyintf(__x)); }
2879 
2880  constexpr _Float16
2881  nextafter(_Float16 __x, _Float16 __y)
2882  {
2883 #if __cpp_if_consteval >= 202106L
2884  // Can't use if (std::__is_constant_evaluated()) here, as it
2885  // doesn't guarantee optimizing the body away at -O0 and
2886  // nothing defines nextafterf16.
2887  if consteval { return __builtin_nextafterf16(__x, __y); }
2888 #endif
2889 #ifdef __INT16_TYPE__
2890  using __float16_int_type = __INT16_TYPE__;
2891 #else
2892  using __float16_int_type = short int;
2893 #endif
2894  __float16_int_type __hx, __hy, __ix, __iy;
2895  __builtin_memcpy(&__hx, &__x, sizeof(__x));
2896  __builtin_memcpy(&__hy, &__y, sizeof(__x));
2897  __ix = __hx & 0x7fff; // |x|
2898  __iy = __hy & 0x7fff; // |y|
2899  if (__ix > 0x7c00 || __iy > 0x7c00) // x or y is NaN
2900  return __x + __y;
2901  if (__x == __y)
2902  return __y; // x == y, return y
2903  if (__ix == 0) // x == 0
2904  {
2905  __hy = (__hy & 0x8000) | 1; // return +-__FLT16_DENORM_MIN__
2906  __builtin_memcpy(&__x, &__hy, sizeof(__x));
2907  __builtin_nextafterf(0.0f, 1.0f); // raise underflow
2908  return __x;
2909  }
2910  if (__hx >= 0) // x > 0
2911  {
2912  if (__hx > __hy) // x > y, x -= ulp
2913  --__hx;
2914  else // x < y, x += ulp
2915  ++__hx;
2916  }
2917  else // x < 0
2918  {
2919  if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp
2920  --__hx;
2921  else // x > y, x += ulp
2922  ++__hx;
2923  }
2924  __hy = __hx & 0x7c00;
2925  if (__hy >= 0x7c00)
2926  __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow
2927  else if (__hy < 0x0400)
2928  __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow
2929  __builtin_memcpy(&__x, &__hx, sizeof(__x));
2930  return __x;
2931  }
2932 
2933  constexpr _Float16
2934  remainder(_Float16 __x, _Float16 __y)
2935  { return _Float16(__builtin_remainderf(__x, __y)); }
2936 
2937  inline _Float16
2938  remquo(_Float16 __x, _Float16 __y, int* __pquo)
2939  { return _Float16(__builtin_remquof(__x, __y, __pquo)); }
2940 
2941  constexpr _Float16
2942  rint(_Float16 __x)
2943  { return _Float16(__builtin_rintf(__x)); }
2944 
2945  constexpr _Float16
2946  round(_Float16 __x)
2947  { return _Float16(__builtin_roundf(__x)); }
2948 
2949  constexpr _Float16
2950  scalbln(_Float16 __x, long __ex)
2951  { return _Float16(__builtin_scalblnf(__x, __ex)); }
2952 
2953  constexpr _Float16
2954  scalbn(_Float16 __x, int __ex)
2955  { return _Float16(__builtin_scalbnf(__x, __ex)); }
2956 
2957  constexpr _Float16
2958  tgamma(_Float16 __x)
2959  { return _Float16(__builtin_tgammaf(__x)); }
2960 
2961  constexpr _Float16
2962  trunc(_Float16 __x)
2963  { return _Float16(__builtin_truncf(__x)); }
2964 #endif
2965 
2966 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2967  constexpr _Float32
2968  acosh(_Float32 __x)
2969  { return __builtin_acoshf(__x); }
2970 
2971  constexpr _Float32
2972  asinh(_Float32 __x)
2973  { return __builtin_asinhf(__x); }
2974 
2975  constexpr _Float32
2976  atanh(_Float32 __x)
2977  { return __builtin_atanhf(__x); }
2978 
2979  constexpr _Float32
2980  cbrt(_Float32 __x)
2981  { return __builtin_cbrtf(__x); }
2982 
2983  constexpr _Float32
2984  copysign(_Float32 __x, _Float32 __y)
2985  { return __builtin_copysignf(__x, __y); }
2986 
2987  constexpr _Float32
2988  erf(_Float32 __x)
2989  { return __builtin_erff(__x); }
2990 
2991  constexpr _Float32
2992  erfc(_Float32 __x)
2993  { return __builtin_erfcf(__x); }
2994 
2995  constexpr _Float32
2996  exp2(_Float32 __x)
2997  { return __builtin_exp2f(__x); }
2998 
2999  constexpr _Float32
3000  expm1(_Float32 __x)
3001  { return __builtin_expm1f(__x); }
3002 
3003  constexpr _Float32
3004  fdim(_Float32 __x, _Float32 __y)
3005  { return __builtin_fdimf(__x, __y); }
3006 
3007  constexpr _Float32
3008  fma(_Float32 __x, _Float32 __y, _Float32 __z)
3009  { return __builtin_fmaf(__x, __y, __z); }
3010 
3011  constexpr _Float32
3012  fmax(_Float32 __x, _Float32 __y)
3013  { return __builtin_fmaxf(__x, __y); }
3014 
3015  constexpr _Float32
3016  fmin(_Float32 __x, _Float32 __y)
3017  { return __builtin_fminf(__x, __y); }
3018 
3019  constexpr _Float32
3020  hypot(_Float32 __x, _Float32 __y)
3021  { return __builtin_hypotf(__x, __y); }
3022 
3023  constexpr int
3024  ilogb(_Float32 __x)
3025  { return __builtin_ilogbf(__x); }
3026 
3027  constexpr _Float32
3028  lgamma(_Float32 __x)
3029  { return __builtin_lgammaf(__x); }
3030 
3031  constexpr long long
3032  llrint(_Float32 __x)
3033  { return __builtin_llrintf(__x); }
3034 
3035  constexpr long long
3036  llround(_Float32 __x)
3037  { return __builtin_llroundf(__x); }
3038 
3039  constexpr _Float32
3040  log1p(_Float32 __x)
3041  { return __builtin_log1pf(__x); }
3042 
3043  // DR 568.
3044  constexpr _Float32
3045  log2(_Float32 __x)
3046  { return __builtin_log2f(__x); }
3047 
3048  constexpr _Float32
3049  logb(_Float32 __x)
3050  { return __builtin_logbf(__x); }
3051 
3052  constexpr long
3053  lrint(_Float32 __x)
3054  { return __builtin_lrintf(__x); }
3055 
3056  constexpr long
3057  lround(_Float32 __x)
3058  { return __builtin_lroundf(__x); }
3059 
3060  constexpr _Float32
3061  nearbyint(_Float32 __x)
3062  { return __builtin_nearbyintf(__x); }
3063 
3064  constexpr _Float32
3065  nextafter(_Float32 __x, _Float32 __y)
3066  { return __builtin_nextafterf(__x, __y); }
3067 
3068  constexpr _Float32
3069  remainder(_Float32 __x, _Float32 __y)
3070  { return __builtin_remainderf(__x, __y); }
3071 
3072  inline _Float32
3073  remquo(_Float32 __x, _Float32 __y, int* __pquo)
3074  { return __builtin_remquof(__x, __y, __pquo); }
3075 
3076  constexpr _Float32
3077  rint(_Float32 __x)
3078  { return __builtin_rintf(__x); }
3079 
3080  constexpr _Float32
3081  round(_Float32 __x)
3082  { return __builtin_roundf(__x); }
3083 
3084  constexpr _Float32
3085  scalbln(_Float32 __x, long __ex)
3086  { return __builtin_scalblnf(__x, __ex); }
3087 
3088  constexpr _Float32
3089  scalbn(_Float32 __x, int __ex)
3090  { return __builtin_scalbnf(__x, __ex); }
3091 
3092  constexpr _Float32
3093  tgamma(_Float32 __x)
3094  { return __builtin_tgammaf(__x); }
3095 
3096  constexpr _Float32
3097  trunc(_Float32 __x)
3098  { return __builtin_truncf(__x); }
3099 #endif
3100 
3101 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3102  constexpr _Float64
3103  acosh(_Float64 __x)
3104  { return __builtin_acosh(__x); }
3105 
3106  constexpr _Float64
3107  asinh(_Float64 __x)
3108  { return __builtin_asinh(__x); }
3109 
3110  constexpr _Float64
3111  atanh(_Float64 __x)
3112  { return __builtin_atanh(__x); }
3113 
3114  constexpr _Float64
3115  cbrt(_Float64 __x)
3116  { return __builtin_cbrt(__x); }
3117 
3118  constexpr _Float64
3119  copysign(_Float64 __x, _Float64 __y)
3120  { return __builtin_copysign(__x, __y); }
3121 
3122  constexpr _Float64
3123  erf(_Float64 __x)
3124  { return __builtin_erf(__x); }
3125 
3126  constexpr _Float64
3127  erfc(_Float64 __x)
3128  { return __builtin_erfc(__x); }
3129 
3130  constexpr _Float64
3131  exp2(_Float64 __x)
3132  { return __builtin_exp2(__x); }
3133 
3134  constexpr _Float64
3135  expm1(_Float64 __x)
3136  { return __builtin_expm1(__x); }
3137 
3138  constexpr _Float64
3139  fdim(_Float64 __x, _Float64 __y)
3140  { return __builtin_fdim(__x, __y); }
3141 
3142  constexpr _Float64
3143  fma(_Float64 __x, _Float64 __y, _Float64 __z)
3144  { return __builtin_fma(__x, __y, __z); }
3145 
3146  constexpr _Float64
3147  fmax(_Float64 __x, _Float64 __y)
3148  { return __builtin_fmax(__x, __y); }
3149 
3150  constexpr _Float64
3151  fmin(_Float64 __x, _Float64 __y)
3152  { return __builtin_fmin(__x, __y); }
3153 
3154  constexpr _Float64
3155  hypot(_Float64 __x, _Float64 __y)
3156  { return __builtin_hypot(__x, __y); }
3157 
3158  constexpr int
3159  ilogb(_Float64 __x)
3160  { return __builtin_ilogb(__x); }
3161 
3162  constexpr _Float64
3163  lgamma(_Float64 __x)
3164  { return __builtin_lgamma(__x); }
3165 
3166  constexpr long long
3167  llrint(_Float64 __x)
3168  { return __builtin_llrint(__x); }
3169 
3170  constexpr long long
3171  llround(_Float64 __x)
3172  { return __builtin_llround(__x); }
3173 
3174  constexpr _Float64
3175  log1p(_Float64 __x)
3176  { return __builtin_log1p(__x); }
3177 
3178  // DR 568.
3179  constexpr _Float64
3180  log2(_Float64 __x)
3181  { return __builtin_log2(__x); }
3182 
3183  constexpr _Float64
3184  logb(_Float64 __x)
3185  { return __builtin_logb(__x); }
3186 
3187  constexpr long
3188  lrint(_Float64 __x)
3189  { return __builtin_lrint(__x); }
3190 
3191  constexpr long
3192  lround(_Float64 __x)
3193  { return __builtin_lround(__x); }
3194 
3195  constexpr _Float64
3196  nearbyint(_Float64 __x)
3197  { return __builtin_nearbyint(__x); }
3198 
3199  constexpr _Float64
3200  nextafter(_Float64 __x, _Float64 __y)
3201  { return __builtin_nextafter(__x, __y); }
3202 
3203  constexpr _Float64
3204  remainder(_Float64 __x, _Float64 __y)
3205  { return __builtin_remainder(__x, __y); }
3206 
3207  inline _Float64
3208  remquo(_Float64 __x, _Float64 __y, int* __pquo)
3209  { return __builtin_remquo(__x, __y, __pquo); }
3210 
3211  constexpr _Float64
3212  rint(_Float64 __x)
3213  { return __builtin_rint(__x); }
3214 
3215  constexpr _Float64
3216  round(_Float64 __x)
3217  { return __builtin_round(__x); }
3218 
3219  constexpr _Float64
3220  scalbln(_Float64 __x, long __ex)
3221  { return __builtin_scalbln(__x, __ex); }
3222 
3223  constexpr _Float64
3224  scalbn(_Float64 __x, int __ex)
3225  { return __builtin_scalbn(__x, __ex); }
3226 
3227  constexpr _Float64
3228  tgamma(_Float64 __x)
3229  { return __builtin_tgamma(__x); }
3230 
3231  constexpr _Float64
3232  trunc(_Float64 __x)
3233  { return __builtin_trunc(__x); }
3234 #endif
3235 
3236 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
3237  constexpr _Float128
3238  acosh(_Float128 __x)
3239  { return __builtin_acoshl(__x); }
3240 
3241  constexpr _Float128
3242  asinh(_Float128 __x)
3243  { return __builtin_asinhl(__x); }
3244 
3245  constexpr _Float128
3246  atanh(_Float128 __x)
3247  { return __builtin_atanhl(__x); }
3248 
3249  constexpr _Float128
3250  cbrt(_Float128 __x)
3251  { return __builtin_cbrtl(__x); }
3252 
3253  constexpr _Float128
3254  copysign(_Float128 __x, _Float128 __y)
3255  { return __builtin_copysignl(__x, __y); }
3256 
3257  constexpr _Float128
3258  erf(_Float128 __x)
3259  { return __builtin_erfl(__x); }
3260 
3261  constexpr _Float128
3262  erfc(_Float128 __x)
3263  { return __builtin_erfcl(__x); }
3264 
3265  constexpr _Float128
3266  exp2(_Float128 __x)
3267  { return __builtin_exp2l(__x); }
3268 
3269  constexpr _Float128
3270  expm1(_Float128 __x)
3271  { return __builtin_expm1l(__x); }
3272 
3273  constexpr _Float128
3274  fdim(_Float128 __x, _Float128 __y)
3275  { return __builtin_fdiml(__x, __y); }
3276 
3277  constexpr _Float128
3278  fma(_Float128 __x, _Float128 __y, _Float128 __z)
3279  { return __builtin_fmal(__x, __y, __z); }
3280 
3281  constexpr _Float128
3282  fmax(_Float128 __x, _Float128 __y)
3283  { return __builtin_fmaxl(__x, __y); }
3284 
3285  constexpr _Float128
3286  fmin(_Float128 __x, _Float128 __y)
3287  { return __builtin_fminl(__x, __y); }
3288 
3289  constexpr _Float128
3290  hypot(_Float128 __x, _Float128 __y)
3291  { return __builtin_hypotl(__x, __y); }
3292 
3293  constexpr int
3294  ilogb(_Float128 __x)
3295  { return __builtin_ilogbl(__x); }
3296 
3297  constexpr _Float128
3298  lgamma(_Float128 __x)
3299  { return __builtin_lgammal(__x); }
3300 
3301  constexpr long long
3302  llrint(_Float128 __x)
3303  { return __builtin_llrintl(__x); }
3304 
3305  constexpr long long
3306  llround(_Float128 __x)
3307  { return __builtin_llroundl(__x); }
3308 
3309  constexpr _Float128
3310  log1p(_Float128 __x)
3311  { return __builtin_log1pl(__x); }
3312 
3313  // DR 568.
3314  constexpr _Float128
3315  log2(_Float128 __x)
3316  { return __builtin_log2l(__x); }
3317 
3318  constexpr _Float128
3319  logb(_Float128 __x)
3320  { return __builtin_logbl(__x); }
3321 
3322  constexpr long
3323  lrint(_Float128 __x)
3324  { return __builtin_lrintl(__x); }
3325 
3326  constexpr long
3327  lround(_Float128 __x)
3328  { return __builtin_lroundl(__x); }
3329 
3330  constexpr _Float128
3331  nearbyint(_Float128 __x)
3332  { return __builtin_nearbyintl(__x); }
3333 
3334  constexpr _Float128
3335  nextafter(_Float128 __x, _Float128 __y)
3336  { return __builtin_nextafterl(__x, __y); }
3337 
3338  constexpr _Float128
3339  remainder(_Float128 __x, _Float128 __y)
3340  { return __builtin_remainderl(__x, __y); }
3341 
3342  inline _Float128
3343  remquo(_Float128 __x, _Float128 __y, int* __pquo)
3344  { return __builtin_remquol(__x, __y, __pquo); }
3345 
3346  constexpr _Float128
3347  rint(_Float128 __x)
3348  { return __builtin_rintl(__x); }
3349 
3350  constexpr _Float128
3351  round(_Float128 __x)
3352  { return __builtin_roundl(__x); }
3353 
3354  constexpr _Float128
3355  scalbln(_Float128 __x, long __ex)
3356  { return __builtin_scalblnl(__x, __ex); }
3357 
3358  constexpr _Float128
3359  scalbn(_Float128 __x, int __ex)
3360  { return __builtin_scalbnl(__x, __ex); }
3361 
3362  constexpr _Float128
3363  tgamma(_Float128 __x)
3364  { return __builtin_tgammal(__x); }
3365 
3366  constexpr _Float128
3367  trunc(_Float128 __x)
3368  { return __builtin_truncl(__x); }
3369 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
3370  constexpr _Float128
3371  acosh(_Float128 __x)
3372  { return __builtin_acoshf128(__x); }
3373 
3374  constexpr _Float128
3375  asinh(_Float128 __x)
3376  { return __builtin_asinhf128(__x); }
3377 
3378  constexpr _Float128
3379  atanh(_Float128 __x)
3380  { return __builtin_atanhf128(__x); }
3381 
3382  constexpr _Float128
3383  cbrt(_Float128 __x)
3384  { return __builtin_cbrtf128(__x); }
3385 
3386  constexpr _Float128
3387  copysign(_Float128 __x, _Float128 __y)
3388  { return __builtin_copysignf128(__x, __y); }
3389 
3390  constexpr _Float128
3391  erf(_Float128 __x)
3392  { return __builtin_erff128(__x); }
3393 
3394  constexpr _Float128
3395  erfc(_Float128 __x)
3396  { return __builtin_erfcf128(__x); }
3397 
3398  constexpr _Float128
3399  exp2(_Float128 __x)
3400  { return __builtin_exp2f128(__x); }
3401 
3402  constexpr _Float128
3403  expm1(_Float128 __x)
3404  { return __builtin_expm1f128(__x); }
3405 
3406  constexpr _Float128
3407  fdim(_Float128 __x, _Float128 __y)
3408  { return __builtin_fdimf128(__x, __y); }
3409 
3410  constexpr _Float128
3411  fma(_Float128 __x, _Float128 __y, _Float128 __z)
3412  { return __builtin_fmaf128(__x, __y, __z); }
3413 
3414  constexpr _Float128
3415  fmax(_Float128 __x, _Float128 __y)
3416  { return __builtin_fmaxf128(__x, __y); }
3417 
3418  constexpr _Float128
3419  fmin(_Float128 __x, _Float128 __y)
3420  { return __builtin_fminf128(__x, __y); }
3421 
3422  constexpr _Float128
3423  hypot(_Float128 __x, _Float128 __y)
3424  { return __builtin_hypotf128(__x, __y); }
3425 
3426  constexpr int
3427  ilogb(_Float128 __x)
3428  { return __builtin_ilogbf128(__x); }
3429 
3430  constexpr _Float128
3431  lgamma(_Float128 __x)
3432  { return __builtin_lgammaf128(__x); }
3433 
3434  constexpr long long
3435  llrint(_Float128 __x)
3436  { return __builtin_llrintf128(__x); }
3437 
3438  constexpr long long
3439  llround(_Float128 __x)
3440  { return __builtin_llroundf128(__x); }
3441 
3442  constexpr _Float128
3443  log1p(_Float128 __x)
3444  { return __builtin_log1pf128(__x); }
3445 
3446  // DR 568.
3447  constexpr _Float128
3448  log2(_Float128 __x)
3449  { return __builtin_log2f128(__x); }
3450 
3451  constexpr _Float128
3452  logb(_Float128 __x)
3453  { return __builtin_logbf128(__x); }
3454 
3455  constexpr long
3456  lrint(_Float128 __x)
3457  { return __builtin_lrintf128(__x); }
3458 
3459  constexpr long
3460  lround(_Float128 __x)
3461  { return __builtin_lroundf128(__x); }
3462 
3463  constexpr _Float128
3464  nearbyint(_Float128 __x)
3465  { return __builtin_nearbyintf128(__x); }
3466 
3467  constexpr _Float128
3468  nextafter(_Float128 __x, _Float128 __y)
3469  { return __builtin_nextafterf128(__x, __y); }
3470 
3471  constexpr _Float128
3472  remainder(_Float128 __x, _Float128 __y)
3473  { return __builtin_remainderf128(__x, __y); }
3474 
3475  inline _Float128
3476  remquo(_Float128 __x, _Float128 __y, int* __pquo)
3477  { return __builtin_remquof128(__x, __y, __pquo); }
3478 
3479  constexpr _Float128
3480  rint(_Float128 __x)
3481  { return __builtin_rintf128(__x); }
3482 
3483  constexpr _Float128
3484  round(_Float128 __x)
3485  { return __builtin_roundf128(__x); }
3486 
3487  constexpr _Float128
3488  scalbln(_Float128 __x, long __ex)
3489  { return __builtin_scalblnf128(__x, __ex); }
3490 
3491  constexpr _Float128
3492  scalbn(_Float128 __x, int __ex)
3493  { return __builtin_scalbnf128(__x, __ex); }
3494 
3495  constexpr _Float128
3496  tgamma(_Float128 __x)
3497  { return __builtin_tgammaf128(__x); }
3498 
3499  constexpr _Float128
3500  trunc(_Float128 __x)
3501  { return __builtin_truncf128(__x); }
3502 #endif
3503 
3504 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3505  constexpr __gnu_cxx::__bfloat16_t
3506  acosh(__gnu_cxx::__bfloat16_t __x)
3507  { return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); }
3508 
3509  constexpr __gnu_cxx::__bfloat16_t
3510  asinh(__gnu_cxx::__bfloat16_t __x)
3511  { return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); }
3512 
3513  constexpr __gnu_cxx::__bfloat16_t
3514  atanh(__gnu_cxx::__bfloat16_t __x)
3515  { return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); }
3516 
3517  constexpr __gnu_cxx::__bfloat16_t
3518  cbrt(__gnu_cxx::__bfloat16_t __x)
3519  { return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); }
3520 
3521  constexpr __gnu_cxx::__bfloat16_t
3522  copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3523  { return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); }
3524 
3525  constexpr __gnu_cxx::__bfloat16_t
3526  erf(__gnu_cxx::__bfloat16_t __x)
3527  { return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); }
3528 
3529  constexpr __gnu_cxx::__bfloat16_t
3530  erfc(__gnu_cxx::__bfloat16_t __x)
3531  { return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); }
3532 
3533  constexpr __gnu_cxx::__bfloat16_t
3534  exp2(__gnu_cxx::__bfloat16_t __x)
3535  { return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); }
3536 
3537  constexpr __gnu_cxx::__bfloat16_t
3538  expm1(__gnu_cxx::__bfloat16_t __x)
3539  { return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); }
3540 
3541  constexpr __gnu_cxx::__bfloat16_t
3542  fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3543  { return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); }
3544 
3545  constexpr __gnu_cxx::__bfloat16_t
3546  fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3547  { return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); }
3548 
3549  constexpr __gnu_cxx::__bfloat16_t
3550  fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3551  { return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); }
3552 
3553  constexpr __gnu_cxx::__bfloat16_t
3554  fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3555  { return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); }
3556 
3557  constexpr __gnu_cxx::__bfloat16_t
3558  hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3559  { return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); }
3560 
3561  constexpr int
3562  ilogb(__gnu_cxx::__bfloat16_t __x)
3563  { return __builtin_ilogbf(__x); }
3564 
3565  constexpr __gnu_cxx::__bfloat16_t
3566  lgamma(__gnu_cxx::__bfloat16_t __x)
3567  { return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); }
3568 
3569  constexpr long long
3570  llrint(__gnu_cxx::__bfloat16_t __x)
3571  { return __builtin_llrintf(__x); }
3572 
3573  constexpr long long
3574  llround(__gnu_cxx::__bfloat16_t __x)
3575  { return __builtin_llroundf(__x); }
3576 
3577  constexpr __gnu_cxx::__bfloat16_t
3578  log1p(__gnu_cxx::__bfloat16_t __x)
3579  { return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); }
3580 
3581  // DR 568.
3582  constexpr __gnu_cxx::__bfloat16_t
3583  log2(__gnu_cxx::__bfloat16_t __x)
3584  { return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); }
3585 
3586  constexpr __gnu_cxx::__bfloat16_t
3587  logb(__gnu_cxx::__bfloat16_t __x)
3588  { return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); }
3589 
3590  constexpr long
3591  lrint(__gnu_cxx::__bfloat16_t __x)
3592  { return __builtin_lrintf(__x); }
3593 
3594  constexpr long
3595  lround(__gnu_cxx::__bfloat16_t __x)
3596  { return __builtin_lroundf(__x); }
3597 
3598  constexpr __gnu_cxx::__bfloat16_t
3599  nearbyint(__gnu_cxx::__bfloat16_t __x)
3600  { return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); }
3601 
3602  constexpr __gnu_cxx::__bfloat16_t
3603  nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3604  {
3605 #if __cpp_if_consteval >= 202106L
3606  // Can't use if (std::__is_constant_evaluated()) here, as it
3607  // doesn't guarantee optimizing the body away at -O0 and
3608  // nothing defines nextafterf16b.
3609  if consteval { return __builtin_nextafterf16b(__x, __y); }
3610 #endif
3611 #ifdef __INT16_TYPE__
3612  using __bfloat16_int_type = __INT16_TYPE__;
3613 #else
3614  using __bfloat16_int_type = short int;
3615 #endif
3616  __bfloat16_int_type __hx, __hy, __ix, __iy;
3617  __builtin_memcpy(&__hx, &__x, sizeof(__x));
3618  __builtin_memcpy(&__hy, &__y, sizeof(__x));
3619  __ix = __hx & 0x7fff; // |x|
3620  __iy = __hy & 0x7fff; // |y|
3621  if (__ix > 0x7f80 || __iy > 0x7f80) // x or y is NaN
3622  return __x + __y;
3623  if (__x == __y)
3624  return __y; // x == y, return y
3625  if (__ix == 0) // x == 0
3626  {
3627  __hy = (__hy & 0x8000) | 1; // return +-__BFLT16_DENORM_MIN__
3628  __builtin_memcpy(&__x, &__hy, sizeof(__x));
3629  __builtin_nextafterf(0.0f, 1.0f); // raise underflow
3630  return __x;
3631  }
3632  if (__hx >= 0) // x > 0
3633  {
3634  if (__hx > __hy) // x > y, x -= ulp
3635  --__hx;
3636  else // x < y, x += ulp
3637  ++__hx;
3638  }
3639  else // x < 0
3640  {
3641  if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp
3642  --__hx;
3643  else // x > y, x += ulp
3644  ++__hx;
3645  }
3646  __hy = __hx & 0x7f80;
3647  if (__hy >= 0x7f80)
3648  __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow
3649  else if (__hy < 0x0080)
3650  __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow
3651  __builtin_memcpy(&__x, &__hx, sizeof(__x));
3652  return __x;
3653  }
3654 
3655  constexpr __gnu_cxx::__bfloat16_t
3656  remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3657  { return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); }
3658 
3659  inline __gnu_cxx::__bfloat16_t
3660  remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, int* __pquo)
3661  { return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); }
3662 
3663  constexpr __gnu_cxx::__bfloat16_t
3664  rint(__gnu_cxx::__bfloat16_t __x)
3665  { return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); }
3666 
3667  constexpr __gnu_cxx::__bfloat16_t
3668  round(__gnu_cxx::__bfloat16_t __x)
3669  { return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); }
3670 
3671  constexpr __gnu_cxx::__bfloat16_t
3672  scalbln(__gnu_cxx::__bfloat16_t __x, long __ex)
3673  { return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); }
3674 
3675  constexpr __gnu_cxx::__bfloat16_t
3676  scalbn(__gnu_cxx::__bfloat16_t __x, int __ex)
3677  { return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); }
3678 
3679  constexpr __gnu_cxx::__bfloat16_t
3680  tgamma(__gnu_cxx::__bfloat16_t __x)
3681  { return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); }
3682 
3683  constexpr __gnu_cxx::__bfloat16_t
3684  trunc(__gnu_cxx::__bfloat16_t __x)
3685  { return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); }
3686 #endif
3687 
3688 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
3689  template<typename _Tp, typename _Up>
3690  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3691  copysign(_Tp __x, _Up __y)
3692  {
3693  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3694  return copysign(__type(__x), __type(__y));
3695  }
3696 
3697  template<typename _Tp, typename _Up>
3698  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3699  fdim(_Tp __x, _Up __y)
3700  {
3701  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3702  return fdim(__type(__x), __type(__y));
3703  }
3704 
3705  template<typename _Tp, typename _Up>
3706  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3707  fmax(_Tp __x, _Up __y)
3708  {
3709  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3710  return fmax(__type(__x), __type(__y));
3711  }
3712 
3713  template<typename _Tp, typename _Up>
3714  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3715  fmin(_Tp __x, _Up __y)
3716  {
3717  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3718  return fmin(__type(__x), __type(__y));
3719  }
3720 
3721  template<typename _Tp, typename _Up>
3722  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3723  hypot(_Tp __x, _Up __y)
3724  {
3725  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3726  return hypot(__type(__x), __type(__y));
3727  }
3728 
3729  template<typename _Tp, typename _Up>
3730  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3731  nextafter(_Tp __x, _Up __y)
3732  {
3733  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3734  return nextafter(__type(__x), __type(__y));
3735  }
3736 
3737  template<typename _Tp, typename _Up>
3738  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3739  remainder(_Tp __x, _Up __y)
3740  {
3741  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3742  return remainder(__type(__x), __type(__y));
3743  }
3744 
3745  template<typename _Tp, typename _Up>
3746  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3747  remquo(_Tp __x, _Up __y, int* __pquo)
3748  {
3749  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3750  return remquo(__type(__x), __type(__y), __pquo);
3751  }
3752 
3753  template<typename _Tp, typename _Up, typename _Vp>
3754  constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
3755  fma(_Tp __x, _Up __y, _Vp __z)
3756  {
3757  typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
3758  return fma(__type(__x), __type(__y), __type(__z));
3759  }
3760 #endif
3761 
3762 #endif // _GLIBCXX_USE_C99_MATH_FUNCS
3763 #endif // C++11
3764 
3765 #ifdef __cpp_lib_hypot // C++ >= 17 && HOSTED
3766  // [c.math.hypot3], three-dimensional hypotenuse
3767  template<typename _Tp>
3768  inline _Tp
3769  __hypot3(_Tp __x, _Tp __y, _Tp __z)
3770  {
3771  __x = std::abs(__x);
3772  __y = std::abs(__y);
3773  __z = std::abs(__z);
3774  if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
3775  return __a * std::sqrt((__x / __a) * (__x / __a)
3776  + (__y / __a) * (__y / __a)
3777  + (__z / __a) * (__z / __a));
3778  else
3779  return {};
3780  }
3781 
3782  inline float
3783  hypot(float __x, float __y, float __z)
3784  { return std::__hypot3<float>(__x, __y, __z); }
3785 
3786  inline double
3787  hypot(double __x, double __y, double __z)
3788  { return std::__hypot3<double>(__x, __y, __z); }
3789 
3790  inline long double
3791  hypot(long double __x, long double __y, long double __z)
3792  { return std::__hypot3<long double>(__x, __y, __z); }
3793 
3794  template<typename _Tp, typename _Up, typename _Vp>
3795  __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3796  hypot(_Tp __x, _Up __y, _Vp __z)
3797  {
3798  using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3799  return std::__hypot3<__type>(__x, __y, __z);
3800  }
3801 
3802 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3803  inline _Float16
3804  hypot(_Float16 __x, _Float16 __y, _Float16 __z)
3805  { return std::__hypot3<_Float16>(__x, __y, __z); }
3806 #endif
3807 
3808 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3809  inline _Float32
3810  hypot(_Float32 __x, _Float32 __y, _Float32 __z)
3811  { return std::__hypot3<_Float32>(__x, __y, __z); }
3812 #endif
3813 
3814 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3815  inline _Float64
3816  hypot(_Float64 __x, _Float64 __y, _Float64 __z)
3817  { return std::__hypot3<_Float64>(__x, __y, __z); }
3818 #endif
3819 
3820 #if defined(__STDCPP_FLOAT128_T__) \
3821  && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3822  || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3823  inline _Float128
3824  hypot(_Float128 __x, _Float128 __y, _Float128 __z)
3825  { return std::__hypot3<_Float128>(__x, __y, __z); }
3826 #endif
3827 
3828 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3829  inline __gnu_cxx::__bfloat16_t
3830  hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3831  { return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3832 #endif
3833 
3834 #endif // __cpp_lib_hypot
3835 
3836 #ifdef __cpp_lib_interpolate // C++ >= 20
3837  // linear interpolation
3838  template<typename _Fp>
3839  constexpr _Fp
3840  __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
3841  {
3842  if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
3843  return __t * __b + (1 - __t) * __a;
3844 
3845  if (__t == 1)
3846  return __b; // exact
3847 
3848  // Exact at __t=0, monotonic except near __t=1,
3849  // bounded, determinate, and consistent:
3850  const _Fp __x = __a + __t * (__b - __a);
3851  return (__t > 1) == (__b > __a)
3852  ? (__b < __x ? __x : __b)
3853  : (__b > __x ? __x : __b); // monotonic near __t=1
3854  }
3855 
3856  constexpr float
3857  lerp(float __a, float __b, float __t) noexcept
3858  { return std::__lerp(__a, __b, __t); }
3859 
3860  constexpr double
3861  lerp(double __a, double __b, double __t) noexcept
3862  { return std::__lerp(__a, __b, __t); }
3863 
3864  constexpr long double
3865  lerp(long double __a, long double __b, long double __t) noexcept
3866  { return std::__lerp(__a, __b, __t); }
3867 
3868  template<typename _Tp, typename _Up, typename _Vp>
3869  constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3870  lerp(_Tp __x, _Up __y, _Vp __z) noexcept
3871  {
3872  using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3873  return std::__lerp<__type>(__x, __y, __z);
3874  }
3875 
3876 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3877  inline _Float16
3878  lerp(_Float16 __x, _Float16 __y, _Float16 __z) noexcept
3879  { return std::__lerp<_Float16>(__x, __y, __z); }
3880 #endif
3881 
3882 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3883  inline _Float32
3884  lerp(_Float32 __x, _Float32 __y, _Float32 __z) noexcept
3885  { return std::__lerp<_Float32>(__x, __y, __z); }
3886 #endif
3887 
3888 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3889  inline _Float64
3890  lerp(_Float64 __x, _Float64 __y, _Float64 __z) noexcept
3891  { return std::__lerp<_Float64>(__x, __y, __z); }
3892 #endif
3893 
3894 #if defined(__STDCPP_FLOAT128_T__) \
3895  && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3896  || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3897  inline _Float128
3898  lerp(_Float128 __x, _Float128 __y, _Float128 __z) noexcept
3899  { return std::__lerp<_Float128>(__x, __y, __z); }
3900 #endif
3901 
3902 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3903  inline __gnu_cxx::__bfloat16_t
3904  lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) noexcept
3905  { return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3906 #endif
3907 #endif // __cpp_lib_interpolate
3908 
3909 _GLIBCXX_END_NAMESPACE_VERSION
3910 } // namespace
3911 
3912 #if _GLIBCXX_USE_STD_SPEC_FUNCS
3913 # include <bits/specfun.h>
3914 #endif
3915 
3916 } // extern "C++"
3917 
3918 #endif