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