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