1// -*- C++ -*- C forwarding header.
3// Copyright (C) 1997-2023 Free Software Foundation, Inc.
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)
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.
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.
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/>.
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.
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
36// ISO C++ 14882: 26.5 C library
39#pragma GCC system_header
41#include <bits/requires_hosted.h>
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
48#undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
49#include <bits/std_abs.h>
52#define _GLIBCXX_CMATH 1
54// Get rid of those macros defined in <math.h> in lieu of real functions.
81namespace std _GLIBCXX_VISIBILITY(default)
83_GLIBCXX_BEGIN_NAMESPACE_VERSION
87#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
88 inline _GLIBCXX_CONSTEXPR float
90 { return __builtin_acosf(__x); }
92 inline _GLIBCXX_CONSTEXPR long double
94 { return __builtin_acosl(__x); }
97 template<typename _Tp>
98 inline _GLIBCXX_CONSTEXPR
99 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
102 { return __builtin_acos(__x); }
106#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
107 inline _GLIBCXX_CONSTEXPR float
109 { return __builtin_asinf(__x); }
111 inline _GLIBCXX_CONSTEXPR long double
112 asin(long double __x)
113 { return __builtin_asinl(__x); }
116 template<typename _Tp>
117 inline _GLIBCXX_CONSTEXPR
118 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
121 { return __builtin_asin(__x); }
125#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
126 inline _GLIBCXX_CONSTEXPR float
128 { return __builtin_atanf(__x); }
130 inline _GLIBCXX_CONSTEXPR long double
131 atan(long double __x)
132 { return __builtin_atanl(__x); }
135 template<typename _Tp>
136 inline _GLIBCXX_CONSTEXPR
137 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
140 { return __builtin_atan(__x); }
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); }
149 inline _GLIBCXX_CONSTEXPR long double
150 atan2(long double __y, long double __x)
151 { return __builtin_atan2l(__y, __x); }
156#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
157 inline _GLIBCXX_CONSTEXPR float
159 { return __builtin_ceilf(__x); }
161 inline _GLIBCXX_CONSTEXPR long double
162 ceil(long double __x)
163 { return __builtin_ceill(__x); }
166 template<typename _Tp>
167 inline _GLIBCXX_CONSTEXPR
168 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
171 { return __builtin_ceil(__x); }
175#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
176 inline _GLIBCXX_CONSTEXPR float
178 { return __builtin_cosf(__x); }
180 inline _GLIBCXX_CONSTEXPR long double
182 { return __builtin_cosl(__x); }
185 template<typename _Tp>
186 inline _GLIBCXX_CONSTEXPR
187 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
190 { return __builtin_cos(__x); }
194#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
195 inline _GLIBCXX_CONSTEXPR float
197 { return __builtin_coshf(__x); }
199 inline _GLIBCXX_CONSTEXPR long double
200 cosh(long double __x)
201 { return __builtin_coshl(__x); }
204 template<typename _Tp>
205 inline _GLIBCXX_CONSTEXPR
206 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
209 { return __builtin_cosh(__x); }
213#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
214 inline _GLIBCXX_CONSTEXPR float
216 { return __builtin_expf(__x); }
218 inline _GLIBCXX_CONSTEXPR long double
220 { return __builtin_expl(__x); }
223 template<typename _Tp>
224 inline _GLIBCXX_CONSTEXPR
225 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
228 { return __builtin_exp(__x); }
232#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
233 inline _GLIBCXX_CONSTEXPR float
235 { return __builtin_fabsf(__x); }
237 inline _GLIBCXX_CONSTEXPR long double
238 fabs(long double __x)
239 { return __builtin_fabsl(__x); }
242 template<typename _Tp>
243 inline _GLIBCXX_CONSTEXPR
244 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
247 { return __builtin_fabs(__x); }
251#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
252 inline _GLIBCXX_CONSTEXPR float
254 { return __builtin_floorf(__x); }
256 inline _GLIBCXX_CONSTEXPR long double
257 floor(long double __x)
258 { return __builtin_floorl(__x); }
261 template<typename _Tp>
262 inline _GLIBCXX_CONSTEXPR
263 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
266 { return __builtin_floor(__x); }
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); }
275 inline _GLIBCXX_CONSTEXPR long double
276 fmod(long double __x, long double __y)
277 { return __builtin_fmodl(__x, __y); }
282#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
284 frexp(float __x, int* __exp)
285 { return __builtin_frexpf(__x, __exp); }
288 frexp(long double __x, int* __exp)
289 { return __builtin_frexpl(__x, __exp); }
292 template<typename _Tp>
293 inline _GLIBCXX_CONSTEXPR
294 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
296 frexp(_Tp __x, int* __exp)
297 { return __builtin_frexp(__x, __exp); }
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); }
306 inline _GLIBCXX_CONSTEXPR long double
307 ldexp(long double __x, int __exp)
308 { return __builtin_ldexpl(__x, __exp); }
311 template<typename _Tp>
312 inline _GLIBCXX_CONSTEXPR
313 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
315 ldexp(_Tp __x, int __exp)
316 { return __builtin_ldexp(__x, __exp); }
320#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
321 inline _GLIBCXX_CONSTEXPR float
323 { return __builtin_logf(__x); }
325 inline _GLIBCXX_CONSTEXPR long double
327 { return __builtin_logl(__x); }
330 template<typename _Tp>
331 inline _GLIBCXX_CONSTEXPR
332 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
335 { return __builtin_log(__x); }
339#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
340 inline _GLIBCXX_CONSTEXPR float
342 { return __builtin_log10f(__x); }
344 inline _GLIBCXX_CONSTEXPR long double
345 log10(long double __x)
346 { return __builtin_log10l(__x); }
349 template<typename _Tp>
350 inline _GLIBCXX_CONSTEXPR
351 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
354 { return __builtin_log10(__x); }
358#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
360 modf(float __x, float* __iptr)
361 { return __builtin_modff(__x, __iptr); }
364 modf(long double __x, long double* __iptr)
365 { return __builtin_modfl(__x, __iptr); }
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); }
375 inline _GLIBCXX_CONSTEXPR long double
376 pow(long double __x, long double __y)
377 { return __builtin_powl(__x, __y); }
379#if __cplusplus < 201103L
380 // _GLIBCXX_RESOLVE_LIB_DEFECTS
381 // DR 550. What should the return type of pow(float,int) be?
383 pow(double __x, int __i)
384 { return __builtin_powi(__x, __i); }
387 pow(float __x, int __n)
388 { return __builtin_powif(__x, __n); }
391 pow(long double __x, int __n)
392 { return __builtin_powil(__x, __n); }
398#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
399 inline _GLIBCXX_CONSTEXPR float
401 { return __builtin_sinf(__x); }
403 inline _GLIBCXX_CONSTEXPR long double
405 { return __builtin_sinl(__x); }
408 template<typename _Tp>
409 inline _GLIBCXX_CONSTEXPR
410 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
413 { return __builtin_sin(__x); }
417#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
418 inline _GLIBCXX_CONSTEXPR float
420 { return __builtin_sinhf(__x); }
422 inline _GLIBCXX_CONSTEXPR long double
423 sinh(long double __x)
424 { return __builtin_sinhl(__x); }
427 template<typename _Tp>
428 inline _GLIBCXX_CONSTEXPR
429 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
432 { return __builtin_sinh(__x); }
436#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
437 inline _GLIBCXX_CONSTEXPR float
439 { return __builtin_sqrtf(__x); }
441 inline _GLIBCXX_CONSTEXPR long double
442 sqrt(long double __x)
443 { return __builtin_sqrtl(__x); }
446 template<typename _Tp>
447 inline _GLIBCXX_CONSTEXPR
448 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
451 { return __builtin_sqrt(__x); }
455#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
456 inline _GLIBCXX_CONSTEXPR float
458 { return __builtin_tanf(__x); }
460 inline _GLIBCXX_CONSTEXPR long double
462 { return __builtin_tanl(__x); }
465 template<typename _Tp>
466 inline _GLIBCXX_CONSTEXPR
467 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
470 { return __builtin_tan(__x); }
474#ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
475 inline _GLIBCXX_CONSTEXPR float
477 { return __builtin_tanhf(__x); }
479 inline _GLIBCXX_CONSTEXPR long double
480 tanh(long double __x)
481 { return __builtin_tanhl(__x); }
484 template<typename _Tp>
485 inline _GLIBCXX_CONSTEXPR
486 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
489 { return __builtin_tanh(__x); }
491#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
494 { return _Float16(__builtin_acosf(__x)); }
498 { return _Float16(__builtin_asinf(__x)); }
502 { return _Float16(__builtin_atanf(__x)); }
505 atan2(_Float16 __y, _Float16 __x)
506 { return _Float16(__builtin_atan2f(__y, __x)); }
510 { return _Float16(__builtin_ceilf(__x)); }
514 { return _Float16(__builtin_cosf(__x)); }
518 { return _Float16(__builtin_coshf(__x)); }
522 { return _Float16(__builtin_expf(__x)); }
526 { return _Float16(__builtin_fabsf(__x)); }
530 { return _Float16(__builtin_floorf(__x)); }
533 fmod(_Float16 __x, _Float16 __y)
534 { return _Float16(__builtin_fmodf(__x, __y)); }
537 frexp(_Float16 __x, int* __exp)
538 { return _Float16(__builtin_frexpf(__x, __exp)); }
541 ldexp(_Float16 __x, int __exp)
542 { return _Float16(__builtin_ldexpf(__x, __exp)); }
546 { return _Float16(__builtin_logf(__x)); }
550 { return _Float16(__builtin_log10f(__x)); }
553 modf(_Float16 __x, _Float16* __iptr)
555 float __i, __ret = __builtin_modff(__x, &__i);
556 *__iptr = _Float16(__i);
557 return _Float16(__ret);
561 pow(_Float16 __x, _Float16 __y)
562 { return _Float16(__builtin_powf(__x, __y)); }
566 { return _Float16(__builtin_sinf(__x)); }
570 { return _Float16(__builtin_sinhf(__x)); }
574 { return _Float16(__builtin_sqrtf(__x)); }
578 { return _Float16(__builtin_tanf(__x)); }
582 { return _Float16(__builtin_tanhf(__x)); }
585#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
588 { return __builtin_acosf(__x); }
592 { return __builtin_asinf(__x); }
596 { return __builtin_atanf(__x); }
599 atan2(_Float32 __y, _Float32 __x)
600 { return __builtin_atan2f(__y, __x); }
604 { return __builtin_ceilf(__x); }
608 { return __builtin_cosf(__x); }
612 { return __builtin_coshf(__x); }
616 { return __builtin_expf(__x); }
620 { return __builtin_fabsf(__x); }
624 { return __builtin_floorf(__x); }
627 fmod(_Float32 __x, _Float32 __y)
628 { return __builtin_fmodf(__x, __y); }
631 frexp(_Float32 __x, int* __exp)
632 { return __builtin_frexpf(__x, __exp); }
635 ldexp(_Float32 __x, int __exp)
636 { return __builtin_ldexpf(__x, __exp); }
640 { return __builtin_logf(__x); }
644 { return __builtin_log10f(__x); }
647 modf(_Float32 __x, _Float32* __iptr)
649 float __i, __ret = __builtin_modff(__x, &__i);
655 pow(_Float32 __x, _Float32 __y)
656 { return __builtin_powf(__x, __y); }
660 { return __builtin_sinf(__x); }
664 { return __builtin_sinhf(__x); }
668 { return __builtin_sqrtf(__x); }
672 { return __builtin_tanf(__x); }
676 { return __builtin_tanhf(__x); }
679#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
682 { return __builtin_acos(__x); }
686 { return __builtin_asin(__x); }
690 { return __builtin_atan(__x); }
693 atan2(_Float64 __y, _Float64 __x)
694 { return __builtin_atan2(__y, __x); }
698 { return __builtin_ceil(__x); }
702 { return __builtin_cos(__x); }
706 { return __builtin_cosh(__x); }
710 { return __builtin_exp(__x); }
714 { return __builtin_fabs(__x); }
718 { return __builtin_floor(__x); }
721 fmod(_Float64 __x, _Float64 __y)
722 { return __builtin_fmod(__x, __y); }
725 frexp(_Float64 __x, int* __exp)
726 { return __builtin_frexp(__x, __exp); }
729 ldexp(_Float64 __x, int __exp)
730 { return __builtin_ldexp(__x, __exp); }
734 { return __builtin_log(__x); }
738 { return __builtin_log10(__x); }
741 modf(_Float64 __x, _Float64* __iptr)
743 double __i, __ret = __builtin_modf(__x, &__i);
749 pow(_Float64 __x, _Float64 __y)
750 { return __builtin_pow(__x, __y); }
754 { return __builtin_sin(__x); }
758 { return __builtin_sinh(__x); }
762 { return __builtin_sqrt(__x); }
766 { return __builtin_tan(__x); }
770 { return __builtin_tanh(__x); }
773#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
776 { return __builtin_acosl(__x); }
780 { return __builtin_asinl(__x); }
784 { return __builtin_atanl(__x); }
787 atan2(_Float128 __y, _Float128 __x)
788 { return __builtin_atan2l(__y, __x); }
792 { return __builtin_ceill(__x); }
796 { return __builtin_cosl(__x); }
800 { return __builtin_coshl(__x); }
804 { return __builtin_expl(__x); }
808 { return __builtin_fabsl(__x); }
812 { return __builtin_floorl(__x); }
815 fmod(_Float128 __x, _Float128 __y)
816 { return __builtin_fmodl(__x, __y); }
819 frexp(_Float128 __x, int* __exp)
820 { return __builtin_frexpl(__x, __exp); }
823 ldexp(_Float128 __x, int __exp)
824 { return __builtin_ldexpl(__x, __exp); }
828 { return __builtin_logl(__x); }
832 { return __builtin_log10l(__x); }
835 modf(_Float128 __x, _Float128* __iptr)
837 long double __i, __ret = __builtin_modfl(__x, &__i);
843 pow(_Float128 __x, _Float128 __y)
844 { return __builtin_powl(__x, __y); }
848 { return __builtin_sinl(__x); }
852 { return __builtin_sinhl(__x); }
856 { return __builtin_sqrtl(__x); }
860 { return __builtin_tanl(__x); }
864 { return __builtin_tanhl(__x); }
865#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
868 { return __builtin_acosf128(__x); }
872 { return __builtin_asinf128(__x); }
876 { return __builtin_atanf128(__x); }
879 atan2(_Float128 __y, _Float128 __x)
880 { return __builtin_atan2f128(__y, __x); }
884 { return __builtin_ceilf128(__x); }
888 { return __builtin_cosf128(__x); }
892 { return __builtin_coshf128(__x); }
896 { return __builtin_expf128(__x); }
900 { return __builtin_fabsf128(__x); }
904 { return __builtin_floorf128(__x); }
907 fmod(_Float128 __x, _Float128 __y)
908 { return __builtin_fmodf128(__x, __y); }
911 frexp(_Float128 __x, int* __exp)
912 { return __builtin_frexpf128(__x, __exp); }
915 ldexp(_Float128 __x, int __exp)
916 { return __builtin_ldexpf128(__x, __exp); }
920 { return __builtin_logf128(__x); }
924 { return __builtin_log10f128(__x); }
927 modf(_Float128 __x, _Float128* __iptr)
928 { return __builtin_modff128(__x, __iptr); }
931 pow(_Float128 __x, _Float128 __y)
932 { return __builtin_powf128(__x, __y); }
936 { return __builtin_sinf128(__x); }
940 { return __builtin_sinhf128(__x); }
944 { return __builtin_sqrtf128(__x); }
948 { return __builtin_tanf128(__x); }
952 { return __builtin_tanhf128(__x); }
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)); }
960 constexpr __gnu_cxx::__bfloat16_t
961 asin(__gnu_cxx::__bfloat16_t __x)
962 { return __gnu_cxx::__bfloat16_t(__builtin_asinf(__x)); }
964 constexpr __gnu_cxx::__bfloat16_t
965 atan(__gnu_cxx::__bfloat16_t __x)
966 { return __gnu_cxx::__bfloat16_t(__builtin_atanf(__x)); }
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)); }
972 constexpr __gnu_cxx::__bfloat16_t
973 ceil(__gnu_cxx::__bfloat16_t __x)
974 { return __gnu_cxx::__bfloat16_t(__builtin_ceilf(__x)); }
976 constexpr __gnu_cxx::__bfloat16_t
977 cos(__gnu_cxx::__bfloat16_t __x)
978 { return __gnu_cxx::__bfloat16_t(__builtin_cosf(__x)); }
980 constexpr __gnu_cxx::__bfloat16_t
981 cosh(__gnu_cxx::__bfloat16_t __x)
982 { return __gnu_cxx::__bfloat16_t(__builtin_coshf(__x)); }
984 constexpr __gnu_cxx::__bfloat16_t
985 exp(__gnu_cxx::__bfloat16_t __x)
986 { return __gnu_cxx::__bfloat16_t(__builtin_expf(__x)); }
988 constexpr __gnu_cxx::__bfloat16_t
989 fabs(__gnu_cxx::__bfloat16_t __x)
990 { return __gnu_cxx::__bfloat16_t(__builtin_fabsf(__x)); }
992 constexpr __gnu_cxx::__bfloat16_t
993 floor(__gnu_cxx::__bfloat16_t __x)
994 { return __gnu_cxx::__bfloat16_t(__builtin_floorf(__x)); }
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)); }
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)); }
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)); }
1008 constexpr __gnu_cxx::__bfloat16_t
1009 log(__gnu_cxx::__bfloat16_t __x)
1010 { return __gnu_cxx::__bfloat16_t(__builtin_logf(__x)); }
1012 constexpr __gnu_cxx::__bfloat16_t
1013 log10(__gnu_cxx::__bfloat16_t __x)
1014 { return __gnu_cxx::__bfloat16_t(__builtin_log10f(__x)); }
1016 inline __gnu_cxx::__bfloat16_t
1017 modf(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t* __iptr)
1019 float __i, __ret = __builtin_modff(__x, &__i);
1020 *__iptr = __gnu_cxx::__bfloat16_t(__i);
1021 return __gnu_cxx::__bfloat16_t(__ret);
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)); }
1028 constexpr __gnu_cxx::__bfloat16_t
1029 sin(__gnu_cxx::__bfloat16_t __x)
1030 { return __gnu_cxx::__bfloat16_t(__builtin_sinf(__x)); }
1032 constexpr __gnu_cxx::__bfloat16_t
1033 sinh(__gnu_cxx::__bfloat16_t __x)
1034 { return __gnu_cxx::__bfloat16_t(__builtin_sinhf(__x)); }
1036 constexpr __gnu_cxx::__bfloat16_t
1037 sqrt(__gnu_cxx::__bfloat16_t __x)
1038 { return __gnu_cxx::__bfloat16_t(__builtin_sqrtf(__x)); }
1040 constexpr __gnu_cxx::__bfloat16_t
1041 tan(__gnu_cxx::__bfloat16_t __x)
1042 { return __gnu_cxx::__bfloat16_t(__builtin_tanf(__x)); }
1044 constexpr __gnu_cxx::__bfloat16_t
1045 tanh(__gnu_cxx::__bfloat16_t __x)
1046 { return __gnu_cxx::__bfloat16_t(__builtin_tanhf(__x)); }
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)
1054 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1055 return atan2(__type(__y), __type(__x));
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)
1063 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1064 return fmod(__type(__x), __type(__y));
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)
1072 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1073 return pow(__type(__x), __type(__y));
1076#if _GLIBCXX_USE_C99_MATH
1077#if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
1079// These are possible macros imported from C99-land.
1087#undef isgreaterequal
1093#if __cplusplus >= 201103L
1095#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1097 fpclassify(float __x)
1098 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1099 FP_SUBNORMAL, FP_ZERO, __x); }
1102 fpclassify(double __x)
1103 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1104 FP_SUBNORMAL, FP_ZERO, __x); }
1107 fpclassify(long double __x)
1108 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1109 FP_SUBNORMAL, FP_ZERO, __x); }
1112#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1113 template<typename _Tp>
1114 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1117 { return __x != 0 ? FP_NORMAL : FP_ZERO; }
1120#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1123 { return __builtin_isfinite(__x); }
1126 isfinite(double __x)
1127 { return __builtin_isfinite(__x); }
1130 isfinite(long double __x)
1131 { return __builtin_isfinite(__x); }
1134#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1135 template<typename _Tp>
1136 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1142#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1145 { return __builtin_isinf(__x); }
1147#if _GLIBCXX_HAVE_OBSOLETE_ISINF \
1148 && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1153 { return __builtin_isinf(__x); }
1157 isinf(long double __x)
1158 { return __builtin_isinf(__x); }
1161#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1162 template<typename _Tp>
1163 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1169#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1172 { return __builtin_isnan(__x); }
1174#if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
1175 && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
1180 { return __builtin_isnan(__x); }
1184 isnan(long double __x)
1185 { return __builtin_isnan(__x); }
1188#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1189 template<typename _Tp>
1190 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1196#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1199 { return __builtin_isnormal(__x); }
1202 isnormal(double __x)
1203 { return __builtin_isnormal(__x); }
1206 isnormal(long double __x)
1207 { return __builtin_isnormal(__x); }
1210#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1211 template<typename _Tp>
1212 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1215 { return __x != 0 ? true : false; }
1218#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1219 // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.
1222 { return __builtin_signbit(__x); }
1226 { return __builtin_signbit(__x); }
1229 signbit(long double __x)
1230 { return __builtin_signbit(__x); }
1233#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1234 template<typename _Tp>
1235 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1238 { return __x < 0 ? true : false; }
1241#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1243 isgreater(float __x, float __y)
1244 { return __builtin_isgreater(__x, __y); }
1247 isgreater(double __x, double __y)
1248 { return __builtin_isgreater(__x, __y); }
1251 isgreater(long double __x, long double __y)
1252 { return __builtin_isgreater(__x, __y); }
1255#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1256 template<typename _Tp, typename _Up>
1258 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1259 && __is_arithmetic<_Up>::__value), bool>::__type
1260 isgreater(_Tp __x, _Up __y)
1262 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1263 return __builtin_isgreater(__type(__x), __type(__y));
1267#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1269 isgreaterequal(float __x, float __y)
1270 { return __builtin_isgreaterequal(__x, __y); }
1273 isgreaterequal(double __x, double __y)
1274 { return __builtin_isgreaterequal(__x, __y); }
1277 isgreaterequal(long double __x, long double __y)
1278 { return __builtin_isgreaterequal(__x, __y); }
1281#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1282 template<typename _Tp, typename _Up>
1284 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1285 && __is_arithmetic<_Up>::__value), bool>::__type
1286 isgreaterequal(_Tp __x, _Up __y)
1288 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1289 return __builtin_isgreaterequal(__type(__x), __type(__y));
1293#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1295 isless(float __x, float __y)
1296 { return __builtin_isless(__x, __y); }
1299 isless(double __x, double __y)
1300 { return __builtin_isless(__x, __y); }
1303 isless(long double __x, long double __y)
1304 { return __builtin_isless(__x, __y); }
1307#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1308 template<typename _Tp, typename _Up>
1310 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1311 && __is_arithmetic<_Up>::__value), bool>::__type
1312 isless(_Tp __x, _Up __y)
1314 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1315 return __builtin_isless(__type(__x), __type(__y));
1319#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1321 islessequal(float __x, float __y)
1322 { return __builtin_islessequal(__x, __y); }
1325 islessequal(double __x, double __y)
1326 { return __builtin_islessequal(__x, __y); }
1329 islessequal(long double __x, long double __y)
1330 { return __builtin_islessequal(__x, __y); }
1333#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1334 template<typename _Tp, typename _Up>
1336 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1337 && __is_arithmetic<_Up>::__value), bool>::__type
1338 islessequal(_Tp __x, _Up __y)
1340 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1341 return __builtin_islessequal(__type(__x), __type(__y));
1345#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1347 islessgreater(float __x, float __y)
1348 { return __builtin_islessgreater(__x, __y); }
1351 islessgreater(double __x, double __y)
1352 { return __builtin_islessgreater(__x, __y); }
1355 islessgreater(long double __x, long double __y)
1356 { return __builtin_islessgreater(__x, __y); }
1359#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1360 template<typename _Tp, typename _Up>
1362 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1363 && __is_arithmetic<_Up>::__value), bool>::__type
1364 islessgreater(_Tp __x, _Up __y)
1366 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1367 return __builtin_islessgreater(__type(__x), __type(__y));
1371#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1373 isunordered(float __x, float __y)
1374 { return __builtin_isunordered(__x, __y); }
1377 isunordered(double __x, double __y)
1378 { return __builtin_isunordered(__x, __y); }
1381 isunordered(long double __x, long double __y)
1382 { return __builtin_isunordered(__x, __y); }
1385#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1386 template<typename _Tp, typename _Up>
1388 __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
1389 && __is_arithmetic<_Up>::__value), bool>::__type
1390 isunordered(_Tp __x, _Up __y)
1392 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1393 return __builtin_isunordered(__type(__x), __type(__y));
1399 template<typename _Tp>
1400 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
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));
1409 template<typename _Tp>
1410 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1414 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1415 return __builtin_isfinite(__type(__f));
1418 template<typename _Tp>
1419 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1423 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1424 return __builtin_isinf(__type(__f));
1427 template<typename _Tp>
1428 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1432 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1433 return __builtin_isnan(__type(__f));
1436 template<typename _Tp>
1437 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1441 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1442 return __builtin_isnormal(__type(__f));
1445 template<typename _Tp>
1446 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1450 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1451 return __builtin_signbit(__type(__f));
1454 template<typename _Tp>
1455 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1457 isgreater(_Tp __f1, _Tp __f2)
1459 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1460 return __builtin_isgreater(__type(__f1), __type(__f2));
1463 template<typename _Tp>
1464 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1466 isgreaterequal(_Tp __f1, _Tp __f2)
1468 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1469 return __builtin_isgreaterequal(__type(__f1), __type(__f2));
1472 template<typename _Tp>
1473 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1475 isless(_Tp __f1, _Tp __f2)
1477 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1478 return __builtin_isless(__type(__f1), __type(__f2));
1481 template<typename _Tp>
1482 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1484 islessequal(_Tp __f1, _Tp __f2)
1486 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1487 return __builtin_islessequal(__type(__f1), __type(__f2));
1490 template<typename _Tp>
1491 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1493 islessgreater(_Tp __f1, _Tp __f2)
1495 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1496 return __builtin_islessgreater(__type(__f1), __type(__f2));
1499 template<typename _Tp>
1500 inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
1502 isunordered(_Tp __f1, _Tp __f2)
1504 typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
1505 return __builtin_isunordered(__type(__f1), __type(__f2));
1510#ifdef __STDCPP_FLOAT16_T__
1512 fpclassify(_Float16 __x)
1513 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1514 FP_SUBNORMAL, FP_ZERO, __x); }
1517 isfinite(_Float16 __x)
1518 { return __builtin_isfinite(__x); }
1522 { return __builtin_isinf(__x); }
1526 { return __builtin_isnan(__x); }
1529 isnormal(_Float16 __x)
1530 { return __builtin_isnormal(__x); }
1533 signbit(_Float16 __x)
1534 { return __builtin_signbit(__x); }
1537 isgreater(_Float16 __x, _Float16 __y)
1538 { return __builtin_isgreater(__x, __y); }
1541 isgreaterequal(_Float16 __x, _Float16 __y)
1542 { return __builtin_isgreaterequal(__x, __y); }
1545 isless(_Float16 __x, _Float16 __y)
1546 { return __builtin_isless(__x, __y); }
1549 islessequal(_Float16 __x, _Float16 __y)
1550 { return __builtin_islessequal(__x, __y); }
1553 islessgreater(_Float16 __x, _Float16 __y)
1554 { return __builtin_islessgreater(__x, __y); }
1557 isunordered(_Float16 __x, _Float16 __y)
1558 { return __builtin_isunordered(__x, __y); }
1561#ifdef __STDCPP_FLOAT32_T__
1563 fpclassify(_Float32 __x)
1564 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1565 FP_SUBNORMAL, FP_ZERO, __x); }
1568 isfinite(_Float32 __x)
1569 { return __builtin_isfinite(__x); }
1573 { return __builtin_isinf(__x); }
1577 { return __builtin_isnan(__x); }
1580 isnormal(_Float32 __x)
1581 { return __builtin_isnormal(__x); }
1584 signbit(_Float32 __x)
1585 { return __builtin_signbit(__x); }
1588 isgreater(_Float32 __x, _Float32 __y)
1589 { return __builtin_isgreater(__x, __y); }
1592 isgreaterequal(_Float32 __x, _Float32 __y)
1593 { return __builtin_isgreaterequal(__x, __y); }
1596 isless(_Float32 __x, _Float32 __y)
1597 { return __builtin_isless(__x, __y); }
1600 islessequal(_Float32 __x, _Float32 __y)
1601 { return __builtin_islessequal(__x, __y); }
1604 islessgreater(_Float32 __x, _Float32 __y)
1605 { return __builtin_islessgreater(__x, __y); }
1608 isunordered(_Float32 __x, _Float32 __y)
1609 { return __builtin_isunordered(__x, __y); }
1612#ifdef __STDCPP_FLOAT64_T__
1614 fpclassify(_Float64 __x)
1615 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1616 FP_SUBNORMAL, FP_ZERO, __x); }
1619 isfinite(_Float64 __x)
1620 { return __builtin_isfinite(__x); }
1624 { return __builtin_isinf(__x); }
1628 { return __builtin_isnan(__x); }
1631 isnormal(_Float64 __x)
1632 { return __builtin_isnormal(__x); }
1635 signbit(_Float64 __x)
1636 { return __builtin_signbit(__x); }
1639 isgreater(_Float64 __x, _Float64 __y)
1640 { return __builtin_isgreater(__x, __y); }
1643 isgreaterequal(_Float64 __x, _Float64 __y)
1644 { return __builtin_isgreaterequal(__x, __y); }
1647 isless(_Float64 __x, _Float64 __y)
1648 { return __builtin_isless(__x, __y); }
1651 islessequal(_Float64 __x, _Float64 __y)
1652 { return __builtin_islessequal(__x, __y); }
1655 islessgreater(_Float64 __x, _Float64 __y)
1656 { return __builtin_islessgreater(__x, __y); }
1659 isunordered(_Float64 __x, _Float64 __y)
1660 { return __builtin_isunordered(__x, __y); }
1663#ifdef __STDCPP_FLOAT128_T__
1665 fpclassify(_Float128 __x)
1666 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1667 FP_SUBNORMAL, FP_ZERO, __x); }
1670 isfinite(_Float128 __x)
1671 { return __builtin_isfinite(__x); }
1674 isinf(_Float128 __x)
1675 { return __builtin_isinf(__x); }
1678 isnan(_Float128 __x)
1679 { return __builtin_isnan(__x); }
1682 isnormal(_Float128 __x)
1683 { return __builtin_isnormal(__x); }
1686 signbit(_Float128 __x)
1687 { return __builtin_signbit(__x); }
1690 isgreater(_Float128 __x, _Float128 __y)
1691 { return __builtin_isgreater(__x, __y); }
1694 isgreaterequal(_Float128 __x, _Float128 __y)
1695 { return __builtin_isgreaterequal(__x, __y); }
1698 isless(_Float128 __x, _Float128 __y)
1699 { return __builtin_isless(__x, __y); }
1702 islessequal(_Float128 __x, _Float128 __y)
1703 { return __builtin_islessequal(__x, __y); }
1706 islessgreater(_Float128 __x, _Float128 __y)
1707 { return __builtin_islessgreater(__x, __y); }
1710 isunordered(_Float128 __x, _Float128 __y)
1711 { return __builtin_isunordered(__x, __y); }
1714#ifdef __STDCPP_BFLOAT16_T__
1716 fpclassify(__gnu_cxx::__bfloat16_t __x)
1717 { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
1718 FP_SUBNORMAL, FP_ZERO, __x); }
1721 isfinite(__gnu_cxx::__bfloat16_t __x)
1722 { return __builtin_isfinite(__x); }
1725 isinf(__gnu_cxx::__bfloat16_t __x)
1726 { return __builtin_isinf(__x); }
1729 isnan(__gnu_cxx::__bfloat16_t __x)
1730 { return __builtin_isnan(__x); }
1733 isnormal(__gnu_cxx::__bfloat16_t __x)
1734 { return __builtin_isnormal(__x); }
1737 signbit(__gnu_cxx::__bfloat16_t __x)
1738 { return __builtin_signbit(__x); }
1741 isgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1742 { return __builtin_isgreater(__x, __y); }
1745 isgreaterequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1746 { return __builtin_isgreaterequal(__x, __y); }
1749 isless(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1750 { return __builtin_isless(__x, __y); }
1753 islessequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1754 { return __builtin_islessequal(__x, __y); }
1757 islessgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1758 { return __builtin_islessgreater(__x, __y); }
1761 isunordered(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
1762 { return __builtin_isunordered(__x, __y); }
1765#endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
1766#endif /* _GLIBCXX_USE_C99_MATH */
1768#if __cplusplus >= 201103L
1770#ifdef _GLIBCXX_USE_C99_MATH_TR1
1820#ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1949#ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1992 using ::nexttowardf;
1993 using ::nexttowardl;
2027 /// Additional overloads.
2028#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2031 { return __builtin_acoshf(__x); }
2033 constexpr long double
2034 acosh(long double __x)
2035 { return __builtin_acoshl(__x); }
2038#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2039 template<typename _Tp>
2040 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2043 { return __builtin_acosh(__x); }
2046#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2049 { return __builtin_asinhf(__x); }
2051 constexpr long double
2052 asinh(long double __x)
2053 { return __builtin_asinhl(__x); }
2056#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2057 template<typename _Tp>
2058 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2061 { return __builtin_asinh(__x); }
2064#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2067 { return __builtin_atanhf(__x); }
2069 constexpr long double
2070 atanh(long double __x)
2071 { return __builtin_atanhl(__x); }
2074#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2075 template<typename _Tp>
2076 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2079 { return __builtin_atanh(__x); }
2082#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2085 { return __builtin_cbrtf(__x); }
2087 constexpr long double
2088 cbrt(long double __x)
2089 { return __builtin_cbrtl(__x); }
2092#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2093 template<typename _Tp>
2094 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2097 { return __builtin_cbrt(__x); }
2100#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2102 copysign(float __x, float __y)
2103 { return __builtin_copysignf(__x, __y); }
2105 constexpr long double
2106 copysign(long double __x, long double __y)
2107 { return __builtin_copysignl(__x, __y); }
2110#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2113 { return __builtin_erff(__x); }
2115 constexpr long double
2116 erf(long double __x)
2117 { return __builtin_erfl(__x); }
2120#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2121 template<typename _Tp>
2122 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2125 { return __builtin_erf(__x); }
2128#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2131 { return __builtin_erfcf(__x); }
2133 constexpr long double
2134 erfc(long double __x)
2135 { return __builtin_erfcl(__x); }
2138#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2139 template<typename _Tp>
2140 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2143 { return __builtin_erfc(__x); }
2146#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2149 { return __builtin_exp2f(__x); }
2151 constexpr long double
2152 exp2(long double __x)
2153 { return __builtin_exp2l(__x); }
2156#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2157 template<typename _Tp>
2158 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2161 { return __builtin_exp2(__x); }
2164#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2167 { return __builtin_expm1f(__x); }
2169 constexpr long double
2170 expm1(long double __x)
2171 { return __builtin_expm1l(__x); }
2174#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2175 template<typename _Tp>
2176 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2179 { return __builtin_expm1(__x); }
2182#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2184 fdim(float __x, float __y)
2185 { return __builtin_fdimf(__x, __y); }
2187 constexpr long double
2188 fdim(long double __x, long double __y)
2189 { return __builtin_fdiml(__x, __y); }
2192#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2194 fma(float __x, float __y, float __z)
2195 { return __builtin_fmaf(__x, __y, __z); }
2197 constexpr long double
2198 fma(long double __x, long double __y, long double __z)
2199 { return __builtin_fmal(__x, __y, __z); }
2202#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2204 fmax(float __x, float __y)
2205 { return __builtin_fmaxf(__x, __y); }
2207 constexpr long double
2208 fmax(long double __x, long double __y)
2209 { return __builtin_fmaxl(__x, __y); }
2212#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2214 fmin(float __x, float __y)
2215 { return __builtin_fminf(__x, __y); }
2217 constexpr long double
2218 fmin(long double __x, long double __y)
2219 { return __builtin_fminl(__x, __y); }
2222#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2224 hypot(float __x, float __y)
2225 { return __builtin_hypotf(__x, __y); }
2227 constexpr long double
2228 hypot(long double __x, long double __y)
2229 { return __builtin_hypotl(__x, __y); }
2232#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2235 { return __builtin_ilogbf(__x); }
2238 ilogb(long double __x)
2239 { return __builtin_ilogbl(__x); }
2242#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2243 template<typename _Tp>
2245 typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2248 { return __builtin_ilogb(__x); }
2251#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2254 { return __builtin_lgammaf(__x); }
2256 constexpr long double
2257 lgamma(long double __x)
2258 { return __builtin_lgammal(__x); }
2261#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2262 template<typename _Tp>
2263 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2266 { return __builtin_lgamma(__x); }
2269#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2272 { return __builtin_llrintf(__x); }
2275 llrint(long double __x)
2276 { return __builtin_llrintl(__x); }
2279#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2280 template<typename _Tp>
2281 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2284 { return __builtin_llrint(__x); }
2287#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2290 { return __builtin_llroundf(__x); }
2293 llround(long double __x)
2294 { return __builtin_llroundl(__x); }
2297#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2298 template<typename _Tp>
2299 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2302 { return __builtin_llround(__x); }
2305#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2308 { return __builtin_log1pf(__x); }
2310 constexpr long double
2311 log1p(long double __x)
2312 { return __builtin_log1pl(__x); }
2315#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2316 template<typename _Tp>
2317 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2320 { return __builtin_log1p(__x); }
2323#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2327 { return __builtin_log2f(__x); }
2329 constexpr long double
2330 log2(long double __x)
2331 { return __builtin_log2l(__x); }
2334#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2335 template<typename _Tp>
2336 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2339 { return __builtin_log2(__x); }
2342#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2345 { return __builtin_logbf(__x); }
2347 constexpr long double
2348 logb(long double __x)
2349 { return __builtin_logbl(__x); }
2352#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2353 template<typename _Tp>
2354 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2357 { return __builtin_logb(__x); }
2360#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2363 { return __builtin_lrintf(__x); }
2366 lrint(long double __x)
2367 { return __builtin_lrintl(__x); }
2370#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2371 template<typename _Tp>
2372 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2375 { return __builtin_lrint(__x); }
2378#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2381 { return __builtin_lroundf(__x); }
2384 lround(long double __x)
2385 { return __builtin_lroundl(__x); }
2388#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2389 template<typename _Tp>
2390 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2393 { return __builtin_lround(__x); }
2396#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2398 nearbyint(float __x)
2399 { return __builtin_nearbyintf(__x); }
2401 constexpr long double
2402 nearbyint(long double __x)
2403 { return __builtin_nearbyintl(__x); }
2406#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2407 template<typename _Tp>
2408 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2411 { return __builtin_nearbyint(__x); }
2414#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2416 nextafter(float __x, float __y)
2417 { return __builtin_nextafterf(__x, __y); }
2419 constexpr long double
2420 nextafter(long double __x, long double __y)
2421 { return __builtin_nextafterl(__x, __y); }
2424#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2426 nexttoward(float __x, long double __y)
2427 { return __builtin_nexttowardf(__x, __y); }
2429 constexpr long double
2430 nexttoward(long double __x, long double __y)
2431 { return __builtin_nexttowardl(__x, __y); }
2434#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2435 template<typename _Tp>
2436 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2438 nexttoward(_Tp __x, long double __y)
2439 { return __builtin_nexttoward(__x, __y); }
2442#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2444 remainder(float __x, float __y)
2445 { return __builtin_remainderf(__x, __y); }
2447 constexpr long double
2448 remainder(long double __x, long double __y)
2449 { return __builtin_remainderl(__x, __y); }
2452#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2454 remquo(float __x, float __y, int* __pquo)
2455 { return __builtin_remquof(__x, __y, __pquo); }
2458 remquo(long double __x, long double __y, int* __pquo)
2459 { return __builtin_remquol(__x, __y, __pquo); }
2462#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2465 { return __builtin_rintf(__x); }
2467 constexpr long double
2468 rint(long double __x)
2469 { return __builtin_rintl(__x); }
2472#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2473 template<typename _Tp>
2474 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2477 { return __builtin_rint(__x); }
2480#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2483 { return __builtin_roundf(__x); }
2485 constexpr long double
2486 round(long double __x)
2487 { return __builtin_roundl(__x); }
2490#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2491 template<typename _Tp>
2492 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2495 { return __builtin_round(__x); }
2498#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2500 scalbln(float __x, long __ex)
2501 { return __builtin_scalblnf(__x, __ex); }
2503 constexpr long double
2504 scalbln(long double __x, long __ex)
2505 { return __builtin_scalblnl(__x, __ex); }
2508#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2509 template<typename _Tp>
2510 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2512 scalbln(_Tp __x, long __ex)
2513 { return __builtin_scalbln(__x, __ex); }
2516#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2518 scalbn(float __x, int __ex)
2519 { return __builtin_scalbnf(__x, __ex); }
2521 constexpr long double
2522 scalbn(long double __x, int __ex)
2523 { return __builtin_scalbnl(__x, __ex); }
2526#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2527 template<typename _Tp>
2528 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2530 scalbn(_Tp __x, int __ex)
2531 { return __builtin_scalbn(__x, __ex); }
2534#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2537 { return __builtin_tgammaf(__x); }
2539 constexpr long double
2540 tgamma(long double __x)
2541 { return __builtin_tgammal(__x); }
2544#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2545 template<typename _Tp>
2546 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2549 { return __builtin_tgamma(__x); }
2552#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
2555 { return __builtin_truncf(__x); }
2557 constexpr long double
2558 trunc(long double __x)
2559 { return __builtin_truncl(__x); }
2562#ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
2563 template<typename _Tp>
2564 constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
2567 { return __builtin_trunc(__x); }
2570#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2573 { return _Float16(__builtin_acoshf(__x)); }
2577 { return _Float16(__builtin_asinhf(__x)); }
2581 { return _Float16(__builtin_atanhf(__x)); }
2585 { return _Float16(__builtin_cbrtf(__x)); }
2588 copysign(_Float16 __x, _Float16 __y)
2589 { return __builtin_copysignf16(__x, __y); }
2593 { return _Float16(__builtin_erff(__x)); }
2597 { return _Float16(__builtin_erfcf(__x)); }
2601 { return _Float16(__builtin_exp2f(__x)); }
2605 { return _Float16(__builtin_expm1f(__x)); }
2608 fdim(_Float16 __x, _Float16 __y)
2609 { return _Float16(__builtin_fdimf(__x, __y)); }
2612 fma(_Float16 __x, _Float16 __y, _Float16 __z)
2613 { return _Float16(__builtin_fmaf(__x, __y, __z)); }
2616 fmax(_Float16 __x, _Float16 __y)
2617 { return _Float16(__builtin_fmaxf(__x, __y)); }
2620 fmin(_Float16 __x, _Float16 __y)
2621 { return _Float16(__builtin_fminf(__x, __y)); }
2624 hypot(_Float16 __x, _Float16 __y)
2625 { return _Float16(__builtin_hypotf(__x, __y)); }
2629 { return _Float16(__builtin_ilogbf(__x)); }
2632 lgamma(_Float16 __x)
2633 { return _Float16(__builtin_lgammaf(__x)); }
2636 llrint(_Float16 __x)
2637 { return _Float16(__builtin_llrintf(__x)); }
2640 llround(_Float16 __x)
2641 { return _Float16(__builtin_llroundf(__x)); }
2645 { return _Float16(__builtin_log1pf(__x)); }
2650 { return _Float16(__builtin_log2f(__x)); }
2654 { return _Float16(__builtin_logbf(__x)); }
2658 { return _Float16(__builtin_lrintf(__x)); }
2661 lround(_Float16 __x)
2662 { return _Float16(__builtin_lroundf(__x)); }
2665 nearbyint(_Float16 __x)
2666 { return _Float16(__builtin_nearbyintf(__x)); }
2669 nextafter(_Float16 __x, _Float16 __y)
2671 if (std::__is_constant_evaluated())
2672 return __builtin_nextafterf16(__x, __y);
2673#ifdef __INT16_TYPE__
2674 using __float16_int_type = __INT16_TYPE__;
2676 using __float16_int_type = short int;
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
2686 return __y; // x == y, return y
2687 if (__ix == 0) // x == 0
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
2694 if (__hx >= 0) // x > 0
2696 if (__hx > __hy) // x > y, x -= ulp
2698 else // x < y, x += ulp
2703 if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp
2705 else // x > y, x += ulp
2708 __hy = __hx & 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));
2718 remainder(_Float16 __x, _Float16 __y)
2719 { return _Float16(__builtin_remainderf(__x, __y)); }
2722 remquo(_Float16 __x, _Float16 __y, int* __pquo)
2723 { return _Float16(__builtin_remquof(__x, __y, __pquo)); }
2727 { return _Float16(__builtin_rintf(__x)); }
2731 { return _Float16(__builtin_roundf(__x)); }
2734 scalbln(_Float16 __x, long __ex)
2735 { return _Float16(__builtin_scalblnf(__x, __ex)); }
2738 scalbn(_Float16 __x, int __ex)
2739 { return _Float16(__builtin_scalbnf(__x, __ex)); }
2742 tgamma(_Float16 __x)
2743 { return _Float16(__builtin_tgammaf(__x)); }
2747 { return _Float16(__builtin_truncf(__x)); }
2750#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
2753 { return __builtin_acoshf(__x); }
2757 { return __builtin_asinhf(__x); }
2761 { return __builtin_atanhf(__x); }
2765 { return __builtin_cbrtf(__x); }
2768 copysign(_Float32 __x, _Float32 __y)
2769 { return __builtin_copysignf(__x, __y); }
2773 { return __builtin_erff(__x); }
2777 { return __builtin_erfcf(__x); }
2781 { return __builtin_exp2f(__x); }
2785 { return __builtin_expm1f(__x); }
2788 fdim(_Float32 __x, _Float32 __y)
2789 { return __builtin_fdimf(__x, __y); }
2792 fma(_Float32 __x, _Float32 __y, _Float32 __z)
2793 { return __builtin_fmaf(__x, __y, __z); }
2796 fmax(_Float32 __x, _Float32 __y)
2797 { return __builtin_fmaxf(__x, __y); }
2800 fmin(_Float32 __x, _Float32 __y)
2801 { return __builtin_fminf(__x, __y); }
2804 hypot(_Float32 __x, _Float32 __y)
2805 { return __builtin_hypotf(__x, __y); }
2809 { return __builtin_ilogbf(__x); }
2812 lgamma(_Float32 __x)
2813 { return __builtin_lgammaf(__x); }
2816 llrint(_Float32 __x)
2817 { return __builtin_llrintf(__x); }
2820 llround(_Float32 __x)
2821 { return __builtin_llroundf(__x); }
2825 { return __builtin_log1pf(__x); }
2830 { return __builtin_log2f(__x); }
2834 { return __builtin_logbf(__x); }
2838 { return __builtin_lrintf(__x); }
2841 lround(_Float32 __x)
2842 { return __builtin_lroundf(__x); }
2845 nearbyint(_Float32 __x)
2846 { return __builtin_nearbyintf(__x); }
2849 nextafter(_Float32 __x, _Float32 __y)
2850 { return __builtin_nextafterf(__x, __y); }
2853 remainder(_Float32 __x, _Float32 __y)
2854 { return __builtin_remainderf(__x, __y); }
2857 remquo(_Float32 __x, _Float32 __y, int* __pquo)
2858 { return __builtin_remquof(__x, __y, __pquo); }
2862 { return __builtin_rintf(__x); }
2866 { return __builtin_roundf(__x); }
2869 scalbln(_Float32 __x, long __ex)
2870 { return __builtin_scalblnf(__x, __ex); }
2873 scalbn(_Float32 __x, int __ex)
2874 { return __builtin_scalbnf(__x, __ex); }
2877 tgamma(_Float32 __x)
2878 { return __builtin_tgammaf(__x); }
2882 { return __builtin_truncf(__x); }
2885#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
2888 { return __builtin_acosh(__x); }
2892 { return __builtin_asinh(__x); }
2896 { return __builtin_atanh(__x); }
2900 { return __builtin_cbrt(__x); }
2903 copysign(_Float64 __x, _Float64 __y)
2904 { return __builtin_copysign(__x, __y); }
2908 { return __builtin_erf(__x); }
2912 { return __builtin_erfc(__x); }
2916 { return __builtin_exp2(__x); }
2920 { return __builtin_expm1(__x); }
2923 fdim(_Float64 __x, _Float64 __y)
2924 { return __builtin_fdim(__x, __y); }
2927 fma(_Float64 __x, _Float64 __y, _Float64 __z)
2928 { return __builtin_fma(__x, __y, __z); }
2931 fmax(_Float64 __x, _Float64 __y)
2932 { return __builtin_fmax(__x, __y); }
2935 fmin(_Float64 __x, _Float64 __y)
2936 { return __builtin_fmin(__x, __y); }
2939 hypot(_Float64 __x, _Float64 __y)
2940 { return __builtin_hypot(__x, __y); }
2944 { return __builtin_ilogb(__x); }
2947 lgamma(_Float64 __x)
2948 { return __builtin_lgamma(__x); }
2951 llrint(_Float64 __x)
2952 { return __builtin_llrint(__x); }
2955 llround(_Float64 __x)
2956 { return __builtin_llround(__x); }
2960 { return __builtin_log1p(__x); }
2965 { return __builtin_log2(__x); }
2969 { return __builtin_logb(__x); }
2973 { return __builtin_lrint(__x); }
2976 lround(_Float64 __x)
2977 { return __builtin_lround(__x); }
2980 nearbyint(_Float64 __x)
2981 { return __builtin_nearbyint(__x); }
2984 nextafter(_Float64 __x, _Float64 __y)
2985 { return __builtin_nextafter(__x, __y); }
2988 remainder(_Float64 __x, _Float64 __y)
2989 { return __builtin_remainder(__x, __y); }
2992 remquo(_Float64 __x, _Float64 __y, int* __pquo)
2993 { return __builtin_remquo(__x, __y, __pquo); }
2997 { return __builtin_rint(__x); }
3001 { return __builtin_round(__x); }
3004 scalbln(_Float64 __x, long __ex)
3005 { return __builtin_scalbln(__x, __ex); }
3008 scalbn(_Float64 __x, int __ex)
3009 { return __builtin_scalbn(__x, __ex); }
3012 tgamma(_Float64 __x)
3013 { return __builtin_tgamma(__x); }
3017 { return __builtin_trunc(__x); }
3020#if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128)
3022 acosh(_Float128 __x)
3023 { return __builtin_acoshl(__x); }
3026 asinh(_Float128 __x)
3027 { return __builtin_asinhl(__x); }
3030 atanh(_Float128 __x)
3031 { return __builtin_atanhl(__x); }
3035 { return __builtin_cbrtl(__x); }
3038 copysign(_Float128 __x, _Float128 __y)
3039 { return __builtin_copysignl(__x, __y); }
3043 { return __builtin_erfl(__x); }
3047 { return __builtin_erfcl(__x); }
3051 { return __builtin_exp2l(__x); }
3054 expm1(_Float128 __x)
3055 { return __builtin_expm1l(__x); }
3058 fdim(_Float128 __x, _Float128 __y)
3059 { return __builtin_fdiml(__x, __y); }
3062 fma(_Float128 __x, _Float128 __y, _Float128 __z)
3063 { return __builtin_fmal(__x, __y, __z); }
3066 fmax(_Float128 __x, _Float128 __y)
3067 { return __builtin_fmaxl(__x, __y); }
3070 fmin(_Float128 __x, _Float128 __y)
3071 { return __builtin_fminl(__x, __y); }
3074 hypot(_Float128 __x, _Float128 __y)
3075 { return __builtin_hypotl(__x, __y); }
3078 ilogb(_Float128 __x)
3079 { return __builtin_ilogbl(__x); }
3082 lgamma(_Float128 __x)
3083 { return __builtin_lgammal(__x); }
3086 llrint(_Float128 __x)
3087 { return __builtin_llrintl(__x); }
3090 llround(_Float128 __x)
3091 { return __builtin_llroundl(__x); }
3094 log1p(_Float128 __x)
3095 { return __builtin_log1pl(__x); }
3100 { return __builtin_log2l(__x); }
3104 { return __builtin_logbl(__x); }
3107 lrint(_Float128 __x)
3108 { return __builtin_lrintl(__x); }
3111 lround(_Float128 __x)
3112 { return __builtin_lroundl(__x); }
3115 nearbyint(_Float128 __x)
3116 { return __builtin_nearbyintl(__x); }
3119 nextafter(_Float128 __x, _Float128 __y)
3120 { return __builtin_nextafterl(__x, __y); }
3123 remainder(_Float128 __x, _Float128 __y)
3124 { return __builtin_remainderl(__x, __y); }
3127 remquo(_Float128 __x, _Float128 __y, int* __pquo)
3128 { return __builtin_remquol(__x, __y, __pquo); }
3132 { return __builtin_rintl(__x); }
3135 round(_Float128 __x)
3136 { return __builtin_roundl(__x); }
3139 scalbln(_Float128 __x, long __ex)
3140 { return __builtin_scalblnl(__x, __ex); }
3143 scalbn(_Float128 __x, int __ex)
3144 { return __builtin_scalbnl(__x, __ex); }
3147 tgamma(_Float128 __x)
3148 { return __builtin_tgammal(__x); }
3151 trunc(_Float128 __x)
3152 { return __builtin_truncl(__x); }
3153#elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH)
3155 acosh(_Float128 __x)
3156 { return __builtin_acoshf128(__x); }
3159 asinh(_Float128 __x)
3160 { return __builtin_asinhf128(__x); }
3163 atanh(_Float128 __x)
3164 { return __builtin_atanhf128(__x); }
3168 { return __builtin_cbrtf128(__x); }
3171 copysign(_Float128 __x, _Float128 __y)
3172 { return __builtin_copysignf128(__x, __y); }
3176 { return __builtin_erff128(__x); }
3180 { return __builtin_erfcf128(__x); }
3184 { return __builtin_exp2f128(__x); }
3187 expm1(_Float128 __x)
3188 { return __builtin_expm1f128(__x); }
3191 fdim(_Float128 __x, _Float128 __y)
3192 { return __builtin_fdimf128(__x, __y); }
3195 fma(_Float128 __x, _Float128 __y, _Float128 __z)
3196 { return __builtin_fmaf128(__x, __y, __z); }
3199 fmax(_Float128 __x, _Float128 __y)
3200 { return __builtin_fmaxf128(__x, __y); }
3203 fmin(_Float128 __x, _Float128 __y)
3204 { return __builtin_fminf128(__x, __y); }
3207 hypot(_Float128 __x, _Float128 __y)
3208 { return __builtin_hypotf128(__x, __y); }
3211 ilogb(_Float128 __x)
3212 { return __builtin_ilogbf128(__x); }
3215 lgamma(_Float128 __x)
3216 { return __builtin_lgammaf128(__x); }
3219 llrint(_Float128 __x)
3220 { return __builtin_llrintf128(__x); }
3223 llround(_Float128 __x)
3224 { return __builtin_llroundf128(__x); }
3227 log1p(_Float128 __x)
3228 { return __builtin_log1pf128(__x); }
3233 { return __builtin_log2f128(__x); }
3237 { return __builtin_logbf128(__x); }
3240 lrint(_Float128 __x)
3241 { return __builtin_lrintf128(__x); }
3244 lround(_Float128 __x)
3245 { return __builtin_lroundf128(__x); }
3248 nearbyint(_Float128 __x)
3249 { return __builtin_nearbyintf128(__x); }
3252 nextafter(_Float128 __x, _Float128 __y)
3253 { return __builtin_nextafterf128(__x, __y); }
3256 remainder(_Float128 __x, _Float128 __y)
3257 { return __builtin_remainderf128(__x, __y); }
3260 remquo(_Float128 __x, _Float128 __y, int* __pquo)
3261 { return __builtin_remquof128(__x, __y, __pquo); }
3265 { return __builtin_rintf128(__x); }
3268 round(_Float128 __x)
3269 { return __builtin_roundf128(__x); }
3272 scalbln(_Float128 __x, long __ex)
3273 { return __builtin_scalblnf128(__x, __ex); }
3276 scalbn(_Float128 __x, int __ex)
3277 { return __builtin_scalbnf128(__x, __ex); }
3280 tgamma(_Float128 __x)
3281 { return __builtin_tgammaf128(__x); }
3284 trunc(_Float128 __x)
3285 { return __builtin_truncf128(__x); }
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)); }
3293 constexpr __gnu_cxx::__bfloat16_t
3294 asinh(__gnu_cxx::__bfloat16_t __x)
3295 { return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); }
3297 constexpr __gnu_cxx::__bfloat16_t
3298 atanh(__gnu_cxx::__bfloat16_t __x)
3299 { return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); }
3301 constexpr __gnu_cxx::__bfloat16_t
3302 cbrt(__gnu_cxx::__bfloat16_t __x)
3303 { return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); }
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)); }
3309 constexpr __gnu_cxx::__bfloat16_t
3310 erf(__gnu_cxx::__bfloat16_t __x)
3311 { return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); }
3313 constexpr __gnu_cxx::__bfloat16_t
3314 erfc(__gnu_cxx::__bfloat16_t __x)
3315 { return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); }
3317 constexpr __gnu_cxx::__bfloat16_t
3318 exp2(__gnu_cxx::__bfloat16_t __x)
3319 { return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); }
3321 constexpr __gnu_cxx::__bfloat16_t
3322 expm1(__gnu_cxx::__bfloat16_t __x)
3323 { return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); }
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)); }
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)); }
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)); }
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)); }
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)); }
3346 ilogb(__gnu_cxx::__bfloat16_t __x)
3347 { return __gnu_cxx::__bfloat16_t(__builtin_ilogbf(__x)); }
3349 constexpr __gnu_cxx::__bfloat16_t
3350 lgamma(__gnu_cxx::__bfloat16_t __x)
3351 { return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); }
3354 llrint(__gnu_cxx::__bfloat16_t __x)
3355 { return __gnu_cxx::__bfloat16_t(__builtin_llrintf(__x)); }
3358 llround(__gnu_cxx::__bfloat16_t __x)
3359 { return __gnu_cxx::__bfloat16_t(__builtin_llroundf(__x)); }
3361 constexpr __gnu_cxx::__bfloat16_t
3362 log1p(__gnu_cxx::__bfloat16_t __x)
3363 { return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); }
3366 constexpr __gnu_cxx::__bfloat16_t
3367 log2(__gnu_cxx::__bfloat16_t __x)
3368 { return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); }
3370 constexpr __gnu_cxx::__bfloat16_t
3371 logb(__gnu_cxx::__bfloat16_t __x)
3372 { return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); }
3375 lrint(__gnu_cxx::__bfloat16_t __x)
3376 { return __gnu_cxx::__bfloat16_t(__builtin_lrintf(__x)); }
3379 lround(__gnu_cxx::__bfloat16_t __x)
3380 { return __gnu_cxx::__bfloat16_t(__builtin_lroundf(__x)); }
3382 constexpr __gnu_cxx::__bfloat16_t
3383 nearbyint(__gnu_cxx::__bfloat16_t __x)
3384 { return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); }
3386 constexpr __gnu_cxx::__bfloat16_t
3387 nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y)
3389 if (std::__is_constant_evaluated())
3390 return __builtin_nextafterf16b(__x, __y);
3391#ifdef __INT16_TYPE__
3392 using __bfloat16_int_type = __INT16_TYPE__;
3394 using __bfloat16_int_type = short int;
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
3404 return __y; // x == y, return y
3405 if (__ix == 0) // x == 0
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
3412 if (__hx >= 0) // x > 0
3414 if (__hx > __hy) // x > y, x -= ulp
3416 else // x < y, x += ulp
3421 if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp
3423 else // x > y, x += ulp
3426 __hy = __hx & 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));
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)); }
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)); }
3443 constexpr __gnu_cxx::__bfloat16_t
3444 rint(__gnu_cxx::__bfloat16_t __x)
3445 { return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); }
3447 constexpr __gnu_cxx::__bfloat16_t
3448 round(__gnu_cxx::__bfloat16_t __x)
3449 { return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); }
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)); }
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)); }
3459 constexpr __gnu_cxx::__bfloat16_t
3460 tgamma(__gnu_cxx::__bfloat16_t __x)
3461 { return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); }
3463 constexpr __gnu_cxx::__bfloat16_t
3464 trunc(__gnu_cxx::__bfloat16_t __x)
3465 { return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); }
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)
3473 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3474 return copysign(__type(__x), __type(__y));
3477 template<typename _Tp, typename _Up>
3478 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3479 fdim(_Tp __x, _Up __y)
3481 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3482 return fdim(__type(__x), __type(__y));
3485 template<typename _Tp, typename _Up>
3486 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3487 fmax(_Tp __x, _Up __y)
3489 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3490 return fmax(__type(__x), __type(__y));
3493 template<typename _Tp, typename _Up>
3494 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3495 fmin(_Tp __x, _Up __y)
3497 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3498 return fmin(__type(__x), __type(__y));
3501 template<typename _Tp, typename _Up>
3502 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3503 hypot(_Tp __x, _Up __y)
3505 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3506 return hypot(__type(__x), __type(__y));
3509 template<typename _Tp, typename _Up>
3510 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3511 nextafter(_Tp __x, _Up __y)
3513 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3514 return nextafter(__type(__x), __type(__y));
3517 template<typename _Tp, typename _Up>
3518 constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3519 remainder(_Tp __x, _Up __y)
3521 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3522 return remainder(__type(__x), __type(__y));
3525 template<typename _Tp, typename _Up>
3526 inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
3527 remquo(_Tp __x, _Up __y, int* __pquo)
3529 typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
3530 return remquo(__type(__x), __type(__y), __pquo);
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)
3537 typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
3538 return fma(__type(__x), __type(__y), __type(__z));
3542#endif // _GLIBCXX_USE_C99_MATH_TR1
3545#if __cplusplus >= 201703L
3547 // [c.math.hypot3], three-dimensional hypotenuse
3548#define __cpp_lib_hypot 201603L
3550 template<typename _Tp>
3552 __hypot3(_Tp __x, _Tp __y, _Tp __z)
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));
3566 hypot(float __x, float __y, float __z)
3567 { return std::__hypot3<float>(__x, __y, __z); }
3570 hypot(double __x, double __y, double __z)
3571 { return std::__hypot3<double>(__x, __y, __z); }
3574 hypot(long double __x, long double __y, long double __z)
3575 { return std::__hypot3<long double>(__x, __y, __z); }
3577 template<typename _Tp, typename _Up, typename _Vp>
3578 __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>
3579 hypot(_Tp __x, _Up __y, _Vp __z)
3581 using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3582 return std::__hypot3<__type>(__x, __y, __z);
3585#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3587 hypot(_Float16 __x, _Float16 __y, _Float16 __z)
3588 { return std::__hypot3<_Float16>(__x, __y, __z); }
3591#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3593 hypot(_Float32 __x, _Float32 __y, _Float32 __z)
3594 { return std::__hypot3<_Float32>(__x, __y, __z); }
3597#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3599 hypot(_Float64 __x, _Float64 __y, _Float64 __z)
3600 { return std::__hypot3<_Float64>(__x, __y, __z); }
3603#if defined(__STDCPP_FLOAT128_T__) \
3604 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3605 || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3607 hypot(_Float128 __x, _Float128 __y, _Float128 __z)
3608 { return std::__hypot3<_Float128>(__x, __y, __z); }
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); }
3619#if __cplusplus >= 202002L
3620 // linear interpolation
3621# define __cpp_lib_interpolate 201902L
3623 template<typename _Fp>
3625 __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
3627 if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0))
3628 return __t * __b + (1 - __t) * __a;
3631 return __b; // exact
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
3642 lerp(float __a, float __b, float __t) noexcept
3643 { return std::__lerp(__a, __b, __t); }
3646 lerp(double __a, double __b, double __t) noexcept
3647 { return std::__lerp(__a, __b, __t); }
3649 constexpr long double
3650 lerp(long double __a, long double __b, long double __t) noexcept
3651 { return std::__lerp(__a, __b, __t); }
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
3657 using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>;
3658 return std::__lerp<__type>(__x, __y, __z);
3661#if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3663 lerp(_Float16 __x, _Float16 __y, _Float16 __z) noexcept
3664 { return std::__lerp<_Float16>(__x, __y, __z); }
3667#if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32)
3669 lerp(_Float32 __x, _Float32 __y, _Float32 __z) noexcept
3670 { return std::__lerp<_Float32>(__x, __y, __z); }
3673#if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64)
3675 lerp(_Float64 __x, _Float64 __y, _Float64 __z) noexcept
3676 { return std::__lerp<_Float64>(__x, __y, __z); }
3679#if defined(__STDCPP_FLOAT128_T__) \
3680 && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \
3681 || defined(_GLIBCXX_HAVE_FLOAT128_MATH))
3683 lerp(_Float128 __x, _Float128 __y, _Float128 __z) noexcept
3684 { return std::__lerp<_Float128>(__x, __y, __z); }
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); }
3695_GLIBCXX_END_NAMESPACE_VERSION
3698#if _GLIBCXX_USE_STD_SPEC_FUNCS
3699# include <bits/specfun.h>