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