cmath

Go to the documentation of this file.
00001 // -*- C++ -*- C forwarding header.
00002 
00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
00004 // Free Software Foundation, Inc.
00005 //
00006 // This file is part of the GNU ISO C++ Library.  This library is free
00007 // software; you can redistribute it and/or modify it under the
00008 // terms of the GNU General Public License as published by the
00009 // Free Software Foundation; either version 2, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU General Public License for more details.
00016 
00017 // You should have received a copy of the GNU General Public License along
00018 // with this library; see the file COPYING.  If not, write to the Free
00019 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
00020 // USA.
00021 
00022 // As a special exception, you may use this file as part of a free software
00023 // library without restriction.  Specifically, if other files instantiate
00024 // templates or use macros or inline functions from this file, or you compile
00025 // this file and link it with other files to produce an executable, this
00026 // file does not by itself cause the resulting executable to be covered by
00027 // the GNU General Public License.  This exception does not however
00028 // invalidate any other reasons why the executable file might be covered by
00029 // the GNU General Public License.
00030 
00031 //
00032 // ISO C++ 14882: 26.5  C library
00033 //
00034 
00035 /** @file cmath
00036  *  This is a Standard C++ Library file.  You should @c #include this file
00037  *  in your programs, rather than any of the "*.h" implementation files.
00038  *
00039  *  This is the C++ version of the Standard C Library header @c math.h,
00040  *  and its contents are (mostly) the same as that header, but are all
00041  *  contained in the namespace @c std.
00042  */
00043 
00044 #ifndef _CPP_CMATH
00045 #define _CPP_CMATH 1
00046 
00047 #pragma GCC system_header
00048 
00049 #include <bits/c++config.h>
00050 
00051 #include <math.h>
00052 
00053 // Get rid of those macros defined in <math.h> in lieu of real functions.
00054 #undef abs
00055 #undef div
00056 #undef acos
00057 #undef asin
00058 #undef atan
00059 #undef atan2
00060 #undef ceil
00061 #undef cos
00062 #undef cosh
00063 #undef exp
00064 #undef fabs
00065 #undef floor
00066 #undef fmod
00067 #undef frexp
00068 #undef ldexp
00069 #undef log
00070 #undef log10
00071 #undef modf
00072 #undef pow
00073 #undef sin
00074 #undef sinh
00075 #undef sqrt
00076 #undef tan
00077 #undef tanh
00078 
00079 // ...and in the darkness bind them...
00080 namespace __gnu_cxx
00081 {
00082   namespace  __c99_binding
00083   {
00084 #if _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_CHECK || \
00085     _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
00086     extern "C" float (acosf)(float);
00087     extern "C" float (asinf)(float);
00088     extern "C" float (atanf)(float);
00089     extern "C" float (atan2f)(float, float);
00090     extern "C" float (ceilf)(float);
00091     extern "C" float (coshf)(float);
00092     extern "C" float (expf)(float);
00093     extern "C" float (floorf)(float);
00094     extern "C" float (fmodf)(float, float);
00095     extern "C" float (frexpf)(float, int*);
00096     extern "C" float (ldexpf)(float, int);
00097     extern "C" float (logf)(float);
00098     extern "C" float (log10f)(float);
00099     extern "C" float (modff)(float, float*);
00100     extern "C" float (powf)(float, float);
00101     extern "C" float (sinhf)(float);
00102     extern "C" float (tanf)(float);
00103     extern "C" float (tanhf)(float);
00104 #endif
00105 #if !_GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC
00106 #if _GLIBCPP_HAVE_ACOSF
00107     using ::acosf;
00108 #endif
00109 #if _GLIBCPP_HAVE_ASINF
00110     using ::asinf;
00111 #endif
00112 #if _GLIBCPP_HAVE_ATANF
00113     using ::atanf;
00114 #endif
00115 #if _GLIBCPP_HAVE_ATAN2F
00116     using ::atan2f;
00117 #endif
00118 #if _GLIBCPP_HAVE_CEILF
00119     using ::ceilf;
00120 #endif
00121 #if _GLIBCPP_HAVE_COSHF
00122     using ::coshf;
00123 #endif
00124 #if _GLIBCPP_HAVE_EXPF
00125     using ::expf;
00126 #endif
00127 #if _GLIBCPP_HAVE_FLOORF
00128     using ::floorf;
00129 #endif
00130 #if _GLIBCPP_HAVE_FMODF
00131     using ::fmodf;
00132 #endif
00133 #if _GLIBCPP_HAVE_FREXPF
00134     using ::frexpf;
00135 #endif
00136 #if _GLIBCPP_HAVE_LDEXPF
00137     using ::ldexpf;
00138 #endif
00139 #if _GLIBCPP_HAVE_LOGF
00140     using ::logf;
00141 #endif
00142 #if _GLIBCPP_HAVE_LOG10F
00143     using ::log10f;
00144 #endif
00145 #if _GLIBCPP_HAVE_MODFF
00146     using ::modff;
00147 #endif
00148 #if _GLIBCPP_HAVE_POWF
00149     using ::powf;
00150 #endif
00151 #if _GLIBCPP_HAVE_SINHF
00152     using ::sinhf;
00153 #endif
00154 #if _GLIBCPP_HAVE_TANF
00155     using ::tanf;
00156 #endif
00157 #if _GLIBCPP_HAVE_TANHF
00158     using ::tanhf;
00159 #endif
00160 #endif /* _GLIBCPP_USE_C99_FLOAT_TRANSCENDENTALS_DYNAMIC */
00161   }
00162 }
00163 
00164 namespace std 
00165 {
00166   // Forward declaration of a helper function.  This really should be
00167   // an `exported' forward declaration.
00168   template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
00169 
00170   inline double
00171   abs(double __x)
00172   { return __builtin_fabs(__x); }
00173 
00174   inline float
00175   abs(float __x)
00176   { return __builtin_fabsf(__x); }
00177 
00178   inline long double
00179   abs(long double __x)
00180   { return __builtin_fabsl(__x); }
00181 
00182 #if _GLIBCPP_HAVE_ACOSF
00183   inline float 
00184   acos(float __x) { return __gnu_cxx::__c99_binding::acosf(__x); }
00185 #else
00186   inline float 
00187   acos(float __x) { return ::acos(static_cast<double>(__x)); }
00188 #endif
00189 
00190   using ::acos;
00191   
00192 #if _GLIBCPP_HAVE_ACOSL
00193   inline long double 
00194   acos(long double __x) { return ::acosl(__x); }
00195 #else
00196   inline long double 
00197   acos(long double __x) { return ::acos(static_cast<double>(__x)); }
00198 #endif
00199 
00200   using ::asin;
00201 
00202 #if _GLIBCPP_HAVE_ASINF
00203   inline float 
00204   asin(float __x) { return __gnu_cxx::__c99_binding::asinf(__x); }
00205 #else
00206   inline float 
00207   asin(float __x) { return ::asin(static_cast<double>(__x)); }
00208 #endif
00209 
00210 #if _GLIBCPP_HAVE_ASINL
00211   inline long double 
00212   asin(long double __x) { return ::asinl(__x); }
00213 #else
00214   inline long double 
00215   asin(long double __x) { return ::asin(static_cast<double>(__x)); }
00216 #endif
00217 
00218   using ::atan;
00219 
00220 #if _GLIBCPP_HAVE_ATANF
00221   inline float 
00222   atan(float __x) { return __gnu_cxx::__c99_binding::atanf(__x); }
00223 #else
00224   inline float 
00225   atan(float __x) { return ::atan(static_cast<double>(__x)); }
00226 #endif
00227 
00228 #if _GLIBCPP_HAVE_ATANL
00229   inline long double 
00230   atan(long double __x) { return ::atanl(__x); }
00231 #else
00232   inline long double 
00233   atan(long double __x) { return ::atan(static_cast<double>(__x)); }
00234 #endif
00235 
00236   using ::atan2;
00237 
00238 #if _GLIBCPP_HAVE_ATAN2F
00239   inline float 
00240   atan2(float __y, float __x) { return __gnu_cxx::__c99_binding::atan2f(__y, __x); }
00241 #else
00242   inline float 
00243   atan2(float __y, float __x)
00244   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
00245 #endif
00246 
00247 #if _GLIBCPP_HAVE_ATAN2L
00248   inline long double 
00249   atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
00250 #else
00251   inline long double 
00252   atan2(long double __y, long double __x) 
00253   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
00254 #endif
00255 
00256   using ::ceil;
00257 
00258 #if _GLIBCPP_HAVE_CEILF
00259   inline float 
00260   ceil(float __x) { return __gnu_cxx::__c99_binding::ceilf(__x); }
00261 #else
00262   inline float 
00263   ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
00264 #endif
00265 
00266 #if _GLIBCPP_HAVE_CEILL
00267   inline long double 
00268   ceil(long double __x) { return ::ceill(__x); }
00269 #else
00270   inline long double 
00271   ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
00272 #endif
00273 
00274   using ::cos;
00275 
00276   inline float
00277   cos(float __x)
00278   { return __builtin_cosf(__x); }
00279 
00280   inline long double
00281   cos(long double __x)
00282   { return __builtin_cosl(__x); }
00283 
00284   using ::cosh;
00285 
00286 #if _GLIBCPP_HAVE_COSHF
00287   inline float 
00288   cosh(float __x) { return __gnu_cxx::__c99_binding::coshf(__x); }
00289 #else
00290   inline float 
00291   cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
00292 #endif
00293 
00294 #if _GLIBCPP_HAVE_COSHL
00295   inline long double 
00296   cosh(long double __x) { return ::coshl(__x); }
00297 #else
00298   inline long double 
00299   cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
00300 #endif
00301 
00302   using ::exp;
00303 
00304 #if _GLIBCPP_HAVE_EXPF
00305   inline float 
00306   exp(float __x) { return __gnu_cxx::__c99_binding::expf(__x); }
00307 #else
00308   inline float 
00309   exp(float __x) { return ::exp(static_cast<double>(__x)); }
00310 #endif
00311 
00312 #if _GLIBCPP_HAVE_EXPL
00313   inline long double 
00314   exp(long double __x) { return ::expl(__x); }
00315 #else
00316   inline long double 
00317   exp(long double __x) { return ::exp(static_cast<double>(__x)); }
00318 #endif
00319 
00320   using ::fabs;
00321 
00322   inline float
00323   fabs(float __x)
00324   { return __builtin_fabsf(__x); }
00325 
00326   inline long double
00327   fabs(long double __x)
00328   { return __builtin_fabsl(__x); }
00329 
00330   using ::floor;
00331 
00332 #if _GLIBCPP_HAVE_FLOORF
00333   inline float 
00334   floor(float __x) { return __gnu_cxx::__c99_binding::floorf(__x); }
00335 #else
00336   inline float 
00337   floor(float __x) { return ::floor(static_cast<double>(__x)); }
00338 #endif
00339 
00340 #if _GLIBCPP_HAVE_FLOORL
00341   inline long double 
00342   floor(long double __x) { return ::floorl(__x); }
00343 #else
00344   inline long double 
00345   floor(long double __x) { return ::floor(static_cast<double>(__x)); }
00346 #endif
00347 
00348   using ::fmod;
00349 
00350 #if _GLIBCPP_HAVE_FMODF
00351   inline float 
00352   fmod(float __x, float __y) { return __gnu_cxx::__c99_binding::fmodf(__x, __y); }
00353 #else
00354   inline float 
00355   fmod(float __x, float __y)
00356   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
00357 #endif
00358 
00359 #if _GLIBCPP_HAVE_FMODL
00360   inline long double 
00361   fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
00362 #else
00363   inline long double 
00364   fmod(long double __x, long double __y) 
00365   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
00366 #endif
00367 
00368   using ::frexp;
00369 
00370 #if _GLIBCPP_HAVE_FREXPF
00371   inline float 
00372   frexp(float __x, int* __exp) { return __gnu_cxx::__c99_binding::frexpf(__x, __exp); }
00373 #else
00374   inline float 
00375   frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
00376 #endif
00377 
00378 #if _GLIBCPP_HAVE_FREXPL
00379   inline long double 
00380   frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
00381 #else
00382   inline long double 
00383   frexp(long double __x, int* __exp) 
00384   { return ::frexp(static_cast<double>(__x), __exp); }
00385 #endif
00386 
00387   using ::ldexp;
00388 
00389 #if _GLIBCPP_HAVE_LDEXPF
00390   inline float 
00391   ldexp(float __x, int __exp) { return __gnu_cxx::__c99_binding::ldexpf(__x, __exp); }
00392 #else
00393   inline float 
00394   ldexp(float __x, int __exp)
00395   { return ::ldexp(static_cast<double>(__x), __exp); }
00396 #endif
00397 
00398 #if _GLIBCPP_HAVE_LDEXPL
00399   inline long double 
00400   ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
00401 #else
00402   inline long double 
00403   ldexp(long double __x, int __exp) 
00404   { return ::ldexp(static_cast<double>(__x), __exp); }
00405 #endif
00406 
00407   using ::log;
00408 
00409 #if _GLIBCPP_HAVE_LOGF
00410   inline float 
00411   log(float __x) { return __gnu_cxx::__c99_binding::logf(__x); }
00412 #else
00413   inline float log(float __x)
00414   { return ::log(static_cast<double>(__x)); }
00415 #endif
00416 
00417 #if _GLIBCPP_HAVE_LOGL
00418   inline long double 
00419   log(long double __x) { return ::logl(__x); }
00420 #else
00421   inline long double 
00422   log(long double __x) { return ::log(static_cast<double>(__x)); }
00423 #endif
00424 
00425   using ::log10;
00426 
00427 #if _GLIBCPP_HAVE_LOG10F
00428   inline float 
00429   log10(float __x) { return __gnu_cxx::__c99_binding::log10f(__x); }
00430 #else
00431   inline float 
00432   log10(float __x) { return ::log10(static_cast<double>(__x)); }
00433 #endif
00434 
00435 #if _GLIBCPP_HAVE_LOG10L
00436   inline long double 
00437   log10(long double __x) { return ::log10l(__x); }
00438 #else
00439   inline long double 
00440   log10(long double __x) { return ::log10(static_cast<double>(__x)); }
00441 #endif
00442 
00443   using ::modf;
00444 
00445 #if _GLIBCPP_HAVE_MODFF
00446   inline float 
00447   modf(float __x, float* __iptr) { return __gnu_cxx::__c99_binding::modff(__x, __iptr); }
00448 #else
00449   inline float 
00450   modf(float __x, float* __iptr)
00451   {
00452     double __tmp;
00453     double __res = ::modf(static_cast<double>(__x), &__tmp);
00454     *__iptr = static_cast<float>(__tmp);
00455     return __res;
00456   }
00457 #endif
00458 
00459 #if _GLIBCPP_HAVE_MODFL
00460   inline long double 
00461   modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
00462 #else
00463   inline long double 
00464   modf(long double __x, long double* __iptr) 
00465   { 
00466     double __tmp;
00467     double __res = ::modf(static_cast<double>(__x), &__tmp);
00468     * __iptr = static_cast<long double>(__tmp);
00469     return __res;
00470   }
00471 #endif
00472 
00473   template<typename _Tp>
00474     inline _Tp
00475     __pow_helper(_Tp __x, int __n)
00476     {
00477       return __n < 0
00478         ? _Tp(1)/__cmath_power(__x, -__n)
00479         : __cmath_power(__x, __n);
00480     }
00481 
00482   using ::pow;
00483 
00484 #if _GLIBCPP_HAVE_POWF
00485   inline float 
00486   pow(float __x, float __y) { return __gnu_cxx::__c99_binding::powf(__x, __y); }
00487 #else
00488   inline float 
00489   pow(float __x, float __y)
00490   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
00491 #endif
00492 
00493 #if _GLIBCPP_HAVE_POWL
00494   inline long double 
00495   pow(long double __x, long double __y) { return ::powl(__x, __y); }
00496 #else
00497   inline long double 
00498   pow(long double __x, long double __y) 
00499   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
00500 #endif
00501 
00502   inline double 
00503   pow(double __x, int __i)
00504   { return __pow_helper(__x, __i); }
00505 
00506   inline float 
00507   pow(float __x, int __n)
00508   { return __pow_helper(__x, __n); }
00509 
00510   inline long double 
00511   pow(long double __x, int __n)
00512   { return __pow_helper(__x, __n); }
00513 
00514   using ::sin;
00515 
00516   inline float
00517   sin(float __x)
00518   { return __builtin_sinf(__x); }
00519 
00520   inline long double
00521   sin(long double __x)
00522   { return __builtin_sinl(__x); }
00523 
00524   using ::sinh;
00525 
00526 #if _GLIBCPP_HAVE_SINHF
00527   inline float 
00528   sinh(float __x) { return __gnu_cxx::__c99_binding::sinhf(__x); }
00529 #else
00530   inline float 
00531   sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
00532 #endif
00533 
00534 #if _GLIBCPP_HAVE_SINHL
00535   inline long double 
00536   sinh(long double __x) { return ::sinhl(__x); }
00537 #else
00538   inline long double 
00539   sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
00540 #endif
00541 
00542   using ::sqrt;
00543 
00544   inline float
00545   sqrt(float __x)
00546   { return __builtin_sqrtf(__x); }
00547 
00548   inline long double
00549   sqrt(long double __x)
00550   { return __builtin_sqrtl(__x); }
00551 
00552   using ::tan;
00553 
00554 #if _GLIBCPP_HAVE_TANF
00555   inline float 
00556   tan(float __x) { return __gnu_cxx::__c99_binding::tanf(__x); }
00557 #else
00558   inline float 
00559   tan(float __x) { return ::tan(static_cast<double>(__x)); }
00560 #endif
00561 
00562 #if _GLIBCPP_HAVE_TANL
00563   inline long double 
00564   tan(long double __x) { return ::tanl(__x); }
00565 #else
00566   inline long double 
00567   tan(long double __x) { return ::tan(static_cast<double>(__x)); }
00568 #endif
00569 
00570   using ::tanh;
00571 
00572 #if _GLIBCPP_HAVE_TANHF
00573   inline float 
00574   tanh(float __x) { return __gnu_cxx::__c99_binding::tanhf(__x); }
00575 #else
00576   inline float 
00577   tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
00578 #endif
00579 
00580 #if _GLIBCPP_HAVE_TANHL
00581   inline long double 
00582   tanh(long double __x) { return ::tanhl(__x); }
00583 #else
00584   inline long double 
00585   tanh(long double __x) { return ::tanh(static_cast<double>(__x)); }
00586 #endif
00587 } 
00588 
00589 
00590 #if _GLIBCPP_USE_C99
00591 #if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC
00592 // These are possible macros imported from C99-land. For strict
00593 // conformance, remove possible C99-injected names from the global
00594 // namespace, and sequester them in the __gnu_cxx extension namespace. 
00595 namespace __gnu_cxx
00596 {
00597   template<typename _Tp>
00598     int 
00599     __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
00600 
00601   template<typename _Tp>
00602     int 
00603     __capture_isfinite(_Tp __f) { return isfinite(__f); }
00604 
00605   template<typename _Tp>
00606     int 
00607     __capture_isinf(_Tp __f) { return isinf(__f); }
00608 
00609   template<typename _Tp>
00610     int 
00611     __capture_isnan(_Tp __f) { return isnan(__f); }
00612 
00613   template<typename _Tp>
00614     int 
00615     __capture_isnormal(_Tp __f) { return isnormal(__f); }
00616 
00617   template<typename _Tp>
00618     int 
00619     __capture_signbit(_Tp __f) { return signbit(__f); }
00620 
00621   template<typename _Tp>
00622     int 
00623     __capture_isgreater(_Tp __f1, _Tp __f2)
00624     { return isgreater(__f1, __f2); }
00625 
00626   template<typename _Tp>
00627      int 
00628      __capture_isgreaterequal(_Tp __f1, _Tp __f2) 
00629      { return isgreaterequal(__f1, __f2); }
00630 
00631   template<typename _Tp>
00632      int 
00633      __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
00634 
00635   template<typename _Tp>
00636      int 
00637      __capture_islessequal(_Tp __f1, _Tp __f2) 
00638      { return islessequal(__f1, __f2); }
00639 
00640   template<typename _Tp>
00641      int 
00642      __capture_islessgreater(_Tp __f1, _Tp __f2) 
00643      { return islessgreater(__f1, __f2); }
00644 
00645   template<typename _Tp>
00646      int 
00647      __capture_isunordered(_Tp __f1, _Tp __f2) 
00648      { return isunordered(__f1, __f2); }
00649 } 
00650 #endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
00651 #endif
00652 
00653 #undef fpclassify
00654 #undef isfinite
00655 #undef isinf
00656 #undef isnan
00657 #undef isnormal
00658 #undef signbit
00659 #undef isgreater
00660 #undef isgreaterequal
00661 #undef isless
00662 #undef islessequal
00663 #undef islessgreater
00664 #undef isunordered
00665 
00666 #if _GLIBCPP_USE_C99
00667 #if !_GLIBCPP_USE_C99_FP_MACROS_DYNAMIC
00668 namespace __gnu_cxx
00669 {
00670   template<typename _Tp>
00671     int
00672     fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
00673 
00674   template<typename _Tp>
00675     int
00676     isfinite(_Tp __f) { return __capture_isfinite(__f); }
00677 
00678   template<typename _Tp>
00679     int 
00680     isinf(_Tp __f) { return __capture_isinf(__f); }
00681 
00682   template<typename _Tp>
00683     int 
00684     isnan(_Tp __f) { return __capture_isnan(__f); }
00685 
00686   template<typename _Tp>
00687     int 
00688     isnormal(_Tp __f) { return __capture_isnormal(__f); }
00689 
00690   template<typename _Tp>
00691     int 
00692     signbit(_Tp __f) { return __capture_signbit(__f); }
00693 
00694   template<typename _Tp>
00695     int 
00696     isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
00697 
00698   template<typename _Tp>
00699     int 
00700     isgreaterequal(_Tp __f1, _Tp __f2) 
00701     { return __capture_isgreaterequal(__f1, __f2); }
00702 
00703   template<typename _Tp>
00704     int 
00705     isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
00706 
00707   template<typename _Tp>
00708     int 
00709     islessequal(_Tp __f1, _Tp __f2) 
00710     { return __capture_islessequal(__f1, __f2); }
00711 
00712   template<typename _Tp>
00713     int 
00714     islessgreater(_Tp __f1, _Tp __f2) 
00715     { return __capture_islessgreater(__f1, __f2); }
00716 
00717   template<typename _Tp>
00718     int 
00719     isunordered(_Tp __f1, _Tp __f2) 
00720     { return __capture_isunordered(__f1, __f2); }
00721 }
00722 
00723 namespace std
00724 {
00725   using __gnu_cxx::fpclassify;
00726   using __gnu_cxx::isfinite;
00727   using __gnu_cxx::isinf;
00728   using __gnu_cxx::isnan;
00729   using __gnu_cxx::isnormal;
00730   using __gnu_cxx::signbit;
00731   using __gnu_cxx::isgreater;
00732   using __gnu_cxx::isgreaterequal;
00733   using __gnu_cxx::isless;
00734   using __gnu_cxx::islessequal;
00735   using __gnu_cxx::islessgreater;
00736   using __gnu_cxx::isunordered;
00737 }
00738 #endif /* _GLIBCPP_USE_C99_FP_MACROS_DYNAMIC */
00739 #endif
00740   
00741 #ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
00742 #  define export
00743 #  include <bits/cmath.tcc>
00744 #endif
00745 
00746 #endif

Generated on Thu Feb 10 23:22:53 2005 for libstdc++-v3 Source by  doxygen 1.4.0