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