cmath

Go to the documentation of this file.
00001 // -*- C++ -*- C forwarding header. 00002 00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002 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 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 namespace std 00080 { 00081 // Forward declaration of a helper function. This really should be 00082 // an `exported' forward declaration. 00083 template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int); 00084 00085 inline double 00086 abs(double __x) 00087 { return __builtin_fabs(__x); } 00088 00089 inline float 00090 abs(float __x) 00091 { return __builtin_fabsf(__x); } 00092 00093 inline long double 00094 abs(long double __x) 00095 { return __builtin_fabsl(__x); } 00096 00097 #if _GLIBCPP_HAVE_ACOSF 00098 inline float 00099 acos(float __x) { return ::acosf(__x); } 00100 #else 00101 inline float 00102 acos(float __x) { return ::acos(static_cast<double>(__x)); } 00103 #endif 00104 00105 using ::acos; 00106 00107 #if _GLIBCPP_HAVE_ACOSL 00108 inline long double 00109 acos(long double __x) { return ::acosl(__x); } 00110 #else 00111 inline long double 00112 acos(long double __x) { return ::acos(static_cast<double>(__x)); } 00113 #endif 00114 00115 using ::asin; 00116 00117 #if _GLIBCPP_HAVE_ASINF 00118 inline float 00119 asin(float __x) { return ::asinf(__x); } 00120 #else 00121 inline float 00122 asin(float __x) { return ::asin(static_cast<double>(__x)); } 00123 #endif 00124 00125 #if _GLIBCPP_HAVE_ASINL 00126 inline long double 00127 asin(long double __x) { return ::asinl(__x); } 00128 #else 00129 inline long double 00130 asin(long double __x) { return ::asin(static_cast<double>(__x)); } 00131 #endif 00132 00133 using ::atan; 00134 00135 #if _GLIBCPP_HAVE_ATANF 00136 inline float 00137 atan(float __x) { return ::atanf(__x); } 00138 #else 00139 inline float 00140 atan(float __x) { return ::atan(static_cast<double>(__x)); } 00141 #endif 00142 00143 #if _GLIBCPP_HAVE_ATANL 00144 inline long double 00145 atan(long double __x) { return ::atanl(__x); } 00146 #else 00147 inline long double 00148 atan(long double __x) { return ::atan(static_cast<double>(__x)); } 00149 #endif 00150 00151 using ::atan2; 00152 00153 #if _GLIBCPP_HAVE_ATAN2F 00154 inline float 00155 atan2(float __y, float __x) { return ::atan2f(__y, __x); } 00156 #else 00157 inline float 00158 atan2(float __y, float __x) 00159 { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); } 00160 #endif 00161 00162 #if _GLIBCPP_HAVE_ATAN2L 00163 inline long double 00164 atan2(long double __y, long double __x) { return ::atan2l(__y, __x); } 00165 #else 00166 inline long double 00167 atan2(long double __y, long double __x) 00168 { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); } 00169 #endif 00170 00171 using ::ceil; 00172 00173 #if _GLIBCPP_HAVE_CEILF 00174 inline float 00175 ceil(float __x) { return ::ceilf(__x); } 00176 #else 00177 inline float 00178 ceil(float __x) { return ::ceil(static_cast<double>(__x)); } 00179 #endif 00180 00181 #if _GLIBCPP_HAVE_CEILL 00182 inline long double 00183 ceil(long double __x) { return ::ceill(__x); } 00184 #else 00185 inline long double 00186 ceil(long double __x) { return ::ceil(static_cast<double>(__x)); } 00187 #endif 00188 00189 using ::cos; 00190 00191 inline float 00192 cos(float __x) 00193 { return __builtin_cosf(__x); } 00194 00195 inline long double 00196 cos(long double __x) 00197 { return __builtin_cosl(__x); } 00198 00199 using ::cosh; 00200 00201 #if _GLIBCPP_HAVE_COSHF 00202 inline float 00203 cosh(float __x) { return ::coshf(__x); } 00204 #else 00205 inline float 00206 cosh(float __x) { return ::cosh(static_cast<double>(__x)); } 00207 #endif 00208 00209 #if _GLIBCPP_HAVE_COSHL 00210 inline long double 00211 cosh(long double __x) { return ::coshl(__x); } 00212 #else 00213 inline long double 00214 cosh(long double __x) { return ::cosh(static_cast<double>(__x)); } 00215 #endif 00216 00217 using ::exp; 00218 00219 #if _GLIBCPP_HAVE_EXPF 00220 inline float 00221 exp(float __x) { return ::expf(__x); } 00222 #else 00223 inline float 00224 exp(float __x) { return ::exp(static_cast<double>(__x)); } 00225 #endif 00226 00227 #if _GLIBCPP_HAVE_EXPL 00228 inline long double 00229 exp(long double __x) { return ::expl(__x); } 00230 #else 00231 inline long double 00232 exp(long double __x) { return ::exp(static_cast<double>(__x)); } 00233 #endif 00234 00235 using ::fabs; 00236 00237 inline float 00238 fabs(float __x) 00239 { return __builtin_fabsf(__x); } 00240 00241 inline long double 00242 fabs(long double __x) 00243 { return __builtin_fabsl(__x); } 00244 00245 using ::floor; 00246 00247 #if _GLIBCPP_HAVE_FLOORF 00248 inline float 00249 floor(float __x) { return ::floorf(__x); } 00250 #else 00251 inline float 00252 floor(float __x) { return ::floor(static_cast<double>(__x)); } 00253 #endif 00254 00255 #if _GLIBCPP_HAVE_FLOORL 00256 inline long double 00257 floor(long double __x) { return ::floorl(__x); } 00258 #else 00259 inline long double 00260 floor(long double __x) { return ::floor(static_cast<double>(__x)); } 00261 #endif 00262 00263 using ::fmod; 00264 00265 #if _GLIBCPP_HAVE_FMODF 00266 inline float 00267 fmod(float __x, float __y) { return ::fmodf(__x, __y); } 00268 #else 00269 inline float 00270 fmod(float __x, float __y) 00271 { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); } 00272 #endif 00273 00274 #if _GLIBCPP_HAVE_FMODL 00275 inline long double 00276 fmod(long double __x, long double __y) { return ::fmodl(__x, __y); } 00277 #else 00278 inline long double 00279 fmod(long double __x, long double __y) 00280 { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); } 00281 #endif 00282 00283 using ::frexp; 00284 00285 #if _GLIBCPP_HAVE_FREXPF 00286 inline float 00287 frexp(float __x, int* __exp) { return ::frexpf(__x, __exp); } 00288 #else 00289 inline float 00290 frexp(float __x, int* __exp) { return ::frexp(__x, __exp); } 00291 #endif 00292 00293 #if _GLIBCPP_HAVE_FREXPL 00294 inline long double 00295 frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); } 00296 #else 00297 inline long double 00298 frexp(long double __x, int* __exp) 00299 { return ::frexp(static_cast<double>(__x), __exp); } 00300 #endif 00301 00302 using ::ldexp; 00303 00304 #if _GLIBCPP_HAVE_LDEXPF 00305 inline float 00306 ldexp(float __x, int __exp) { return ::ldexpf(__x, __exp); } 00307 #else 00308 inline float 00309 ldexp(float __x, int __exp) 00310 { return ::ldexp(static_cast<double>(__x), __exp); } 00311 #endif 00312 00313 #if _GLIBCPP_HAVE_LDEXPL 00314 inline long double 00315 ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); } 00316 #else 00317 inline long double 00318 ldexp(long double __x, int __exp) 00319 { return ::ldexp(static_cast<double>(__x), __exp); } 00320 #endif 00321 00322 using ::log; 00323 00324 #if _GLIBCPP_HAVE_LOGF 00325 inline float 00326 log(float __x) { return ::logf(__x); } 00327 #else 00328 inline float log(float __x) 00329 { return ::log(static_cast<double>(__x)); } 00330 #endif 00331 00332 #if _GLIBCPP_HAVE_LOGL 00333 inline long double 00334 log(long double __x) { return ::logl(__x); } 00335 #else 00336 inline long double 00337 log(long double __x) { return ::log(static_cast<double>(__x)); } 00338 #endif 00339 00340 using ::log10; 00341 00342 #if _GLIBCPP_HAVE_LOG10F 00343 inline float 00344 log10(float __x) { return ::log10f(__x); } 00345 #else 00346 inline float 00347 log10(float __x) { return ::log10(static_cast<double>(__x)); } 00348 #endif 00349 00350 #if _GLIBCPP_HAVE_LOG10L 00351 inline long double 00352 log10(long double __x) { return ::log10l(__x); } 00353 #else 00354 inline long double 00355 log10(long double __x) { return ::log10(static_cast<double>(__x)); } 00356 #endif 00357 00358 using ::modf; 00359 00360 #if _GLIBCPP_HAVE_MODFF 00361 inline float 00362 modf(float __x, float* __iptr) { return ::modff(__x, __iptr); } 00363 #else 00364 inline float 00365 modf(float __x, float* __iptr) 00366 { 00367 double __tmp; 00368 double __res = ::modf(static_cast<double>(__x), &__tmp); 00369 *__iptr = static_cast<float>(__tmp); 00370 return __res; 00371 } 00372 #endif 00373 00374 #if _GLIBCPP_HAVE_MODFL 00375 inline long double 00376 modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); } 00377 #else 00378 inline long double 00379 modf(long double __x, long double* __iptr) 00380 { 00381 double __tmp; 00382 double __res = ::modf(static_cast<double>(__x), &__tmp); 00383 * __iptr = static_cast<long double>(__tmp); 00384 return __res; 00385 } 00386 #endif 00387 00388 template<typename _Tp> 00389 inline _Tp 00390 __pow_helper(_Tp __x, int __n) 00391 { 00392 return __n < 0 00393 ? _Tp(1)/__cmath_power(__x, -__n) 00394 : __cmath_power(__x, __n); 00395 } 00396 00397 using ::pow; 00398 00399 #if _GLIBCPP_HAVE_POWF 00400 inline float 00401 pow(float __x, float __y) { return ::powf(__x, __y); } 00402 #else 00403 inline float 00404 pow(float __x, float __y) 00405 { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); } 00406 #endif 00407 00408 #if _GLIBCPP_HAVE_POWL 00409 inline long double 00410 pow(long double __x, long double __y) { return ::powl(__x, __y); } 00411 #else 00412 inline long double 00413 pow(long double __x, long double __y) 00414 { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); } 00415 #endif 00416 00417 inline double 00418 pow(double __x, int __i) 00419 { return __pow_helper(__x, __i); } 00420 00421 inline float 00422 pow(float __x, int __n) 00423 { return __pow_helper(__x, __n); } 00424 00425 inline long double 00426 pow(long double __x, int __n) 00427 { return __pow_helper(__x, __n); } 00428 00429 using ::sin; 00430 00431 inline float 00432 sin(float __x) 00433 { return __builtin_sinf(__x); } 00434 00435 inline long double 00436 sin(long double __x) 00437 { return __builtin_sinl(__x); } 00438 00439 using ::sinh; 00440 00441 #if _GLIBCPP_HAVE_SINHF 00442 inline float 00443 sinh(float __x) { return ::sinhf(__x); } 00444 #else 00445 inline float 00446 sinh(float __x) { return ::sinh(static_cast<double>(__x)); } 00447 #endif 00448 00449 #if _GLIBCPP_HAVE_SINHL 00450 inline long double 00451 sinh(long double __x) { return ::sinhl(__x); } 00452 #else 00453 inline long double 00454 sinh(long double __x) { return ::sinh(static_cast<double>(__x)); } 00455 #endif 00456 00457 using ::sqrt; 00458 00459 inline float 00460 sqrt(float __x) 00461 { return __builtin_sqrtf(__x); } 00462 00463 inline long double 00464 sqrt(long double __x) 00465 { return __builtin_sqrtl(__x); } 00466 00467 using ::tan; 00468 00469 #if _GLIBCPP_HAVE_TANF 00470 inline float 00471 tan(float __x) { return ::tanf(__x); } 00472 #else 00473 inline float 00474 tan(float __x) { return ::tan(static_cast<double>(__x)); } 00475 #endif 00476 00477 #if _GLIBCPP_HAVE_TANL 00478 inline long double 00479 tan(long double __x) { return ::tanl(__x); } 00480 #else 00481 inline long double 00482 tan(long double __x) { return ::tan(static_cast<double>(__x)); } 00483 #endif 00484 00485 using ::tanh; 00486 00487 #if _GLIBCPP_HAVE_TANHF 00488 inline float 00489 tanh(float __x) { return ::tanhf(__x); } 00490 #else 00491 inline float 00492 tanh(float __x) { return ::tanh(static_cast<double>(__x)); } 00493 #endif 00494 00495 #if _GLIBCPP_HAVE_TANHL 00496 inline long double 00497 tanh(long double __x) { return ::tanhl(__x); } 00498 #else 00499 inline long double 00500 tanh(long double __x) { return ::tanh(static_cast<double>(__x)); } 00501 #endif 00502 } 00503 00504 00505 #if _GLIBCPP_USE_C99 00506 // These are possible macros imported from C99-land. For strict 00507 // conformance, remove possible C99-injected names from the global 00508 // namespace, and sequester them in the __gnu_cxx extension namespace. 00509 namespace __gnu_cxx 00510 { 00511 template<typename _Tp> 00512 int 00513 __capture_fpclassify(_Tp __f) { return fpclassify(__f); } 00514 00515 template<typename _Tp> 00516 int 00517 __capture_isfinite(_Tp __f) { return isfinite(__f); } 00518 00519 template<typename _Tp> 00520 int 00521 __capture_isinf(_Tp __f) { return isinf(__f); } 00522 00523 template<typename _Tp> 00524 int 00525 __capture_isnan(_Tp __f) { return isnan(__f); } 00526 00527 template<typename _Tp> 00528 int 00529 __capture_isnormal(_Tp __f) { return isnormal(__f); } 00530 00531 template<typename _Tp> 00532 int 00533 __capture_signbit(_Tp __f) { return signbit(__f); } 00534 00535 template<typename _Tp> 00536 int 00537 __capture_isgreater(_Tp __f1, _Tp __f2) 00538 { return isgreater(__f1, __f2); } 00539 00540 template<typename _Tp> 00541 int 00542 __capture_isgreaterequal(_Tp __f1, _Tp __f2) 00543 { return isgreaterequal(__f1, __f2); } 00544 00545 template<typename _Tp> 00546 int 00547 __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); } 00548 00549 template<typename _Tp> 00550 int 00551 __capture_islessequal(_Tp __f1, _Tp __f2) 00552 { return islessequal(__f1, __f2); } 00553 00554 template<typename _Tp> 00555 int 00556 __capture_islessgreater(_Tp __f1, _Tp __f2) 00557 { return islessgreater(__f1, __f2); } 00558 00559 template<typename _Tp> 00560 int 00561 __capture_isunordered(_Tp __f1, _Tp __f2) 00562 { return isunordered(__f1, __f2); } 00563 } 00564 #endif 00565 00566 #undef fpclassify 00567 #undef isfinite 00568 #undef isinf 00569 #undef isnan 00570 #undef isnormal 00571 #undef signbit 00572 #undef isgreater 00573 #undef isgreaterequal 00574 #undef isless 00575 #undef islessequal 00576 #undef islessgreater 00577 #undef isunordered 00578 00579 #if _GLIBCPP_USE_C99 00580 namespace __gnu_cxx 00581 { 00582 template<typename _Tp> 00583 int 00584 fpclassify(_Tp __f) { return __capture_fpclassify(__f); } 00585 00586 template<typename _Tp> 00587 int 00588 isfinite(_Tp __f) { return __capture_isfinite(__f); } 00589 00590 template<typename _Tp> 00591 int 00592 isinf(_Tp __f) { return __capture_isinf(__f); } 00593 00594 template<typename _Tp> 00595 int 00596 isnan(_Tp __f) { return __capture_isnan(__f); } 00597 00598 template<typename _Tp> 00599 int 00600 isnormal(_Tp __f) { return __capture_isnormal(__f); } 00601 00602 template<typename _Tp> 00603 int 00604 signbit(_Tp __f) { return __capture_signbit(__f); } 00605 00606 template<typename _Tp> 00607 int 00608 isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); } 00609 00610 template<typename _Tp> 00611 int 00612 isgreaterequal(_Tp __f1, _Tp __f2) 00613 { return __capture_isgreaterequal(__f1, __f2); } 00614 00615 template<typename _Tp> 00616 int 00617 isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); } 00618 00619 template<typename _Tp> 00620 int 00621 islessequal(_Tp __f1, _Tp __f2) 00622 { return __capture_islessequal(__f1, __f2); } 00623 00624 template<typename _Tp> 00625 int 00626 islessgreater(_Tp __f1, _Tp __f2) 00627 { return __capture_islessgreater(__f1, __f2); } 00628 00629 template<typename _Tp> 00630 int 00631 isunordered(_Tp __f1, _Tp __f2) 00632 { return __capture_isunordered(__f1, __f2); } 00633 } 00634 00635 namespace std 00636 { 00637 using __gnu_cxx::fpclassify; 00638 using __gnu_cxx::isfinite; 00639 using __gnu_cxx::isinf; 00640 using __gnu_cxx::isnan; 00641 using __gnu_cxx::isnormal; 00642 using __gnu_cxx::signbit; 00643 using __gnu_cxx::isgreater; 00644 using __gnu_cxx::isgreaterequal; 00645 using __gnu_cxx::isless; 00646 using __gnu_cxx::islessequal; 00647 using __gnu_cxx::islessgreater; 00648 using __gnu_cxx::isunordered; 00649 } 00650 #endif 00651 00652 #ifdef _GLIBCPP_NO_TEMPLATE_EXPORT 00653 # define export 00654 # include <bits/cmath.tcc> 00655 #endif 00656 00657 #endif

Generated on Wed Sep 29 13:54:47 2004 for libstdc++-v3 Source by doxygen 1.3.7