libstdc++-v3/include/c_std/std_cmath.h

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