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

source code of include/c++/13/cmath