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 _Float16(__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 _Float16(__builtin_llrintf(__x)); }
2843 
2844  constexpr long long
2845  llround(_Float16 __x)
2846  { return _Float16(__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 _Float16(__builtin_lrintf(__x)); }
2864 
2865  constexpr long
2866  lround(_Float16 __x)
2867  { return _Float16(__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 (std::__is_constant_evaluated())
2877  return __builtin_nextafterf16(__x, __y);
2878 #ifdef __INT16_TYPE__
2879  using __float16_int_type = __INT16_TYPE__;
2880 #else
2881  using __float16_int_type = short int;
2882 #endif
2883  __float16_int_type __hx, __hy, __ix, __iy;
2884  __builtin_memcpy(&__hx, &__x, sizeof(__x));
2885  __builtin_memcpy(&__hy, &__y, sizeof(__x));
2886  __ix = __hx & 0x7fff; // |x|
2887  __iy = __hy & 0x7fff; // |y|
2888  if (__ix > 0x7c00 || __iy > 0x7c00) // x or y is NaN
2889  return __x + __y;
2890  if (__x == __y)
2891  return __y; // x == y, return y
2892  if (__ix == 0) // x == 0
2893  {
2894  __hy = (__hy & 0x8000) | 1; // return +-__FLT16_DENORM_MIN__
2895  __builtin_memcpy(&__x, &__hy, sizeof(__x));
2896  __builtin_nextafterf(0.0f, 1.0f); // raise underflow
2897  return __x;
2898  }
2899  if (__hx >= 0) // x > 0
2900  {
2901  if (__hx > __hy) // x > y, x -= ulp
2902  --__hx;
2903  else // x < y, x += ulp
2904  ++__hx;
2905  }
2906  else // x < 0
2907  {
2908  if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp
2909  --__hx;
2910  else // x > y, x += ulp
2911  ++__hx;
2912  }
2913  __hy = __hx & 0x7c00;
2914  if (__hy >= 0x7c00)
2915  __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow
2916  else if (__hy < 0x0400)
2917  __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow
2918  __builtin_memcpy(&__x, &__hx, sizeof(__x));
2919  return __x;
2920  }
2921 
2922  constexpr _Float16
2923  remainder(_Float16 __x, _Float16 __y)
2924  { return _Float16(__builtin_remainderf(__x, __y)); }
2925 
2926  inline _Float16
2927  remquo(_Float16 __x, _Float16 __y, int* __pquo)
2928  { return _Float16(__builtin_remquof(__x, __y, __pquo)); }
2929 
2930  constexpr _Float16
2931  rint(_Float16 __x)
2932  { return _Float16(__builtin_rintf(__x)); }
2933 
2934  constexpr _Float16
2935  round(_Float16 __x)
2936  { return _Float16(__builtin_roundf(__x)); }
2937 
2938  constexpr _Float16
2939  scalbln(_Float16 __x, long __ex)
2940  { return _Float16(__builtin_scalblnf(__x, __ex)); }
2941 
2942  constexpr _Float16
2943  scalbn(_Float16 __x, int __ex)
2944  { return _Float16(__builtin_scalbnf(__x, __ex)); }
2945 
2946  constexpr _Float16
2947  tgamma(_Float16 __x)
2948  { return _Float16(__builtin_tgammaf(__x)); }
2949 
2950  constexpr _Float16
2951  trunc(_Float16 __x)
2952  { return _Float16(__builtin_truncf(__x)); }
2953 #endif
2954 
2955 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2956  constexpr _Float32
2957  acosh(_Float32 __x)
2958  { return __builtin_acoshf(__x); }
2959 
2960  constexpr _Float32
2961  asinh(_Float32 __x)
2962  { return __builtin_asinhf(__x); }
2963 
2964  constexpr _Float32
2965  atanh(_Float32 __x)
2966  { return __builtin_atanhf(__x); }
2967 
2968  constexpr _Float32
2969  cbrt(_Float32 __x)
2970  { return __builtin_cbrtf(__x); }
2971 
2972  constexpr _Float32
2973  copysign(_Float32 __x, _Float32 __y)
2974  { return __builtin_copysignf(__x, __y); }
2975 
2976  constexpr _Float32
2977  erf(_Float32 __x)
2978  { return __builtin_erff(__x); }
2979 
2980  constexpr _Float32
2981  erfc(_Float32 __x)
2982  { return __builtin_erfcf(__x); }
2983 
2984  constexpr _Float32
2985  exp2(_Float32 __x)
2986  { return __builtin_exp2f(__x); }
2987 
2988  constexpr _Float32
2989  expm1(_Float32 __x)
2990  { return __builtin_expm1f(__x); }
2991 
2992  constexpr _Float32
2993  fdim(_Float32 __x, _Float32 __y)
2994  { return __builtin_fdimf(__x, __y); }
2995 
2996  constexpr _Float32
2997  fma(_Float32 __x, _Float32 __y, _Float32 __z)
2998  { return __builtin_fmaf(__x, __y, __z); }
2999 
3000  constexpr _Float32
3001  fmax(_Float32 __x, _Float32 __y)
3002  { return __builtin_fmaxf(__x, __y); }
3003 
3004  constexpr _Float32
3005  fmin(_Float32 __x, _Float32 __y)
3006  { return __builtin_fminf(__x, __y); }
3007 
3008  constexpr _Float32
3009  hypot(_Float32 __x, _Float32 __y)
3010  { return __builtin_hypotf(__x, __y); }
3011 
3012  constexpr int
3013  ilogb(_Float32 __x)
3014  { return __builtin_ilogbf(__x); }
3015 
3016  constexpr _Float32
3017  lgamma(_Float32 __x)
3018  { return __builtin_lgammaf(__x); }
3019 
3020  constexpr long long
3021  llrint(_Float32 __x)
3022  { return __builtin_llrintf(__x); }
3023 
3024  constexpr long long
3025  llround(_Float32 __x)
3026  { return __builtin_llroundf(__x); }
3027 
3028  constexpr _Float32
3029  log1p(_Float32 __x)
3030  { return __builtin_log1pf(__x); }
3031 
3032  // DR 568.
3033  constexpr _Float32
3034  log2(_Float32 __x)
3035  { return __builtin_log2f(__x); }
3036 
3037  constexpr _Float32
3038  logb(_Float32 __x)
3039  { return __builtin_logbf(__x); }
3040 
3041  constexpr long
3042  lrint(_Float32 __x)
3043  { return __builtin_lrintf(__x); }
3044 
3045  constexpr long
3046  lround(_Float32 __x)
3047  { return __builtin_lroundf(__x); }
3048 
3049  constexpr _Float32
3050  nearbyint(_Float32 __x)
3051  { return __builtin_nearbyintf(__x); }
3052 
3053  constexpr _Float32
3054  nextafter(_Float32 __x, _Float32 __y)
3055  { return __builtin_nextafterf(__x, __y); }
3056 
3057  constexpr _Float32
3058  remainder(_Float32 __x, _Float32 __y)
3059  { return __builtin_remainderf(__x, __y); }
3060 
3061  inline _Float32
3062  remquo(_Float32 __x, _Float32 __y, int* __pquo)
3063  { return __builtin_remquof(__x, __y, __pquo); }
3064 
3065  constexpr _Float32
3066  rint(_Float32 __x)
3067  { return __builtin_rintf(__x); }
3068 
3069  constexpr _Float32
3070  round(_Float32 __x)
3071  { return __builtin_roundf(__x); }
3072 
3073  constexpr _Float32
3074  scalbln(_Float32 __x, long __ex)
3075  { return __builtin_scalblnf(__x, __ex); }
3076 
3077  constexpr _Float32
3078  scalbn(_Float32 __x, int __ex)
3079  { return __builtin_scalbnf(__x, __ex); }
3080 
3081  constexpr _Float32
3082  tgamma(_Float32 __x)
3083  { return __builtin_tgammaf(__x); }
3084 
3085  constexpr _Float32
3086  trunc(_Float32 __x)
3087  { return __builtin_truncf(__x); }
3088 #endif
3089 
3090 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3091  constexpr _Float64
3092  acosh(_Float64 __x)
3093  { return __builtin_acosh(__x); }
3094 
3095  constexpr _Float64
3096  asinh(_Float64 __x)
3097  { return __builtin_asinh(__x); }
3098 
3099  constexpr _Float64
3100  atanh(_Float64 __x)
3101  { return __builtin_atanh(__x); }
3102 
3103  constexpr _Float64
3104  cbrt(_Float64 __x)
3105  { return __builtin_cbrt(__x); }
3106 
3107  constexpr _Float64
3108  copysign(_Float64 __x, _Float64 __y)
3109  { return __builtin_copysign(__x, __y); }
3110 
3111  constexpr _Float64
3112  erf(_Float64 __x)
3113  { return __builtin_erf(__x); }
3114 
3115  constexpr _Float64
3116  erfc(_Float64 __x)
3117  { return __builtin_erfc(__x); }
3118 
3119  constexpr _Float64
3120  exp2(_Float64 __x)
3121  { return __builtin_exp2(__x); }
3122 
3123  constexpr _Float64
3124  expm1(_Float64 __x)
3125  { return __builtin_expm1(__x); }
3126 
3127  constexpr _Float64
3128  fdim(_Float64 __x, _Float64 __y)
3129  { return __builtin_fdim(__x, __y); }
3130 
3131  constexpr _Float64
3132  fma(_Float64 __x, _Float64 __y, _Float64 __z)
3133  { return __builtin_fma(__x, __y, __z); }
3134 
3135  constexpr _Float64
3136  fmax(_Float64 __x, _Float64 __y)
3137  { return __builtin_fmax(__x, __y); }
3138 
3139  constexpr _Float64
3140  fmin(_Float64 __x, _Float64 __y)
3141  { return __builtin_fmin(__x, __y); }
3142 
3143  constexpr _Float64
3144  hypot(_Float64 __x, _Float64 __y)
3145  { return __builtin_hypot(__x, __y); }
3146 
3147  constexpr int
3148  ilogb(_Float64 __x)
3149  { return __builtin_ilogb(__x); }
3150 
3151  constexpr _Float64
3152  lgamma(_Float64 __x)
3153  { return __builtin_lgamma(__x); }
3154 
3155  constexpr long long
3156  llrint(_Float64 __x)
3157  { return __builtin_llrint(__x); }
3158 
3159  constexpr long long
3160  llround(_Float64 __x)
3161  { return __builtin_llround(__x); }
3162 
3163  constexpr _Float64
3164  log1p(_Float64 __x)
3165  { return __builtin_log1p(__x); }
3166 
3167  // DR 568.
3168  constexpr _Float64
3169  log2(_Float64 __x)
3170  { return __builtin_log2(__x); }
3171 
3172  constexpr _Float64
3173  logb(_Float64 __x)
3174  { return __builtin_logb(__x); }
3175 
3176  constexpr long
3177  lrint(_Float64 __x)
3178  { return __builtin_lrint(__x); }
3179 
3180  constexpr long
3181  lround(_Float64 __x)
3182  { return __builtin_lround(__x); }
3183 
3184  constexpr _Float64
3185  nearbyint(_Float64 __x)
3186  { return __builtin_nearbyint(__x); }
3187 
3188  constexpr _Float64
3189  nextafter(_Float64 __x, _Float64 __y)
3190  { return __builtin_nextafter(__x, __y); }
3191 
3192  constexpr _Float64
3193  remainder(_Float64 __x, _Float64 __y)
3194  { return __builtin_remainder(__x, __y); }
3195 
3196  inline _Float64
3197  remquo(_Float64 __x, _Float64 __y, int* __pquo)
3198  { return __builtin_remquo(__x, __y, __pquo); }
3199 
3200  constexpr _Float64
3201  rint(_Float64 __x)
3202  { return __builtin_rint(__x); }
3203 
3204  constexpr _Float64
3205  round(_Float64 __x)
3206  { return __builtin_round(__x); }
3207 
3208  constexpr _Float64
3209  scalbln(_Float64 __x, long __ex)
3210  { return __builtin_scalbln(__x, __ex); }
3211 
3212  constexpr _Float64
3213  scalbn(_Float64 __x, int __ex)
3214  { return __builtin_scalbn(__x, __ex); }
3215 
3216  constexpr _Float64
3217  tgamma(_Float64 __x)
3218  { return __builtin_tgamma(__x); }
3219 
3220  constexpr _Float64
3221  trunc(_Float64 __x)
3222  { return __builtin_trunc(__x); }
3223 #endif
3224 
3225 #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
3226  constexpr _Float128
3227  acosh(_Float128 __x)
3228  { return __builtin_acoshl(__x); }
3229 
3230  constexpr _Float128
3231  asinh(_Float128 __x)
3232  { return __builtin_asinhl(__x); }
3233 
3234  constexpr _Float128
3235  atanh(_Float128 __x)
3236  { return __builtin_atanhl(__x); }
3237 
3238  constexpr _Float128
3239  cbrt(_Float128 __x)
3240  { return __builtin_cbrtl(__x); }
3241 
3242  constexpr _Float128
3243  copysign(_Float128 __x, _Float128 __y)
3244  { return __builtin_copysignl(__x, __y); }
3245 
3246  constexpr _Float128
3247  erf(_Float128 __x)
3248  { return __builtin_erfl(__x); }
3249 
3250  constexpr _Float128
3251  erfc(_Float128 __x)
3252  { return __builtin_erfcl(__x); }
3253 
3254  constexpr _Float128
3255  exp2(_Float128 __x)
3256  { return __builtin_exp2l(__x); }
3257 
3258  constexpr _Float128
3259  expm1(_Float128 __x)
3260  { return __builtin_expm1l(__x); }
3261 
3262  constexpr _Float128
3263  fdim(_Float128 __x, _Float128 __y)
3264  { return __builtin_fdiml(__x, __y); }
3265 
3266  constexpr _Float128
3267  fma(_Float128 __x, _Float128 __y, _Float128 __z)
3268  { return __builtin_fmal(__x, __y, __z); }
3269 
3270  constexpr _Float128
3271  fmax(_Float128 __x, _Float128 __y)
3272  { return __builtin_fmaxl(__x, __y); }
3273 
3274  constexpr _Float128
3275  fmin(_Float128 __x, _Float128 __y)
3276  { return __builtin_fminl(__x, __y); }
3277 
3278  constexpr _Float128
3279  hypot(_Float128 __x, _Float128 __y)
3280  { return __builtin_hypotl(__x, __y); }
3281 
3282  constexpr int
3283  ilogb(_Float128 __x)
3284  { return __builtin_ilogbl(__x); }
3285 
3286  constexpr _Float128
3287  lgamma(_Float128 __x)
3288  { return __builtin_lgammal(__x); }
3289 
3290  constexpr long long
3291  llrint(_Float128 __x)
3292  { return __builtin_llrintl(__x); }
3293 
3294  constexpr long long
3295  llround(_Float128 __x)
3296  { return __builtin_llroundl(__x); }
3297 
3298  constexpr _Float128
3299  log1p(_Float128 __x)
3300  { return __builtin_log1pl(__x); }
3301 
3302  // DR 568.
3303  constexpr _Float128
3304  log2(_Float128 __x)
3305  { return __builtin_log2l(__x); }
3306 
3307  constexpr _Float128
3308  logb(_Float128 __x)
3309  { return __builtin_logbl(__x); }
3310 
3311  constexpr long
3312  lrint(_Float128 __x)
3313  { return __builtin_lrintl(__x); }
3314 
3315  constexpr long
3316  lround(_Float128 __x)
3317  { return __builtin_lroundl(__x); }
3318 
3319  constexpr _Float128
3320  nearbyint(_Float128 __x)
3321  { return __builtin_nearbyintl(__x); }
3322 
3323  constexpr _Float128
3324  nextafter(_Float128 __x, _Float128 __y)
3325  { return __builtin_nextafterl(__x, __y); }
3326 
3327  constexpr _Float128
3328  remainder(_Float128 __x, _Float128 __y)
3329  { return __builtin_remainderl(__x, __y); }
3330 
3331  inline _Float128
3332  remquo(_Float128 __x, _Float128 __y, int* __pquo)
3333  { return __builtin_remquol(__x, __y, __pquo); }
3334 
3335  constexpr _Float128
3336  rint(_Float128 __x)
3337  { return __builtin_rintl(__x); }
3338 
3339  constexpr _Float128
3340  round(_Float128 __x)
3341  { return __builtin_roundl(__x); }
3342 
3343  constexpr _Float128
3344  scalbln(_Float128 __x, long __ex)
3345  { return __builtin_scalblnl(__x, __ex); }
3346 
3347  constexpr _Float128
3348  scalbn(_Float128 __x, int __ex)
3349  { return __builtin_scalbnl(__x, __ex); }
3350 
3351  constexpr _Float128
3352  tgamma(_Float128 __x)
3353  { return __builtin_tgammal(__x); }
3354 
3355  constexpr _Float128
3356  trunc(_Float128 __x)
3357  { return __builtin_truncl(__x); }
3358 #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
3359  constexpr _Float128
3360  acosh(_Float128 __x)
3361  { return __builtin_acoshf128(__x); }
3362 
3363  constexpr _Float128
3364  asinh(_Float128 __x)
3365  { return __builtin_asinhf128(__x); }
3366 
3367  constexpr _Float128
3368  atanh(_Float128 __x)
3369  { return __builtin_atanhf128(__x); }
3370 
3371  constexpr _Float128
3372  cbrt(_Float128 __x)
3373  { return __builtin_cbrtf128(__x); }
3374 
3375  constexpr _Float128
3376  copysign(_Float128 __x, _Float128 __y)
3377  { return __builtin_copysignf128(__x, __y); }
3378 
3379  constexpr _Float128
3380  erf(_Float128 __x)
3381  { return __builtin_erff128(__x); }
3382 
3383  constexpr _Float128
3384  erfc(_Float128 __x)
3385  { return __builtin_erfcf128(__x); }
3386 
3387  constexpr _Float128
3388  exp2(_Float128 __x)
3389  { return __builtin_exp2f128(__x); }
3390 
3391  constexpr _Float128
3392  expm1(_Float128 __x)
3393  { return __builtin_expm1f128(__x); }
3394 
3395  constexpr _Float128
3396  fdim(_Float128 __x, _Float128 __y)
3397  { return __builtin_fdimf128(__x, __y); }
3398 
3399  constexpr _Float128
3400  fma(_Float128 __x, _Float128 __y, _Float128 __z)
3401  { return __builtin_fmaf128(__x, __y, __z); }
3402 
3403  constexpr _Float128
3404  fmax(_Float128 __x, _Float128 __y)
3405  { return __builtin_fmaxf128(__x, __y); }
3406 
3407  constexpr _Float128
3408  fmin(_Float128 __x, _Float128 __y)
3409  { return __builtin_fminf128(__x, __y); }
3410 
3411  constexpr _Float128
3412  hypot(_Float128 __x, _Float128 __y)
3413  { return __builtin_hypotf128(__x, __y); }
3414 
3415  constexpr int
3416  ilogb(_Float128 __x)
3417  { return __builtin_ilogbf128(__x); }
3418 
3419  constexpr _Float128
3420  lgamma(_Float128 __x)
3421  { return __builtin_lgammaf128(__x); }
3422 
3423  constexpr long long
3424  llrint(_Float128 __x)
3425  { return __builtin_llrintf128(__x); }
3426 
3427  constexpr long long
3428  llround(_Float128 __x)
3429  { return __builtin_llroundf128(__x); }
3430 
3431  constexpr _Float128
3432  log1p(_Float128 __x)
3433  { return __builtin_log1pf128(__x); }
3434 
3435  // DR 568.
3436  constexpr _Float128
3437  log2(_Float128 __x)
3438  { return __builtin_log2f128(__x); }
3439 
3440  constexpr _Float128
3441  logb(_Float128 __x)
3442  { return __builtin_logbf128(__x); }
3443 
3444  constexpr long
3445  lrint(_Float128 __x)
3446  { return __builtin_lrintf128(__x); }
3447 
3448  constexpr long
3449  lround(_Float128 __x)
3450  { return __builtin_lroundf128(__x); }
3451 
3452  constexpr _Float128
3453  nearbyint(_Float128 __x)
3454  { return __builtin_nearbyintf128(__x); }
3455 
3456  constexpr _Float128
3457  nextafter(_Float128 __x, _Float128 __y)
3458  { return __builtin_nextafterf128(__x, __y); }
3459 
3460  constexpr _Float128
3461  remainder(_Float128 __x, _Float128 __y)
3462  { return __builtin_remainderf128(__x, __y); }
3463 
3464  inline _Float128
3465  remquo(_Float128 __x, _Float128 __y, int* __pquo)
3466  { return __builtin_remquof128(__x, __y, __pquo); }
3467 
3468  constexpr _Float128
3469  rint(_Float128 __x)
3470  { return __builtin_rintf128(__x); }
3471 
3472  constexpr _Float128
3473  round(_Float128 __x)
3474  { return __builtin_roundf128(__x); }
3475 
3476  constexpr _Float128
3477  scalbln(_Float128 __x, long __ex)
3478  { return __builtin_scalblnf128(__x, __ex); }
3479 
3480  constexpr _Float128
3481  scalbn(_Float128 __x, int __ex)
3482  { return __builtin_scalbnf128(__x, __ex); }
3483 
3484  constexpr _Float128
3485  tgamma(_Float128 __x)
3486  { return __builtin_tgammaf128(__x); }
3487 
3488  constexpr _Float128
3489  trunc(_Float128 __x)
3490  { return __builtin_truncf128(__x); }
3491 #endif
3492 
3493 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3494  constexpr __gnu_cxx::__bfloat16_t
3495  acosh(__gnu_cxx::__bfloat16_t __x)
3496  { return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); }
3497 
3498  constexpr __gnu_cxx::__bfloat16_t
3499  asinh(__gnu_cxx::__bfloat16_t __x)
3500  { return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); }
3501 
3502  constexpr __gnu_cxx::__bfloat16_t
3503  atanh(__gnu_cxx::__bfloat16_t __x)
3504  { return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); }
3505 
3506  constexpr __gnu_cxx::__bfloat16_t
3507  cbrt(__gnu_cxx::__bfloat16_t __x)
3508  { return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); }
3509 
3510  constexpr __gnu_cxx::__bfloat16_t
3511  copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3512  { return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); }
3513 
3514  constexpr __gnu_cxx::__bfloat16_t
3515  erf(__gnu_cxx::__bfloat16_t __x)
3516  { return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); }
3517 
3518  constexpr __gnu_cxx::__bfloat16_t
3519  erfc(__gnu_cxx::__bfloat16_t __x)
3520  { return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); }
3521 
3522  constexpr __gnu_cxx::__bfloat16_t
3523  exp2(__gnu_cxx::__bfloat16_t __x)
3524  { return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); }
3525 
3526  constexpr __gnu_cxx::__bfloat16_t
3527  expm1(__gnu_cxx::__bfloat16_t __x)
3528  { return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); }
3529 
3530  constexpr __gnu_cxx::__bfloat16_t
3531  fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3532  { return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); }
3533 
3534  constexpr __gnu_cxx::__bfloat16_t
3535  fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3536  { return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); }
3537 
3538  constexpr __gnu_cxx::__bfloat16_t
3539  fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3540  { return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); }
3541 
3542  constexpr __gnu_cxx::__bfloat16_t
3543  fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3544  { return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); }
3545 
3546  constexpr __gnu_cxx::__bfloat16_t
3547  hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3548  { return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); }
3549 
3550  constexpr int
3551  ilogb(__gnu_cxx::__bfloat16_t __x)
3552  { return __gnu_cxx::__bfloat16_t(__builtin_ilogbf(__x)); }
3553 
3554  constexpr __gnu_cxx::__bfloat16_t
3555  lgamma(__gnu_cxx::__bfloat16_t __x)
3556  { return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); }
3557 
3558  constexpr long long
3559  llrint(__gnu_cxx::__bfloat16_t __x)
3560  { return __gnu_cxx::__bfloat16_t(__builtin_llrintf(__x)); }
3561 
3562  constexpr long long
3563  llround(__gnu_cxx::__bfloat16_t __x)
3564  { return __gnu_cxx::__bfloat16_t(__builtin_llroundf(__x)); }
3565 
3566  constexpr __gnu_cxx::__bfloat16_t
3567  log1p(__gnu_cxx::__bfloat16_t __x)
3568  { return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); }
3569 
3570  // DR 568.
3571  constexpr __gnu_cxx::__bfloat16_t
3572  log2(__gnu_cxx::__bfloat16_t __x)
3573  { return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); }
3574 
3575  constexpr __gnu_cxx::__bfloat16_t
3576  logb(__gnu_cxx::__bfloat16_t __x)
3577  { return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); }
3578 
3579  constexpr long
3580  lrint(__gnu_cxx::__bfloat16_t __x)
3581  { return __gnu_cxx::__bfloat16_t(__builtin_lrintf(__x)); }
3582 
3583  constexpr long
3584  lround(__gnu_cxx::__bfloat16_t __x)
3585  { return __gnu_cxx::__bfloat16_t(__builtin_lroundf(__x)); }
3586 
3587  constexpr __gnu_cxx::__bfloat16_t
3588  nearbyint(__gnu_cxx::__bfloat16_t __x)
3589  { return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); }
3590 
3591  constexpr __gnu_cxx::__bfloat16_t
3592  nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3593  {
3594  if (std::__is_constant_evaluated())
3595  return __builtin_nextafterf16b(__x, __y);
3596 #ifdef __INT16_TYPE__
3597  using __bfloat16_int_type = __INT16_TYPE__;
3598 #else
3599  using __bfloat16_int_type = short int;
3600 #endif
3601  __bfloat16_int_type __hx, __hy, __ix, __iy;
3602  __builtin_memcpy(&__hx, &__x, sizeof(__x));
3603  __builtin_memcpy(&__hy, &__y, sizeof(__x));
3604  __ix = __hx & 0x7fff; // |x|
3605  __iy = __hy & 0x7fff; // |y|
3606  if (__ix > 0x7f80 || __iy > 0x7f80) // x or y is NaN
3607  return __x + __y;
3608  if (__x == __y)
3609  return __y; // x == y, return y
3610  if (__ix == 0) // x == 0
3611  {
3612  __hy = (__hy & 0x8000) | 1; // return +-__BFLT16_DENORM_MIN__
3613  __builtin_memcpy(&__x, &__hy, sizeof(__x));
3614  __builtin_nextafterf(0.0f, 1.0f); // raise underflow
3615  return __x;
3616  }
3617  if (__hx >= 0) // x > 0
3618  {
3619  if (__hx > __hy) // x > y, x -= ulp
3620  --__hx;
3621  else // x < y, x += ulp
3622  ++__hx;
3623  }
3624  else // x < 0
3625  {
3626  if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp
3627  --__hx;
3628  else // x > y, x += ulp
3629  ++__hx;
3630  }
3631  __hy = __hx & 0x7f80;
3632  if (__hy >= 0x7f80)
3633  __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow
3634  else if (__hy < 0x0080)
3635  __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow
3636  __builtin_memcpy(&__x, &__hx, sizeof(__x));
3637  return __x;
3638  }
3639 
3640  constexpr __gnu_cxx::__bfloat16_t
3641  remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3642  { return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); }
3643 
3644  inline __gnu_cxx::__bfloat16_t
3645  remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, int* __pquo)
3646  { return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); }
3647 
3648  constexpr __gnu_cxx::__bfloat16_t
3649  rint(__gnu_cxx::__bfloat16_t __x)
3650  { return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); }
3651 
3652  constexpr __gnu_cxx::__bfloat16_t
3653  round(__gnu_cxx::__bfloat16_t __x)
3654  { return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); }
3655 
3656  constexpr __gnu_cxx::__bfloat16_t
3657  scalbln(__gnu_cxx::__bfloat16_t __x, long __ex)
3658  { return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); }
3659 
3660  constexpr __gnu_cxx::__bfloat16_t
3661  scalbn(__gnu_cxx::__bfloat16_t __x, int __ex)
3662  { return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); }
3663 
3664  constexpr __gnu_cxx::__bfloat16_t
3665  tgamma(__gnu_cxx::__bfloat16_t __x)
3666  { return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); }
3667 
3668  constexpr __gnu_cxx::__bfloat16_t
3669  trunc(__gnu_cxx::__bfloat16_t __x)
3670  { return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); }
3671 #endif
3672 
3673 #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
3674  template<typename _Tp, typename _Up>
3675  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3676  copysign(_Tp __x, _Up __y)
3677  {
3678  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3679  return copysign(__type(__x), __type(__y));
3680  }
3681 
3682  template<typename _Tp, typename _Up>
3683  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3684  fdim(_Tp __x, _Up __y)
3685  {
3686  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3687  return fdim(__type(__x), __type(__y));
3688  }
3689 
3690  template<typename _Tp, typename _Up>
3691  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3692  fmax(_Tp __x, _Up __y)
3693  {
3694  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3695  return fmax(__type(__x), __type(__y));
3696  }
3697 
3698  template<typename _Tp, typename _Up>
3699  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3700  fmin(_Tp __x, _Up __y)
3701  {
3702  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3703  return fmin(__type(__x), __type(__y));
3704  }
3705 
3706  template<typename _Tp, typename _Up>
3707  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3708  hypot(_Tp __x, _Up __y)
3709  {
3710  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3711  return hypot(__type(__x), __type(__y));
3712  }
3713 
3714  template<typename _Tp, typename _Up>
3715  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3716  nextafter(_Tp __x, _Up __y)
3717  {
3718  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3719  return nextafter(__type(__x), __type(__y));
3720  }
3721 
3722  template<typename _Tp, typename _Up>
3723  constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3724  remainder(_Tp __x, _Up __y)
3725  {
3726  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3727  return remainder(__type(__x), __type(__y));
3728  }
3729 
3730  template<typename _Tp, typename _Up>
3731  inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3732  remquo(_Tp __x, _Up __y, int* __pquo)
3733  {
3734  typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3735  return remquo(__type(__x), __type(__y), __pquo);
3736  }
3737 
3738  template<typename _Tp, typename _Up, typename _Vp>
3739  constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
3740  fma(_Tp __x, _Up __y, _Vp __z)
3741  {
3742  typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
3743  return fma(__type(__x), __type(__y), __type(__z));
3744  }
3745 #endif
3746 
3747 #endif // _GLIBCXX_USE_C99_MATH_FUNCS
3748 #endif // C++11
3749 
3750 #ifdef __cpp_lib_hypot // C++ >= 17 && HOSTED
3751  // [c.math.hypot3], three-dimensional hypotenuse
3752  template<typename _Tp>
3753  inline _Tp
3754  __hypot3(_Tp __x, _Tp __y, _Tp __z)
3755  {
3756  __x = std::abs(__x);
3757  __y = std::abs(__y);
3758  __z = std::abs(__z);
3759  if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
3760  return __a * std::sqrt((__x / __a) * (__x / __a)
3761  + (__y / __a) * (__y / __a)
3762  + (__z / __a) * (__z / __a));
3763  else
3764  return {};
3765  }
3766 
3767  inline float
3768  hypot(float __x, float __y, float __z)
3769  { return std::__hypot3<float>(__x, __y, __z); }
3770 
3771  inline double
3772  hypot(double __x, double __y, double __z)
3773  { return std::__hypot3<double>(__x, __y, __z); }
3774 
3775  inline long double
3776  hypot(long double __x, long double __y, long double __z)
3777  { return std::__hypot3<long double>(__x, __y, __z); }
3778 
3779  template<typename _Tp, typename _Up, typename _Vp>
3780  __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3781  hypot(_Tp __x, _Up __y, _Vp __z)
3782  {
3783  using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3784  return std::__hypot3<__type>(__x, __y, __z);
3785  }
3786 
3787 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3788  inline _Float16
3789  hypot(_Float16 __x, _Float16 __y, _Float16 __z)
3790  { return std::__hypot3<_Float16>(__x, __y, __z); }
3791 #endif
3792 
3793 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3794  inline _Float32
3795  hypot(_Float32 __x, _Float32 __y, _Float32 __z)
3796  { return std::__hypot3<_Float32>(__x, __y, __z); }
3797 #endif
3798 
3799 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3800  inline _Float64
3801  hypot(_Float64 __x, _Float64 __y, _Float64 __z)
3802  { return std::__hypot3<_Float64>(__x, __y, __z); }
3803 #endif
3804 
3805 #if defined(__STDCPP_FLOAT128_T__) \
3806  && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3807  || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3808  inline _Float128
3809  hypot(_Float128 __x, _Float128 __y, _Float128 __z)
3810  { return std::__hypot3<_Float128>(__x, __y, __z); }
3811 #endif
3812 
3813 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3814  inline __gnu_cxx::__bfloat16_t
3815  hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z)
3816  { return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3817 #endif
3818 
3819 #endif // __cpp_lib_hypot
3820 
3821 #ifdef __cpp_lib_interpolate // C++ >= 20
3822  // linear interpolation
3823  template<typename _Fp>
3824  constexpr _Fp
3825  __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
3826  {
3827  if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
3828  return __t * __b + (1 - __t) * __a;
3829 
3830  if (__t == 1)
3831  return __b; // exact
3832 
3833  // Exact at __t=0, monotonic except near __t=1,
3834  // bounded, determinate, and consistent:
3835  const _Fp __x = __a + __t * (__b - __a);
3836  return (__t > 1) == (__b > __a)
3837  ? (__b < __x ? __x : __b)
3838  : (__b > __x ? __x : __b); // monotonic near __t=1
3839  }
3840 
3841  constexpr float
3842  lerp(float __a, float __b, float __t) noexcept
3843  { return std::__lerp(__a, __b, __t); }
3844 
3845  constexpr double
3846  lerp(double __a, double __b, double __t) noexcept
3847  { return std::__lerp(__a, __b, __t); }
3848 
3849  constexpr long double
3850  lerp(long double __a, long double __b, long double __t) noexcept
3851  { return std::__lerp(__a, __b, __t); }
3852 
3853  template<typename _Tp, typename _Up, typename _Vp>
3854  constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3855  lerp(_Tp __x, _Up __y, _Vp __z) noexcept
3856  {
3857  using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3858  return std::__lerp<__type>(__x, __y, __z);
3859  }
3860 
3861 #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3862  inline _Float16
3863  lerp(_Float16 __x, _Float16 __y, _Float16 __z) noexcept
3864  { return std::__lerp<_Float16>(__x, __y, __z); }
3865 #endif
3866 
3867 #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3868  inline _Float32
3869  lerp(_Float32 __x, _Float32 __y, _Float32 __z) noexcept
3870  { return std::__lerp<_Float32>(__x, __y, __z); }
3871 #endif
3872 
3873 #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3874  inline _Float64
3875  lerp(_Float64 __x, _Float64 __y, _Float64 __z) noexcept
3876  { return std::__lerp<_Float64>(__x, __y, __z); }
3877 #endif
3878 
3879 #if defined(__STDCPP_FLOAT128_T__) \
3880  && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3881  || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3882  inline _Float128
3883  lerp(_Float128 __x, _Float128 __y, _Float128 __z) noexcept
3884  { return std::__lerp<_Float128>(__x, __y, __z); }
3885 #endif
3886 
3887 #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3888  inline __gnu_cxx::__bfloat16_t
3889  lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) noexcept
3890  { return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); }
3891 #endif
3892 #endif // __cpp_lib_interpolate
3893 
3894 _GLIBCXX_END_NAMESPACE_VERSION
3895 } // namespace
3896 
3897 #if _GLIBCXX_USE_STD_SPEC_FUNCS
3898 # include <bits/specfun.h>
3899 #endif
3900 
3901 } // extern "C++"
3902 
3903 #endif