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 |
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 | isfinite(double __x) |
1127 | { return __builtin_isfinite(__x); } |
1128 | |
1129 | constexpr bool |
1130 | isfinite(long double __x) |
1131 | { return __builtin_isfinite(__x); } |
1132 | #endif |
1133 | |
1134 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1135 | template<typename _Tp> |
1136 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1137 | bool>::__type |
1138 | isfinite(_Tp __x) |
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 __x) |
1166 | { return false; } |
1167 | #endif |
1168 | |
1169 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1170 | constexpr bool |
1171 | isnan(float __x) |
1172 | { return __builtin_isnan(__x); } |
1173 | |
1174 | #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \ |
1175 | && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC |
1176 | using ::isnan; |
1177 | #else |
1178 | constexpr bool |
1179 | isnan(double __x) |
1180 | { return __builtin_isnan(__x); } |
1181 | #endif |
1182 | |
1183 | constexpr bool |
1184 | isnan(long double __x) |
1185 | { return __builtin_isnan(__x); } |
1186 | #endif |
1187 | |
1188 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1189 | template<typename _Tp> |
1190 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1191 | bool>::__type |
1192 | isnan(_Tp __x) |
1193 | { return false; } |
1194 | #endif |
1195 | |
1196 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1197 | constexpr bool |
1198 | isnormal(float __x) |
1199 | { return __builtin_isnormal(__x); } |
1200 | |
1201 | constexpr bool |
1202 | isnormal(double __x) |
1203 | { return __builtin_isnormal(__x); } |
1204 | |
1205 | constexpr bool |
1206 | isnormal(long double __x) |
1207 | { return __builtin_isnormal(__x); } |
1208 | #endif |
1209 | |
1210 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1211 | template<typename _Tp> |
1212 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1213 | bool>::__type |
1214 | isnormal(_Tp __x) |
1215 | { return __x != 0 ? true : false; } |
1216 | #endif |
1217 | |
1218 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1219 | // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic. |
1220 | constexpr bool |
1221 | signbit(float __x) |
1222 | { return __builtin_signbit(__x); } |
1223 | |
1224 | constexpr bool |
1225 | signbit(double __x) |
1226 | { return __builtin_signbit(__x); } |
1227 | |
1228 | constexpr bool |
1229 | signbit(long double __x) |
1230 | { return __builtin_signbit(__x); } |
1231 | #endif |
1232 | |
1233 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1234 | template<typename _Tp> |
1235 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
1236 | bool>::__type |
1237 | signbit(_Tp __x) |
1238 | { return __x < 0 ? true : false; } |
1239 | #endif |
1240 | |
1241 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1242 | constexpr bool |
1243 | isgreater(float __x, float __y) |
1244 | { return __builtin_isgreater(__x, __y); } |
1245 | |
1246 | constexpr bool |
1247 | isgreater(double __x, double __y) |
1248 | { return __builtin_isgreater(__x, __y); } |
1249 | |
1250 | constexpr bool |
1251 | isgreater(long double __x, long double __y) |
1252 | { return __builtin_isgreater(__x, __y); } |
1253 | #endif |
1254 | |
1255 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1256 | template<typename _Tp, typename _Up> |
1257 | constexpr typename |
1258 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
1259 | && __is_arithmetic<_Up>::__value), bool>::__type |
1260 | isgreater(_Tp __x, _Up __y) |
1261 | { |
1262 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1263 | return __builtin_isgreater(__type(__x), __type(__y)); |
1264 | } |
1265 | #endif |
1266 | |
1267 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1268 | constexpr bool |
1269 | isgreaterequal(float __x, float __y) |
1270 | { return __builtin_isgreaterequal(__x, __y); } |
1271 | |
1272 | constexpr bool |
1273 | isgreaterequal(double __x, double __y) |
1274 | { return __builtin_isgreaterequal(__x, __y); } |
1275 | |
1276 | constexpr bool |
1277 | isgreaterequal(long double __x, long double __y) |
1278 | { return __builtin_isgreaterequal(__x, __y); } |
1279 | #endif |
1280 | |
1281 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1282 | template<typename _Tp, typename _Up> |
1283 | constexpr typename |
1284 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
1285 | && __is_arithmetic<_Up>::__value), bool>::__type |
1286 | isgreaterequal(_Tp __x, _Up __y) |
1287 | { |
1288 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1289 | return __builtin_isgreaterequal(__type(__x), __type(__y)); |
1290 | } |
1291 | #endif |
1292 | |
1293 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1294 | constexpr bool |
1295 | isless(float __x, float __y) |
1296 | { return __builtin_isless(__x, __y); } |
1297 | |
1298 | constexpr bool |
1299 | isless(double __x, double __y) |
1300 | { return __builtin_isless(__x, __y); } |
1301 | |
1302 | constexpr bool |
1303 | isless(long double __x, long double __y) |
1304 | { return __builtin_isless(__x, __y); } |
1305 | #endif |
1306 | |
1307 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1308 | template<typename _Tp, typename _Up> |
1309 | constexpr typename |
1310 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
1311 | && __is_arithmetic<_Up>::__value), bool>::__type |
1312 | isless(_Tp __x, _Up __y) |
1313 | { |
1314 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1315 | return __builtin_isless(__type(__x), __type(__y)); |
1316 | } |
1317 | #endif |
1318 | |
1319 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1320 | constexpr bool |
1321 | islessequal(float __x, float __y) |
1322 | { return __builtin_islessequal(__x, __y); } |
1323 | |
1324 | constexpr bool |
1325 | islessequal(double __x, double __y) |
1326 | { return __builtin_islessequal(__x, __y); } |
1327 | |
1328 | constexpr bool |
1329 | islessequal(long double __x, long double __y) |
1330 | { return __builtin_islessequal(__x, __y); } |
1331 | #endif |
1332 | |
1333 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1334 | template<typename _Tp, typename _Up> |
1335 | constexpr typename |
1336 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
1337 | && __is_arithmetic<_Up>::__value), bool>::__type |
1338 | islessequal(_Tp __x, _Up __y) |
1339 | { |
1340 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1341 | return __builtin_islessequal(__type(__x), __type(__y)); |
1342 | } |
1343 | #endif |
1344 | |
1345 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1346 | constexpr bool |
1347 | islessgreater(float __x, float __y) |
1348 | { return __builtin_islessgreater(__x, __y); } |
1349 | |
1350 | constexpr bool |
1351 | islessgreater(double __x, double __y) |
1352 | { return __builtin_islessgreater(__x, __y); } |
1353 | |
1354 | constexpr bool |
1355 | islessgreater(long double __x, long double __y) |
1356 | { return __builtin_islessgreater(__x, __y); } |
1357 | #endif |
1358 | |
1359 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1360 | template<typename _Tp, typename _Up> |
1361 | constexpr typename |
1362 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
1363 | && __is_arithmetic<_Up>::__value), bool>::__type |
1364 | islessgreater(_Tp __x, _Up __y) |
1365 | { |
1366 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1367 | return __builtin_islessgreater(__type(__x), __type(__y)); |
1368 | } |
1369 | #endif |
1370 | |
1371 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
1372 | constexpr bool |
1373 | isunordered(float __x, float __y) |
1374 | { return __builtin_isunordered(__x, __y); } |
1375 | |
1376 | constexpr bool |
1377 | isunordered(double __x, double __y) |
1378 | { return __builtin_isunordered(__x, __y); } |
1379 | |
1380 | constexpr bool |
1381 | isunordered(long double __x, long double __y) |
1382 | { return __builtin_isunordered(__x, __y); } |
1383 | #endif |
1384 | |
1385 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
1386 | template<typename _Tp, typename _Up> |
1387 | constexpr typename |
1388 | __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value |
1389 | && __is_arithmetic<_Up>::__value), bool>::__type |
1390 | isunordered(_Tp __x, _Up __y) |
1391 | { |
1392 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
1393 | return __builtin_isunordered(__type(__x), __type(__y)); |
1394 | } |
1395 | #endif |
1396 | |
1397 | #else |
1398 | |
1399 | template<typename _Tp> |
1400 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1401 | int>::__type |
1402 | fpclassify(_Tp __f) |
1403 | { |
1404 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1405 | return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
1406 | FP_SUBNORMAL, FP_ZERO, __type(__f)); |
1407 | } |
1408 | |
1409 | template<typename _Tp> |
1410 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1411 | int>::__type |
1412 | isfinite(_Tp __f) |
1413 | { |
1414 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1415 | return __builtin_isfinite(__type(__f)); |
1416 | } |
1417 | |
1418 | template<typename _Tp> |
1419 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1420 | int>::__type |
1421 | isinf(_Tp __f) |
1422 | { |
1423 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1424 | return __builtin_isinf(__type(__f)); |
1425 | } |
1426 | |
1427 | template<typename _Tp> |
1428 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1429 | int>::__type |
1430 | isnan(_Tp __f) |
1431 | { |
1432 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1433 | return __builtin_isnan(__type(__f)); |
1434 | } |
1435 | |
1436 | template<typename _Tp> |
1437 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1438 | int>::__type |
1439 | isnormal(_Tp __f) |
1440 | { |
1441 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1442 | return __builtin_isnormal(__type(__f)); |
1443 | } |
1444 | |
1445 | template<typename _Tp> |
1446 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1447 | int>::__type |
1448 | signbit(_Tp __f) |
1449 | { |
1450 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1451 | return __builtin_signbit(__type(__f)); |
1452 | } |
1453 | |
1454 | template<typename _Tp> |
1455 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1456 | int>::__type |
1457 | isgreater(_Tp __f1, _Tp __f2) |
1458 | { |
1459 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1460 | return __builtin_isgreater(__type(__f1), __type(__f2)); |
1461 | } |
1462 | |
1463 | template<typename _Tp> |
1464 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1465 | int>::__type |
1466 | isgreaterequal(_Tp __f1, _Tp __f2) |
1467 | { |
1468 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1469 | return __builtin_isgreaterequal(__type(__f1), __type(__f2)); |
1470 | } |
1471 | |
1472 | template<typename _Tp> |
1473 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1474 | int>::__type |
1475 | isless(_Tp __f1, _Tp __f2) |
1476 | { |
1477 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1478 | return __builtin_isless(__type(__f1), __type(__f2)); |
1479 | } |
1480 | |
1481 | template<typename _Tp> |
1482 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1483 | int>::__type |
1484 | islessequal(_Tp __f1, _Tp __f2) |
1485 | { |
1486 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1487 | return __builtin_islessequal(__type(__f1), __type(__f2)); |
1488 | } |
1489 | |
1490 | template<typename _Tp> |
1491 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1492 | int>::__type |
1493 | islessgreater(_Tp __f1, _Tp __f2) |
1494 | { |
1495 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1496 | return __builtin_islessgreater(__type(__f1), __type(__f2)); |
1497 | } |
1498 | |
1499 | template<typename _Tp> |
1500 | inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value, |
1501 | int>::__type |
1502 | isunordered(_Tp __f1, _Tp __f2) |
1503 | { |
1504 | typedef typename __gnu_cxx::__promote<_Tp>::__type __type; |
1505 | return __builtin_isunordered(__type(__f1), __type(__f2)); |
1506 | } |
1507 | |
1508 | #endif // C++11 |
1509 | |
1510 | #ifdef __STDCPP_FLOAT16_T__ |
1511 | constexpr int |
1512 | fpclassify(_Float16 __x) |
1513 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
1514 | FP_SUBNORMAL, FP_ZERO, __x); } |
1515 | |
1516 | constexpr bool |
1517 | isfinite(_Float16 __x) |
1518 | { return __builtin_isfinite(__x); } |
1519 | |
1520 | constexpr bool |
1521 | isinf(_Float16 __x) |
1522 | { return __builtin_isinf(__x); } |
1523 | |
1524 | constexpr bool |
1525 | isnan(_Float16 __x) |
1526 | { return __builtin_isnan(__x); } |
1527 | |
1528 | constexpr bool |
1529 | isnormal(_Float16 __x) |
1530 | { return __builtin_isnormal(__x); } |
1531 | |
1532 | constexpr bool |
1533 | signbit(_Float16 __x) |
1534 | { return __builtin_signbit(__x); } |
1535 | |
1536 | constexpr bool |
1537 | isgreater(_Float16 __x, _Float16 __y) |
1538 | { return __builtin_isgreater(__x, __y); } |
1539 | |
1540 | constexpr bool |
1541 | isgreaterequal(_Float16 __x, _Float16 __y) |
1542 | { return __builtin_isgreaterequal(__x, __y); } |
1543 | |
1544 | constexpr bool |
1545 | isless(_Float16 __x, _Float16 __y) |
1546 | { return __builtin_isless(__x, __y); } |
1547 | |
1548 | constexpr bool |
1549 | islessequal(_Float16 __x, _Float16 __y) |
1550 | { return __builtin_islessequal(__x, __y); } |
1551 | |
1552 | constexpr bool |
1553 | islessgreater(_Float16 __x, _Float16 __y) |
1554 | { return __builtin_islessgreater(__x, __y); } |
1555 | |
1556 | constexpr bool |
1557 | isunordered(_Float16 __x, _Float16 __y) |
1558 | { return __builtin_isunordered(__x, __y); } |
1559 | #endif |
1560 | |
1561 | #ifdef __STDCPP_FLOAT32_T__ |
1562 | constexpr int |
1563 | fpclassify(_Float32 __x) |
1564 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
1565 | FP_SUBNORMAL, FP_ZERO, __x); } |
1566 | |
1567 | constexpr bool |
1568 | isfinite(_Float32 __x) |
1569 | { return __builtin_isfinite(__x); } |
1570 | |
1571 | constexpr bool |
1572 | isinf(_Float32 __x) |
1573 | { return __builtin_isinf(__x); } |
1574 | |
1575 | constexpr bool |
1576 | isnan(_Float32 __x) |
1577 | { return __builtin_isnan(__x); } |
1578 | |
1579 | constexpr bool |
1580 | isnormal(_Float32 __x) |
1581 | { return __builtin_isnormal(__x); } |
1582 | |
1583 | constexpr bool |
1584 | signbit(_Float32 __x) |
1585 | { return __builtin_signbit(__x); } |
1586 | |
1587 | constexpr bool |
1588 | isgreater(_Float32 __x, _Float32 __y) |
1589 | { return __builtin_isgreater(__x, __y); } |
1590 | |
1591 | constexpr bool |
1592 | isgreaterequal(_Float32 __x, _Float32 __y) |
1593 | { return __builtin_isgreaterequal(__x, __y); } |
1594 | |
1595 | constexpr bool |
1596 | isless(_Float32 __x, _Float32 __y) |
1597 | { return __builtin_isless(__x, __y); } |
1598 | |
1599 | constexpr bool |
1600 | islessequal(_Float32 __x, _Float32 __y) |
1601 | { return __builtin_islessequal(__x, __y); } |
1602 | |
1603 | constexpr bool |
1604 | islessgreater(_Float32 __x, _Float32 __y) |
1605 | { return __builtin_islessgreater(__x, __y); } |
1606 | |
1607 | constexpr bool |
1608 | isunordered(_Float32 __x, _Float32 __y) |
1609 | { return __builtin_isunordered(__x, __y); } |
1610 | #endif |
1611 | |
1612 | #ifdef __STDCPP_FLOAT64_T__ |
1613 | constexpr int |
1614 | fpclassify(_Float64 __x) |
1615 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
1616 | FP_SUBNORMAL, FP_ZERO, __x); } |
1617 | |
1618 | constexpr bool |
1619 | isfinite(_Float64 __x) |
1620 | { return __builtin_isfinite(__x); } |
1621 | |
1622 | constexpr bool |
1623 | isinf(_Float64 __x) |
1624 | { return __builtin_isinf(__x); } |
1625 | |
1626 | constexpr bool |
1627 | isnan(_Float64 __x) |
1628 | { return __builtin_isnan(__x); } |
1629 | |
1630 | constexpr bool |
1631 | isnormal(_Float64 __x) |
1632 | { return __builtin_isnormal(__x); } |
1633 | |
1634 | constexpr bool |
1635 | signbit(_Float64 __x) |
1636 | { return __builtin_signbit(__x); } |
1637 | |
1638 | constexpr bool |
1639 | isgreater(_Float64 __x, _Float64 __y) |
1640 | { return __builtin_isgreater(__x, __y); } |
1641 | |
1642 | constexpr bool |
1643 | isgreaterequal(_Float64 __x, _Float64 __y) |
1644 | { return __builtin_isgreaterequal(__x, __y); } |
1645 | |
1646 | constexpr bool |
1647 | isless(_Float64 __x, _Float64 __y) |
1648 | { return __builtin_isless(__x, __y); } |
1649 | |
1650 | constexpr bool |
1651 | islessequal(_Float64 __x, _Float64 __y) |
1652 | { return __builtin_islessequal(__x, __y); } |
1653 | |
1654 | constexpr bool |
1655 | islessgreater(_Float64 __x, _Float64 __y) |
1656 | { return __builtin_islessgreater(__x, __y); } |
1657 | |
1658 | constexpr bool |
1659 | isunordered(_Float64 __x, _Float64 __y) |
1660 | { return __builtin_isunordered(__x, __y); } |
1661 | #endif |
1662 | |
1663 | #ifdef __STDCPP_FLOAT128_T__ |
1664 | constexpr int |
1665 | fpclassify(_Float128 __x) |
1666 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
1667 | FP_SUBNORMAL, FP_ZERO, __x); } |
1668 | |
1669 | constexpr bool |
1670 | isfinite(_Float128 __x) |
1671 | { return __builtin_isfinite(__x); } |
1672 | |
1673 | constexpr bool |
1674 | isinf(_Float128 __x) |
1675 | { return __builtin_isinf(__x); } |
1676 | |
1677 | constexpr bool |
1678 | isnan(_Float128 __x) |
1679 | { return __builtin_isnan(__x); } |
1680 | |
1681 | constexpr bool |
1682 | isnormal(_Float128 __x) |
1683 | { return __builtin_isnormal(__x); } |
1684 | |
1685 | constexpr bool |
1686 | signbit(_Float128 __x) |
1687 | { return __builtin_signbit(__x); } |
1688 | |
1689 | constexpr bool |
1690 | isgreater(_Float128 __x, _Float128 __y) |
1691 | { return __builtin_isgreater(__x, __y); } |
1692 | |
1693 | constexpr bool |
1694 | isgreaterequal(_Float128 __x, _Float128 __y) |
1695 | { return __builtin_isgreaterequal(__x, __y); } |
1696 | |
1697 | constexpr bool |
1698 | isless(_Float128 __x, _Float128 __y) |
1699 | { return __builtin_isless(__x, __y); } |
1700 | |
1701 | constexpr bool |
1702 | islessequal(_Float128 __x, _Float128 __y) |
1703 | { return __builtin_islessequal(__x, __y); } |
1704 | |
1705 | constexpr bool |
1706 | islessgreater(_Float128 __x, _Float128 __y) |
1707 | { return __builtin_islessgreater(__x, __y); } |
1708 | |
1709 | constexpr bool |
1710 | isunordered(_Float128 __x, _Float128 __y) |
1711 | { return __builtin_isunordered(__x, __y); } |
1712 | #endif |
1713 | |
1714 | #ifdef __STDCPP_BFLOAT16_T__ |
1715 | constexpr int |
1716 | fpclassify(__gnu_cxx::__bfloat16_t __x) |
1717 | { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL, |
1718 | FP_SUBNORMAL, FP_ZERO, __x); } |
1719 | |
1720 | constexpr bool |
1721 | isfinite(__gnu_cxx::__bfloat16_t __x) |
1722 | { return __builtin_isfinite(__x); } |
1723 | |
1724 | constexpr bool |
1725 | isinf(__gnu_cxx::__bfloat16_t __x) |
1726 | { return __builtin_isinf(__x); } |
1727 | |
1728 | constexpr bool |
1729 | isnan(__gnu_cxx::__bfloat16_t __x) |
1730 | { return __builtin_isnan(__x); } |
1731 | |
1732 | constexpr bool |
1733 | isnormal(__gnu_cxx::__bfloat16_t __x) |
1734 | { return __builtin_isnormal(__x); } |
1735 | |
1736 | constexpr bool |
1737 | signbit(__gnu_cxx::__bfloat16_t __x) |
1738 | { return __builtin_signbit(__x); } |
1739 | |
1740 | constexpr bool |
1741 | isgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
1742 | { return __builtin_isgreater(__x, __y); } |
1743 | |
1744 | constexpr bool |
1745 | isgreaterequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
1746 | { return __builtin_isgreaterequal(__x, __y); } |
1747 | |
1748 | constexpr bool |
1749 | isless(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
1750 | { return __builtin_isless(__x, __y); } |
1751 | |
1752 | constexpr bool |
1753 | islessequal(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
1754 | { return __builtin_islessequal(__x, __y); } |
1755 | |
1756 | constexpr bool |
1757 | islessgreater(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
1758 | { return __builtin_islessgreater(__x, __y); } |
1759 | |
1760 | constexpr bool |
1761 | isunordered(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
1762 | { return __builtin_isunordered(__x, __y); } |
1763 | #endif |
1764 | |
1765 | #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */ |
1766 | #endif /* _GLIBCXX_USE_C99_MATH */ |
1767 | |
1768 | #if __cplusplus >= 201103L |
1769 | |
1770 | #ifdef _GLIBCXX_USE_C99_MATH_TR1 |
1771 | |
1772 | #undef acosh |
1773 | #undef acoshf |
1774 | #undef acoshl |
1775 | #undef asinh |
1776 | #undef asinhf |
1777 | #undef asinhl |
1778 | #undef atanh |
1779 | #undef atanhf |
1780 | #undef atanhl |
1781 | #undef cbrt |
1782 | #undef cbrtf |
1783 | #undef cbrtl |
1784 | #undef copysign |
1785 | #undef copysignf |
1786 | #undef copysignl |
1787 | #undef erf |
1788 | #undef erff |
1789 | #undef erfl |
1790 | #undef erfc |
1791 | #undef erfcf |
1792 | #undef erfcl |
1793 | #undef exp2 |
1794 | #undef exp2f |
1795 | #undef exp2l |
1796 | #undef expm1 |
1797 | #undef expm1f |
1798 | #undef expm1l |
1799 | #undef fdim |
1800 | #undef fdimf |
1801 | #undef fdiml |
1802 | #undef fma |
1803 | #undef fmaf |
1804 | #undef fmal |
1805 | #undef fmax |
1806 | #undef fmaxf |
1807 | #undef fmaxl |
1808 | #undef fmin |
1809 | #undef fminf |
1810 | #undef fminl |
1811 | #undef hypot |
1812 | #undef hypotf |
1813 | #undef hypotl |
1814 | #undef ilogb |
1815 | #undef ilogbf |
1816 | #undef ilogbl |
1817 | #undef lgamma |
1818 | #undef lgammaf |
1819 | #undef lgammal |
1820 | #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS |
1821 | #undef llrint |
1822 | #undef llrintf |
1823 | #undef llrintl |
1824 | #undef llround |
1825 | #undef llroundf |
1826 | #undef llroundl |
1827 | #endif |
1828 | #undef log1p |
1829 | #undef log1pf |
1830 | #undef log1pl |
1831 | #undef log2 |
1832 | #undef log2f |
1833 | #undef log2l |
1834 | #undef logb |
1835 | #undef logbf |
1836 | #undef logbl |
1837 | #undef lrint |
1838 | #undef lrintf |
1839 | #undef lrintl |
1840 | #undef lround |
1841 | #undef lroundf |
1842 | #undef lroundl |
1843 | #undef nan |
1844 | #undef nanf |
1845 | #undef nanl |
1846 | #undef nearbyint |
1847 | #undef nearbyintf |
1848 | #undef nearbyintl |
1849 | #undef nextafter |
1850 | #undef nextafterf |
1851 | #undef nextafterl |
1852 | #undef nexttoward |
1853 | #undef nexttowardf |
1854 | #undef nexttowardl |
1855 | #undef remainder |
1856 | #undef remainderf |
1857 | #undef remainderl |
1858 | #undef remquo |
1859 | #undef remquof |
1860 | #undef remquol |
1861 | #undef rint |
1862 | #undef rintf |
1863 | #undef rintl |
1864 | #undef round |
1865 | #undef roundf |
1866 | #undef roundl |
1867 | #undef scalbln |
1868 | #undef scalblnf |
1869 | #undef scalblnl |
1870 | #undef scalbn |
1871 | #undef scalbnf |
1872 | #undef scalbnl |
1873 | #undef tgamma |
1874 | #undef tgammaf |
1875 | #undef tgammal |
1876 | #undef trunc |
1877 | #undef truncf |
1878 | #undef truncl |
1879 | |
1880 | // types |
1881 | using ::double_t; |
1882 | using ::float_t; |
1883 | |
1884 | // functions |
1885 | using ::acosh; |
1886 | using ::acoshf; |
1887 | using ::acoshl; |
1888 | |
1889 | using ::asinh; |
1890 | using ::asinhf; |
1891 | using ::asinhl; |
1892 | |
1893 | using ::atanh; |
1894 | using ::atanhf; |
1895 | using ::atanhl; |
1896 | |
1897 | using ::cbrt; |
1898 | using ::cbrtf; |
1899 | using ::cbrtl; |
1900 | |
1901 | using ::copysign; |
1902 | using ::copysignf; |
1903 | using ::copysignl; |
1904 | |
1905 | using ::erf; |
1906 | using ::erff; |
1907 | using ::erfl; |
1908 | |
1909 | using ::erfc; |
1910 | using ::erfcf; |
1911 | using ::erfcl; |
1912 | |
1913 | using ::exp2; |
1914 | using ::exp2f; |
1915 | using ::exp2l; |
1916 | |
1917 | using ::expm1; |
1918 | using ::expm1f; |
1919 | using ::expm1l; |
1920 | |
1921 | using ::fdim; |
1922 | using ::fdimf; |
1923 | using ::fdiml; |
1924 | |
1925 | using ::fma; |
1926 | using ::fmaf; |
1927 | using ::fmal; |
1928 | |
1929 | using ::fmax; |
1930 | using ::fmaxf; |
1931 | using ::fmaxl; |
1932 | |
1933 | using ::fmin; |
1934 | using ::fminf; |
1935 | using ::fminl; |
1936 | |
1937 | using ::hypot; |
1938 | using ::hypotf; |
1939 | using ::hypotl; |
1940 | |
1941 | using ::ilogb; |
1942 | using ::ilogbf; |
1943 | using ::ilogbl; |
1944 | |
1945 | using ::lgamma; |
1946 | using ::lgammaf; |
1947 | using ::lgammal; |
1948 | |
1949 | #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS |
1950 | using ::llrint; |
1951 | using ::llrintf; |
1952 | using ::llrintl; |
1953 | |
1954 | using ::llround; |
1955 | using ::llroundf; |
1956 | using ::llroundl; |
1957 | #endif |
1958 | |
1959 | using ::log1p; |
1960 | using ::log1pf; |
1961 | using ::log1pl; |
1962 | |
1963 | using ::log2; |
1964 | using ::log2f; |
1965 | using ::log2l; |
1966 | |
1967 | using ::logb; |
1968 | using ::logbf; |
1969 | using ::logbl; |
1970 | |
1971 | using ::lrint; |
1972 | using ::lrintf; |
1973 | using ::lrintl; |
1974 | |
1975 | using ::lround; |
1976 | using ::lroundf; |
1977 | using ::lroundl; |
1978 | |
1979 | using ::nan; |
1980 | using ::nanf; |
1981 | using ::nanl; |
1982 | |
1983 | using ::nearbyint; |
1984 | using ::nearbyintf; |
1985 | using ::nearbyintl; |
1986 | |
1987 | using ::nextafter; |
1988 | using ::nextafterf; |
1989 | using ::nextafterl; |
1990 | |
1991 | using ::nexttoward; |
1992 | using ::nexttowardf; |
1993 | using ::nexttowardl; |
1994 | |
1995 | using ::remainder; |
1996 | using ::remainderf; |
1997 | using ::remainderl; |
1998 | |
1999 | using ::remquo; |
2000 | using ::remquof; |
2001 | using ::remquol; |
2002 | |
2003 | using ::rint; |
2004 | using ::rintf; |
2005 | using ::rintl; |
2006 | |
2007 | using ::round; |
2008 | using ::roundf; |
2009 | using ::roundl; |
2010 | |
2011 | using ::scalbln; |
2012 | using ::scalblnf; |
2013 | using ::scalblnl; |
2014 | |
2015 | using ::scalbn; |
2016 | using ::scalbnf; |
2017 | using ::scalbnl; |
2018 | |
2019 | using ::tgamma; |
2020 | using ::tgammaf; |
2021 | using ::tgammal; |
2022 | |
2023 | using ::trunc; |
2024 | using ::truncf; |
2025 | using ::truncl; |
2026 | |
2027 | /// Additional overloads. |
2028 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2029 | constexpr float |
2030 | acosh(float __x) |
2031 | { return __builtin_acoshf(__x); } |
2032 | |
2033 | constexpr long double |
2034 | acosh(long double __x) |
2035 | { return __builtin_acoshl(__x); } |
2036 | #endif |
2037 | |
2038 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2039 | template<typename _Tp> |
2040 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2041 | double>::__type |
2042 | acosh(_Tp __x) |
2043 | { return __builtin_acosh(__x); } |
2044 | #endif |
2045 | |
2046 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2047 | constexpr float |
2048 | asinh(float __x) |
2049 | { return __builtin_asinhf(__x); } |
2050 | |
2051 | constexpr long double |
2052 | asinh(long double __x) |
2053 | { return __builtin_asinhl(__x); } |
2054 | #endif |
2055 | |
2056 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2057 | template<typename _Tp> |
2058 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2059 | double>::__type |
2060 | asinh(_Tp __x) |
2061 | { return __builtin_asinh(__x); } |
2062 | #endif |
2063 | |
2064 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2065 | constexpr float |
2066 | atanh(float __x) |
2067 | { return __builtin_atanhf(__x); } |
2068 | |
2069 | constexpr long double |
2070 | atanh(long double __x) |
2071 | { return __builtin_atanhl(__x); } |
2072 | #endif |
2073 | |
2074 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2075 | template<typename _Tp> |
2076 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2077 | double>::__type |
2078 | atanh(_Tp __x) |
2079 | { return __builtin_atanh(__x); } |
2080 | #endif |
2081 | |
2082 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2083 | constexpr float |
2084 | cbrt(float __x) |
2085 | { return __builtin_cbrtf(__x); } |
2086 | |
2087 | constexpr long double |
2088 | cbrt(long double __x) |
2089 | { return __builtin_cbrtl(__x); } |
2090 | #endif |
2091 | |
2092 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2093 | template<typename _Tp> |
2094 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2095 | double>::__type |
2096 | cbrt(_Tp __x) |
2097 | { return __builtin_cbrt(__x); } |
2098 | #endif |
2099 | |
2100 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2101 | constexpr float |
2102 | copysign(float __x, float __y) |
2103 | { return __builtin_copysignf(__x, __y); } |
2104 | |
2105 | constexpr long double |
2106 | copysign(long double __x, long double __y) |
2107 | { return __builtin_copysignl(__x, __y); } |
2108 | #endif |
2109 | |
2110 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2111 | constexpr float |
2112 | erf(float __x) |
2113 | { return __builtin_erff(__x); } |
2114 | |
2115 | constexpr long double |
2116 | erf(long double __x) |
2117 | { return __builtin_erfl(__x); } |
2118 | #endif |
2119 | |
2120 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2121 | template<typename _Tp> |
2122 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2123 | double>::__type |
2124 | erf(_Tp __x) |
2125 | { return __builtin_erf(__x); } |
2126 | #endif |
2127 | |
2128 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2129 | constexpr float |
2130 | erfc(float __x) |
2131 | { return __builtin_erfcf(__x); } |
2132 | |
2133 | constexpr long double |
2134 | erfc(long double __x) |
2135 | { return __builtin_erfcl(__x); } |
2136 | #endif |
2137 | |
2138 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2139 | template<typename _Tp> |
2140 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2141 | double>::__type |
2142 | erfc(_Tp __x) |
2143 | { return __builtin_erfc(__x); } |
2144 | #endif |
2145 | |
2146 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2147 | constexpr float |
2148 | exp2(float __x) |
2149 | { return __builtin_exp2f(__x); } |
2150 | |
2151 | constexpr long double |
2152 | exp2(long double __x) |
2153 | { return __builtin_exp2l(__x); } |
2154 | #endif |
2155 | |
2156 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2157 | template<typename _Tp> |
2158 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2159 | double>::__type |
2160 | exp2(_Tp __x) |
2161 | { return __builtin_exp2(__x); } |
2162 | #endif |
2163 | |
2164 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2165 | constexpr float |
2166 | expm1(float __x) |
2167 | { return __builtin_expm1f(__x); } |
2168 | |
2169 | constexpr long double |
2170 | expm1(long double __x) |
2171 | { return __builtin_expm1l(__x); } |
2172 | #endif |
2173 | |
2174 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2175 | template<typename _Tp> |
2176 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2177 | double>::__type |
2178 | expm1(_Tp __x) |
2179 | { return __builtin_expm1(__x); } |
2180 | #endif |
2181 | |
2182 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2183 | constexpr float |
2184 | fdim(float __x, float __y) |
2185 | { return __builtin_fdimf(__x, __y); } |
2186 | |
2187 | constexpr long double |
2188 | fdim(long double __x, long double __y) |
2189 | { return __builtin_fdiml(__x, __y); } |
2190 | #endif |
2191 | |
2192 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2193 | constexpr float |
2194 | fma(float __x, float __y, float __z) |
2195 | { return __builtin_fmaf(__x, __y, __z); } |
2196 | |
2197 | constexpr long double |
2198 | fma(long double __x, long double __y, long double __z) |
2199 | { return __builtin_fmal(__x, __y, __z); } |
2200 | #endif |
2201 | |
2202 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2203 | constexpr float |
2204 | fmax(float __x, float __y) |
2205 | { return __builtin_fmaxf(__x, __y); } |
2206 | |
2207 | constexpr long double |
2208 | fmax(long double __x, long double __y) |
2209 | { return __builtin_fmaxl(__x, __y); } |
2210 | #endif |
2211 | |
2212 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2213 | constexpr float |
2214 | fmin(float __x, float __y) |
2215 | { return __builtin_fminf(__x, __y); } |
2216 | |
2217 | constexpr long double |
2218 | fmin(long double __x, long double __y) |
2219 | { return __builtin_fminl(__x, __y); } |
2220 | #endif |
2221 | |
2222 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2223 | constexpr float |
2224 | hypot(float __x, float __y) |
2225 | { return __builtin_hypotf(__x, __y); } |
2226 | |
2227 | constexpr long double |
2228 | hypot(long double __x, long double __y) |
2229 | { return __builtin_hypotl(__x, __y); } |
2230 | #endif |
2231 | |
2232 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2233 | constexpr int |
2234 | ilogb(float __x) |
2235 | { return __builtin_ilogbf(__x); } |
2236 | |
2237 | constexpr int |
2238 | ilogb(long double __x) |
2239 | { return __builtin_ilogbl(__x); } |
2240 | #endif |
2241 | |
2242 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2243 | template<typename _Tp> |
2244 | constexpr |
2245 | typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2246 | int>::__type |
2247 | ilogb(_Tp __x) |
2248 | { return __builtin_ilogb(__x); } |
2249 | #endif |
2250 | |
2251 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2252 | constexpr float |
2253 | lgamma(float __x) |
2254 | { return __builtin_lgammaf(__x); } |
2255 | |
2256 | constexpr long double |
2257 | lgamma(long double __x) |
2258 | { return __builtin_lgammal(__x); } |
2259 | #endif |
2260 | |
2261 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2262 | template<typename _Tp> |
2263 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2264 | double>::__type |
2265 | lgamma(_Tp __x) |
2266 | { return __builtin_lgamma(__x); } |
2267 | #endif |
2268 | |
2269 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2270 | constexpr long long |
2271 | llrint(float __x) |
2272 | { return __builtin_llrintf(__x); } |
2273 | |
2274 | constexpr long long |
2275 | llrint(long double __x) |
2276 | { return __builtin_llrintl(__x); } |
2277 | #endif |
2278 | |
2279 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2280 | template<typename _Tp> |
2281 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2282 | long long>::__type |
2283 | llrint(_Tp __x) |
2284 | { return __builtin_llrint(__x); } |
2285 | #endif |
2286 | |
2287 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2288 | constexpr long long |
2289 | llround(float __x) |
2290 | { return __builtin_llroundf(__x); } |
2291 | |
2292 | constexpr long long |
2293 | llround(long double __x) |
2294 | { return __builtin_llroundl(__x); } |
2295 | #endif |
2296 | |
2297 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2298 | template<typename _Tp> |
2299 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2300 | long long>::__type |
2301 | llround(_Tp __x) |
2302 | { return __builtin_llround(__x); } |
2303 | #endif |
2304 | |
2305 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2306 | constexpr float |
2307 | log1p(float __x) |
2308 | { return __builtin_log1pf(__x); } |
2309 | |
2310 | constexpr long double |
2311 | log1p(long double __x) |
2312 | { return __builtin_log1pl(__x); } |
2313 | #endif |
2314 | |
2315 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2316 | template<typename _Tp> |
2317 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2318 | double>::__type |
2319 | log1p(_Tp __x) |
2320 | { return __builtin_log1p(__x); } |
2321 | #endif |
2322 | |
2323 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2324 | // DR 568. |
2325 | constexpr float |
2326 | log2(float __x) |
2327 | { return __builtin_log2f(__x); } |
2328 | |
2329 | constexpr long double |
2330 | log2(long double __x) |
2331 | { return __builtin_log2l(__x); } |
2332 | #endif |
2333 | |
2334 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2335 | template<typename _Tp> |
2336 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2337 | double>::__type |
2338 | log2(_Tp __x) |
2339 | { return __builtin_log2(__x); } |
2340 | #endif |
2341 | |
2342 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2343 | constexpr float |
2344 | logb(float __x) |
2345 | { return __builtin_logbf(__x); } |
2346 | |
2347 | constexpr long double |
2348 | logb(long double __x) |
2349 | { return __builtin_logbl(__x); } |
2350 | #endif |
2351 | |
2352 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2353 | template<typename _Tp> |
2354 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2355 | double>::__type |
2356 | logb(_Tp __x) |
2357 | { return __builtin_logb(__x); } |
2358 | #endif |
2359 | |
2360 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2361 | constexpr long |
2362 | lrint(float __x) |
2363 | { return __builtin_lrintf(__x); } |
2364 | |
2365 | constexpr long |
2366 | lrint(long double __x) |
2367 | { return __builtin_lrintl(__x); } |
2368 | #endif |
2369 | |
2370 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2371 | template<typename _Tp> |
2372 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2373 | long>::__type |
2374 | lrint(_Tp __x) |
2375 | { return __builtin_lrint(__x); } |
2376 | #endif |
2377 | |
2378 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2379 | constexpr long |
2380 | lround(float __x) |
2381 | { return __builtin_lroundf(__x); } |
2382 | |
2383 | constexpr long |
2384 | lround(long double __x) |
2385 | { return __builtin_lroundl(__x); } |
2386 | #endif |
2387 | |
2388 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2389 | template<typename _Tp> |
2390 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2391 | long>::__type |
2392 | lround(_Tp __x) |
2393 | { return __builtin_lround(__x); } |
2394 | #endif |
2395 | |
2396 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2397 | constexpr float |
2398 | nearbyint(float __x) |
2399 | { return __builtin_nearbyintf(__x); } |
2400 | |
2401 | constexpr long double |
2402 | nearbyint(long double __x) |
2403 | { return __builtin_nearbyintl(__x); } |
2404 | #endif |
2405 | |
2406 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2407 | template<typename _Tp> |
2408 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2409 | double>::__type |
2410 | nearbyint(_Tp __x) |
2411 | { return __builtin_nearbyint(__x); } |
2412 | #endif |
2413 | |
2414 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2415 | constexpr float |
2416 | nextafter(float __x, float __y) |
2417 | { return __builtin_nextafterf(__x, __y); } |
2418 | |
2419 | constexpr long double |
2420 | nextafter(long double __x, long double __y) |
2421 | { return __builtin_nextafterl(__x, __y); } |
2422 | #endif |
2423 | |
2424 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2425 | constexpr float |
2426 | nexttoward(float __x, long double __y) |
2427 | { return __builtin_nexttowardf(__x, __y); } |
2428 | |
2429 | constexpr long double |
2430 | nexttoward(long double __x, long double __y) |
2431 | { return __builtin_nexttowardl(__x, __y); } |
2432 | #endif |
2433 | |
2434 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2435 | template<typename _Tp> |
2436 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2437 | double>::__type |
2438 | nexttoward(_Tp __x, long double __y) |
2439 | { return __builtin_nexttoward(__x, __y); } |
2440 | #endif |
2441 | |
2442 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2443 | constexpr float |
2444 | remainder(float __x, float __y) |
2445 | { return __builtin_remainderf(__x, __y); } |
2446 | |
2447 | constexpr long double |
2448 | remainder(long double __x, long double __y) |
2449 | { return __builtin_remainderl(__x, __y); } |
2450 | #endif |
2451 | |
2452 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2453 | inline float |
2454 | remquo(float __x, float __y, int* __pquo) |
2455 | { return __builtin_remquof(__x, __y, __pquo); } |
2456 | |
2457 | inline long double |
2458 | remquo(long double __x, long double __y, int* __pquo) |
2459 | { return __builtin_remquol(__x, __y, __pquo); } |
2460 | #endif |
2461 | |
2462 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2463 | constexpr float |
2464 | rint(float __x) |
2465 | { return __builtin_rintf(__x); } |
2466 | |
2467 | constexpr long double |
2468 | rint(long double __x) |
2469 | { return __builtin_rintl(__x); } |
2470 | #endif |
2471 | |
2472 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2473 | template<typename _Tp> |
2474 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2475 | double>::__type |
2476 | rint(_Tp __x) |
2477 | { return __builtin_rint(__x); } |
2478 | #endif |
2479 | |
2480 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2481 | constexpr float |
2482 | round(float __x) |
2483 | { return __builtin_roundf(__x); } |
2484 | |
2485 | constexpr long double |
2486 | round(long double __x) |
2487 | { return __builtin_roundl(__x); } |
2488 | #endif |
2489 | |
2490 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2491 | template<typename _Tp> |
2492 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2493 | double>::__type |
2494 | round(_Tp __x) |
2495 | { return __builtin_round(__x); } |
2496 | #endif |
2497 | |
2498 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2499 | constexpr float |
2500 | scalbln(float __x, long __ex) |
2501 | { return __builtin_scalblnf(__x, __ex); } |
2502 | |
2503 | constexpr long double |
2504 | scalbln(long double __x, long __ex) |
2505 | { return __builtin_scalblnl(__x, __ex); } |
2506 | #endif |
2507 | |
2508 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2509 | template<typename _Tp> |
2510 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2511 | double>::__type |
2512 | scalbln(_Tp __x, long __ex) |
2513 | { return __builtin_scalbln(__x, __ex); } |
2514 | #endif |
2515 | |
2516 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2517 | constexpr float |
2518 | scalbn(float __x, int __ex) |
2519 | { return __builtin_scalbnf(__x, __ex); } |
2520 | |
2521 | constexpr long double |
2522 | scalbn(long double __x, int __ex) |
2523 | { return __builtin_scalbnl(__x, __ex); } |
2524 | #endif |
2525 | |
2526 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2527 | template<typename _Tp> |
2528 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2529 | double>::__type |
2530 | scalbn(_Tp __x, int __ex) |
2531 | { return __builtin_scalbn(__x, __ex); } |
2532 | #endif |
2533 | |
2534 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2535 | constexpr float |
2536 | tgamma(float __x) |
2537 | { return __builtin_tgammaf(__x); } |
2538 | |
2539 | constexpr long double |
2540 | tgamma(long double __x) |
2541 | { return __builtin_tgammal(__x); } |
2542 | #endif |
2543 | |
2544 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2545 | template<typename _Tp> |
2546 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2547 | double>::__type |
2548 | tgamma(_Tp __x) |
2549 | { return __builtin_tgamma(__x); } |
2550 | #endif |
2551 | |
2552 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP |
2553 | constexpr float |
2554 | trunc(float __x) |
2555 | { return __builtin_truncf(__x); } |
2556 | |
2557 | constexpr long double |
2558 | trunc(long double __x) |
2559 | { return __builtin_truncl(__x); } |
2560 | #endif |
2561 | |
2562 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
2563 | template<typename _Tp> |
2564 | constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, |
2565 | double>::__type |
2566 | trunc(_Tp __x) |
2567 | { return __builtin_trunc(__x); } |
2568 | #endif |
2569 | |
2570 | #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
2571 | constexpr _Float16 |
2572 | acosh(_Float16 __x) |
2573 | { return _Float16(__builtin_acoshf(__x)); } |
2574 | |
2575 | constexpr _Float16 |
2576 | asinh(_Float16 __x) |
2577 | { return _Float16(__builtin_asinhf(__x)); } |
2578 | |
2579 | constexpr _Float16 |
2580 | atanh(_Float16 __x) |
2581 | { return _Float16(__builtin_atanhf(__x)); } |
2582 | |
2583 | constexpr _Float16 |
2584 | cbrt(_Float16 __x) |
2585 | { return _Float16(__builtin_cbrtf(__x)); } |
2586 | |
2587 | constexpr _Float16 |
2588 | copysign(_Float16 __x, _Float16 __y) |
2589 | { return __builtin_copysignf16(__x, __y); } |
2590 | |
2591 | constexpr _Float16 |
2592 | erf(_Float16 __x) |
2593 | { return _Float16(__builtin_erff(__x)); } |
2594 | |
2595 | constexpr _Float16 |
2596 | erfc(_Float16 __x) |
2597 | { return _Float16(__builtin_erfcf(__x)); } |
2598 | |
2599 | constexpr _Float16 |
2600 | exp2(_Float16 __x) |
2601 | { return _Float16(__builtin_exp2f(__x)); } |
2602 | |
2603 | constexpr _Float16 |
2604 | expm1(_Float16 __x) |
2605 | { return _Float16(__builtin_expm1f(__x)); } |
2606 | |
2607 | constexpr _Float16 |
2608 | fdim(_Float16 __x, _Float16 __y) |
2609 | { return _Float16(__builtin_fdimf(__x, __y)); } |
2610 | |
2611 | constexpr _Float16 |
2612 | fma(_Float16 __x, _Float16 __y, _Float16 __z) |
2613 | { return _Float16(__builtin_fmaf(__x, __y, __z)); } |
2614 | |
2615 | constexpr _Float16 |
2616 | fmax(_Float16 __x, _Float16 __y) |
2617 | { return _Float16(__builtin_fmaxf(__x, __y)); } |
2618 | |
2619 | constexpr _Float16 |
2620 | fmin(_Float16 __x, _Float16 __y) |
2621 | { return _Float16(__builtin_fminf(__x, __y)); } |
2622 | |
2623 | constexpr _Float16 |
2624 | hypot(_Float16 __x, _Float16 __y) |
2625 | { return _Float16(__builtin_hypotf(__x, __y)); } |
2626 | |
2627 | constexpr int |
2628 | ilogb(_Float16 __x) |
2629 | { return _Float16(__builtin_ilogbf(__x)); } |
2630 | |
2631 | constexpr _Float16 |
2632 | lgamma(_Float16 __x) |
2633 | { return _Float16(__builtin_lgammaf(__x)); } |
2634 | |
2635 | constexpr long long |
2636 | llrint(_Float16 __x) |
2637 | { return _Float16(__builtin_llrintf(__x)); } |
2638 | |
2639 | constexpr long long |
2640 | llround(_Float16 __x) |
2641 | { return _Float16(__builtin_llroundf(__x)); } |
2642 | |
2643 | constexpr _Float16 |
2644 | log1p(_Float16 __x) |
2645 | { return _Float16(__builtin_log1pf(__x)); } |
2646 | |
2647 | // DR 568. |
2648 | constexpr _Float16 |
2649 | log2(_Float16 __x) |
2650 | { return _Float16(__builtin_log2f(__x)); } |
2651 | |
2652 | constexpr _Float16 |
2653 | logb(_Float16 __x) |
2654 | { return _Float16(__builtin_logbf(__x)); } |
2655 | |
2656 | constexpr long |
2657 | lrint(_Float16 __x) |
2658 | { return _Float16(__builtin_lrintf(__x)); } |
2659 | |
2660 | constexpr long |
2661 | lround(_Float16 __x) |
2662 | { return _Float16(__builtin_lroundf(__x)); } |
2663 | |
2664 | constexpr _Float16 |
2665 | nearbyint(_Float16 __x) |
2666 | { return _Float16(__builtin_nearbyintf(__x)); } |
2667 | |
2668 | constexpr _Float16 |
2669 | nextafter(_Float16 __x, _Float16 __y) |
2670 | { |
2671 | if (std::__is_constant_evaluated()) |
2672 | return __builtin_nextafterf16(__x, __y); |
2673 | #ifdef __INT16_TYPE__ |
2674 | using __float16_int_type = __INT16_TYPE__; |
2675 | #else |
2676 | using __float16_int_type = short int; |
2677 | #endif |
2678 | __float16_int_type __hx, __hy, __ix, __iy; |
2679 | __builtin_memcpy(&__hx, &__x, sizeof(__x)); |
2680 | __builtin_memcpy(&__hy, &__y, sizeof(__x)); |
2681 | __ix = __hx & 0x7fff; // |x| |
2682 | __iy = __hy & 0x7fff; // |y| |
2683 | if (__ix > 0x7c00 || __iy > 0x7c00) // x or y is NaN |
2684 | return __x + __y; |
2685 | if (__x == __y) |
2686 | return __y; // x == y, return y |
2687 | if (__ix == 0) // x == 0 |
2688 | { |
2689 | __hy = (__hy & 0x8000) | 1; // return +-__FLT16_DENORM_MIN__ |
2690 | __builtin_memcpy(&__x, &__hy, sizeof(__x)); |
2691 | __builtin_nextafterf(0.0f, 1.0f); // raise underflow |
2692 | return __x; |
2693 | } |
2694 | if (__hx >= 0) // x > 0 |
2695 | { |
2696 | if (__hx > __hy) // x > y, x -= ulp |
2697 | --__hx; |
2698 | else // x < y, x += ulp |
2699 | ++__hx; |
2700 | } |
2701 | else // x < 0 |
2702 | { |
2703 | if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp |
2704 | --__hx; |
2705 | else // x > y, x += ulp |
2706 | ++__hx; |
2707 | } |
2708 | __hy = __hx & 0x7c00; |
2709 | if (__hy >= 0x7c00) |
2710 | __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow |
2711 | else if (__hy < 0x0400) |
2712 | __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow |
2713 | __builtin_memcpy(&__x, &__hx, sizeof(__x)); |
2714 | return __x; |
2715 | } |
2716 | |
2717 | constexpr _Float16 |
2718 | remainder(_Float16 __x, _Float16 __y) |
2719 | { return _Float16(__builtin_remainderf(__x, __y)); } |
2720 | |
2721 | inline _Float16 |
2722 | remquo(_Float16 __x, _Float16 __y, int* __pquo) |
2723 | { return _Float16(__builtin_remquof(__x, __y, __pquo)); } |
2724 | |
2725 | constexpr _Float16 |
2726 | rint(_Float16 __x) |
2727 | { return _Float16(__builtin_rintf(__x)); } |
2728 | |
2729 | constexpr _Float16 |
2730 | round(_Float16 __x) |
2731 | { return _Float16(__builtin_roundf(__x)); } |
2732 | |
2733 | constexpr _Float16 |
2734 | scalbln(_Float16 __x, long __ex) |
2735 | { return _Float16(__builtin_scalblnf(__x, __ex)); } |
2736 | |
2737 | constexpr _Float16 |
2738 | scalbn(_Float16 __x, int __ex) |
2739 | { return _Float16(__builtin_scalbnf(__x, __ex)); } |
2740 | |
2741 | constexpr _Float16 |
2742 | tgamma(_Float16 __x) |
2743 | { return _Float16(__builtin_tgammaf(__x)); } |
2744 | |
2745 | constexpr _Float16 |
2746 | trunc(_Float16 __x) |
2747 | { return _Float16(__builtin_truncf(__x)); } |
2748 | #endif |
2749 | |
2750 | #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
2751 | constexpr _Float32 |
2752 | acosh(_Float32 __x) |
2753 | { return __builtin_acoshf(__x); } |
2754 | |
2755 | constexpr _Float32 |
2756 | asinh(_Float32 __x) |
2757 | { return __builtin_asinhf(__x); } |
2758 | |
2759 | constexpr _Float32 |
2760 | atanh(_Float32 __x) |
2761 | { return __builtin_atanhf(__x); } |
2762 | |
2763 | constexpr _Float32 |
2764 | cbrt(_Float32 __x) |
2765 | { return __builtin_cbrtf(__x); } |
2766 | |
2767 | constexpr _Float32 |
2768 | copysign(_Float32 __x, _Float32 __y) |
2769 | { return __builtin_copysignf(__x, __y); } |
2770 | |
2771 | constexpr _Float32 |
2772 | erf(_Float32 __x) |
2773 | { return __builtin_erff(__x); } |
2774 | |
2775 | constexpr _Float32 |
2776 | erfc(_Float32 __x) |
2777 | { return __builtin_erfcf(__x); } |
2778 | |
2779 | constexpr _Float32 |
2780 | exp2(_Float32 __x) |
2781 | { return __builtin_exp2f(__x); } |
2782 | |
2783 | constexpr _Float32 |
2784 | expm1(_Float32 __x) |
2785 | { return __builtin_expm1f(__x); } |
2786 | |
2787 | constexpr _Float32 |
2788 | fdim(_Float32 __x, _Float32 __y) |
2789 | { return __builtin_fdimf(__x, __y); } |
2790 | |
2791 | constexpr _Float32 |
2792 | fma(_Float32 __x, _Float32 __y, _Float32 __z) |
2793 | { return __builtin_fmaf(__x, __y, __z); } |
2794 | |
2795 | constexpr _Float32 |
2796 | fmax(_Float32 __x, _Float32 __y) |
2797 | { return __builtin_fmaxf(__x, __y); } |
2798 | |
2799 | constexpr _Float32 |
2800 | fmin(_Float32 __x, _Float32 __y) |
2801 | { return __builtin_fminf(__x, __y); } |
2802 | |
2803 | constexpr _Float32 |
2804 | hypot(_Float32 __x, _Float32 __y) |
2805 | { return __builtin_hypotf(__x, __y); } |
2806 | |
2807 | constexpr int |
2808 | ilogb(_Float32 __x) |
2809 | { return __builtin_ilogbf(__x); } |
2810 | |
2811 | constexpr _Float32 |
2812 | lgamma(_Float32 __x) |
2813 | { return __builtin_lgammaf(__x); } |
2814 | |
2815 | constexpr long long |
2816 | llrint(_Float32 __x) |
2817 | { return __builtin_llrintf(__x); } |
2818 | |
2819 | constexpr long long |
2820 | llround(_Float32 __x) |
2821 | { return __builtin_llroundf(__x); } |
2822 | |
2823 | constexpr _Float32 |
2824 | log1p(_Float32 __x) |
2825 | { return __builtin_log1pf(__x); } |
2826 | |
2827 | // DR 568. |
2828 | constexpr _Float32 |
2829 | log2(_Float32 __x) |
2830 | { return __builtin_log2f(__x); } |
2831 | |
2832 | constexpr _Float32 |
2833 | logb(_Float32 __x) |
2834 | { return __builtin_logbf(__x); } |
2835 | |
2836 | constexpr long |
2837 | lrint(_Float32 __x) |
2838 | { return __builtin_lrintf(__x); } |
2839 | |
2840 | constexpr long |
2841 | lround(_Float32 __x) |
2842 | { return __builtin_lroundf(__x); } |
2843 | |
2844 | constexpr _Float32 |
2845 | nearbyint(_Float32 __x) |
2846 | { return __builtin_nearbyintf(__x); } |
2847 | |
2848 | constexpr _Float32 |
2849 | nextafter(_Float32 __x, _Float32 __y) |
2850 | { return __builtin_nextafterf(__x, __y); } |
2851 | |
2852 | constexpr _Float32 |
2853 | remainder(_Float32 __x, _Float32 __y) |
2854 | { return __builtin_remainderf(__x, __y); } |
2855 | |
2856 | inline _Float32 |
2857 | remquo(_Float32 __x, _Float32 __y, int* __pquo) |
2858 | { return __builtin_remquof(__x, __y, __pquo); } |
2859 | |
2860 | constexpr _Float32 |
2861 | rint(_Float32 __x) |
2862 | { return __builtin_rintf(__x); } |
2863 | |
2864 | constexpr _Float32 |
2865 | round(_Float32 __x) |
2866 | { return __builtin_roundf(__x); } |
2867 | |
2868 | constexpr _Float32 |
2869 | scalbln(_Float32 __x, long __ex) |
2870 | { return __builtin_scalblnf(__x, __ex); } |
2871 | |
2872 | constexpr _Float32 |
2873 | scalbn(_Float32 __x, int __ex) |
2874 | { return __builtin_scalbnf(__x, __ex); } |
2875 | |
2876 | constexpr _Float32 |
2877 | tgamma(_Float32 __x) |
2878 | { return __builtin_tgammaf(__x); } |
2879 | |
2880 | constexpr _Float32 |
2881 | trunc(_Float32 __x) |
2882 | { return __builtin_truncf(__x); } |
2883 | #endif |
2884 | |
2885 | #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64) |
2886 | constexpr _Float64 |
2887 | acosh(_Float64 __x) |
2888 | { return __builtin_acosh(__x); } |
2889 | |
2890 | constexpr _Float64 |
2891 | asinh(_Float64 __x) |
2892 | { return __builtin_asinh(__x); } |
2893 | |
2894 | constexpr _Float64 |
2895 | atanh(_Float64 __x) |
2896 | { return __builtin_atanh(__x); } |
2897 | |
2898 | constexpr _Float64 |
2899 | cbrt(_Float64 __x) |
2900 | { return __builtin_cbrt(__x); } |
2901 | |
2902 | constexpr _Float64 |
2903 | copysign(_Float64 __x, _Float64 __y) |
2904 | { return __builtin_copysign(__x, __y); } |
2905 | |
2906 | constexpr _Float64 |
2907 | erf(_Float64 __x) |
2908 | { return __builtin_erf(__x); } |
2909 | |
2910 | constexpr _Float64 |
2911 | erfc(_Float64 __x) |
2912 | { return __builtin_erfc(__x); } |
2913 | |
2914 | constexpr _Float64 |
2915 | exp2(_Float64 __x) |
2916 | { return __builtin_exp2(__x); } |
2917 | |
2918 | constexpr _Float64 |
2919 | expm1(_Float64 __x) |
2920 | { return __builtin_expm1(__x); } |
2921 | |
2922 | constexpr _Float64 |
2923 | fdim(_Float64 __x, _Float64 __y) |
2924 | { return __builtin_fdim(__x, __y); } |
2925 | |
2926 | constexpr _Float64 |
2927 | fma(_Float64 __x, _Float64 __y, _Float64 __z) |
2928 | { return __builtin_fma(__x, __y, __z); } |
2929 | |
2930 | constexpr _Float64 |
2931 | fmax(_Float64 __x, _Float64 __y) |
2932 | { return __builtin_fmax(__x, __y); } |
2933 | |
2934 | constexpr _Float64 |
2935 | fmin(_Float64 __x, _Float64 __y) |
2936 | { return __builtin_fmin(__x, __y); } |
2937 | |
2938 | constexpr _Float64 |
2939 | hypot(_Float64 __x, _Float64 __y) |
2940 | { return __builtin_hypot(__x, __y); } |
2941 | |
2942 | constexpr int |
2943 | ilogb(_Float64 __x) |
2944 | { return __builtin_ilogb(__x); } |
2945 | |
2946 | constexpr _Float64 |
2947 | lgamma(_Float64 __x) |
2948 | { return __builtin_lgamma(__x); } |
2949 | |
2950 | constexpr long long |
2951 | llrint(_Float64 __x) |
2952 | { return __builtin_llrint(__x); } |
2953 | |
2954 | constexpr long long |
2955 | llround(_Float64 __x) |
2956 | { return __builtin_llround(__x); } |
2957 | |
2958 | constexpr _Float64 |
2959 | log1p(_Float64 __x) |
2960 | { return __builtin_log1p(__x); } |
2961 | |
2962 | // DR 568. |
2963 | constexpr _Float64 |
2964 | log2(_Float64 __x) |
2965 | { return __builtin_log2(__x); } |
2966 | |
2967 | constexpr _Float64 |
2968 | logb(_Float64 __x) |
2969 | { return __builtin_logb(__x); } |
2970 | |
2971 | constexpr long |
2972 | lrint(_Float64 __x) |
2973 | { return __builtin_lrint(__x); } |
2974 | |
2975 | constexpr long |
2976 | lround(_Float64 __x) |
2977 | { return __builtin_lround(__x); } |
2978 | |
2979 | constexpr _Float64 |
2980 | nearbyint(_Float64 __x) |
2981 | { return __builtin_nearbyint(__x); } |
2982 | |
2983 | constexpr _Float64 |
2984 | nextafter(_Float64 __x, _Float64 __y) |
2985 | { return __builtin_nextafter(__x, __y); } |
2986 | |
2987 | constexpr _Float64 |
2988 | remainder(_Float64 __x, _Float64 __y) |
2989 | { return __builtin_remainder(__x, __y); } |
2990 | |
2991 | inline _Float64 |
2992 | remquo(_Float64 __x, _Float64 __y, int* __pquo) |
2993 | { return __builtin_remquo(__x, __y, __pquo); } |
2994 | |
2995 | constexpr _Float64 |
2996 | rint(_Float64 __x) |
2997 | { return __builtin_rint(__x); } |
2998 | |
2999 | constexpr _Float64 |
3000 | round(_Float64 __x) |
3001 | { return __builtin_round(__x); } |
3002 | |
3003 | constexpr _Float64 |
3004 | scalbln(_Float64 __x, long __ex) |
3005 | { return __builtin_scalbln(__x, __ex); } |
3006 | |
3007 | constexpr _Float64 |
3008 | scalbn(_Float64 __x, int __ex) |
3009 | { return __builtin_scalbn(__x, __ex); } |
3010 | |
3011 | constexpr _Float64 |
3012 | tgamma(_Float64 __x) |
3013 | { return __builtin_tgamma(__x); } |
3014 | |
3015 | constexpr _Float64 |
3016 | trunc(_Float64 __x) |
3017 | { return __builtin_trunc(__x); } |
3018 | #endif |
3019 | |
3020 | #if defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) |
3021 | constexpr _Float128 |
3022 | acosh(_Float128 __x) |
3023 | { return __builtin_acoshl(__x); } |
3024 | |
3025 | constexpr _Float128 |
3026 | asinh(_Float128 __x) |
3027 | { return __builtin_asinhl(__x); } |
3028 | |
3029 | constexpr _Float128 |
3030 | atanh(_Float128 __x) |
3031 | { return __builtin_atanhl(__x); } |
3032 | |
3033 | constexpr _Float128 |
3034 | cbrt(_Float128 __x) |
3035 | { return __builtin_cbrtl(__x); } |
3036 | |
3037 | constexpr _Float128 |
3038 | copysign(_Float128 __x, _Float128 __y) |
3039 | { return __builtin_copysignl(__x, __y); } |
3040 | |
3041 | constexpr _Float128 |
3042 | erf(_Float128 __x) |
3043 | { return __builtin_erfl(__x); } |
3044 | |
3045 | constexpr _Float128 |
3046 | erfc(_Float128 __x) |
3047 | { return __builtin_erfcl(__x); } |
3048 | |
3049 | constexpr _Float128 |
3050 | exp2(_Float128 __x) |
3051 | { return __builtin_exp2l(__x); } |
3052 | |
3053 | constexpr _Float128 |
3054 | expm1(_Float128 __x) |
3055 | { return __builtin_expm1l(__x); } |
3056 | |
3057 | constexpr _Float128 |
3058 | fdim(_Float128 __x, _Float128 __y) |
3059 | { return __builtin_fdiml(__x, __y); } |
3060 | |
3061 | constexpr _Float128 |
3062 | fma(_Float128 __x, _Float128 __y, _Float128 __z) |
3063 | { return __builtin_fmal(__x, __y, __z); } |
3064 | |
3065 | constexpr _Float128 |
3066 | fmax(_Float128 __x, _Float128 __y) |
3067 | { return __builtin_fmaxl(__x, __y); } |
3068 | |
3069 | constexpr _Float128 |
3070 | fmin(_Float128 __x, _Float128 __y) |
3071 | { return __builtin_fminl(__x, __y); } |
3072 | |
3073 | constexpr _Float128 |
3074 | hypot(_Float128 __x, _Float128 __y) |
3075 | { return __builtin_hypotl(__x, __y); } |
3076 | |
3077 | constexpr int |
3078 | ilogb(_Float128 __x) |
3079 | { return __builtin_ilogbl(__x); } |
3080 | |
3081 | constexpr _Float128 |
3082 | lgamma(_Float128 __x) |
3083 | { return __builtin_lgammal(__x); } |
3084 | |
3085 | constexpr long long |
3086 | llrint(_Float128 __x) |
3087 | { return __builtin_llrintl(__x); } |
3088 | |
3089 | constexpr long long |
3090 | llround(_Float128 __x) |
3091 | { return __builtin_llroundl(__x); } |
3092 | |
3093 | constexpr _Float128 |
3094 | log1p(_Float128 __x) |
3095 | { return __builtin_log1pl(__x); } |
3096 | |
3097 | // DR 568. |
3098 | constexpr _Float128 |
3099 | log2(_Float128 __x) |
3100 | { return __builtin_log2l(__x); } |
3101 | |
3102 | constexpr _Float128 |
3103 | logb(_Float128 __x) |
3104 | { return __builtin_logbl(__x); } |
3105 | |
3106 | constexpr long |
3107 | lrint(_Float128 __x) |
3108 | { return __builtin_lrintl(__x); } |
3109 | |
3110 | constexpr long |
3111 | lround(_Float128 __x) |
3112 | { return __builtin_lroundl(__x); } |
3113 | |
3114 | constexpr _Float128 |
3115 | nearbyint(_Float128 __x) |
3116 | { return __builtin_nearbyintl(__x); } |
3117 | |
3118 | constexpr _Float128 |
3119 | nextafter(_Float128 __x, _Float128 __y) |
3120 | { return __builtin_nextafterl(__x, __y); } |
3121 | |
3122 | constexpr _Float128 |
3123 | remainder(_Float128 __x, _Float128 __y) |
3124 | { return __builtin_remainderl(__x, __y); } |
3125 | |
3126 | inline _Float128 |
3127 | remquo(_Float128 __x, _Float128 __y, int* __pquo) |
3128 | { return __builtin_remquol(__x, __y, __pquo); } |
3129 | |
3130 | constexpr _Float128 |
3131 | rint(_Float128 __x) |
3132 | { return __builtin_rintl(__x); } |
3133 | |
3134 | constexpr _Float128 |
3135 | round(_Float128 __x) |
3136 | { return __builtin_roundl(__x); } |
3137 | |
3138 | constexpr _Float128 |
3139 | scalbln(_Float128 __x, long __ex) |
3140 | { return __builtin_scalblnl(__x, __ex); } |
3141 | |
3142 | constexpr _Float128 |
3143 | scalbn(_Float128 __x, int __ex) |
3144 | { return __builtin_scalbnl(__x, __ex); } |
3145 | |
3146 | constexpr _Float128 |
3147 | tgamma(_Float128 __x) |
3148 | { return __builtin_tgammal(__x); } |
3149 | |
3150 | constexpr _Float128 |
3151 | trunc(_Float128 __x) |
3152 | { return __builtin_truncl(__x); } |
3153 | #elif defined(__STDCPP_FLOAT128_T__) && defined(_GLIBCXX_HAVE_FLOAT128_MATH) |
3154 | constexpr _Float128 |
3155 | acosh(_Float128 __x) |
3156 | { return __builtin_acoshf128(__x); } |
3157 | |
3158 | constexpr _Float128 |
3159 | asinh(_Float128 __x) |
3160 | { return __builtin_asinhf128(__x); } |
3161 | |
3162 | constexpr _Float128 |
3163 | atanh(_Float128 __x) |
3164 | { return __builtin_atanhf128(__x); } |
3165 | |
3166 | constexpr _Float128 |
3167 | cbrt(_Float128 __x) |
3168 | { return __builtin_cbrtf128(__x); } |
3169 | |
3170 | constexpr _Float128 |
3171 | copysign(_Float128 __x, _Float128 __y) |
3172 | { return __builtin_copysignf128(__x, __y); } |
3173 | |
3174 | constexpr _Float128 |
3175 | erf(_Float128 __x) |
3176 | { return __builtin_erff128(__x); } |
3177 | |
3178 | constexpr _Float128 |
3179 | erfc(_Float128 __x) |
3180 | { return __builtin_erfcf128(__x); } |
3181 | |
3182 | constexpr _Float128 |
3183 | exp2(_Float128 __x) |
3184 | { return __builtin_exp2f128(__x); } |
3185 | |
3186 | constexpr _Float128 |
3187 | expm1(_Float128 __x) |
3188 | { return __builtin_expm1f128(__x); } |
3189 | |
3190 | constexpr _Float128 |
3191 | fdim(_Float128 __x, _Float128 __y) |
3192 | { return __builtin_fdimf128(__x, __y); } |
3193 | |
3194 | constexpr _Float128 |
3195 | fma(_Float128 __x, _Float128 __y, _Float128 __z) |
3196 | { return __builtin_fmaf128(__x, __y, __z); } |
3197 | |
3198 | constexpr _Float128 |
3199 | fmax(_Float128 __x, _Float128 __y) |
3200 | { return __builtin_fmaxf128(__x, __y); } |
3201 | |
3202 | constexpr _Float128 |
3203 | fmin(_Float128 __x, _Float128 __y) |
3204 | { return __builtin_fminf128(__x, __y); } |
3205 | |
3206 | constexpr _Float128 |
3207 | hypot(_Float128 __x, _Float128 __y) |
3208 | { return __builtin_hypotf128(__x, __y); } |
3209 | |
3210 | constexpr int |
3211 | ilogb(_Float128 __x) |
3212 | { return __builtin_ilogbf128(__x); } |
3213 | |
3214 | constexpr _Float128 |
3215 | lgamma(_Float128 __x) |
3216 | { return __builtin_lgammaf128(__x); } |
3217 | |
3218 | constexpr long long |
3219 | llrint(_Float128 __x) |
3220 | { return __builtin_llrintf128(__x); } |
3221 | |
3222 | constexpr long long |
3223 | llround(_Float128 __x) |
3224 | { return __builtin_llroundf128(__x); } |
3225 | |
3226 | constexpr _Float128 |
3227 | log1p(_Float128 __x) |
3228 | { return __builtin_log1pf128(__x); } |
3229 | |
3230 | // DR 568. |
3231 | constexpr _Float128 |
3232 | log2(_Float128 __x) |
3233 | { return __builtin_log2f128(__x); } |
3234 | |
3235 | constexpr _Float128 |
3236 | logb(_Float128 __x) |
3237 | { return __builtin_logbf128(__x); } |
3238 | |
3239 | constexpr long |
3240 | lrint(_Float128 __x) |
3241 | { return __builtin_lrintf128(__x); } |
3242 | |
3243 | constexpr long |
3244 | lround(_Float128 __x) |
3245 | { return __builtin_lroundf128(__x); } |
3246 | |
3247 | constexpr _Float128 |
3248 | nearbyint(_Float128 __x) |
3249 | { return __builtin_nearbyintf128(__x); } |
3250 | |
3251 | constexpr _Float128 |
3252 | nextafter(_Float128 __x, _Float128 __y) |
3253 | { return __builtin_nextafterf128(__x, __y); } |
3254 | |
3255 | constexpr _Float128 |
3256 | remainder(_Float128 __x, _Float128 __y) |
3257 | { return __builtin_remainderf128(__x, __y); } |
3258 | |
3259 | inline _Float128 |
3260 | remquo(_Float128 __x, _Float128 __y, int* __pquo) |
3261 | { return __builtin_remquof128(__x, __y, __pquo); } |
3262 | |
3263 | constexpr _Float128 |
3264 | rint(_Float128 __x) |
3265 | { return __builtin_rintf128(__x); } |
3266 | |
3267 | constexpr _Float128 |
3268 | round(_Float128 __x) |
3269 | { return __builtin_roundf128(__x); } |
3270 | |
3271 | constexpr _Float128 |
3272 | scalbln(_Float128 __x, long __ex) |
3273 | { return __builtin_scalblnf128(__x, __ex); } |
3274 | |
3275 | constexpr _Float128 |
3276 | scalbn(_Float128 __x, int __ex) |
3277 | { return __builtin_scalbnf128(__x, __ex); } |
3278 | |
3279 | constexpr _Float128 |
3280 | tgamma(_Float128 __x) |
3281 | { return __builtin_tgammaf128(__x); } |
3282 | |
3283 | constexpr _Float128 |
3284 | trunc(_Float128 __x) |
3285 | { return __builtin_truncf128(__x); } |
3286 | #endif |
3287 | |
3288 | #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
3289 | constexpr __gnu_cxx::__bfloat16_t |
3290 | acosh(__gnu_cxx::__bfloat16_t __x) |
3291 | { return __gnu_cxx::__bfloat16_t(__builtin_acoshf(__x)); } |
3292 | |
3293 | constexpr __gnu_cxx::__bfloat16_t |
3294 | asinh(__gnu_cxx::__bfloat16_t __x) |
3295 | { return __gnu_cxx::__bfloat16_t(__builtin_asinhf(__x)); } |
3296 | |
3297 | constexpr __gnu_cxx::__bfloat16_t |
3298 | atanh(__gnu_cxx::__bfloat16_t __x) |
3299 | { return __gnu_cxx::__bfloat16_t(__builtin_atanhf(__x)); } |
3300 | |
3301 | constexpr __gnu_cxx::__bfloat16_t |
3302 | cbrt(__gnu_cxx::__bfloat16_t __x) |
3303 | { return __gnu_cxx::__bfloat16_t(__builtin_cbrtf(__x)); } |
3304 | |
3305 | constexpr __gnu_cxx::__bfloat16_t |
3306 | copysign(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
3307 | { return __gnu_cxx::__bfloat16_t(__builtin_copysignf(__x, __y)); } |
3308 | |
3309 | constexpr __gnu_cxx::__bfloat16_t |
3310 | erf(__gnu_cxx::__bfloat16_t __x) |
3311 | { return __gnu_cxx::__bfloat16_t(__builtin_erff(__x)); } |
3312 | |
3313 | constexpr __gnu_cxx::__bfloat16_t |
3314 | erfc(__gnu_cxx::__bfloat16_t __x) |
3315 | { return __gnu_cxx::__bfloat16_t(__builtin_erfcf(__x)); } |
3316 | |
3317 | constexpr __gnu_cxx::__bfloat16_t |
3318 | exp2(__gnu_cxx::__bfloat16_t __x) |
3319 | { return __gnu_cxx::__bfloat16_t(__builtin_exp2f(__x)); } |
3320 | |
3321 | constexpr __gnu_cxx::__bfloat16_t |
3322 | expm1(__gnu_cxx::__bfloat16_t __x) |
3323 | { return __gnu_cxx::__bfloat16_t(__builtin_expm1f(__x)); } |
3324 | |
3325 | constexpr __gnu_cxx::__bfloat16_t |
3326 | fdim(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
3327 | { return __gnu_cxx::__bfloat16_t(__builtin_fdimf(__x, __y)); } |
3328 | |
3329 | constexpr __gnu_cxx::__bfloat16_t |
3330 | fma(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) |
3331 | { return __gnu_cxx::__bfloat16_t(__builtin_fmaf(__x, __y, __z)); } |
3332 | |
3333 | constexpr __gnu_cxx::__bfloat16_t |
3334 | fmax(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
3335 | { return __gnu_cxx::__bfloat16_t(__builtin_fmaxf(__x, __y)); } |
3336 | |
3337 | constexpr __gnu_cxx::__bfloat16_t |
3338 | fmin(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
3339 | { return __gnu_cxx::__bfloat16_t(__builtin_fminf(__x, __y)); } |
3340 | |
3341 | constexpr __gnu_cxx::__bfloat16_t |
3342 | hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
3343 | { return __gnu_cxx::__bfloat16_t(__builtin_hypotf(__x, __y)); } |
3344 | |
3345 | constexpr int |
3346 | ilogb(__gnu_cxx::__bfloat16_t __x) |
3347 | { return __gnu_cxx::__bfloat16_t(__builtin_ilogbf(__x)); } |
3348 | |
3349 | constexpr __gnu_cxx::__bfloat16_t |
3350 | lgamma(__gnu_cxx::__bfloat16_t __x) |
3351 | { return __gnu_cxx::__bfloat16_t(__builtin_lgammaf(__x)); } |
3352 | |
3353 | constexpr long long |
3354 | llrint(__gnu_cxx::__bfloat16_t __x) |
3355 | { return __gnu_cxx::__bfloat16_t(__builtin_llrintf(__x)); } |
3356 | |
3357 | constexpr long long |
3358 | llround(__gnu_cxx::__bfloat16_t __x) |
3359 | { return __gnu_cxx::__bfloat16_t(__builtin_llroundf(__x)); } |
3360 | |
3361 | constexpr __gnu_cxx::__bfloat16_t |
3362 | log1p(__gnu_cxx::__bfloat16_t __x) |
3363 | { return __gnu_cxx::__bfloat16_t(__builtin_log1pf(__x)); } |
3364 | |
3365 | // DR 568. |
3366 | constexpr __gnu_cxx::__bfloat16_t |
3367 | log2(__gnu_cxx::__bfloat16_t __x) |
3368 | { return __gnu_cxx::__bfloat16_t(__builtin_log2f(__x)); } |
3369 | |
3370 | constexpr __gnu_cxx::__bfloat16_t |
3371 | logb(__gnu_cxx::__bfloat16_t __x) |
3372 | { return __gnu_cxx::__bfloat16_t(__builtin_logbf(__x)); } |
3373 | |
3374 | constexpr long |
3375 | lrint(__gnu_cxx::__bfloat16_t __x) |
3376 | { return __gnu_cxx::__bfloat16_t(__builtin_lrintf(__x)); } |
3377 | |
3378 | constexpr long |
3379 | lround(__gnu_cxx::__bfloat16_t __x) |
3380 | { return __gnu_cxx::__bfloat16_t(__builtin_lroundf(__x)); } |
3381 | |
3382 | constexpr __gnu_cxx::__bfloat16_t |
3383 | nearbyint(__gnu_cxx::__bfloat16_t __x) |
3384 | { return __gnu_cxx::__bfloat16_t(__builtin_nearbyintf(__x)); } |
3385 | |
3386 | constexpr __gnu_cxx::__bfloat16_t |
3387 | nextafter(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
3388 | { |
3389 | if (std::__is_constant_evaluated()) |
3390 | return __builtin_nextafterf16b(__x, __y); |
3391 | #ifdef __INT16_TYPE__ |
3392 | using __bfloat16_int_type = __INT16_TYPE__; |
3393 | #else |
3394 | using __bfloat16_int_type = short int; |
3395 | #endif |
3396 | __bfloat16_int_type __hx, __hy, __ix, __iy; |
3397 | __builtin_memcpy(&__hx, &__x, sizeof(__x)); |
3398 | __builtin_memcpy(&__hy, &__y, sizeof(__x)); |
3399 | __ix = __hx & 0x7fff; // |x| |
3400 | __iy = __hy & 0x7fff; // |y| |
3401 | if (__ix > 0x7f80 || __iy > 0x7f80) // x or y is NaN |
3402 | return __x + __y; |
3403 | if (__x == __y) |
3404 | return __y; // x == y, return y |
3405 | if (__ix == 0) // x == 0 |
3406 | { |
3407 | __hy = (__hy & 0x8000) | 1; // return +-__BFLT16_DENORM_MIN__ |
3408 | __builtin_memcpy(&__x, &__hy, sizeof(__x)); |
3409 | __builtin_nextafterf(0.0f, 1.0f); // raise underflow |
3410 | return __x; |
3411 | } |
3412 | if (__hx >= 0) // x > 0 |
3413 | { |
3414 | if (__hx > __hy) // x > y, x -= ulp |
3415 | --__hx; |
3416 | else // x < y, x += ulp |
3417 | ++__hx; |
3418 | } |
3419 | else // x < 0 |
3420 | { |
3421 | if (__hy >= 0 || __hx > __hy) // x < y, x -= ulp |
3422 | --__hx; |
3423 | else // x > y, x += ulp |
3424 | ++__hx; |
3425 | } |
3426 | __hy = __hx & 0x7f80; |
3427 | if (__hy >= 0x7f80) |
3428 | __builtin_nextafterf(__FLT_MAX__, __builtin_inff()); // overflow |
3429 | else if (__hy < 0x0080) |
3430 | __builtin_nextafterf(__FLT_MIN__, 0.0f); // underflow |
3431 | __builtin_memcpy(&__x, &__hx, sizeof(__x)); |
3432 | return __x; |
3433 | } |
3434 | |
3435 | constexpr __gnu_cxx::__bfloat16_t |
3436 | remainder(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y) |
3437 | { return __gnu_cxx::__bfloat16_t(__builtin_remainderf(__x, __y)); } |
3438 | |
3439 | inline __gnu_cxx::__bfloat16_t |
3440 | remquo(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, int* __pquo) |
3441 | { return __gnu_cxx::__bfloat16_t(__builtin_remquof(__x, __y, __pquo)); } |
3442 | |
3443 | constexpr __gnu_cxx::__bfloat16_t |
3444 | rint(__gnu_cxx::__bfloat16_t __x) |
3445 | { return __gnu_cxx::__bfloat16_t(__builtin_rintf(__x)); } |
3446 | |
3447 | constexpr __gnu_cxx::__bfloat16_t |
3448 | round(__gnu_cxx::__bfloat16_t __x) |
3449 | { return __gnu_cxx::__bfloat16_t(__builtin_roundf(__x)); } |
3450 | |
3451 | constexpr __gnu_cxx::__bfloat16_t |
3452 | scalbln(__gnu_cxx::__bfloat16_t __x, long __ex) |
3453 | { return __gnu_cxx::__bfloat16_t(__builtin_scalblnf(__x, __ex)); } |
3454 | |
3455 | constexpr __gnu_cxx::__bfloat16_t |
3456 | scalbn(__gnu_cxx::__bfloat16_t __x, int __ex) |
3457 | { return __gnu_cxx::__bfloat16_t(__builtin_scalbnf(__x, __ex)); } |
3458 | |
3459 | constexpr __gnu_cxx::__bfloat16_t |
3460 | tgamma(__gnu_cxx::__bfloat16_t __x) |
3461 | { return __gnu_cxx::__bfloat16_t(__builtin_tgammaf(__x)); } |
3462 | |
3463 | constexpr __gnu_cxx::__bfloat16_t |
3464 | trunc(__gnu_cxx::__bfloat16_t __x) |
3465 | { return __gnu_cxx::__bfloat16_t(__builtin_truncf(__x)); } |
3466 | #endif |
3467 | |
3468 | #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT |
3469 | template<typename _Tp, typename _Up> |
3470 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3471 | copysign(_Tp __x, _Up __y) |
3472 | { |
3473 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3474 | return copysign(__type(__x), __type(__y)); |
3475 | } |
3476 | |
3477 | template<typename _Tp, typename _Up> |
3478 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3479 | fdim(_Tp __x, _Up __y) |
3480 | { |
3481 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3482 | return fdim(__type(__x), __type(__y)); |
3483 | } |
3484 | |
3485 | template<typename _Tp, typename _Up> |
3486 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3487 | fmax(_Tp __x, _Up __y) |
3488 | { |
3489 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3490 | return fmax(__type(__x), __type(__y)); |
3491 | } |
3492 | |
3493 | template<typename _Tp, typename _Up> |
3494 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3495 | fmin(_Tp __x, _Up __y) |
3496 | { |
3497 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3498 | return fmin(__type(__x), __type(__y)); |
3499 | } |
3500 | |
3501 | template<typename _Tp, typename _Up> |
3502 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3503 | hypot(_Tp __x, _Up __y) |
3504 | { |
3505 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3506 | return hypot(__type(__x), __type(__y)); |
3507 | } |
3508 | |
3509 | template<typename _Tp, typename _Up> |
3510 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3511 | nextafter(_Tp __x, _Up __y) |
3512 | { |
3513 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3514 | return nextafter(__type(__x), __type(__y)); |
3515 | } |
3516 | |
3517 | template<typename _Tp, typename _Up> |
3518 | constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3519 | remainder(_Tp __x, _Up __y) |
3520 | { |
3521 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3522 | return remainder(__type(__x), __type(__y)); |
3523 | } |
3524 | |
3525 | template<typename _Tp, typename _Up> |
3526 | inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type |
3527 | remquo(_Tp __x, _Up __y, int* __pquo) |
3528 | { |
3529 | typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; |
3530 | return remquo(__type(__x), __type(__y), __pquo); |
3531 | } |
3532 | |
3533 | template<typename _Tp, typename _Up, typename _Vp> |
3534 | constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type |
3535 | fma(_Tp __x, _Up __y, _Vp __z) |
3536 | { |
3537 | typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; |
3538 | return fma(__type(__x), __type(__y), __type(__z)); |
3539 | } |
3540 | #endif |
3541 | |
3542 | #endif // _GLIBCXX_USE_C99_MATH_TR1 |
3543 | #endif // C++11 |
3544 | |
3545 | #if __cplusplus >= 201703L |
3546 | |
3547 | // [c.math.hypot3], three-dimensional hypotenuse |
3548 | #define __cpp_lib_hypot 201603L |
3549 | |
3550 | template<typename _Tp> |
3551 | inline _Tp |
3552 | __hypot3(_Tp __x, _Tp __y, _Tp __z) |
3553 | { |
3554 | __x = std::abs(__x); |
3555 | __y = std::abs(__y); |
3556 | __z = std::abs(__z); |
3557 | if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) |
3558 | return __a * std::sqrt((__x / __a) * (__x / __a) |
3559 | + (__y / __a) * (__y / __a) |
3560 | + (__z / __a) * (__z / __a)); |
3561 | else |
3562 | return {}; |
3563 | } |
3564 | |
3565 | inline float |
3566 | hypot(float __x, float __y, float __z) |
3567 | { return std::__hypot3<float>(__x, __y, __z); } |
3568 | |
3569 | inline double |
3570 | hypot(double __x, double __y, double __z) |
3571 | { return std::__hypot3<double>(__x, __y, __z); } |
3572 | |
3573 | inline long double |
3574 | hypot(long double __x, long double __y, long double __z) |
3575 | { return std::__hypot3<long double>(__x, __y, __z); } |
3576 | |
3577 | template<typename _Tp, typename _Up, typename _Vp> |
3578 | __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> |
3579 | hypot(_Tp __x, _Up __y, _Vp __z) |
3580 | { |
3581 | using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; |
3582 | return std::__hypot3<__type>(__x, __y, __z); |
3583 | } |
3584 | |
3585 | #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
3586 | inline _Float16 |
3587 | hypot(_Float16 __x, _Float16 __y, _Float16 __z) |
3588 | { return std::__hypot3<_Float16>(__x, __y, __z); } |
3589 | #endif |
3590 | |
3591 | #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
3592 | inline _Float32 |
3593 | hypot(_Float32 __x, _Float32 __y, _Float32 __z) |
3594 | { return std::__hypot3<_Float32>(__x, __y, __z); } |
3595 | #endif |
3596 | |
3597 | #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64) |
3598 | inline _Float64 |
3599 | hypot(_Float64 __x, _Float64 __y, _Float64 __z) |
3600 | { return std::__hypot3<_Float64>(__x, __y, __z); } |
3601 | #endif |
3602 | |
3603 | #if defined(__STDCPP_FLOAT128_T__) \ |
3604 | && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \ |
3605 | || defined(_GLIBCXX_HAVE_FLOAT128_MATH)) |
3606 | inline _Float128 |
3607 | hypot(_Float128 __x, _Float128 __y, _Float128 __z) |
3608 | { return std::__hypot3<_Float128>(__x, __y, __z); } |
3609 | #endif |
3610 | |
3611 | #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
3612 | inline __gnu_cxx::__bfloat16_t |
3613 | hypot(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) |
3614 | { return std::__hypot3<__gnu_cxx::__bfloat16_t>(__x, __y, __z); } |
3615 | #endif |
3616 | |
3617 | #endif // C++17 |
3618 | |
3619 | #if __cplusplus >= 202002L |
3620 | // linear interpolation |
3621 | # define __cpp_lib_interpolate 201902L |
3622 | |
3623 | template<typename _Fp> |
3624 | constexpr _Fp |
3625 | __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept |
3626 | { |
3627 | if ((__a <= 0 && __b >= 0) || (__a >= 0 && __b <= 0)) |
3628 | return __t * __b + (1 - __t) * __a; |
3629 | |
3630 | if (__t == 1) |
3631 | return __b; // exact |
3632 | |
3633 | // Exact at __t=0, monotonic except near __t=1, |
3634 | // bounded, determinate, and consistent: |
3635 | const _Fp __x = __a + __t * (__b - __a); |
3636 | return (__t > 1) == (__b > __a) |
3637 | ? (__b < __x ? __x : __b) |
3638 | : (__b > __x ? __x : __b); // monotonic near __t=1 |
3639 | } |
3640 | |
3641 | constexpr float |
3642 | lerp(float __a, float __b, float __t) noexcept |
3643 | { return std::__lerp(__a, __b, __t); } |
3644 | |
3645 | constexpr double |
3646 | lerp(double __a, double __b, double __t) noexcept |
3647 | { return std::__lerp(__a, __b, __t); } |
3648 | |
3649 | constexpr long double |
3650 | lerp(long double __a, long double __b, long double __t) noexcept |
3651 | { return std::__lerp(__a, __b, __t); } |
3652 | |
3653 | template<typename _Tp, typename _Up, typename _Vp> |
3654 | constexpr __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> |
3655 | lerp(_Tp __x, _Up __y, _Vp __z) noexcept |
3656 | { |
3657 | using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; |
3658 | return std::__lerp<__type>(__x, __y, __z); |
3659 | } |
3660 | |
3661 | #if defined(__STDCPP_FLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
3662 | inline _Float16 |
3663 | lerp(_Float16 __x, _Float16 __y, _Float16 __z) noexcept |
3664 | { return std::__lerp<_Float16>(__x, __y, __z); } |
3665 | #endif |
3666 | |
3667 | #if defined(__STDCPP_FLOAT32_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
3668 | inline _Float32 |
3669 | lerp(_Float32 __x, _Float32 __y, _Float32 __z) noexcept |
3670 | { return std::__lerp<_Float32>(__x, __y, __z); } |
3671 | #endif |
3672 | |
3673 | #if defined(__STDCPP_FLOAT64_T__) && defined(_GLIBCXX_DOUBLE_IS_IEEE_BINARY64) |
3674 | inline _Float64 |
3675 | lerp(_Float64 __x, _Float64 __y, _Float64 __z) noexcept |
3676 | { return std::__lerp<_Float64>(__x, __y, __z); } |
3677 | #endif |
3678 | |
3679 | #if defined(__STDCPP_FLOAT128_T__) \ |
3680 | && (defined(_GLIBCXX_LDOUBLE_IS_IEEE_BINARY128) \ |
3681 | || defined(_GLIBCXX_HAVE_FLOAT128_MATH)) |
3682 | inline _Float128 |
3683 | lerp(_Float128 __x, _Float128 __y, _Float128 __z) noexcept |
3684 | { return std::__lerp<_Float128>(__x, __y, __z); } |
3685 | #endif |
3686 | |
3687 | #if defined(__STDCPP_BFLOAT16_T__) && defined(_GLIBCXX_FLOAT_IS_IEEE_BINARY32) |
3688 | inline __gnu_cxx::__bfloat16_t |
3689 | lerp(__gnu_cxx::__bfloat16_t __x, __gnu_cxx::__bfloat16_t __y, __gnu_cxx::__bfloat16_t __z) noexcept |
3690 | { return std::__lerp<__gnu_cxx::__bfloat16_t>(__x, __y, __z); } |
3691 | #endif |
3692 | |
3693 | #endif // C++20 |
3694 | |
3695 | _GLIBCXX_END_NAMESPACE_VERSION |
3696 | } // namespace |
3697 | |
3698 | #if _GLIBCXX_USE_STD_SPEC_FUNCS |
3699 | # include <bits/specfun.h> |
3700 | #endif |
3701 | |
3702 | } // extern "C++" |
3703 | |
3704 | #endif |
3705 | |