mingw/lib/gcc/mingw32/4.4.0/include/c++/cmath

   1 // -*- C++ -*- C forwarding header.
   2
   3 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   4 // 2006, 2007, 2008, 2009
   5 // Free Software Foundation, Inc.
   6 //
   7 // This file is part of the GNU ISO C++ Library.  This library is free
   8 // software; you can redistribute it and/or modify it under the
   9 // terms of the GNU General Public License as published by the
  10 // Free Software Foundation; either version 3, or (at your option)
  11 // any later version.
  12
  13 // This library is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // Under Section 7 of GPL version 3, you are granted additional
  19 // permissions described in the GCC Runtime Library Exception, version
  20 // 3.1, as published by the Free Software Foundation.
  21
  22 // You should have received a copy of the GNU General Public License and
  23 // a copy of the GCC Runtime Library Exception along with this program;
  24 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25 // <http://www.gnu.org/licenses/>.
  26
  27 /** @file include/cmath
  28  *  This is a Standard C++ Library file.  You should @c #include this file
  29  *  in your programs, rather than any of the "*.h" implementation files.
  30  *
  31  *  This is the C++ version of the Standard C Library header @c math.h,
  32  *  and its contents are (mostly) the same as that header, but are all
  33  *  contained in the namespace @c std (except for names which are defined
  34  *  as macros in C).
  35  */
  36
  37 //
  38 // ISO C++ 14882: 26.5  C library
  39 //
  40
  41 #pragma GCC system_header
  42
  43 #include <bits/c++config.h>
  44 #include <bits/cpp_type_traits.h>
  45 #include <ext/type_traits.h>
  46 #include <math.h>
  47
  48 #ifndef _GLIBCXX_CMATH
  49 #define _GLIBCXX_CMATH 1
  50
  51 // Get rid of those macros defined in <math.h> in lieu of real functions.
  52 #undef abs
  53 #undef div
  54 #undef acos
  55 #undef asin
  56 #undef atan
  57 #undef atan2
  58 #undef ceil
  59 #undef cos
  60 #undef cosh
  61 #undef exp
  62 #undef fabs
  63 #undef floor
  64 #undef fmod
  65 #undef frexp
  66 #undef ldexp
  67 #undef log
  68 #undef log10
  69 #undef modf
  70 #undef pow
  71 #undef sin
  72 #undef sinh
  73 #undef sqrt
  74 #undef tan
  75 #undef tanh
  76
  77 _GLIBCXX_BEGIN_NAMESPACE(std)
  78
  79   // Forward declaration of a helper function.  This really should be
  80   // an `exported' forward declaration.
  81   template<typename _Tp>
  82     _Tp __cmath_power(_Tp, unsigned int);
  83
  84   template<typename _Tp>
  85     inline _Tp
  86     __pow_helper(_Tp __x, int __n)
  87     {
  88       return __n < 0
  89         ? _Tp(1)/__cmath_power(__x, -__n)
  90         : __cmath_power(__x, __n);
  91     }
  92
  93   inline double
  94   abs(double __x)
  95   { return __builtin_fabs(__x); }
  96
  97   inline float
  98   abs(float __x)
  99   { return __builtin_fabsf(__x); }
 100
 101   inline long double
 102   abs(long double __x)
 103   { return __builtin_fabsl(__x); }
 104
 105   using ::acos;
 106
 107   inline float
 108   acos(float __x)
 109   { return __builtin_acosf(__x); }
 110
 111   inline long double
 112   acos(long double __x)
 113   { return __builtin_acosl(__x); }
 114
 115   template<typename _Tp>
 116     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 117                                            double>::__type
 118     acos(_Tp __x)
 119     { return __builtin_acos(__x); }
 120
 121   using ::asin;
 122
 123   inline float
 124   asin(float __x)
 125   { return __builtin_asinf(__x); }
 126
 127   inline long double
 128   asin(long double __x)
 129   { return __builtin_asinl(__x); }
 130
 131   template<typename _Tp>
 132     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 133                                            double>::__type
 134     asin(_Tp __x)
 135     { return __builtin_asin(__x); }
 136
 137   using ::atan;
 138
 139   inline float
 140   atan(float __x)
 141   { return __builtin_atanf(__x); }
 142
 143   inline long double
 144   atan(long double __x)
 145   { return __builtin_atanl(__x); }
 146
 147   template<typename _Tp>
 148     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 149                                            double>::__type
 150     atan(_Tp __x)
 151     { return __builtin_atan(__x); }
 152
 153   using ::atan2;
 154
 155   inline float
 156   atan2(float __y, float __x)
 157   { return __builtin_atan2f(__y, __x); }
 158
 159   inline long double
 160   atan2(long double __y, long double __x)
 161   { return __builtin_atan2l(__y, __x); }
 162
 163   template<typename _Tp, typename _Up>
 164     inline
 165     typename __gnu_cxx::__promote_2<
 166     typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
 167                                     && __is_arithmetic<_Up>::__value,
 168                                     _Tp>::__type, _Up>::__type
 169     atan2(_Tp __y, _Up __x)
 170     {
 171       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 172       return atan2(__type(__y), __type(__x));
 173     }
 174
 175   using ::ceil;
 176
 177   inline float
 178   ceil(float __x)
 179   { return __builtin_ceilf(__x); }
 180
 181   inline long double
 182   ceil(long double __x)
 183   { return __builtin_ceill(__x); }
 184
 185   template<typename _Tp>
 186     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 187                                            double>::__type
 188     ceil(_Tp __x)
 189     { return __builtin_ceil(__x); }
 190
 191   using ::cos;
 192
 193   inline float
 194   cos(float __x)
 195   { return __builtin_cosf(__x); }
 196
 197   inline long double
 198   cos(long double __x)
 199   { return __builtin_cosl(__x); }
 200
 201   template<typename _Tp>
 202     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 203                                            double>::__type
 204     cos(_Tp __x)
 205     { return __builtin_cos(__x); }
 206
 207   using ::cosh;
 208
 209   inline float
 210   cosh(float __x)
 211   { return __builtin_coshf(__x); }
 212
 213   inline long double
 214   cosh(long double __x)
 215   { return __builtin_coshl(__x); }
 216
 217   template<typename _Tp>
 218     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 219                                            double>::__type
 220     cosh(_Tp __x)
 221     { return __builtin_cosh(__x); }
 222
 223   using ::exp;
 224
 225   inline float
 226   exp(float __x)
 227   { return __builtin_expf(__x); }
 228
 229   inline long double
 230   exp(long double __x)
 231   { return __builtin_expl(__x); }
 232
 233   template<typename _Tp>
 234     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 235                                            double>::__type
 236     exp(_Tp __x)
 237     { return __builtin_exp(__x); }
 238
 239   using ::fabs;
 240
 241   inline float
 242   fabs(float __x)
 243   { return __builtin_fabsf(__x); }
 244
 245   inline long double
 246   fabs(long double __x)
 247   { return __builtin_fabsl(__x); }
 248
 249   template<typename _Tp>
 250     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 251                                            double>::__type
 252     fabs(_Tp __x)
 253     { return __builtin_fabs(__x); }
 254
 255   using ::floor;
 256
 257   inline float
 258   floor(float __x)
 259   { return __builtin_floorf(__x); }
 260
 261   inline long double
 262   floor(long double __x)
 263   { return __builtin_floorl(__x); }
 264
 265   template<typename _Tp>
 266     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 267                                            double>::__type
 268     floor(_Tp __x)
 269     { return __builtin_floor(__x); }
 270
 271   using ::fmod;
 272
 273   inline float
 274   fmod(float __x, float __y)
 275   { return __builtin_fmodf(__x, __y); }
 276
 277   inline long double
 278   fmod(long double __x, long double __y)
 279   { return __builtin_fmodl(__x, __y); }
 280
 281   using ::frexp;
 282
 283   inline float
 284   frexp(float __x, int* __exp)
 285   { return __builtin_frexpf(__x, __exp); }
 286
 287   inline long double
 288   frexp(long double __x, int* __exp)
 289   { return __builtin_frexpl(__x, __exp); }
 290
 291   template<typename _Tp>
 292     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 293                                            double>::__type
 294     frexp(_Tp __x, int* __exp)
 295     { return __builtin_frexp(__x, __exp); }
 296
 297   using ::ldexp;
 298
 299   inline float
 300   ldexp(float __x, int __exp)
 301   { return __builtin_ldexpf(__x, __exp); }
 302
 303   inline long double
 304   ldexp(long double __x, int __exp)
 305   { return __builtin_ldexpl(__x, __exp); }
 306
 307   template<typename _Tp>
 308     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 309                                            double>::__type
 310   ldexp(_Tp __x, int __exp)
 311   { return __builtin_ldexp(__x, __exp); }
 312
 313   using ::log;
 314
 315   inline float
 316   log(float __x)
 317   { return __builtin_logf(__x); }
 318
 319   inline long double
 320   log(long double __x)
 321   { return __builtin_logl(__x); }
 322
 323   template<typename _Tp>
 324     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 325                                            double>::__type
 326     log(_Tp __x)
 327     { return __builtin_log(__x); }
 328
 329   using ::log10;
 330
 331   inline float
 332   log10(float __x)
 333   { return __builtin_log10f(__x); }
 334
 335   inline long double
 336   log10(long double __x)
 337   { return __builtin_log10l(__x); }
 338
 339   template<typename _Tp>
 340     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 341                                            double>::__type
 342     log10(_Tp __x)
 343     { return __builtin_log10(__x); }
 344
 345   using ::modf;
 346
 347   inline float
 348   modf(float __x, float* __iptr)
 349   { return __builtin_modff(__x, __iptr); }
 350
 351   inline long double
 352   modf(long double __x, long double* __iptr)
 353   { return __builtin_modfl(__x, __iptr); }
 354
 355   using ::pow;
 356
 357   inline float
 358   pow(float __x, float __y)
 359   { return __builtin_powf(__x, __y); }
 360
 361   inline long double
 362   pow(long double __x, long double __y)
 363   { return __builtin_powl(__x, __y); }
 364
 365 #ifndef __GXX_EXPERIMENTAL_CXX0X__
 366   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 367   // DR 550. What should the return type of pow(float,int) be?
 368   inline double
 369   pow(double __x, int __i)
 370   { return __builtin_powi(__x, __i); }
 371
 372   inline float
 373   pow(float __x, int __n)
 374   { return __builtin_powif(__x, __n); }
 375
 376   inline long double
 377   pow(long double __x, int __n)
 378   { return __builtin_powil(__x, __n); }
 379 #endif
 380
 381   template<typename _Tp, typename _Up>
 382     inline
 383     typename __gnu_cxx::__promote_2<
 384     typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
 385                                     && __is_arithmetic<_Up>::__value,
 386                                     _Tp>::__type, _Up>::__type
 387     pow(_Tp __x, _Up __y)
 388     {
 389       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
 390       return pow(__type(__x), __type(__y));
 391     }
 392
 393   using ::sin;
 394
 395   inline float
 396   sin(float __x)
 397   { return __builtin_sinf(__x); }
 398
 399   inline long double
 400   sin(long double __x)
 401   { return __builtin_sinl(__x); }
 402
 403   template<typename _Tp>
 404     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 405                                            double>::__type
 406     sin(_Tp __x)
 407     { return __builtin_sin(__x); }
 408
 409   using ::sinh;
 410
 411   inline float
 412   sinh(float __x)
 413   { return __builtin_sinhf(__x); }
 414
 415   inline long double
 416   sinh(long double __x)
 417   { return __builtin_sinhl(__x); }
 418
 419   template<typename _Tp>
 420     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 421                                            double>::__type
 422     sinh(_Tp __x)
 423     { return __builtin_sinh(__x); }
 424
 425   using ::sqrt;
 426
 427   inline float
 428   sqrt(float __x)
 429   { return __builtin_sqrtf(__x); }
 430
 431   inline long double
 432   sqrt(long double __x)
 433   { return __builtin_sqrtl(__x); }
 434
 435   template<typename _Tp>
 436     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 437                                            double>::__type
 438     sqrt(_Tp __x)
 439     { return __builtin_sqrt(__x); }
 440
 441   using ::tan;
 442
 443   inline float
 444   tan(float __x)
 445   { return __builtin_tanf(__x); }
 446
 447   inline long double
 448   tan(long double __x)
 449   { return __builtin_tanl(__x); }
 450
 451   template<typename _Tp>
 452     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 453                                            double>::__type
 454     tan(_Tp __x)
 455     { return __builtin_tan(__x); }
 456
 457   using ::tanh;
 458
 459   inline float
 460   tanh(float __x)
 461   { return __builtin_tanhf(__x); }
 462
 463   inline long double
 464   tanh(long double __x)
 465   { return __builtin_tanhl(__x); }
 466
 467   template<typename _Tp>
 468     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
 469                                            double>::__type
 470     tanh(_Tp __x)
 471     { return __builtin_tanh(__x); }
 472
 473 _GLIBCXX_END_NAMESPACE
 474
 475 #if _GLIBCXX_USE_C99_MATH
 476 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
 477
 478 // These are possible macros imported from C99-land.
 479 #undef fpclassify
 480 #undef isfinite
 481 #undef isinf
 482 #undef isnan
 483 #undef isnormal
 484 #undef signbit
 485 #undef isgreater
 486 #undef isgreaterequal
 487 #undef isless
 488 #undef islessequal
 489 #undef islessgreater
 490 #undef isunordered
 491
 492 _GLIBCXX_BEGIN_NAMESPACE(std)
 493
 494   template<typename _Tp>
 495     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 496                                            int>::__type
 497     fpclassify(_Tp __f)
 498     {
 499       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 500       return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
 501                                   FP_SUBNORMAL, FP_ZERO, __type(__f));
 502     }
 503
 504   template<typename _Tp>
 505     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 506                                            int>::__type
 507     isfinite(_Tp __f)
 508     {
 509       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 510       return __builtin_isfinite(__type(__f));
 511     }
 512
 513   template<typename _Tp>
 514     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 515                                            int>::__type
 516     isinf(_Tp __f)
 517     {
 518       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 519       return __builtin_isinf(__type(__f));
 520     }
 521
 522   template<typename _Tp>
 523     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 524                                            int>::__type
 525     isnan(_Tp __f)
 526     {
 527       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 528       return __builtin_isnan(__type(__f));
 529     }
 530
 531   template<typename _Tp>
 532     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 533                                            int>::__type
 534     isnormal(_Tp __f)
 535     {
 536       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 537       return __builtin_isnormal(__type(__f));
 538     }
 539
 540   template<typename _Tp>
 541     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 542                                            int>::__type
 543     signbit(_Tp __f)
 544     {
 545       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 546       return __builtin_signbit(__type(__f));
 547     }
 548
 549   template<typename _Tp>
 550     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 551                                            int>::__type
 552     isgreater(_Tp __f1, _Tp __f2)
 553     {
 554       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 555       return __builtin_isgreater(__type(__f1), __type(__f2));
 556     }
 557
 558   template<typename _Tp>
 559     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 560                                            int>::__type
 561     isgreaterequal(_Tp __f1, _Tp __f2)
 562     {
 563       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 564       return __builtin_isgreaterequal(__type(__f1), __type(__f2));
 565     }
 566
 567   template<typename _Tp>
 568     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 569                                            int>::__type
 570     isless(_Tp __f1, _Tp __f2)
 571     {
 572       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 573       return __builtin_isless(__type(__f1), __type(__f2));
 574     }
 575
 576   template<typename _Tp>
 577     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 578                                            int>::__type
 579     islessequal(_Tp __f1, _Tp __f2)
 580     {
 581       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 582       return __builtin_islessequal(__type(__f1), __type(__f2));
 583     }
 584
 585   template<typename _Tp>
 586     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 587                                            int>::__type
 588     islessgreater(_Tp __f1, _Tp __f2)
 589     {
 590       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 591       return __builtin_islessgreater(__type(__f1), __type(__f2));
 592     }
 593
 594   template<typename _Tp>
 595     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
 596                                            int>::__type
 597     isunordered(_Tp __f1, _Tp __f2)
 598     {
 599       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
 600       return __builtin_isunordered(__type(__f1), __type(__f2));
 601     }
 602
 603 _GLIBCXX_END_NAMESPACE
 604
 605 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
 606 #endif
 607
 608 #ifndef _GLIBCXX_EXPORT_TEMPLATE
 609 # include <bits/cmath.tcc>
 610 #endif
 611
 612 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 613 #  if defined(_GLIBCXX_INCLUDE_AS_TR1)
 614 #    error C++0x header cannot be included from TR1 header
 615 #  endif
 616 #  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
 617 #    include <tr1_impl/cmath>
 618 #  else
 619 #    define _GLIBCXX_INCLUDE_AS_CXX0X
 620 #    define _GLIBCXX_BEGIN_NAMESPACE_TR1
 621 #    define _GLIBCXX_END_NAMESPACE_TR1
 622 #    define _GLIBCXX_TR1
 623 #    include <tr1_impl/cmath>
 624 #    undef _GLIBCXX_TR1
 625 #    undef _GLIBCXX_END_NAMESPACE_TR1
 626 #    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
 627 #    undef _GLIBCXX_INCLUDE_AS_CXX0X
 628 #  endif
 629 #endif
 630
 631 #endif