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 Wed Aug 4 21:43:09 2004 for libstdc++-v3 Source by doxygen 1.3.8