Line data Source code
1 : // -*- C++ -*- C forwarding header.
2 :
3 : // Copyright (C) 1997-2019 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/c++config.h>
42 : #include <bits/cpp_type_traits.h>
43 : #include <ext/type_traits.h>
44 : #define _GLIBCXX_INCLUDE_NEXT_C_HEADERS
45 : #include_next <math.h>
46 : #undef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
47 : #include <bits/std_abs.h>
48 :
49 : #ifndef _GLIBCXX_CMATH
50 : #define _GLIBCXX_CMATH 1
51 :
52 : // Get rid of those macros defined in <math.h> in lieu of real functions.
53 : #undef div
54 : #undef acos
55 : #undef asin
56 : #undef atan
57 : #undef atan2
58 : #undef ceil
59 : #undef cos
60 : #undef cosh
61 : #undef exp
62 : #undef fabs
63 : #undef floor
64 : #undef fmod
65 : #undef frexp
66 : #undef ldexp
67 : #undef log
68 : #undef log10
69 : #undef modf
70 : #undef pow
71 : #undef sin
72 : #undef sinh
73 : #undef sqrt
74 : #undef tan
75 : #undef tanh
76 :
77 : extern "C++"
78 : {
79 : namespace std _GLIBCXX_VISIBILITY(default)
80 : {
81 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
82 :
83 : using ::acos;
84 :
85 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
86 : inline _GLIBCXX_CONSTEXPR float
87 : acos(float __x)
88 : { return __builtin_acosf(__x); }
89 :
90 : inline _GLIBCXX_CONSTEXPR long double
91 : acos(long double __x)
92 : { return __builtin_acosl(__x); }
93 : #endif
94 :
95 : template<typename _Tp>
96 : inline _GLIBCXX_CONSTEXPR
97 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
98 : double>::__type
99 : acos(_Tp __x)
100 : { return __builtin_acos(__x); }
101 :
102 : using ::asin;
103 :
104 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
105 : inline _GLIBCXX_CONSTEXPR float
106 : asin(float __x)
107 : { return __builtin_asinf(__x); }
108 :
109 : inline _GLIBCXX_CONSTEXPR long double
110 : asin(long double __x)
111 : { return __builtin_asinl(__x); }
112 : #endif
113 :
114 : template<typename _Tp>
115 : inline _GLIBCXX_CONSTEXPR
116 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
117 : double>::__type
118 : asin(_Tp __x)
119 : { return __builtin_asin(__x); }
120 :
121 : using ::atan;
122 :
123 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
124 : inline _GLIBCXX_CONSTEXPR float
125 : atan(float __x)
126 : { return __builtin_atanf(__x); }
127 :
128 : inline _GLIBCXX_CONSTEXPR long double
129 : atan(long double __x)
130 : { return __builtin_atanl(__x); }
131 : #endif
132 :
133 : template<typename _Tp>
134 : inline _GLIBCXX_CONSTEXPR
135 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
136 : double>::__type
137 : atan(_Tp __x)
138 : { return __builtin_atan(__x); }
139 :
140 : using ::atan2;
141 :
142 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
143 : inline _GLIBCXX_CONSTEXPR float
144 : atan2(float __y, float __x)
145 : { return __builtin_atan2f(__y, __x); }
146 :
147 : inline _GLIBCXX_CONSTEXPR long double
148 : atan2(long double __y, long double __x)
149 : { return __builtin_atan2l(__y, __x); }
150 : #endif
151 :
152 : template<typename _Tp, typename _Up>
153 : inline _GLIBCXX_CONSTEXPR
154 : typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
155 : atan2(_Tp __y, _Up __x)
156 : {
157 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
158 : return atan2(__type(__y), __type(__x));
159 : }
160 :
161 : using ::ceil;
162 :
163 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
164 : inline _GLIBCXX_CONSTEXPR float
165 : ceil(float __x)
166 : { return __builtin_ceilf(__x); }
167 :
168 : inline _GLIBCXX_CONSTEXPR long double
169 : ceil(long double __x)
170 : { return __builtin_ceill(__x); }
171 : #endif
172 :
173 : template<typename _Tp>
174 : inline _GLIBCXX_CONSTEXPR
175 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
176 : double>::__type
177 : ceil(_Tp __x)
178 : { return __builtin_ceil(__x); }
179 :
180 : using ::cos;
181 :
182 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
183 : inline _GLIBCXX_CONSTEXPR float
184 : cos(float __x)
185 : { return __builtin_cosf(__x); }
186 :
187 : inline _GLIBCXX_CONSTEXPR long double
188 : cos(long double __x)
189 : { return __builtin_cosl(__x); }
190 : #endif
191 :
192 : template<typename _Tp>
193 : inline _GLIBCXX_CONSTEXPR
194 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
195 : double>::__type
196 : cos(_Tp __x)
197 : { return __builtin_cos(__x); }
198 :
199 : using ::cosh;
200 :
201 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
202 : inline _GLIBCXX_CONSTEXPR float
203 : cosh(float __x)
204 : { return __builtin_coshf(__x); }
205 :
206 : inline _GLIBCXX_CONSTEXPR long double
207 : cosh(long double __x)
208 : { return __builtin_coshl(__x); }
209 : #endif
210 :
211 : template<typename _Tp>
212 : inline _GLIBCXX_CONSTEXPR
213 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
214 : double>::__type
215 : cosh(_Tp __x)
216 : { return __builtin_cosh(__x); }
217 :
218 : using ::exp;
219 :
220 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
221 : inline _GLIBCXX_CONSTEXPR float
222 : exp(float __x)
223 : { return __builtin_expf(__x); }
224 :
225 : inline _GLIBCXX_CONSTEXPR long double
226 : exp(long double __x)
227 : { return __builtin_expl(__x); }
228 : #endif
229 :
230 : template<typename _Tp>
231 : inline _GLIBCXX_CONSTEXPR
232 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
233 : double>::__type
234 : exp(_Tp __x)
235 : { return __builtin_exp(__x); }
236 :
237 : using ::fabs;
238 :
239 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
240 : inline _GLIBCXX_CONSTEXPR float
241 : fabs(float __x)
242 : { return __builtin_fabsf(__x); }
243 :
244 : inline _GLIBCXX_CONSTEXPR long double
245 : fabs(long double __x)
246 : { return __builtin_fabsl(__x); }
247 : #endif
248 :
249 : template<typename _Tp>
250 : inline _GLIBCXX_CONSTEXPR
251 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
252 : double>::__type
253 : fabs(_Tp __x)
254 : { return __builtin_fabs(__x); }
255 :
256 : using ::floor;
257 :
258 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
259 : inline _GLIBCXX_CONSTEXPR float
260 : floor(float __x)
261 : { return __builtin_floorf(__x); }
262 :
263 : inline _GLIBCXX_CONSTEXPR long double
264 : floor(long double __x)
265 : { return __builtin_floorl(__x); }
266 : #endif
267 :
268 : template<typename _Tp>
269 : inline _GLIBCXX_CONSTEXPR
270 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
271 : double>::__type
272 : floor(_Tp __x)
273 : { return __builtin_floor(__x); }
274 :
275 : using ::fmod;
276 :
277 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
278 : inline _GLIBCXX_CONSTEXPR float
279 : fmod(float __x, float __y)
280 : { return __builtin_fmodf(__x, __y); }
281 :
282 : inline _GLIBCXX_CONSTEXPR long double
283 : fmod(long double __x, long double __y)
284 : { return __builtin_fmodl(__x, __y); }
285 : #endif
286 :
287 : template<typename _Tp, typename _Up>
288 : inline _GLIBCXX_CONSTEXPR
289 : typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
290 : fmod(_Tp __x, _Up __y)
291 : {
292 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
293 : return fmod(__type(__x), __type(__y));
294 : }
295 :
296 : using ::frexp;
297 :
298 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
299 : inline float
300 : frexp(float __x, int* __exp)
301 : { return __builtin_frexpf(__x, __exp); }
302 :
303 : inline long double
304 : frexp(long double __x, int* __exp)
305 : { return __builtin_frexpl(__x, __exp); }
306 : #endif
307 :
308 : template<typename _Tp>
309 : inline _GLIBCXX_CONSTEXPR
310 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
311 : double>::__type
312 : frexp(_Tp __x, int* __exp)
313 : { return __builtin_frexp(__x, __exp); }
314 :
315 : using ::ldexp;
316 :
317 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
318 : inline _GLIBCXX_CONSTEXPR float
319 : ldexp(float __x, int __exp)
320 : { return __builtin_ldexpf(__x, __exp); }
321 :
322 : inline _GLIBCXX_CONSTEXPR long double
323 : ldexp(long double __x, int __exp)
324 : { return __builtin_ldexpl(__x, __exp); }
325 : #endif
326 :
327 : template<typename _Tp>
328 : inline _GLIBCXX_CONSTEXPR
329 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
330 : double>::__type
331 : ldexp(_Tp __x, int __exp)
332 : { return __builtin_ldexp(__x, __exp); }
333 :
334 : using ::log;
335 :
336 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
337 : inline _GLIBCXX_CONSTEXPR float
338 : log(float __x)
339 : { return __builtin_logf(__x); }
340 :
341 : inline _GLIBCXX_CONSTEXPR long double
342 : log(long double __x)
343 : { return __builtin_logl(__x); }
344 : #endif
345 :
346 : template<typename _Tp>
347 : inline _GLIBCXX_CONSTEXPR
348 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
349 : double>::__type
350 : log(_Tp __x)
351 : { return __builtin_log(__x); }
352 :
353 : using ::log10;
354 :
355 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
356 : inline _GLIBCXX_CONSTEXPR float
357 : log10(float __x)
358 : { return __builtin_log10f(__x); }
359 :
360 : inline _GLIBCXX_CONSTEXPR long double
361 : log10(long double __x)
362 : { return __builtin_log10l(__x); }
363 : #endif
364 :
365 : template<typename _Tp>
366 : inline _GLIBCXX_CONSTEXPR
367 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
368 : double>::__type
369 : log10(_Tp __x)
370 : { return __builtin_log10(__x); }
371 :
372 : using ::modf;
373 :
374 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
375 : inline float
376 : modf(float __x, float* __iptr)
377 : { return __builtin_modff(__x, __iptr); }
378 :
379 : inline long double
380 : modf(long double __x, long double* __iptr)
381 : { return __builtin_modfl(__x, __iptr); }
382 : #endif
383 :
384 : using ::pow;
385 :
386 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
387 : inline _GLIBCXX_CONSTEXPR float
388 : pow(float __x, float __y)
389 : { return __builtin_powf(__x, __y); }
390 :
391 : inline _GLIBCXX_CONSTEXPR long double
392 : pow(long double __x, long double __y)
393 : { return __builtin_powl(__x, __y); }
394 :
395 : #if __cplusplus < 201103L
396 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
397 : // DR 550. What should the return type of pow(float,int) be?
398 : inline double
399 : pow(double __x, int __i)
400 : { return __builtin_powi(__x, __i); }
401 :
402 : inline float
403 : pow(float __x, int __n)
404 : { return __builtin_powif(__x, __n); }
405 :
406 : inline long double
407 : pow(long double __x, int __n)
408 : { return __builtin_powil(__x, __n); }
409 : #endif
410 : #endif
411 :
412 : template<typename _Tp, typename _Up>
413 : inline _GLIBCXX_CONSTEXPR
414 : typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
415 0 : pow(_Tp __x, _Up __y)
416 : {
417 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
418 0 : return pow(__type(__x), __type(__y));
419 : }
420 :
421 : using ::sin;
422 :
423 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
424 : inline _GLIBCXX_CONSTEXPR float
425 : sin(float __x)
426 : { return __builtin_sinf(__x); }
427 :
428 : inline _GLIBCXX_CONSTEXPR long double
429 : sin(long double __x)
430 : { return __builtin_sinl(__x); }
431 : #endif
432 :
433 : template<typename _Tp>
434 : inline _GLIBCXX_CONSTEXPR
435 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
436 : double>::__type
437 : sin(_Tp __x)
438 : { return __builtin_sin(__x); }
439 :
440 : using ::sinh;
441 :
442 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
443 : inline _GLIBCXX_CONSTEXPR float
444 : sinh(float __x)
445 : { return __builtin_sinhf(__x); }
446 :
447 : inline _GLIBCXX_CONSTEXPR long double
448 : sinh(long double __x)
449 : { return __builtin_sinhl(__x); }
450 : #endif
451 :
452 : template<typename _Tp>
453 : inline _GLIBCXX_CONSTEXPR
454 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
455 : double>::__type
456 : sinh(_Tp __x)
457 : { return __builtin_sinh(__x); }
458 :
459 : using ::sqrt;
460 :
461 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
462 : inline _GLIBCXX_CONSTEXPR float
463 : sqrt(float __x)
464 : { return __builtin_sqrtf(__x); }
465 :
466 : inline _GLIBCXX_CONSTEXPR long double
467 : sqrt(long double __x)
468 : { return __builtin_sqrtl(__x); }
469 : #endif
470 :
471 : template<typename _Tp>
472 : inline _GLIBCXX_CONSTEXPR
473 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
474 : double>::__type
475 : sqrt(_Tp __x)
476 : { return __builtin_sqrt(__x); }
477 :
478 : using ::tan;
479 :
480 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
481 : inline _GLIBCXX_CONSTEXPR float
482 : tan(float __x)
483 : { return __builtin_tanf(__x); }
484 :
485 : inline _GLIBCXX_CONSTEXPR long double
486 : tan(long double __x)
487 : { return __builtin_tanl(__x); }
488 : #endif
489 :
490 : template<typename _Tp>
491 : inline _GLIBCXX_CONSTEXPR
492 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
493 : double>::__type
494 : tan(_Tp __x)
495 : { return __builtin_tan(__x); }
496 :
497 : using ::tanh;
498 :
499 : #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
500 : inline _GLIBCXX_CONSTEXPR float
501 : tanh(float __x)
502 : { return __builtin_tanhf(__x); }
503 :
504 : inline _GLIBCXX_CONSTEXPR long double
505 : tanh(long double __x)
506 : { return __builtin_tanhl(__x); }
507 : #endif
508 :
509 : template<typename _Tp>
510 : inline _GLIBCXX_CONSTEXPR
511 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
512 : double>::__type
513 : tanh(_Tp __x)
514 : { return __builtin_tanh(__x); }
515 :
516 : #if _GLIBCXX_USE_C99_MATH
517 : #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
518 :
519 : // These are possible macros imported from C99-land.
520 : #undef fpclassify
521 : #undef isfinite
522 : #undef isinf
523 : #undef isnan
524 : #undef isnormal
525 : #undef signbit
526 : #undef isgreater
527 : #undef isgreaterequal
528 : #undef isless
529 : #undef islessequal
530 : #undef islessgreater
531 : #undef isunordered
532 :
533 : #if __cplusplus >= 201103L
534 :
535 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
536 : constexpr int
537 : fpclassify(float __x)
538 : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
539 : FP_SUBNORMAL, FP_ZERO, __x); }
540 :
541 : constexpr int
542 : fpclassify(double __x)
543 : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
544 : FP_SUBNORMAL, FP_ZERO, __x); }
545 :
546 : constexpr int
547 : fpclassify(long double __x)
548 : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
549 : FP_SUBNORMAL, FP_ZERO, __x); }
550 : #endif
551 :
552 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
553 : template<typename _Tp>
554 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
555 : int>::__type
556 : fpclassify(_Tp __x)
557 : { return __x != 0 ? FP_NORMAL : FP_ZERO; }
558 : #endif
559 :
560 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
561 : constexpr bool
562 : isfinite(float __x)
563 : { return __builtin_isfinite(__x); }
564 :
565 : constexpr bool
566 : isfinite(double __x)
567 : { return __builtin_isfinite(__x); }
568 :
569 : constexpr bool
570 : isfinite(long double __x)
571 : { return __builtin_isfinite(__x); }
572 : #endif
573 :
574 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
575 : template<typename _Tp>
576 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
577 : bool>::__type
578 : isfinite(_Tp __x)
579 : { return true; }
580 : #endif
581 :
582 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
583 : constexpr bool
584 : isinf(float __x)
585 : { return __builtin_isinf(__x); }
586 :
587 : #if _GLIBCXX_HAVE_OBSOLETE_ISINF \
588 : && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
589 : using ::isinf;
590 : #else
591 : constexpr bool
592 0 : isinf(double __x)
593 0 : { return __builtin_isinf(__x); }
594 : #endif
595 :
596 : constexpr bool
597 : isinf(long double __x)
598 : { return __builtin_isinf(__x); }
599 : #endif
600 :
601 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
602 : template<typename _Tp>
603 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
604 : bool>::__type
605 : isinf(_Tp __x)
606 : { return false; }
607 : #endif
608 :
609 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
610 : constexpr bool
611 0 : isnan(float __x)
612 0 : { return __builtin_isnan(__x); }
613 :
614 : #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
615 : && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
616 : using ::isnan;
617 : #else
618 : constexpr bool
619 0 : isnan(double __x)
620 0 : { return __builtin_isnan(__x); }
621 : #endif
622 :
623 : constexpr bool
624 : isnan(long double __x)
625 : { return __builtin_isnan(__x); }
626 : #endif
627 :
628 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
629 : template<typename _Tp>
630 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
631 : bool>::__type
632 : isnan(_Tp __x)
633 : { return false; }
634 : #endif
635 :
636 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
637 : constexpr bool
638 : isnormal(float __x)
639 : { return __builtin_isnormal(__x); }
640 :
641 : constexpr bool
642 : isnormal(double __x)
643 : { return __builtin_isnormal(__x); }
644 :
645 : constexpr bool
646 : isnormal(long double __x)
647 : { return __builtin_isnormal(__x); }
648 : #endif
649 :
650 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
651 : template<typename _Tp>
652 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
653 : bool>::__type
654 : isnormal(_Tp __x)
655 : { return __x != 0 ? true : false; }
656 : #endif
657 :
658 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
659 : // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.
660 : constexpr bool
661 : signbit(float __x)
662 : { return __builtin_signbit(__x); }
663 :
664 : constexpr bool
665 0 : signbit(double __x)
666 0 : { return __builtin_signbit(__x); }
667 :
668 : constexpr bool
669 : signbit(long double __x)
670 : { return __builtin_signbit(__x); }
671 : #endif
672 :
673 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
674 : template<typename _Tp>
675 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
676 : bool>::__type
677 : signbit(_Tp __x)
678 : { return __x < 0 ? true : false; }
679 : #endif
680 :
681 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
682 : constexpr bool
683 : isgreater(float __x, float __y)
684 : { return __builtin_isgreater(__x, __y); }
685 :
686 : constexpr bool
687 : isgreater(double __x, double __y)
688 : { return __builtin_isgreater(__x, __y); }
689 :
690 : constexpr bool
691 : isgreater(long double __x, long double __y)
692 : { return __builtin_isgreater(__x, __y); }
693 : #endif
694 :
695 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
696 : template<typename _Tp, typename _Up>
697 : constexpr typename
698 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
699 : && __is_arithmetic<_Up>::__value), bool>::__type
700 : isgreater(_Tp __x, _Up __y)
701 : {
702 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
703 : return __builtin_isgreater(__type(__x), __type(__y));
704 : }
705 : #endif
706 :
707 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
708 : constexpr bool
709 : isgreaterequal(float __x, float __y)
710 : { return __builtin_isgreaterequal(__x, __y); }
711 :
712 : constexpr bool
713 : isgreaterequal(double __x, double __y)
714 : { return __builtin_isgreaterequal(__x, __y); }
715 :
716 : constexpr bool
717 : isgreaterequal(long double __x, long double __y)
718 : { return __builtin_isgreaterequal(__x, __y); }
719 : #endif
720 :
721 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
722 : template<typename _Tp, typename _Up>
723 : constexpr typename
724 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
725 : && __is_arithmetic<_Up>::__value), bool>::__type
726 : isgreaterequal(_Tp __x, _Up __y)
727 : {
728 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
729 : return __builtin_isgreaterequal(__type(__x), __type(__y));
730 : }
731 : #endif
732 :
733 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
734 : constexpr bool
735 : isless(float __x, float __y)
736 : { return __builtin_isless(__x, __y); }
737 :
738 : constexpr bool
739 : isless(double __x, double __y)
740 : { return __builtin_isless(__x, __y); }
741 :
742 : constexpr bool
743 : isless(long double __x, long double __y)
744 : { return __builtin_isless(__x, __y); }
745 : #endif
746 :
747 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
748 : template<typename _Tp, typename _Up>
749 : constexpr typename
750 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
751 : && __is_arithmetic<_Up>::__value), bool>::__type
752 : isless(_Tp __x, _Up __y)
753 : {
754 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
755 : return __builtin_isless(__type(__x), __type(__y));
756 : }
757 : #endif
758 :
759 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
760 : constexpr bool
761 : islessequal(float __x, float __y)
762 : { return __builtin_islessequal(__x, __y); }
763 :
764 : constexpr bool
765 : islessequal(double __x, double __y)
766 : { return __builtin_islessequal(__x, __y); }
767 :
768 : constexpr bool
769 : islessequal(long double __x, long double __y)
770 : { return __builtin_islessequal(__x, __y); }
771 : #endif
772 :
773 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
774 : template<typename _Tp, typename _Up>
775 : constexpr typename
776 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
777 : && __is_arithmetic<_Up>::__value), bool>::__type
778 : islessequal(_Tp __x, _Up __y)
779 : {
780 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
781 : return __builtin_islessequal(__type(__x), __type(__y));
782 : }
783 : #endif
784 :
785 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
786 : constexpr bool
787 : islessgreater(float __x, float __y)
788 : { return __builtin_islessgreater(__x, __y); }
789 :
790 : constexpr bool
791 : islessgreater(double __x, double __y)
792 : { return __builtin_islessgreater(__x, __y); }
793 :
794 : constexpr bool
795 : islessgreater(long double __x, long double __y)
796 : { return __builtin_islessgreater(__x, __y); }
797 : #endif
798 :
799 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
800 : template<typename _Tp, typename _Up>
801 : constexpr typename
802 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
803 : && __is_arithmetic<_Up>::__value), bool>::__type
804 : islessgreater(_Tp __x, _Up __y)
805 : {
806 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
807 : return __builtin_islessgreater(__type(__x), __type(__y));
808 : }
809 : #endif
810 :
811 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
812 : constexpr bool
813 : isunordered(float __x, float __y)
814 : { return __builtin_isunordered(__x, __y); }
815 :
816 : constexpr bool
817 : isunordered(double __x, double __y)
818 : { return __builtin_isunordered(__x, __y); }
819 :
820 : constexpr bool
821 : isunordered(long double __x, long double __y)
822 : { return __builtin_isunordered(__x, __y); }
823 : #endif
824 :
825 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
826 : template<typename _Tp, typename _Up>
827 : constexpr typename
828 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
829 : && __is_arithmetic<_Up>::__value), bool>::__type
830 : isunordered(_Tp __x, _Up __y)
831 : {
832 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
833 : return __builtin_isunordered(__type(__x), __type(__y));
834 : }
835 : #endif
836 :
837 : #else
838 :
839 : template<typename _Tp>
840 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
841 : int>::__type
842 : fpclassify(_Tp __f)
843 : {
844 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
845 : return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
846 : FP_SUBNORMAL, FP_ZERO, __type(__f));
847 : }
848 :
849 : template<typename _Tp>
850 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
851 : int>::__type
852 : isfinite(_Tp __f)
853 : {
854 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
855 : return __builtin_isfinite(__type(__f));
856 : }
857 :
858 : template<typename _Tp>
859 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
860 : int>::__type
861 : isinf(_Tp __f)
862 : {
863 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
864 : return __builtin_isinf(__type(__f));
865 : }
866 :
867 : template<typename _Tp>
868 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
869 : int>::__type
870 : isnan(_Tp __f)
871 : {
872 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
873 : return __builtin_isnan(__type(__f));
874 : }
875 :
876 : template<typename _Tp>
877 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
878 : int>::__type
879 : isnormal(_Tp __f)
880 : {
881 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
882 : return __builtin_isnormal(__type(__f));
883 : }
884 :
885 : template<typename _Tp>
886 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
887 : int>::__type
888 : signbit(_Tp __f)
889 : {
890 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
891 : return __builtin_signbit(__type(__f));
892 : }
893 :
894 : template<typename _Tp>
895 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
896 : int>::__type
897 : isgreater(_Tp __f1, _Tp __f2)
898 : {
899 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
900 : return __builtin_isgreater(__type(__f1), __type(__f2));
901 : }
902 :
903 : template<typename _Tp>
904 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
905 : int>::__type
906 : isgreaterequal(_Tp __f1, _Tp __f2)
907 : {
908 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
909 : return __builtin_isgreaterequal(__type(__f1), __type(__f2));
910 : }
911 :
912 : template<typename _Tp>
913 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
914 : int>::__type
915 : isless(_Tp __f1, _Tp __f2)
916 : {
917 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
918 : return __builtin_isless(__type(__f1), __type(__f2));
919 : }
920 :
921 : template<typename _Tp>
922 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
923 : int>::__type
924 : islessequal(_Tp __f1, _Tp __f2)
925 : {
926 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
927 : return __builtin_islessequal(__type(__f1), __type(__f2));
928 : }
929 :
930 : template<typename _Tp>
931 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
932 : int>::__type
933 : islessgreater(_Tp __f1, _Tp __f2)
934 : {
935 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
936 : return __builtin_islessgreater(__type(__f1), __type(__f2));
937 : }
938 :
939 : template<typename _Tp>
940 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
941 : int>::__type
942 : isunordered(_Tp __f1, _Tp __f2)
943 : {
944 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
945 : return __builtin_isunordered(__type(__f1), __type(__f2));
946 : }
947 :
948 : #endif // C++11
949 : #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
950 : #endif /* _GLIBCXX_USE_C99_MATH */
951 :
952 : #if __cplusplus >= 201103L
953 :
954 : #ifdef _GLIBCXX_USE_C99_MATH_TR1
955 :
956 : #undef acosh
957 : #undef acoshf
958 : #undef acoshl
959 : #undef asinh
960 : #undef asinhf
961 : #undef asinhl
962 : #undef atanh
963 : #undef atanhf
964 : #undef atanhl
965 : #undef cbrt
966 : #undef cbrtf
967 : #undef cbrtl
968 : #undef copysign
969 : #undef copysignf
970 : #undef copysignl
971 : #undef erf
972 : #undef erff
973 : #undef erfl
974 : #undef erfc
975 : #undef erfcf
976 : #undef erfcl
977 : #undef exp2
978 : #undef exp2f
979 : #undef exp2l
980 : #undef expm1
981 : #undef expm1f
982 : #undef expm1l
983 : #undef fdim
984 : #undef fdimf
985 : #undef fdiml
986 : #undef fma
987 : #undef fmaf
988 : #undef fmal
989 : #undef fmax
990 : #undef fmaxf
991 : #undef fmaxl
992 : #undef fmin
993 : #undef fminf
994 : #undef fminl
995 : #undef hypot
996 : #undef hypotf
997 : #undef hypotl
998 : #undef ilogb
999 : #undef ilogbf
1000 : #undef ilogbl
1001 : #undef lgamma
1002 : #undef lgammaf
1003 : #undef lgammal
1004 : #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1005 : #undef llrint
1006 : #undef llrintf
1007 : #undef llrintl
1008 : #undef llround
1009 : #undef llroundf
1010 : #undef llroundl
1011 : #endif
1012 : #undef log1p
1013 : #undef log1pf
1014 : #undef log1pl
1015 : #undef log2
1016 : #undef log2f
1017 : #undef log2l
1018 : #undef logb
1019 : #undef logbf
1020 : #undef logbl
1021 : #undef lrint
1022 : #undef lrintf
1023 : #undef lrintl
1024 : #undef lround
1025 : #undef lroundf
1026 : #undef lroundl
1027 : #undef nan
1028 : #undef nanf
1029 : #undef nanl
1030 : #undef nearbyint
1031 : #undef nearbyintf
1032 : #undef nearbyintl
1033 : #undef nextafter
1034 : #undef nextafterf
1035 : #undef nextafterl
1036 : #undef nexttoward
1037 : #undef nexttowardf
1038 : #undef nexttowardl
1039 : #undef remainder
1040 : #undef remainderf
1041 : #undef remainderl
1042 : #undef remquo
1043 : #undef remquof
1044 : #undef remquol
1045 : #undef rint
1046 : #undef rintf
1047 : #undef rintl
1048 : #undef round
1049 : #undef roundf
1050 : #undef roundl
1051 : #undef scalbln
1052 : #undef scalblnf
1053 : #undef scalblnl
1054 : #undef scalbn
1055 : #undef scalbnf
1056 : #undef scalbnl
1057 : #undef tgamma
1058 : #undef tgammaf
1059 : #undef tgammal
1060 : #undef trunc
1061 : #undef truncf
1062 : #undef truncl
1063 :
1064 : // types
1065 : using ::double_t;
1066 : using ::float_t;
1067 :
1068 : // functions
1069 : using ::acosh;
1070 : using ::acoshf;
1071 : using ::acoshl;
1072 :
1073 : using ::asinh;
1074 : using ::asinhf;
1075 : using ::asinhl;
1076 :
1077 : using ::atanh;
1078 : using ::atanhf;
1079 : using ::atanhl;
1080 :
1081 : using ::cbrt;
1082 : using ::cbrtf;
1083 : using ::cbrtl;
1084 :
1085 : using ::copysign;
1086 : using ::copysignf;
1087 : using ::copysignl;
1088 :
1089 : using ::erf;
1090 : using ::erff;
1091 : using ::erfl;
1092 :
1093 : using ::erfc;
1094 : using ::erfcf;
1095 : using ::erfcl;
1096 :
1097 : using ::exp2;
1098 : using ::exp2f;
1099 : using ::exp2l;
1100 :
1101 : using ::expm1;
1102 : using ::expm1f;
1103 : using ::expm1l;
1104 :
1105 : using ::fdim;
1106 : using ::fdimf;
1107 : using ::fdiml;
1108 :
1109 : using ::fma;
1110 : using ::fmaf;
1111 : using ::fmal;
1112 :
1113 : using ::fmax;
1114 : using ::fmaxf;
1115 : using ::fmaxl;
1116 :
1117 : using ::fmin;
1118 : using ::fminf;
1119 : using ::fminl;
1120 :
1121 : using ::hypot;
1122 : using ::hypotf;
1123 : using ::hypotl;
1124 :
1125 : using ::ilogb;
1126 : using ::ilogbf;
1127 : using ::ilogbl;
1128 :
1129 : using ::lgamma;
1130 : using ::lgammaf;
1131 : using ::lgammal;
1132 :
1133 : #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1134 : using ::llrint;
1135 : using ::llrintf;
1136 : using ::llrintl;
1137 :
1138 : using ::llround;
1139 : using ::llroundf;
1140 : using ::llroundl;
1141 : #endif
1142 :
1143 : using ::log1p;
1144 : using ::log1pf;
1145 : using ::log1pl;
1146 :
1147 : using ::log2;
1148 : using ::log2f;
1149 : using ::log2l;
1150 :
1151 : using ::logb;
1152 : using ::logbf;
1153 : using ::logbl;
1154 :
1155 : using ::lrint;
1156 : using ::lrintf;
1157 : using ::lrintl;
1158 :
1159 : using ::lround;
1160 : using ::lroundf;
1161 : using ::lroundl;
1162 :
1163 : using ::nan;
1164 : using ::nanf;
1165 : using ::nanl;
1166 :
1167 : using ::nearbyint;
1168 : using ::nearbyintf;
1169 : using ::nearbyintl;
1170 :
1171 : using ::nextafter;
1172 : using ::nextafterf;
1173 : using ::nextafterl;
1174 :
1175 : using ::nexttoward;
1176 : using ::nexttowardf;
1177 : using ::nexttowardl;
1178 :
1179 : using ::remainder;
1180 : using ::remainderf;
1181 : using ::remainderl;
1182 :
1183 : using ::remquo;
1184 : using ::remquof;
1185 : using ::remquol;
1186 :
1187 : using ::rint;
1188 : using ::rintf;
1189 : using ::rintl;
1190 :
1191 : using ::round;
1192 : using ::roundf;
1193 : using ::roundl;
1194 :
1195 : using ::scalbln;
1196 : using ::scalblnf;
1197 : using ::scalblnl;
1198 :
1199 : using ::scalbn;
1200 : using ::scalbnf;
1201 : using ::scalbnl;
1202 :
1203 : using ::tgamma;
1204 : using ::tgammaf;
1205 : using ::tgammal;
1206 :
1207 : using ::trunc;
1208 : using ::truncf;
1209 : using ::truncl;
1210 :
1211 : /// Additional overloads.
1212 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1213 : constexpr float
1214 : acosh(float __x)
1215 : { return __builtin_acoshf(__x); }
1216 :
1217 : constexpr long double
1218 : acosh(long double __x)
1219 : { return __builtin_acoshl(__x); }
1220 : #endif
1221 :
1222 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1223 : template<typename _Tp>
1224 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1225 : double>::__type
1226 : acosh(_Tp __x)
1227 : { return __builtin_acosh(__x); }
1228 : #endif
1229 :
1230 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1231 : constexpr float
1232 : asinh(float __x)
1233 : { return __builtin_asinhf(__x); }
1234 :
1235 : constexpr long double
1236 : asinh(long double __x)
1237 : { return __builtin_asinhl(__x); }
1238 : #endif
1239 :
1240 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1241 : template<typename _Tp>
1242 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1243 : double>::__type
1244 : asinh(_Tp __x)
1245 : { return __builtin_asinh(__x); }
1246 : #endif
1247 :
1248 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1249 : constexpr float
1250 : atanh(float __x)
1251 : { return __builtin_atanhf(__x); }
1252 :
1253 : constexpr long double
1254 : atanh(long double __x)
1255 : { return __builtin_atanhl(__x); }
1256 : #endif
1257 :
1258 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1259 : template<typename _Tp>
1260 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1261 : double>::__type
1262 : atanh(_Tp __x)
1263 : { return __builtin_atanh(__x); }
1264 : #endif
1265 :
1266 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1267 : constexpr float
1268 : cbrt(float __x)
1269 : { return __builtin_cbrtf(__x); }
1270 :
1271 : constexpr long double
1272 : cbrt(long double __x)
1273 : { return __builtin_cbrtl(__x); }
1274 : #endif
1275 :
1276 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1277 : template<typename _Tp>
1278 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1279 : double>::__type
1280 : cbrt(_Tp __x)
1281 : { return __builtin_cbrt(__x); }
1282 : #endif
1283 :
1284 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1285 : constexpr float
1286 : copysign(float __x, float __y)
1287 : { return __builtin_copysignf(__x, __y); }
1288 :
1289 : constexpr long double
1290 : copysign(long double __x, long double __y)
1291 : { return __builtin_copysignl(__x, __y); }
1292 : #endif
1293 :
1294 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1295 : template<typename _Tp, typename _Up>
1296 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1297 : copysign(_Tp __x, _Up __y)
1298 : {
1299 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1300 : return copysign(__type(__x), __type(__y));
1301 : }
1302 : #endif
1303 :
1304 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1305 : constexpr float
1306 : erf(float __x)
1307 : { return __builtin_erff(__x); }
1308 :
1309 : constexpr long double
1310 : erf(long double __x)
1311 : { return __builtin_erfl(__x); }
1312 : #endif
1313 :
1314 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1315 : template<typename _Tp>
1316 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1317 : double>::__type
1318 : erf(_Tp __x)
1319 : { return __builtin_erf(__x); }
1320 : #endif
1321 :
1322 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1323 : constexpr float
1324 : erfc(float __x)
1325 : { return __builtin_erfcf(__x); }
1326 :
1327 : constexpr long double
1328 : erfc(long double __x)
1329 : { return __builtin_erfcl(__x); }
1330 : #endif
1331 :
1332 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1333 : template<typename _Tp>
1334 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1335 : double>::__type
1336 : erfc(_Tp __x)
1337 : { return __builtin_erfc(__x); }
1338 : #endif
1339 :
1340 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1341 : constexpr float
1342 : exp2(float __x)
1343 : { return __builtin_exp2f(__x); }
1344 :
1345 : constexpr long double
1346 : exp2(long double __x)
1347 : { return __builtin_exp2l(__x); }
1348 : #endif
1349 :
1350 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1351 : template<typename _Tp>
1352 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1353 : double>::__type
1354 : exp2(_Tp __x)
1355 : { return __builtin_exp2(__x); }
1356 : #endif
1357 :
1358 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1359 : constexpr float
1360 : expm1(float __x)
1361 : { return __builtin_expm1f(__x); }
1362 :
1363 : constexpr long double
1364 : expm1(long double __x)
1365 : { return __builtin_expm1l(__x); }
1366 : #endif
1367 :
1368 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1369 : template<typename _Tp>
1370 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1371 : double>::__type
1372 : expm1(_Tp __x)
1373 : { return __builtin_expm1(__x); }
1374 : #endif
1375 :
1376 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1377 : constexpr float
1378 : fdim(float __x, float __y)
1379 : { return __builtin_fdimf(__x, __y); }
1380 :
1381 : constexpr long double
1382 : fdim(long double __x, long double __y)
1383 : { return __builtin_fdiml(__x, __y); }
1384 : #endif
1385 :
1386 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1387 : template<typename _Tp, typename _Up>
1388 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1389 : fdim(_Tp __x, _Up __y)
1390 : {
1391 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1392 : return fdim(__type(__x), __type(__y));
1393 : }
1394 : #endif
1395 :
1396 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1397 : constexpr float
1398 : fma(float __x, float __y, float __z)
1399 : { return __builtin_fmaf(__x, __y, __z); }
1400 :
1401 : constexpr long double
1402 : fma(long double __x, long double __y, long double __z)
1403 : { return __builtin_fmal(__x, __y, __z); }
1404 : #endif
1405 :
1406 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1407 : template<typename _Tp, typename _Up, typename _Vp>
1408 : constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1409 : fma(_Tp __x, _Up __y, _Vp __z)
1410 : {
1411 : typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
1412 : return fma(__type(__x), __type(__y), __type(__z));
1413 : }
1414 : #endif
1415 :
1416 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1417 : constexpr float
1418 : fmax(float __x, float __y)
1419 : { return __builtin_fmaxf(__x, __y); }
1420 :
1421 : constexpr long double
1422 : fmax(long double __x, long double __y)
1423 : { return __builtin_fmaxl(__x, __y); }
1424 : #endif
1425 :
1426 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1427 : template<typename _Tp, typename _Up>
1428 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1429 : fmax(_Tp __x, _Up __y)
1430 : {
1431 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1432 : return fmax(__type(__x), __type(__y));
1433 : }
1434 : #endif
1435 :
1436 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1437 : constexpr float
1438 : fmin(float __x, float __y)
1439 : { return __builtin_fminf(__x, __y); }
1440 :
1441 : constexpr long double
1442 : fmin(long double __x, long double __y)
1443 : { return __builtin_fminl(__x, __y); }
1444 : #endif
1445 :
1446 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1447 : template<typename _Tp, typename _Up>
1448 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1449 : fmin(_Tp __x, _Up __y)
1450 : {
1451 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1452 : return fmin(__type(__x), __type(__y));
1453 : }
1454 : #endif
1455 :
1456 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1457 : constexpr float
1458 : hypot(float __x, float __y)
1459 : { return __builtin_hypotf(__x, __y); }
1460 :
1461 : constexpr long double
1462 : hypot(long double __x, long double __y)
1463 : { return __builtin_hypotl(__x, __y); }
1464 : #endif
1465 :
1466 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1467 : template<typename _Tp, typename _Up>
1468 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1469 : hypot(_Tp __x, _Up __y)
1470 : {
1471 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1472 : return hypot(__type(__x), __type(__y));
1473 : }
1474 : #endif
1475 :
1476 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1477 : constexpr int
1478 : ilogb(float __x)
1479 : { return __builtin_ilogbf(__x); }
1480 :
1481 : constexpr int
1482 : ilogb(long double __x)
1483 : { return __builtin_ilogbl(__x); }
1484 : #endif
1485 :
1486 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1487 : template<typename _Tp>
1488 : constexpr
1489 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1490 : int>::__type
1491 : ilogb(_Tp __x)
1492 : { return __builtin_ilogb(__x); }
1493 : #endif
1494 :
1495 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1496 : constexpr float
1497 : lgamma(float __x)
1498 : { return __builtin_lgammaf(__x); }
1499 :
1500 : constexpr long double
1501 : lgamma(long double __x)
1502 : { return __builtin_lgammal(__x); }
1503 : #endif
1504 :
1505 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1506 : template<typename _Tp>
1507 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1508 : double>::__type
1509 : lgamma(_Tp __x)
1510 : { return __builtin_lgamma(__x); }
1511 : #endif
1512 :
1513 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1514 : constexpr long long
1515 : llrint(float __x)
1516 : { return __builtin_llrintf(__x); }
1517 :
1518 : constexpr long long
1519 : llrint(long double __x)
1520 : { return __builtin_llrintl(__x); }
1521 : #endif
1522 :
1523 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1524 : template<typename _Tp>
1525 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1526 : long long>::__type
1527 : llrint(_Tp __x)
1528 : { return __builtin_llrint(__x); }
1529 : #endif
1530 :
1531 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1532 : constexpr long long
1533 : llround(float __x)
1534 : { return __builtin_llroundf(__x); }
1535 :
1536 : constexpr long long
1537 : llround(long double __x)
1538 : { return __builtin_llroundl(__x); }
1539 : #endif
1540 :
1541 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1542 : template<typename _Tp>
1543 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1544 : long long>::__type
1545 : llround(_Tp __x)
1546 : { return __builtin_llround(__x); }
1547 : #endif
1548 :
1549 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1550 : constexpr float
1551 : log1p(float __x)
1552 : { return __builtin_log1pf(__x); }
1553 :
1554 : constexpr long double
1555 : log1p(long double __x)
1556 : { return __builtin_log1pl(__x); }
1557 : #endif
1558 :
1559 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1560 : template<typename _Tp>
1561 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1562 : double>::__type
1563 : log1p(_Tp __x)
1564 : { return __builtin_log1p(__x); }
1565 : #endif
1566 :
1567 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1568 : // DR 568.
1569 : constexpr float
1570 : log2(float __x)
1571 : { return __builtin_log2f(__x); }
1572 :
1573 : constexpr long double
1574 : log2(long double __x)
1575 : { return __builtin_log2l(__x); }
1576 : #endif
1577 :
1578 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1579 : template<typename _Tp>
1580 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1581 : double>::__type
1582 : log2(_Tp __x)
1583 : { return __builtin_log2(__x); }
1584 : #endif
1585 :
1586 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1587 : constexpr float
1588 : logb(float __x)
1589 : { return __builtin_logbf(__x); }
1590 :
1591 : constexpr long double
1592 : logb(long double __x)
1593 : { return __builtin_logbl(__x); }
1594 : #endif
1595 :
1596 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1597 : template<typename _Tp>
1598 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1599 : double>::__type
1600 : logb(_Tp __x)
1601 : { return __builtin_logb(__x); }
1602 : #endif
1603 :
1604 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1605 : constexpr long
1606 : lrint(float __x)
1607 : { return __builtin_lrintf(__x); }
1608 :
1609 : constexpr long
1610 : lrint(long double __x)
1611 : { return __builtin_lrintl(__x); }
1612 : #endif
1613 :
1614 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1615 : template<typename _Tp>
1616 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1617 : long>::__type
1618 : lrint(_Tp __x)
1619 : { return __builtin_lrint(__x); }
1620 : #endif
1621 :
1622 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1623 : constexpr long
1624 : lround(float __x)
1625 : { return __builtin_lroundf(__x); }
1626 :
1627 : constexpr long
1628 : lround(long double __x)
1629 : { return __builtin_lroundl(__x); }
1630 : #endif
1631 :
1632 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1633 : template<typename _Tp>
1634 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1635 : long>::__type
1636 : lround(_Tp __x)
1637 : { return __builtin_lround(__x); }
1638 : #endif
1639 :
1640 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1641 : constexpr float
1642 : nearbyint(float __x)
1643 : { return __builtin_nearbyintf(__x); }
1644 :
1645 : constexpr long double
1646 : nearbyint(long double __x)
1647 : { return __builtin_nearbyintl(__x); }
1648 : #endif
1649 :
1650 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1651 : template<typename _Tp>
1652 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1653 : double>::__type
1654 : nearbyint(_Tp __x)
1655 : { return __builtin_nearbyint(__x); }
1656 : #endif
1657 :
1658 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1659 : constexpr float
1660 : nextafter(float __x, float __y)
1661 : { return __builtin_nextafterf(__x, __y); }
1662 :
1663 : constexpr long double
1664 : nextafter(long double __x, long double __y)
1665 : { return __builtin_nextafterl(__x, __y); }
1666 : #endif
1667 :
1668 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1669 : template<typename _Tp, typename _Up>
1670 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1671 : nextafter(_Tp __x, _Up __y)
1672 : {
1673 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1674 : return nextafter(__type(__x), __type(__y));
1675 : }
1676 : #endif
1677 :
1678 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1679 : constexpr float
1680 : nexttoward(float __x, long double __y)
1681 : { return __builtin_nexttowardf(__x, __y); }
1682 :
1683 : constexpr long double
1684 : nexttoward(long double __x, long double __y)
1685 : { return __builtin_nexttowardl(__x, __y); }
1686 : #endif
1687 :
1688 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1689 : template<typename _Tp>
1690 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1691 : double>::__type
1692 : nexttoward(_Tp __x, long double __y)
1693 : { return __builtin_nexttoward(__x, __y); }
1694 : #endif
1695 :
1696 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1697 : constexpr float
1698 : remainder(float __x, float __y)
1699 : { return __builtin_remainderf(__x, __y); }
1700 :
1701 : constexpr long double
1702 : remainder(long double __x, long double __y)
1703 : { return __builtin_remainderl(__x, __y); }
1704 : #endif
1705 :
1706 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1707 : template<typename _Tp, typename _Up>
1708 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1709 : remainder(_Tp __x, _Up __y)
1710 : {
1711 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1712 : return remainder(__type(__x), __type(__y));
1713 : }
1714 : #endif
1715 :
1716 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1717 : inline float
1718 : remquo(float __x, float __y, int* __pquo)
1719 : { return __builtin_remquof(__x, __y, __pquo); }
1720 :
1721 : inline long double
1722 : remquo(long double __x, long double __y, int* __pquo)
1723 : { return __builtin_remquol(__x, __y, __pquo); }
1724 : #endif
1725 :
1726 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1727 : template<typename _Tp, typename _Up>
1728 : inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1729 : remquo(_Tp __x, _Up __y, int* __pquo)
1730 : {
1731 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1732 : return remquo(__type(__x), __type(__y), __pquo);
1733 : }
1734 : #endif
1735 :
1736 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1737 : constexpr float
1738 : rint(float __x)
1739 : { return __builtin_rintf(__x); }
1740 :
1741 : constexpr long double
1742 : rint(long double __x)
1743 : { return __builtin_rintl(__x); }
1744 : #endif
1745 :
1746 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1747 : template<typename _Tp>
1748 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1749 : double>::__type
1750 : rint(_Tp __x)
1751 : { return __builtin_rint(__x); }
1752 : #endif
1753 :
1754 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1755 : constexpr float
1756 : round(float __x)
1757 : { return __builtin_roundf(__x); }
1758 :
1759 : constexpr long double
1760 : round(long double __x)
1761 : { return __builtin_roundl(__x); }
1762 : #endif
1763 :
1764 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1765 : template<typename _Tp>
1766 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1767 : double>::__type
1768 : round(_Tp __x)
1769 : { return __builtin_round(__x); }
1770 : #endif
1771 :
1772 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1773 : constexpr float
1774 : scalbln(float __x, long __ex)
1775 : { return __builtin_scalblnf(__x, __ex); }
1776 :
1777 : constexpr long double
1778 : scalbln(long double __x, long __ex)
1779 : { return __builtin_scalblnl(__x, __ex); }
1780 : #endif
1781 :
1782 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1783 : template<typename _Tp>
1784 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1785 : double>::__type
1786 : scalbln(_Tp __x, long __ex)
1787 : { return __builtin_scalbln(__x, __ex); }
1788 : #endif
1789 :
1790 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1791 : constexpr float
1792 : scalbn(float __x, int __ex)
1793 : { return __builtin_scalbnf(__x, __ex); }
1794 :
1795 : constexpr long double
1796 : scalbn(long double __x, int __ex)
1797 : { return __builtin_scalbnl(__x, __ex); }
1798 : #endif
1799 :
1800 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1801 : template<typename _Tp>
1802 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1803 : double>::__type
1804 : scalbn(_Tp __x, int __ex)
1805 : { return __builtin_scalbn(__x, __ex); }
1806 : #endif
1807 :
1808 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1809 : constexpr float
1810 : tgamma(float __x)
1811 : { return __builtin_tgammaf(__x); }
1812 :
1813 : constexpr long double
1814 : tgamma(long double __x)
1815 : { return __builtin_tgammal(__x); }
1816 : #endif
1817 :
1818 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1819 : template<typename _Tp>
1820 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1821 : double>::__type
1822 : tgamma(_Tp __x)
1823 : { return __builtin_tgamma(__x); }
1824 : #endif
1825 :
1826 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1827 : constexpr float
1828 : trunc(float __x)
1829 : { return __builtin_truncf(__x); }
1830 :
1831 : constexpr long double
1832 : trunc(long double __x)
1833 : { return __builtin_truncl(__x); }
1834 : #endif
1835 :
1836 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1837 : template<typename _Tp>
1838 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1839 : double>::__type
1840 : trunc(_Tp __x)
1841 : { return __builtin_trunc(__x); }
1842 : #endif
1843 :
1844 : #endif // _GLIBCXX_USE_C99_MATH_TR1
1845 : #endif // C++11
1846 :
1847 : #if __cplusplus > 201402L
1848 :
1849 : // [c.math.hypot3], three-dimensional hypotenuse
1850 : #define __cpp_lib_hypot 201603
1851 :
1852 : template<typename _Tp>
1853 : inline _Tp
1854 : __hypot3(_Tp __x, _Tp __y, _Tp __z)
1855 : {
1856 : __x = std::abs(__x);
1857 : __y = std::abs(__y);
1858 : __z = std::abs(__z);
1859 : if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
1860 : return __a * std::sqrt((__x / __a) * (__x / __a)
1861 : + (__y / __a) * (__y / __a)
1862 : + (__z / __a) * (__z / __a));
1863 : else
1864 : return {};
1865 : }
1866 :
1867 : inline float
1868 : hypot(float __x, float __y, float __z)
1869 : { return std::__hypot3<float>(__x, __y, __z); }
1870 :
1871 : inline double
1872 : hypot(double __x, double __y, double __z)
1873 : { return std::__hypot3<double>(__x, __y, __z); }
1874 :
1875 : inline long double
1876 : hypot(long double __x, long double __y, long double __z)
1877 : { return std::__hypot3<long double>(__x, __y, __z); }
1878 :
1879 : template<typename _Tp, typename _Up, typename _Vp>
1880 : typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1881 : hypot(_Tp __x, _Up __y, _Vp __z)
1882 : {
1883 : using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;
1884 : return std::__hypot3<__type>(__x, __y, __z);
1885 : }
1886 : #endif // C++17
1887 :
1888 : #if __cplusplus > 201703L
1889 : // linear interpolation
1890 : # define __cpp_lib_interpolate 201902L
1891 :
1892 : template<typename _Fp>
1893 : constexpr _Fp
1894 : __lerp(_Fp __a, _Fp __b, _Fp __t) noexcept
1895 : {
1896 : if (__a <= 0 && __b >= 0 || __a >= 0 && __b <= 0)
1897 : return __t * __b + (1 - __t) * __a;
1898 :
1899 : if (__t == 1)
1900 : return __b; // exact
1901 :
1902 : // Exact at __t=0, monotonic except near __t=1,
1903 : // bounded, determinate, and consistent:
1904 : const _Fp __x = __a + __t * (__b - __a);
1905 : return __t > 1 == __b > __a
1906 : ? (__b < __x ? __x : __b)
1907 : : (__b > __x ? __x : __b); // monotonic near __t=1
1908 : }
1909 :
1910 : constexpr float
1911 : lerp(float __a, float __b, float __t) noexcept
1912 : { return std::__lerp(__a, __b, __t); }
1913 :
1914 : constexpr double
1915 : lerp(double __a, double __b, double __t) noexcept
1916 : { return std::__lerp(__a, __b, __t); }
1917 :
1918 : constexpr long double
1919 : lerp(long double __a, long double __b, long double __t) noexcept
1920 : { return std::__lerp(__a, __b, __t); }
1921 : #endif // C++20
1922 :
1923 : _GLIBCXX_END_NAMESPACE_VERSION
1924 : } // namespace
1925 :
1926 : #if _GLIBCXX_USE_STD_SPEC_FUNCS
1927 : # include <bits/specfun.h>
1928 : #endif
1929 :
1930 : } // extern "C++"
1931 :
1932 : #endif
|
