Line data Source code
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 :
79 : extern "C++"
80 : {
81 : namespace 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 32 : isfinite(double __x)
1127 32 : { 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 0 : isnan(double __x)
1180 0 : { 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 8 : signbit(double __x)
1226 8 : { 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
|
