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