1// -*- C++ -*- C forwarding header.
2
3// Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
4// Free Software Foundation, Inc.
5//
6// This file is part of the GNU ISO C++ Library.  This library is free
7// software; you can redistribute it and/or modify it under the
8// terms of the GNU General Public License as published by the
9// Free Software Foundation; either version 2, or (at your option)
10// any later version.
11
12// This library is distributed in the hope that it will be useful,
13// but WITHOUT ANY WARRANTY; without even the implied warranty of
14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15// GNU General Public License for more details.
16
17// You should have received a copy of the GNU General Public License along
18// with this library; see the file COPYING.  If not, write to the Free
19// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20// USA.
21
22// As a special exception, you may use this file as part of a free software
23// library without restriction.  Specifically, if other files instantiate
24// templates or use macros or inline functions from this file, or you compile
25// this file and link it with other files to produce an executable, this
26// file does not by itself cause the resulting executable to be covered by
27// the GNU General Public License.  This exception does not however
28// invalidate any other reasons why the executable file might be covered by
29// the GNU General Public License.
30
31//
32// ISO C++ 14882: 26.5  C library
33//
34
35/** @file cmath
36 *  This is a Standard C++ Library file.  You should @c #include this file
37 *  in your programs, rather than any of the "*.h" implementation files.
38 *
39 *  This is the C++ version of the Standard C Library header @c math.h,
40 *  and its contents are (mostly) the same as that header, but are all
41 *  contained in the namespace @c std.
42 */
43
44#ifndef _CPP_CMATH
45#define _CPP_CMATH 1
46
47#pragma GCC system_header
48
49#include <bits/c++config.h>
50#include <bits/cpp_type_traits.h>
51
52#include <math.h>
53
54// Get rid of those macros defined in <math.h> in lieu of real functions.
55#undef abs
56#undef div
57#undef acos
58#undef asin
59#undef atan
60#undef atan2
61#undef ceil
62#undef cos
63#undef cosh
64#undef exp
65#undef fabs
66#undef floor
67#undef fmod
68#undef frexp
69#undef ldexp
70#undef log
71#undef log10
72#undef modf
73#undef pow
74#undef sin
75#undef sinh
76#undef sqrt
77#undef tan
78#undef tanh
79
80// ...and in the darkness bind them...
81namespace __gnu_cxx
82{
83  namespace  __c99_binding
84  {
85#if defined(_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_CHECK) || \
86    defined(_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC)
87    extern "C" float (acosf)(float);
88    extern "C" float (asinf)(float);
89    extern "C" float (atanf)(float);
90    extern "C" float (atan2f)(float, float);
91    extern "C" float (ceilf)(float);
92    extern "C" float (coshf)(float);
93    extern "C" float (expf)(float);
94    extern "C" float (floorf)(float);
95    extern "C" float (fmodf)(float, float);
96    extern "C" float (frexpf)(float, int*);
97    extern "C" float (ldexpf)(float, int);
98    extern "C" float (logf)(float);
99    extern "C" float (log10f)(float);
100    extern "C" float (modff)(float, float*);
101    extern "C" float (powf)(float, float);
102    extern "C" float (sinhf)(float);
103    extern "C" float (tanf)(float);
104    extern "C" float (tanhf)(float);
105#endif
106#if !defined(_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC)
107#if defined(_GLIBCPP_HAVE_ACOSF)
108    using ::acosf;
109#endif
110#if defined(_GLIBCPP_HAVE_ASINF)
111    using ::asinf;
112#endif
113#if defined(_GLIBCPP_HAVE_ATANF)
114    using ::atanf;
115#endif
116#if defined(_GLIBCPP_HAVE_ATAN2F)
117    using ::atan2f;
118#endif
119#if defined(_GLIBCPP_HAVE_CEILF)
120    using ::ceilf;
121#endif
122#if defined(_GLIBCPP_HAVE_COSHF)
123    using ::coshf;
124#endif
125#if defined(_GLIBCPP_HAVE_EXPF)
126    using ::expf;
127#endif
128#if defined(_GLIBCPP_HAVE_FLOORF)
129    using ::floorf;
130#endif
131#if defined(_GLIBCPP_HAVE_FMODF)
132    using ::fmodf;
133#endif
134#if defined(_GLIBCPP_HAVE_FREXPF)
135    using ::frexpf;
136#endif
137#if defined(_GLIBCPP_HAVE_LDEXPF)
138    using ::ldexpf;
139#endif
140#if defined(_GLIBCPP_HAVE_LOGF)
141    using ::logf;
142#endif
143#if defined(_GLIBCPP_HAVE_LOG10F)
144    using ::log10f;
145#endif
146#if defined(_GLIBCPP_HAVE_MODFF)
147    using ::modff;
148#endif
149#if defined(_GLIBCPP_HAVE_POWF)
150    using ::powf;
151#endif
152#if defined(_GLIBCPP_HAVE_SINHF)
153    using ::sinhf;
154#endif
155#if defined(_GLIBCPP_HAVE_TANF)
156    using ::tanf;
157#endif
158#if defined(_GLIBCPP_HAVE_TANHF)
159    using ::tanhf;
160#endif
161#endif /* _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */
162  }
163}
164
165namespace std
166{
167  // Forward declaration of a helper function.  This really should be
168  // an `exported' forward declaration.
169  template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
170
171  inline double
172  abs(double __x)
173  { return __builtin_fabs(__x); }
174
175  inline float
176  abs(float __x)
177  { return __builtin_fabsf(__x); }
178
179  inline long double
180  abs(long double __x)
181  { return __builtin_fabsl(__x); }
182
183#if defined(_GLIBCPP_HAVE_ACOSF)
184  inline float
185  acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); }
186#else
187  inline float
188  acos(float __x) { return ::acos(static_cast<double>(__x)); }
189#endif
190
191  using ::acos;
192
193#if defined(_GLIBCPP_HAVE_ACOSL)
194  inline long double
195  acos(long double __x) { return ::acosl(__x); }
196#else
197  inline long double
198  acos(long double __x) { return ::acos(static_cast<double>(__x)); }
199#endif
200
201  template<typename _Tp>
202    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
203    acos(_Tp __x)
204    {
205      return ::acos(static_cast<double>(__x));
206    }
207
208  using ::asin;
209
210#if defined(_GLIBCPP_HAVE_ASINF)
211  inline float
212  asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); }
213#else
214  inline float
215  asin(float __x) { return ::asin(static_cast<double>(__x)); }
216#endif
217
218#if defined(_GLIBCPP_HAVE_ASINL)
219  inline long double
220  asin(long double __x) { return ::asinl(__x); }
221#else
222  inline long double
223  asin(long double __x) { return ::asin(static_cast<double>(__x)); }
224#endif
225
226  template<typename _Tp>
227    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
228    asin(_Tp __x)
229    { return ::asin(static_cast<double>(__x)); }
230
231  using ::atan;
232
233#if defined(_GLIBCPP_HAVE_ATANF)
234  inline float
235  atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); }
236#else
237  inline float
238  atan(float __x) { return ::atan(static_cast<double>(__x)); }
239#endif
240
241#if defined(_GLIBCPP_HAVE_ATANL)
242  inline long double
243  atan(long double __x) { return ::atanl(__x); }
244#else
245  inline long double
246  atan(long double __x) { return ::atan(static_cast<double>(__x)); }
247#endif
248
249  template<typename _Tp>
250    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
251    atan(_Tp __x)
252    { return ::atan(static_cast<double>(__x)); }
253
254  using ::atan2;
255
256#if defined(_GLIBCPP_HAVE_ATAN2F)
257  inline float
258  atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); }
259#else
260  inline float
261  atan2(float __y, float __x)
262  { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
263#endif
264
265#if defined(_GLIBCPP_HAVE_ATAN2L)
266  inline long double
267  atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
268#else
269  inline long double
270  atan2(long double __y, long double __x)
271  { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
272#endif
273
274  template<typename _Tp, typename _Up>
275    inline typename __enable_if<double, __is_integer<_Tp>::_M_type
276                                        && __is_integer<_Up>::_M_type>::_M_type
277    atan2(_Tp __x, _Up __y)
278    { return ::atan2(static_cast<double>(__x), static_cast<double>(__y)); }
279
280  using ::ceil;
281
282#if defined(_GLIBCPP_HAVE_CEILF)
283  inline float
284  ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); }
285#else
286  inline float
287  ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
288#endif
289
290#if defined(_GLIBCPP_HAVE_CEILL)
291  inline long double
292  ceil(long double __x) { return ::ceill(__x); }
293#else
294  inline long double
295  ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
296#endif
297
298  template<typename _Tp>
299    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
300    ceil(_Tp __x)
301    { return ::ceil(static_cast<double>(__x)); }
302
303  using ::cos;
304
305  inline float
306  cos(float __x)
307  { return __builtin_cosf(__x); }
308
309  inline long double
310  cos(long double __x)
311  { return __builtin_cosl(__x); }
312
313  template<typename _Tp>
314    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
315    cos(_Tp __x)
316    { return __builtin_cos(__x); }
317
318  using ::cosh;
319
320#if defined(_GLIBCPP_HAVE_COSHF)
321  inline float
322  cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); }
323#else
324  inline float
325  cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
326#endif
327
328#if defined(_GLIBCPP_HAVE_COSHL)
329  inline long double
330  cosh(long double __x) { return ::coshl(__x); }
331#else
332  inline long double
333  cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
334#endif
335
336  template<typename _Tp>
337    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
338    cosh(_Tp __x)
339    { return ::cosh(static_cast<double>(__x)); }
340
341  using ::exp;
342
343#if defined(_GLIBCPP_HAVE_EXPF)
344  inline float
345  exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); }
346#else
347  inline float
348  exp(float __x) { return ::exp(static_cast<double>(__x)); }
349#endif
350
351#if defined(_GLIBCPP_HAVE_EXPL)
352  inline long double
353  exp(long double __x) { return ::expl(__x); }
354#else
355  inline long double
356  exp(long double __x) { return ::exp(static_cast<double>(__x)); }
357#endif
358
359  template<typename _Tp>
360    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
361    exp(_Tp __x)
362    { return ::exp(static_cast<double>(__x)); }
363
364  using ::fabs;
365
366  inline float
367  fabs(float __x)
368  { return __builtin_fabsf(__x); }
369
370  inline long double
371  fabs(long double __x)
372  { return __builtin_fabsl(__x); }
373
374  template<typename _Tp>
375    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
376    fabs(_Tp __x)
377    { return __builtin_fabs(__x); }
378
379  using ::floor;
380
381#if defined(_GLIBCPP_HAVE_FLOORF)
382  inline float
383  floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); }
384#else
385  inline float
386  floor(float __x) { return ::floor(static_cast<double>(__x)); }
387#endif
388
389#if defined(_GLIBCPP_HAVE_FLOORL)
390  inline long double
391  floor(long double __x) { return ::floorl(__x); }
392#else
393  inline long double
394  floor(long double __x) { return ::floor(static_cast<double>(__x)); }
395#endif
396
397  template<typename _Tp>
398    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
399    floor(_Tp __x)
400    { return ::floor(static_cast<double>(__x)); }
401
402  using ::fmod;
403
404#if defined(_GLIBCPP_HAVE_FMODF)
405  inline float
406  fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); }
407#else
408  inline float
409  fmod(float __x, float __y)
410  { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
411#endif
412
413#if defined(_GLIBCPP_HAVE_FMODL)
414  inline long double
415  fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
416#else
417  inline long double
418  fmod(long double __x, long double __y)
419  { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
420#endif
421
422  using ::frexp;
423
424#if defined(_GLIBCPP_HAVE_FREXPF)
425  inline float
426  frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); }
427#else
428  inline float
429  frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
430#endif
431
432#if defined(_GLIBCPP_HAVE_FREXPL)
433  inline long double
434  frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
435#else
436  inline long double
437  frexp(long double __x, int* __exp)
438  { return ::frexp(static_cast<double>(__x), __exp); }
439#endif
440
441  template<typename _Tp>
442    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
443    frexp(_Tp __x, int* __exp)
444    { return ::frexp(static_cast<double>(__x), __exp); }
445
446  using ::ldexp;
447
448#if defined(_GLIBCPP_HAVE_LDEXPF)
449  inline float
450  ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); }
451#else
452  inline float
453  ldexp(float __x, int __exp)
454  { return ::ldexp(static_cast<double>(__x), __exp); }
455#endif
456
457#if defined(_GLIBCPP_HAVE_LDEXPL)
458  inline long double
459  ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
460#else
461  inline long double
462  ldexp(long double __x, int __exp)
463  { return ::ldexp(static_cast<double>(__x), __exp); }
464#endif
465
466  template<typename _Tp>
467  inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
468  ldexp(_Tp __x, int __exp)
469  { return ::ldexp(static_cast<double>(__x), __exp); }
470
471  using ::log;
472
473#if defined(_GLIBCPP_HAVE_LOGF)
474  inline float
475  log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); }
476#else
477  inline float log(float __x)
478  { return ::log(static_cast<double>(__x)); }
479#endif
480
481#if defined(_GLIBCPP_HAVE_LOGL)
482  inline long double
483  log(long double __x) { return ::logl(__x); }
484#else
485  inline long double
486  log(long double __x) { return ::log(static_cast<double>(__x)); }
487#endif
488
489  template<typename _Tp>
490    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
491    log(_Tp __x)
492    { return ::log(static_cast<double>(__x)); }
493
494  using ::log10;
495
496#if defined(_GLIBCPP_HAVE_LOG10F)
497  inline float
498  log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); }
499#else
500  inline float
501  log10(float __x) { return ::log10(static_cast<double>(__x)); }
502#endif
503
504#if defined(_GLIBCPP_HAVE_LOG10L)
505  inline long double
506  log10(long double __x) { return ::log10l(__x); }
507#else
508  inline long double
509  log10(long double __x) { return ::log10(static_cast<double>(__x)); }
510#endif
511
512  template<typename _Tp>
513    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
514    log10(_Tp __x)
515    { return ::log10(static_cast<double>(__x)); }
516
517  using ::modf;
518
519#if defined(_GLIBCPP_HAVE_MODFF)
520  inline float
521  modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); }
522#else
523  inline float
524  modf(float __x, float* __iptr)
525  {
526    double __tmp;
527    double __res = ::modf(static_cast<double>(__x), &__tmp);
528    *__iptr = static_cast<float>(__tmp);
529    return __res;
530  }
531#endif
532
533#if defined(_GLIBCPP_HAVE_MODFL)
534  inline long double
535  modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
536#else
537  inline long double
538  modf(long double __x, long double* __iptr)
539  {
540    double __tmp;
541    double __res = ::modf(static_cast<double>(__x), &__tmp);
542    * __iptr = static_cast<long double>(__tmp);
543    return __res;
544  }
545#endif
546
547  template<typename _Tp>
548    inline _Tp
549    __pow_helper(_Tp __x, int __n)
550    {
551      return __n < 0
552        ? _Tp(1)/__cmath_power(__x, -__n)
553        : __cmath_power(__x, __n);
554    }
555
556  using ::pow;
557
558#if defined(_GLIBCPP_HAVE_POWF)
559  inline float
560  pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); }
561#else
562  inline float
563  pow(float __x, float __y)
564  { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
565#endif
566
567#if defined(_GLIBCPP_HAVE_POWL)
568  inline long double
569  pow(long double __x, long double __y) { return ::powl(__x, __y); }
570#else
571  inline long double
572  pow(long double __x, long double __y)
573  { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
574#endif
575
576  inline double
577  pow(double __x, int __i)
578  { return __pow_helper(__x, __i); }
579
580  inline float
581  pow(float __x, int __n)
582  { return __pow_helper(__x, __n); }
583
584  inline long double
585  pow(long double __x, int __n)
586  { return __pow_helper(__x, __n); }
587
588  using ::sin;
589
590  inline float
591  sin(float __x)
592  { return __builtin_sinf(__x); }
593
594  inline long double
595  sin(long double __x)
596  { return __builtin_sinl(__x); }
597
598  template<typename _Tp>
599    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
600    sin(_Tp __x)
601    { return __builtin_sin(__x); }
602
603  using ::sinh;
604
605#if defined(_GLIBCPP_HAVE_SINHF)
606  inline float
607  sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); }
608#else
609  inline float
610  sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
611#endif
612
613#if defined(_GLIBCPP_HAVE_SINHL)
614  inline long double
615  sinh(long double __x) { return ::sinhl(__x); }
616#else
617  inline long double
618  sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
619#endif
620
621  template<typename _Tp>
622    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
623    sinh(_Tp __x)
624    { return ::sinh(static_cast<_Tp>(__x)); }
625
626  using ::sqrt;
627
628  inline float
629  sqrt(float __x)
630  { return __builtin_sqrtf(__x); }
631
632  inline long double
633  sqrt(long double __x)
634  { return __builtin_sqrtl(__x); }
635
636  template<typename _Tp>
637    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
638    sqrt(_Tp __x)
639    { return __builtin_sqrt(__x); }
640
641  using ::tan;
642
643#if defined(_GLIBCPP_HAVE_TANF)
644  inline float
645  tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); }
646#else
647  inline float
648  tan(float __x) { return ::tan(static_cast<double>(__x)); }
649#endif
650
651#if defined(_GLIBCPP_HAVE_TANL)
652  inline long double
653  tan(long double __x) { return ::tanl(__x); }
654#else
655  inline long double
656  tan(long double __x) { return ::tan(static_cast<double>(__x)); }
657#endif
658
659  template<typename _Tp>
660    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
661    tan(_Tp __x)
662    { return ::tan(static_cast<double>(__x)); }
663
664  using ::tanh;
665
666#if defined(_GLIBCPP_HAVE_TANHF)
667  inline float
668  tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); }
669#else
670  inline float
671  tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
672#endif
673
674#if defined(_GLIBCPP_HAVE_TANHL)
675  inline long double
676  tanh(long double __x) { return ::tanhl(__x); }
677#else
678  inline long double
679  tanh(long double __x) { return ::tanh(static_cast<double>(__x)); }
680#endif
681
682  template<typename _Tp>
683    inline typename __enable_if<double, __is_integer<_Tp>::_M_type>::_M_type
684    tanh(_Tp __x)
685    { return ::tanh(static_cast<double>(__x)); }
686}
687
688
689#if defined(_GLIBCPP_USE_C99)
690#if !defined(_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC)
691// These are possible macros imported from C99-land. For strict
692// conformance, remove possible C99-injected names from the global
693// namespace, and sequester them in the __gnu_cxx extension namespace.
694namespace __gnu_cxx
695{
696  template<typename _Tp>
697    int
698    __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
699
700  template<typename _Tp>
701    int
702    __capture_isfinite(_Tp __f) { return isfinite(__f); }
703
704  template<typename _Tp>
705    int
706    __capture_isinf(_Tp __f) { return isinf(__f); }
707
708  template<typename _Tp>
709    int
710    __capture_isnan(_Tp __f) { return isnan(__f); }
711
712  template<typename _Tp>
713    int
714    __capture_isnormal(_Tp __f) { return isnormal(__f); }
715
716  template<typename _Tp>
717    int
718    __capture_signbit(_Tp __f) { return signbit(__f); }
719
720  template<typename _Tp>
721    int
722    __capture_isgreater(_Tp __f1, _Tp __f2)
723    { return isgreater(__f1, __f2); }
724
725  template<typename _Tp>
726     int
727     __capture_isgreaterequal(_Tp __f1, _Tp __f2)
728     { return isgreaterequal(__f1, __f2); }
729
730  template<typename _Tp>
731     int
732     __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
733
734  template<typename _Tp>
735     int
736     __capture_islessequal(_Tp __f1, _Tp __f2)
737     { return islessequal(__f1, __f2); }
738
739  template<typename _Tp>
740     int
741     __capture_islessgreater(_Tp __f1, _Tp __f2)
742     { return islessgreater(__f1, __f2); }
743
744  template<typename _Tp>
745     int
746     __capture_isunordered(_Tp __f1, _Tp __f2)
747     { return isunordered(__f1, __f2); }
748}
749
750#undef fpclassify
751#undef isfinite
752#undef isinf
753#undef isnan
754#undef isnormal
755#undef signbit
756#undef isgreater
757#undef isgreaterequal
758#undef isless
759#undef islessequal
760#undef islessgreater
761#undef isunordered
762
763namespace __gnu_cxx
764{
765  template<typename _Tp>
766    int
767    fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
768
769  template<typename _Tp>
770    int
771    isfinite(_Tp __f) { return __capture_isfinite(__f); }
772
773  template<typename _Tp>
774    int
775    isinf(_Tp __f) { return __capture_isinf(__f); }
776
777  template<typename _Tp>
778    int
779    isnan(_Tp __f) { return __capture_isnan(__f); }
780
781  template<typename _Tp>
782    int
783    isnormal(_Tp __f) { return __capture_isnormal(__f); }
784
785  template<typename _Tp>
786    int
787    signbit(_Tp __f) { return __capture_signbit(__f); }
788
789  template<typename _Tp>
790    int
791    isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
792
793  template<typename _Tp>
794    int
795    isgreaterequal(_Tp __f1, _Tp __f2)
796    { return __capture_isgreaterequal(__f1, __f2); }
797
798  template<typename _Tp>
799    int
800    isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
801
802  template<typename _Tp>
803    int
804    islessequal(_Tp __f1, _Tp __f2)
805    { return __capture_islessequal(__f1, __f2); }
806
807  template<typename _Tp>
808    int
809    islessgreater(_Tp __f1, _Tp __f2)
810    { return __capture_islessgreater(__f1, __f2); }
811
812  template<typename _Tp>
813    int
814    isunordered(_Tp __f1, _Tp __f2)
815    { return __capture_isunordered(__f1, __f2); }
816}
817
818namespace std
819{
820  using __gnu_cxx::fpclassify;
821  using __gnu_cxx::isfinite;
822  using __gnu_cxx::isinf;
823  using __gnu_cxx::isnan;
824  using __gnu_cxx::isnormal;
825  using __gnu_cxx::signbit;
826  using __gnu_cxx::isgreater;
827  using __gnu_cxx::isgreaterequal;
828  using __gnu_cxx::isless;
829  using __gnu_cxx::islessequal;
830  using __gnu_cxx::islessgreater;
831  using __gnu_cxx::isunordered;
832}
833#endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
834#endif
835
836#ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
837#  define export
838#  include <bits/cmath.tcc>
839#endif
840
841#endif
842