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