File Coverage

/usr/include/c++/5/cmath
Criterion Covered Total %
statement 2 2 100.0
branch n/a
condition n/a
subroutine n/a
pod n/a
total 2 2 100.0


line stmt bran cond sub pod time code
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             // .
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
42             #include
43             #include
44             #include
45              
46             #ifndef _GLIBCXX_CMATH
47             #define _GLIBCXX_CMATH 1
48              
49             // Get rid of those macros defined in 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
366             inline _GLIBCXX_CONSTEXPR
367             typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
368             double>::__type
369 278           log(_Tp __x)
370 278           { 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
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
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
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
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
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
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
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              
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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              
1062             namespace 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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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