Line data Source code
1 : // -*- C++ -*- C forwarding header.
2 :
3 : // Copyright (C) 1997-2017 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 22 : { 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 496 : { 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 : pow(_Tp __x, _Up __y)
416 : {
417 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
418 : 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 20 : { 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 : _GLIBCXX_END_NAMESPACE_VERSION
517 : } // namespace
518 :
519 : #if _GLIBCXX_USE_C99_MATH
520 : #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
521 :
522 : // These are possible macros imported from C99-land.
523 : #undef fpclassify
524 : #undef isfinite
525 : #undef isinf
526 : #undef isnan
527 : #undef isnormal
528 : #undef signbit
529 : #undef isgreater
530 : #undef isgreaterequal
531 : #undef isless
532 : #undef islessequal
533 : #undef islessgreater
534 : #undef isunordered
535 :
536 : namespace std _GLIBCXX_VISIBILITY(default)
537 : {
538 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
539 :
540 : #if __cplusplus >= 201103L
541 :
542 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
543 : constexpr int
544 : fpclassify(float __x)
545 : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
546 : FP_SUBNORMAL, FP_ZERO, __x); }
547 :
548 : constexpr int
549 : fpclassify(double __x)
550 : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
551 : FP_SUBNORMAL, FP_ZERO, __x); }
552 :
553 : constexpr int
554 : fpclassify(long double __x)
555 : { return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
556 : FP_SUBNORMAL, FP_ZERO, __x); }
557 : #endif
558 :
559 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
560 : template<typename _Tp>
561 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
562 : int>::__type
563 : fpclassify(_Tp __x)
564 : { return __x != 0 ? FP_NORMAL : FP_ZERO; }
565 : #endif
566 :
567 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
568 : constexpr bool
569 : isfinite(float __x)
570 : { return __builtin_isfinite(__x); }
571 :
572 : constexpr bool
573 : isfinite(double __x)
574 : { return __builtin_isfinite(__x); }
575 :
576 : constexpr bool
577 : isfinite(long double __x)
578 : { return __builtin_isfinite(__x); }
579 : #endif
580 :
581 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
582 : template<typename _Tp>
583 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
584 : bool>::__type
585 : isfinite(_Tp __x)
586 : { return true; }
587 : #endif
588 :
589 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
590 : constexpr bool
591 : isinf(float __x)
592 : { return __builtin_isinf(__x); }
593 :
594 : #if _GLIBCXX_HAVE_OBSOLETE_ISINF \
595 : && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
596 : using ::isinf;
597 : #else
598 : constexpr bool
599 : isinf(double __x)
600 : { return __builtin_isinf(__x); }
601 : #endif
602 :
603 : constexpr bool
604 : isinf(long double __x)
605 : { return __builtin_isinf(__x); }
606 : #endif
607 :
608 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
609 : template<typename _Tp>
610 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
611 : bool>::__type
612 : isinf(_Tp __x)
613 : { return false; }
614 : #endif
615 :
616 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
617 : constexpr bool
618 : isnan(float __x)
619 : { return __builtin_isnan(__x); }
620 :
621 : #if _GLIBCXX_HAVE_OBSOLETE_ISNAN \
622 : && !_GLIBCXX_NO_OBSOLETE_ISINF_ISNAN_DYNAMIC
623 : using ::isnan;
624 : #else
625 : constexpr bool
626 : isnan(double __x)
627 : { return __builtin_isnan(__x); }
628 : #endif
629 :
630 : constexpr bool
631 : isnan(long double __x)
632 : { return __builtin_isnan(__x); }
633 : #endif
634 :
635 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
636 : template<typename _Tp>
637 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
638 : bool>::__type
639 : isnan(_Tp __x)
640 : { return false; }
641 : #endif
642 :
643 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
644 : constexpr bool
645 : isnormal(float __x)
646 : { return __builtin_isnormal(__x); }
647 :
648 : constexpr bool
649 : isnormal(double __x)
650 : { return __builtin_isnormal(__x); }
651 :
652 : constexpr bool
653 : isnormal(long double __x)
654 : { return __builtin_isnormal(__x); }
655 : #endif
656 :
657 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
658 : template<typename _Tp>
659 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
660 : bool>::__type
661 : isnormal(_Tp __x)
662 : { return __x != 0 ? true : false; }
663 : #endif
664 :
665 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
666 : // Note: middle-end/36757 is fixed, __builtin_signbit is type-generic.
667 : constexpr bool
668 : signbit(float __x)
669 : { return __builtin_signbit(__x); }
670 :
671 : constexpr bool
672 : signbit(double __x)
673 : { return __builtin_signbit(__x); }
674 :
675 : constexpr bool
676 : signbit(long double __x)
677 : { return __builtin_signbit(__x); }
678 : #endif
679 :
680 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
681 : template<typename _Tp>
682 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
683 : bool>::__type
684 : signbit(_Tp __x)
685 : { return __x < 0 ? true : false; }
686 : #endif
687 :
688 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
689 : constexpr bool
690 : isgreater(float __x, float __y)
691 : { return __builtin_isgreater(__x, __y); }
692 :
693 : constexpr bool
694 : isgreater(double __x, double __y)
695 : { return __builtin_isgreater(__x, __y); }
696 :
697 : constexpr bool
698 : isgreater(long double __x, long double __y)
699 : { return __builtin_isgreater(__x, __y); }
700 : #endif
701 :
702 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
703 : template<typename _Tp, typename _Up>
704 : constexpr typename
705 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
706 : && __is_arithmetic<_Up>::__value), bool>::__type
707 : isgreater(_Tp __x, _Up __y)
708 : {
709 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
710 : return __builtin_isgreater(__type(__x), __type(__y));
711 : }
712 : #endif
713 :
714 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
715 : constexpr bool
716 : isgreaterequal(float __x, float __y)
717 : { return __builtin_isgreaterequal(__x, __y); }
718 :
719 : constexpr bool
720 : isgreaterequal(double __x, double __y)
721 : { return __builtin_isgreaterequal(__x, __y); }
722 :
723 : constexpr bool
724 : isgreaterequal(long double __x, long double __y)
725 : { return __builtin_isgreaterequal(__x, __y); }
726 : #endif
727 :
728 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
729 : template<typename _Tp, typename _Up>
730 : constexpr typename
731 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
732 : && __is_arithmetic<_Up>::__value), bool>::__type
733 : isgreaterequal(_Tp __x, _Up __y)
734 : {
735 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
736 : return __builtin_isgreaterequal(__type(__x), __type(__y));
737 : }
738 : #endif
739 :
740 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
741 : constexpr bool
742 : isless(float __x, float __y)
743 : { return __builtin_isless(__x, __y); }
744 :
745 : constexpr bool
746 : isless(double __x, double __y)
747 : { return __builtin_isless(__x, __y); }
748 :
749 : constexpr bool
750 : isless(long double __x, long double __y)
751 : { return __builtin_isless(__x, __y); }
752 : #endif
753 :
754 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
755 : template<typename _Tp, typename _Up>
756 : constexpr typename
757 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
758 : && __is_arithmetic<_Up>::__value), bool>::__type
759 : isless(_Tp __x, _Up __y)
760 : {
761 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
762 : return __builtin_isless(__type(__x), __type(__y));
763 : }
764 : #endif
765 :
766 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
767 : constexpr bool
768 : islessequal(float __x, float __y)
769 : { return __builtin_islessequal(__x, __y); }
770 :
771 : constexpr bool
772 : islessequal(double __x, double __y)
773 : { return __builtin_islessequal(__x, __y); }
774 :
775 : constexpr bool
776 : islessequal(long double __x, long double __y)
777 : { return __builtin_islessequal(__x, __y); }
778 : #endif
779 :
780 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
781 : template<typename _Tp, typename _Up>
782 : constexpr typename
783 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
784 : && __is_arithmetic<_Up>::__value), bool>::__type
785 : islessequal(_Tp __x, _Up __y)
786 : {
787 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
788 : return __builtin_islessequal(__type(__x), __type(__y));
789 : }
790 : #endif
791 :
792 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
793 : constexpr bool
794 : islessgreater(float __x, float __y)
795 : { return __builtin_islessgreater(__x, __y); }
796 :
797 : constexpr bool
798 : islessgreater(double __x, double __y)
799 : { return __builtin_islessgreater(__x, __y); }
800 :
801 : constexpr bool
802 : islessgreater(long double __x, long double __y)
803 : { return __builtin_islessgreater(__x, __y); }
804 : #endif
805 :
806 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
807 : template<typename _Tp, typename _Up>
808 : constexpr typename
809 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
810 : && __is_arithmetic<_Up>::__value), bool>::__type
811 : islessgreater(_Tp __x, _Up __y)
812 : {
813 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
814 : return __builtin_islessgreater(__type(__x), __type(__y));
815 : }
816 : #endif
817 :
818 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
819 : constexpr bool
820 : isunordered(float __x, float __y)
821 : { return __builtin_isunordered(__x, __y); }
822 :
823 : constexpr bool
824 : isunordered(double __x, double __y)
825 : { return __builtin_isunordered(__x, __y); }
826 :
827 : constexpr bool
828 : isunordered(long double __x, long double __y)
829 : { return __builtin_isunordered(__x, __y); }
830 : #endif
831 :
832 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
833 : template<typename _Tp, typename _Up>
834 : constexpr typename
835 : __gnu_cxx::__enable_if<(__is_arithmetic<_Tp>::__value
836 : && __is_arithmetic<_Up>::__value), bool>::__type
837 : isunordered(_Tp __x, _Up __y)
838 : {
839 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
840 : return __builtin_isunordered(__type(__x), __type(__y));
841 : }
842 : #endif
843 :
844 : #else
845 :
846 : template<typename _Tp>
847 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
848 : int>::__type
849 : fpclassify(_Tp __f)
850 : {
851 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
852 : return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
853 : FP_SUBNORMAL, FP_ZERO, __type(__f));
854 : }
855 :
856 : template<typename _Tp>
857 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
858 : int>::__type
859 : isfinite(_Tp __f)
860 : {
861 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
862 : return __builtin_isfinite(__type(__f));
863 : }
864 :
865 : template<typename _Tp>
866 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
867 : int>::__type
868 : isinf(_Tp __f)
869 : {
870 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
871 : return __builtin_isinf(__type(__f));
872 : }
873 :
874 : template<typename _Tp>
875 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
876 : int>::__type
877 : isnan(_Tp __f)
878 : {
879 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
880 : return __builtin_isnan(__type(__f));
881 : }
882 :
883 : template<typename _Tp>
884 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
885 : int>::__type
886 : isnormal(_Tp __f)
887 : {
888 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
889 : return __builtin_isnormal(__type(__f));
890 : }
891 :
892 : template<typename _Tp>
893 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
894 : int>::__type
895 : signbit(_Tp __f)
896 : {
897 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
898 : return __builtin_signbit(__type(__f));
899 : }
900 :
901 : template<typename _Tp>
902 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
903 : int>::__type
904 : isgreater(_Tp __f1, _Tp __f2)
905 : {
906 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
907 : return __builtin_isgreater(__type(__f1), __type(__f2));
908 : }
909 :
910 : template<typename _Tp>
911 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
912 : int>::__type
913 : isgreaterequal(_Tp __f1, _Tp __f2)
914 : {
915 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
916 : return __builtin_isgreaterequal(__type(__f1), __type(__f2));
917 : }
918 :
919 : template<typename _Tp>
920 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
921 : int>::__type
922 : isless(_Tp __f1, _Tp __f2)
923 : {
924 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
925 : return __builtin_isless(__type(__f1), __type(__f2));
926 : }
927 :
928 : template<typename _Tp>
929 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
930 : int>::__type
931 : islessequal(_Tp __f1, _Tp __f2)
932 : {
933 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
934 : return __builtin_islessequal(__type(__f1), __type(__f2));
935 : }
936 :
937 : template<typename _Tp>
938 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
939 : int>::__type
940 : islessgreater(_Tp __f1, _Tp __f2)
941 : {
942 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
943 : return __builtin_islessgreater(__type(__f1), __type(__f2));
944 : }
945 :
946 : template<typename _Tp>
947 : inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
948 : int>::__type
949 : isunordered(_Tp __f1, _Tp __f2)
950 : {
951 : typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
952 : return __builtin_isunordered(__type(__f1), __type(__f2));
953 : }
954 :
955 : #endif
956 :
957 : _GLIBCXX_END_NAMESPACE_VERSION
958 : } // namespace
959 :
960 : #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
961 : #endif
962 :
963 : #if __cplusplus >= 201103L
964 :
965 : #ifdef _GLIBCXX_USE_C99_MATH_TR1
966 :
967 : #undef acosh
968 : #undef acoshf
969 : #undef acoshl
970 : #undef asinh
971 : #undef asinhf
972 : #undef asinhl
973 : #undef atanh
974 : #undef atanhf
975 : #undef atanhl
976 : #undef cbrt
977 : #undef cbrtf
978 : #undef cbrtl
979 : #undef copysign
980 : #undef copysignf
981 : #undef copysignl
982 : #undef erf
983 : #undef erff
984 : #undef erfl
985 : #undef erfc
986 : #undef erfcf
987 : #undef erfcl
988 : #undef exp2
989 : #undef exp2f
990 : #undef exp2l
991 : #undef expm1
992 : #undef expm1f
993 : #undef expm1l
994 : #undef fdim
995 : #undef fdimf
996 : #undef fdiml
997 : #undef fma
998 : #undef fmaf
999 : #undef fmal
1000 : #undef fmax
1001 : #undef fmaxf
1002 : #undef fmaxl
1003 : #undef fmin
1004 : #undef fminf
1005 : #undef fminl
1006 : #undef hypot
1007 : #undef hypotf
1008 : #undef hypotl
1009 : #undef ilogb
1010 : #undef ilogbf
1011 : #undef ilogbl
1012 : #undef lgamma
1013 : #undef lgammaf
1014 : #undef lgammal
1015 : #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1016 : #undef llrint
1017 : #undef llrintf
1018 : #undef llrintl
1019 : #undef llround
1020 : #undef llroundf
1021 : #undef llroundl
1022 : #endif
1023 : #undef log1p
1024 : #undef log1pf
1025 : #undef log1pl
1026 : #undef log2
1027 : #undef log2f
1028 : #undef log2l
1029 : #undef logb
1030 : #undef logbf
1031 : #undef logbl
1032 : #undef lrint
1033 : #undef lrintf
1034 : #undef lrintl
1035 : #undef lround
1036 : #undef lroundf
1037 : #undef lroundl
1038 : #undef nan
1039 : #undef nanf
1040 : #undef nanl
1041 : #undef nearbyint
1042 : #undef nearbyintf
1043 : #undef nearbyintl
1044 : #undef nextafter
1045 : #undef nextafterf
1046 : #undef nextafterl
1047 : #undef nexttoward
1048 : #undef nexttowardf
1049 : #undef nexttowardl
1050 : #undef remainder
1051 : #undef remainderf
1052 : #undef remainderl
1053 : #undef remquo
1054 : #undef remquof
1055 : #undef remquol
1056 : #undef rint
1057 : #undef rintf
1058 : #undef rintl
1059 : #undef round
1060 : #undef roundf
1061 : #undef roundl
1062 : #undef scalbln
1063 : #undef scalblnf
1064 : #undef scalblnl
1065 : #undef scalbn
1066 : #undef scalbnf
1067 : #undef scalbnl
1068 : #undef tgamma
1069 : #undef tgammaf
1070 : #undef tgammal
1071 : #undef trunc
1072 : #undef truncf
1073 : #undef truncl
1074 :
1075 : namespace std _GLIBCXX_VISIBILITY(default)
1076 : {
1077 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
1078 :
1079 : // types
1080 : using ::double_t;
1081 : using ::float_t;
1082 :
1083 : // functions
1084 : using ::acosh;
1085 : using ::acoshf;
1086 : using ::acoshl;
1087 :
1088 : using ::asinh;
1089 : using ::asinhf;
1090 : using ::asinhl;
1091 :
1092 : using ::atanh;
1093 : using ::atanhf;
1094 : using ::atanhl;
1095 :
1096 : using ::cbrt;
1097 : using ::cbrtf;
1098 : using ::cbrtl;
1099 :
1100 : using ::copysign;
1101 : using ::copysignf;
1102 : using ::copysignl;
1103 :
1104 : using ::erf;
1105 : using ::erff;
1106 : using ::erfl;
1107 :
1108 : using ::erfc;
1109 : using ::erfcf;
1110 : using ::erfcl;
1111 :
1112 : using ::exp2;
1113 : using ::exp2f;
1114 : using ::exp2l;
1115 :
1116 : using ::expm1;
1117 : using ::expm1f;
1118 : using ::expm1l;
1119 :
1120 : using ::fdim;
1121 : using ::fdimf;
1122 : using ::fdiml;
1123 :
1124 : using ::fma;
1125 : using ::fmaf;
1126 : using ::fmal;
1127 :
1128 : using ::fmax;
1129 : using ::fmaxf;
1130 : using ::fmaxl;
1131 :
1132 : using ::fmin;
1133 : using ::fminf;
1134 : using ::fminl;
1135 :
1136 : using ::hypot;
1137 : using ::hypotf;
1138 : using ::hypotl;
1139 :
1140 : using ::ilogb;
1141 : using ::ilogbf;
1142 : using ::ilogbl;
1143 :
1144 : using ::lgamma;
1145 : using ::lgammaf;
1146 : using ::lgammal;
1147 :
1148 : #ifndef _GLIBCXX_NO_C99_ROUNDING_FUNCS
1149 : using ::llrint;
1150 : using ::llrintf;
1151 : using ::llrintl;
1152 :
1153 : using ::llround;
1154 : using ::llroundf;
1155 : using ::llroundl;
1156 : #endif
1157 :
1158 : using ::log1p;
1159 : using ::log1pf;
1160 : using ::log1pl;
1161 :
1162 : using ::log2;
1163 : using ::log2f;
1164 : using ::log2l;
1165 :
1166 : using ::logb;
1167 : using ::logbf;
1168 : using ::logbl;
1169 :
1170 : using ::lrint;
1171 : using ::lrintf;
1172 : using ::lrintl;
1173 :
1174 : using ::lround;
1175 : using ::lroundf;
1176 : using ::lroundl;
1177 :
1178 : using ::nan;
1179 : using ::nanf;
1180 : using ::nanl;
1181 :
1182 : using ::nearbyint;
1183 : using ::nearbyintf;
1184 : using ::nearbyintl;
1185 :
1186 : using ::nextafter;
1187 : using ::nextafterf;
1188 : using ::nextafterl;
1189 :
1190 : using ::nexttoward;
1191 : using ::nexttowardf;
1192 : using ::nexttowardl;
1193 :
1194 : using ::remainder;
1195 : using ::remainderf;
1196 : using ::remainderl;
1197 :
1198 : using ::remquo;
1199 : using ::remquof;
1200 : using ::remquol;
1201 :
1202 : using ::rint;
1203 : using ::rintf;
1204 : using ::rintl;
1205 :
1206 : using ::round;
1207 : using ::roundf;
1208 : using ::roundl;
1209 :
1210 : using ::scalbln;
1211 : using ::scalblnf;
1212 : using ::scalblnl;
1213 :
1214 : using ::scalbn;
1215 : using ::scalbnf;
1216 : using ::scalbnl;
1217 :
1218 : using ::tgamma;
1219 : using ::tgammaf;
1220 : using ::tgammal;
1221 :
1222 : using ::trunc;
1223 : using ::truncf;
1224 : using ::truncl;
1225 :
1226 : /// Additional overloads.
1227 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1228 : constexpr float
1229 : acosh(float __x)
1230 : { return __builtin_acoshf(__x); }
1231 :
1232 : constexpr long double
1233 : acosh(long double __x)
1234 : { return __builtin_acoshl(__x); }
1235 : #endif
1236 :
1237 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1238 : template<typename _Tp>
1239 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1240 : double>::__type
1241 : acosh(_Tp __x)
1242 : { return __builtin_acosh(__x); }
1243 : #endif
1244 :
1245 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1246 : constexpr float
1247 : asinh(float __x)
1248 : { return __builtin_asinhf(__x); }
1249 :
1250 : constexpr long double
1251 : asinh(long double __x)
1252 : { return __builtin_asinhl(__x); }
1253 : #endif
1254 :
1255 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1256 : template<typename _Tp>
1257 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1258 : double>::__type
1259 : asinh(_Tp __x)
1260 : { return __builtin_asinh(__x); }
1261 : #endif
1262 :
1263 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1264 : constexpr float
1265 : atanh(float __x)
1266 : { return __builtin_atanhf(__x); }
1267 :
1268 : constexpr long double
1269 : atanh(long double __x)
1270 : { return __builtin_atanhl(__x); }
1271 : #endif
1272 :
1273 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1274 : template<typename _Tp>
1275 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1276 : double>::__type
1277 : atanh(_Tp __x)
1278 : { return __builtin_atanh(__x); }
1279 : #endif
1280 :
1281 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1282 : constexpr float
1283 : cbrt(float __x)
1284 : { return __builtin_cbrtf(__x); }
1285 :
1286 : constexpr long double
1287 : cbrt(long double __x)
1288 : { return __builtin_cbrtl(__x); }
1289 : #endif
1290 :
1291 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1292 : template<typename _Tp>
1293 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1294 : double>::__type
1295 : cbrt(_Tp __x)
1296 : { return __builtin_cbrt(__x); }
1297 : #endif
1298 :
1299 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1300 : constexpr float
1301 : copysign(float __x, float __y)
1302 : { return __builtin_copysignf(__x, __y); }
1303 :
1304 : constexpr long double
1305 : copysign(long double __x, long double __y)
1306 : { return __builtin_copysignl(__x, __y); }
1307 : #endif
1308 :
1309 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1310 : template<typename _Tp, typename _Up>
1311 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1312 : copysign(_Tp __x, _Up __y)
1313 : {
1314 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1315 : return copysign(__type(__x), __type(__y));
1316 : }
1317 : #endif
1318 :
1319 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1320 : constexpr float
1321 : erf(float __x)
1322 : { return __builtin_erff(__x); }
1323 :
1324 : constexpr long double
1325 : erf(long double __x)
1326 : { return __builtin_erfl(__x); }
1327 : #endif
1328 :
1329 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1330 : template<typename _Tp>
1331 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1332 : double>::__type
1333 : erf(_Tp __x)
1334 : { return __builtin_erf(__x); }
1335 : #endif
1336 :
1337 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1338 : constexpr float
1339 : erfc(float __x)
1340 : { return __builtin_erfcf(__x); }
1341 :
1342 : constexpr long double
1343 : erfc(long double __x)
1344 : { return __builtin_erfcl(__x); }
1345 : #endif
1346 :
1347 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1348 : template<typename _Tp>
1349 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1350 : double>::__type
1351 : erfc(_Tp __x)
1352 : { return __builtin_erfc(__x); }
1353 : #endif
1354 :
1355 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1356 : constexpr float
1357 : exp2(float __x)
1358 : { return __builtin_exp2f(__x); }
1359 :
1360 : constexpr long double
1361 : exp2(long double __x)
1362 : { return __builtin_exp2l(__x); }
1363 : #endif
1364 :
1365 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1366 : template<typename _Tp>
1367 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1368 : double>::__type
1369 : exp2(_Tp __x)
1370 : { return __builtin_exp2(__x); }
1371 : #endif
1372 :
1373 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1374 : constexpr float
1375 : expm1(float __x)
1376 : { return __builtin_expm1f(__x); }
1377 :
1378 : constexpr long double
1379 : expm1(long double __x)
1380 : { return __builtin_expm1l(__x); }
1381 : #endif
1382 :
1383 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1384 : template<typename _Tp>
1385 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1386 : double>::__type
1387 : expm1(_Tp __x)
1388 : { return __builtin_expm1(__x); }
1389 : #endif
1390 :
1391 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1392 : constexpr float
1393 : fdim(float __x, float __y)
1394 : { return __builtin_fdimf(__x, __y); }
1395 :
1396 : constexpr long double
1397 : fdim(long double __x, long double __y)
1398 : { return __builtin_fdiml(__x, __y); }
1399 : #endif
1400 :
1401 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1402 : template<typename _Tp, typename _Up>
1403 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1404 : fdim(_Tp __x, _Up __y)
1405 : {
1406 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1407 : return fdim(__type(__x), __type(__y));
1408 : }
1409 : #endif
1410 :
1411 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1412 : constexpr float
1413 : fma(float __x, float __y, float __z)
1414 : { return __builtin_fmaf(__x, __y, __z); }
1415 :
1416 : constexpr long double
1417 : fma(long double __x, long double __y, long double __z)
1418 : { return __builtin_fmal(__x, __y, __z); }
1419 : #endif
1420 :
1421 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1422 : template<typename _Tp, typename _Up, typename _Vp>
1423 : constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1424 : fma(_Tp __x, _Up __y, _Vp __z)
1425 : {
1426 : typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
1427 : return fma(__type(__x), __type(__y), __type(__z));
1428 : }
1429 : #endif
1430 :
1431 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1432 : constexpr float
1433 : fmax(float __x, float __y)
1434 : { return __builtin_fmaxf(__x, __y); }
1435 :
1436 : constexpr long double
1437 : fmax(long double __x, long double __y)
1438 : { return __builtin_fmaxl(__x, __y); }
1439 : #endif
1440 :
1441 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1442 : template<typename _Tp, typename _Up>
1443 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1444 : fmax(_Tp __x, _Up __y)
1445 : {
1446 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1447 : return fmax(__type(__x), __type(__y));
1448 : }
1449 : #endif
1450 :
1451 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1452 : constexpr float
1453 : fmin(float __x, float __y)
1454 : { return __builtin_fminf(__x, __y); }
1455 :
1456 : constexpr long double
1457 : fmin(long double __x, long double __y)
1458 : { return __builtin_fminl(__x, __y); }
1459 : #endif
1460 :
1461 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1462 : template<typename _Tp, typename _Up>
1463 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1464 : fmin(_Tp __x, _Up __y)
1465 : {
1466 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1467 : return fmin(__type(__x), __type(__y));
1468 : }
1469 : #endif
1470 :
1471 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1472 : constexpr float
1473 : hypot(float __x, float __y)
1474 : { return __builtin_hypotf(__x, __y); }
1475 :
1476 : constexpr long double
1477 : hypot(long double __x, long double __y)
1478 : { return __builtin_hypotl(__x, __y); }
1479 : #endif
1480 :
1481 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1482 : template<typename _Tp, typename _Up>
1483 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1484 : hypot(_Tp __x, _Up __y)
1485 : {
1486 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1487 : return hypot(__type(__x), __type(__y));
1488 : }
1489 : #endif
1490 :
1491 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1492 : constexpr int
1493 : ilogb(float __x)
1494 : { return __builtin_ilogbf(__x); }
1495 :
1496 : constexpr int
1497 : ilogb(long double __x)
1498 : { return __builtin_ilogbl(__x); }
1499 : #endif
1500 :
1501 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1502 : template<typename _Tp>
1503 : constexpr
1504 : typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1505 : int>::__type
1506 : ilogb(_Tp __x)
1507 : { return __builtin_ilogb(__x); }
1508 : #endif
1509 :
1510 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1511 : constexpr float
1512 : lgamma(float __x)
1513 : { return __builtin_lgammaf(__x); }
1514 :
1515 : constexpr long double
1516 : lgamma(long double __x)
1517 : { return __builtin_lgammal(__x); }
1518 : #endif
1519 :
1520 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1521 : template<typename _Tp>
1522 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1523 : double>::__type
1524 : lgamma(_Tp __x)
1525 : { return __builtin_lgamma(__x); }
1526 : #endif
1527 :
1528 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1529 : constexpr long long
1530 : llrint(float __x)
1531 : { return __builtin_llrintf(__x); }
1532 :
1533 : constexpr long long
1534 : llrint(long double __x)
1535 : { return __builtin_llrintl(__x); }
1536 : #endif
1537 :
1538 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1539 : template<typename _Tp>
1540 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1541 : long long>::__type
1542 : llrint(_Tp __x)
1543 : { return __builtin_llrint(__x); }
1544 : #endif
1545 :
1546 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1547 : constexpr long long
1548 : llround(float __x)
1549 : { return __builtin_llroundf(__x); }
1550 :
1551 : constexpr long long
1552 : llround(long double __x)
1553 : { return __builtin_llroundl(__x); }
1554 : #endif
1555 :
1556 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1557 : template<typename _Tp>
1558 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1559 : long long>::__type
1560 : llround(_Tp __x)
1561 : { return __builtin_llround(__x); }
1562 : #endif
1563 :
1564 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1565 : constexpr float
1566 : log1p(float __x)
1567 : { return __builtin_log1pf(__x); }
1568 :
1569 : constexpr long double
1570 : log1p(long double __x)
1571 : { return __builtin_log1pl(__x); }
1572 : #endif
1573 :
1574 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1575 : template<typename _Tp>
1576 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1577 : double>::__type
1578 : log1p(_Tp __x)
1579 : { return __builtin_log1p(__x); }
1580 : #endif
1581 :
1582 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1583 : // DR 568.
1584 : constexpr float
1585 : log2(float __x)
1586 : { return __builtin_log2f(__x); }
1587 :
1588 : constexpr long double
1589 : log2(long double __x)
1590 : { return __builtin_log2l(__x); }
1591 : #endif
1592 :
1593 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1594 : template<typename _Tp>
1595 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1596 : double>::__type
1597 : log2(_Tp __x)
1598 : { return __builtin_log2(__x); }
1599 : #endif
1600 :
1601 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1602 : constexpr float
1603 : logb(float __x)
1604 : { return __builtin_logbf(__x); }
1605 :
1606 : constexpr long double
1607 : logb(long double __x)
1608 : { return __builtin_logbl(__x); }
1609 : #endif
1610 :
1611 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1612 : template<typename _Tp>
1613 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1614 : double>::__type
1615 : logb(_Tp __x)
1616 : { return __builtin_logb(__x); }
1617 : #endif
1618 :
1619 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1620 : constexpr long
1621 : lrint(float __x)
1622 : { return __builtin_lrintf(__x); }
1623 :
1624 : constexpr long
1625 : lrint(long double __x)
1626 : { return __builtin_lrintl(__x); }
1627 : #endif
1628 :
1629 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1630 : template<typename _Tp>
1631 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1632 : long>::__type
1633 : lrint(_Tp __x)
1634 : { return __builtin_lrint(__x); }
1635 : #endif
1636 :
1637 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1638 : constexpr long
1639 : lround(float __x)
1640 : { return __builtin_lroundf(__x); }
1641 :
1642 : constexpr long
1643 : lround(long double __x)
1644 : { return __builtin_lroundl(__x); }
1645 : #endif
1646 :
1647 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1648 : template<typename _Tp>
1649 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1650 : long>::__type
1651 : lround(_Tp __x)
1652 : { return __builtin_lround(__x); }
1653 : #endif
1654 :
1655 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1656 : constexpr float
1657 : nearbyint(float __x)
1658 : { return __builtin_nearbyintf(__x); }
1659 :
1660 : constexpr long double
1661 : nearbyint(long double __x)
1662 : { return __builtin_nearbyintl(__x); }
1663 : #endif
1664 :
1665 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1666 : template<typename _Tp>
1667 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1668 : double>::__type
1669 : nearbyint(_Tp __x)
1670 : { return __builtin_nearbyint(__x); }
1671 : #endif
1672 :
1673 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1674 : constexpr float
1675 : nextafter(float __x, float __y)
1676 : { return __builtin_nextafterf(__x, __y); }
1677 :
1678 : constexpr long double
1679 : nextafter(long double __x, long double __y)
1680 : { return __builtin_nextafterl(__x, __y); }
1681 : #endif
1682 :
1683 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1684 : template<typename _Tp, typename _Up>
1685 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1686 : nextafter(_Tp __x, _Up __y)
1687 : {
1688 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1689 : return nextafter(__type(__x), __type(__y));
1690 : }
1691 : #endif
1692 :
1693 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1694 : constexpr float
1695 : nexttoward(float __x, long double __y)
1696 : { return __builtin_nexttowardf(__x, __y); }
1697 :
1698 : constexpr long double
1699 : nexttoward(long double __x, long double __y)
1700 : { return __builtin_nexttowardl(__x, __y); }
1701 : #endif
1702 :
1703 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1704 : template<typename _Tp>
1705 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1706 : double>::__type
1707 : nexttoward(_Tp __x, long double __y)
1708 : { return __builtin_nexttoward(__x, __y); }
1709 : #endif
1710 :
1711 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1712 : constexpr float
1713 : remainder(float __x, float __y)
1714 : { return __builtin_remainderf(__x, __y); }
1715 :
1716 : constexpr long double
1717 : remainder(long double __x, long double __y)
1718 : { return __builtin_remainderl(__x, __y); }
1719 : #endif
1720 :
1721 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1722 : template<typename _Tp, typename _Up>
1723 : constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1724 : remainder(_Tp __x, _Up __y)
1725 : {
1726 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1727 : return remainder(__type(__x), __type(__y));
1728 : }
1729 : #endif
1730 :
1731 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1732 : inline float
1733 : remquo(float __x, float __y, int* __pquo)
1734 : { return __builtin_remquof(__x, __y, __pquo); }
1735 :
1736 : inline long double
1737 : remquo(long double __x, long double __y, int* __pquo)
1738 : { return __builtin_remquol(__x, __y, __pquo); }
1739 : #endif
1740 :
1741 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1742 : template<typename _Tp, typename _Up>
1743 : inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
1744 : remquo(_Tp __x, _Up __y, int* __pquo)
1745 : {
1746 : typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
1747 : return remquo(__type(__x), __type(__y), __pquo);
1748 : }
1749 : #endif
1750 :
1751 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1752 : constexpr float
1753 : rint(float __x)
1754 : { return __builtin_rintf(__x); }
1755 :
1756 : constexpr long double
1757 : rint(long double __x)
1758 : { return __builtin_rintl(__x); }
1759 : #endif
1760 :
1761 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1762 : template<typename _Tp>
1763 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1764 : double>::__type
1765 : rint(_Tp __x)
1766 : { return __builtin_rint(__x); }
1767 : #endif
1768 :
1769 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1770 : constexpr float
1771 : round(float __x)
1772 : { return __builtin_roundf(__x); }
1773 :
1774 : constexpr long double
1775 : round(long double __x)
1776 : { return __builtin_roundl(__x); }
1777 : #endif
1778 :
1779 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1780 : template<typename _Tp>
1781 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1782 : double>::__type
1783 : round(_Tp __x)
1784 : { return __builtin_round(__x); }
1785 : #endif
1786 :
1787 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1788 : constexpr float
1789 : scalbln(float __x, long __ex)
1790 : { return __builtin_scalblnf(__x, __ex); }
1791 :
1792 : constexpr long double
1793 : scalbln(long double __x, long __ex)
1794 : { return __builtin_scalblnl(__x, __ex); }
1795 : #endif
1796 :
1797 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1798 : template<typename _Tp>
1799 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1800 : double>::__type
1801 : scalbln(_Tp __x, long __ex)
1802 : { return __builtin_scalbln(__x, __ex); }
1803 : #endif
1804 :
1805 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1806 : constexpr float
1807 : scalbn(float __x, int __ex)
1808 : { return __builtin_scalbnf(__x, __ex); }
1809 :
1810 : constexpr long double
1811 : scalbn(long double __x, int __ex)
1812 : { return __builtin_scalbnl(__x, __ex); }
1813 : #endif
1814 :
1815 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1816 : template<typename _Tp>
1817 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1818 : double>::__type
1819 : scalbn(_Tp __x, int __ex)
1820 : { return __builtin_scalbn(__x, __ex); }
1821 : #endif
1822 :
1823 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1824 : constexpr float
1825 : tgamma(float __x)
1826 : { return __builtin_tgammaf(__x); }
1827 :
1828 : constexpr long double
1829 : tgamma(long double __x)
1830 : { return __builtin_tgammal(__x); }
1831 : #endif
1832 :
1833 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1834 : template<typename _Tp>
1835 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1836 : double>::__type
1837 : tgamma(_Tp __x)
1838 : { return __builtin_tgamma(__x); }
1839 : #endif
1840 :
1841 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_FP
1842 : constexpr float
1843 : trunc(float __x)
1844 : { return __builtin_truncf(__x); }
1845 :
1846 : constexpr long double
1847 : trunc(long double __x)
1848 : { return __builtin_truncl(__x); }
1849 : #endif
1850 :
1851 : #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO_INT
1852 : template<typename _Tp>
1853 : constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
1854 : double>::__type
1855 : trunc(_Tp __x)
1856 : { return __builtin_trunc(__x); }
1857 : #endif
1858 :
1859 : _GLIBCXX_END_NAMESPACE_VERSION
1860 : } // namespace
1861 :
1862 : #endif // _GLIBCXX_USE_C99_MATH_TR1
1863 :
1864 : #endif // C++11
1865 :
1866 : #if __cplusplus > 201402L
1867 : namespace std _GLIBCXX_VISIBILITY(default)
1868 : {
1869 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
1870 :
1871 : // [c.math.hypot3], three-dimensional hypotenuse
1872 : #define __cpp_lib_hypot 201603
1873 :
1874 : template<typename _Tp>
1875 : inline _Tp
1876 : __hypot3(_Tp __x, _Tp __y, _Tp __z)
1877 : {
1878 : __x = std::abs(__x);
1879 : __y = std::abs(__y);
1880 : __z = std::abs(__z);
1881 : if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x)
1882 : return __a * std::sqrt((__x / __a) * (__x / __a)
1883 : + (__y / __a) * (__y / __a)
1884 : + (__z / __a) * (__z / __a));
1885 : else
1886 : return {};
1887 : }
1888 :
1889 : inline float
1890 : hypot(float __x, float __y, float __z)
1891 : { return std::__hypot3<float>(__x, __y, __z); }
1892 :
1893 : inline double
1894 : hypot(double __x, double __y, double __z)
1895 : { return std::__hypot3<double>(__x, __y, __z); }
1896 :
1897 : inline long double
1898 : hypot(long double __x, long double __y, long double __z)
1899 : { return std::__hypot3<long double>(__x, __y, __z); }
1900 :
1901 : template<typename _Tp, typename _Up, typename _Vp>
1902 : typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
1903 : hypot(_Tp __x, _Up __y, _Vp __z)
1904 : {
1905 : using __type = typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type;
1906 : return std::__hypot3<__type>(__x, __y, __z);
1907 : }
1908 : _GLIBCXX_END_NAMESPACE_VERSION
1909 : } // namespace
1910 : #endif // C++17
1911 :
1912 :
1913 : #if _GLIBCXX_USE_STD_SPEC_FUNCS
1914 : # include <bits/specfun.h>
1915 : #endif
1916 :
1917 : } // extern "C++"
1918 :
1919 : #endif
|
