# cmath

Go to the documentation of this file.

    00001 // -*- C++ -*- C forwarding header.
    00002
    00003 // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
    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, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
    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 /** @file include/cmath
    00032  *  This is a Standard C++ Library file.  You should @c #include this file
    00033  *  in your programs, rather than any of the "*.h" implementation files.
    00034  *
    00035  *  This is the C++ version of the Standard C Library header @c math.h,
    00036  *  and its contents are (mostly) the same as that header, but are all
    00037  *  contained in the namespace @c std (except for names which are defined
    00038  *  as macros in C).
    00039  */
    00040
    00041 //
    00042 // ISO C++ 14882: 26.5  C library
    00043 //
    00044
    00045 #ifndef _GLIBCXX_CMATH
    00046 #define _GLIBCXX_CMATH 1
    00047
    00048 #pragma GCC system_header
    00049
    00050 #include <bits/c++config.h>
    00051 #include <bits/cpp_type_traits.h>
    00052 #include <ext/type_traits.h>
    00053
    00054 #include <math.h>
    00055
    00056 // Get rid of those macros defined in <math.h> in lieu of real functions.
    00057 #undef abs
    00058 #undef div
    00059 #undef acos
    00060 #undef asin
    00061 #undef atan
    00062 #undef atan2
    00063 #undef ceil
    00064 #undef cos
    00065 #undef cosh
    00066 #undef exp
    00067 #undef fabs
    00068 #undef floor
    00069 #undef fmod
    00070 #undef frexp
    00071 #undef ldexp
    00072 #undef log
    00073 #undef log10
    00074 #undef modf
    00075 #undef pow
    00076 #undef sin
    00077 #undef sinh
    00078 #undef sqrt
    00079 #undef tan
    00080 #undef tanh
    00081
    00082 _GLIBCXX_BEGIN_NAMESPACE(std)
    00083
    00084   // Forward declaration of a helper function.  This really should be
    00085   // an `exported' forward declaration.
    00086   template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
    00087
    00088   inline double
    00089   abs(double __x)
    00090   { return __builtin_fabs(__x); }
    00091
    00092   inline float
    00093   abs(float __x)
    00094   { return __builtin_fabsf(__x); }
    00095
    00096   inline long double
    00097   abs(long double __x)
    00098   { return __builtin_fabsl(__x); }
    00099
    00100   using ::acos;
    00101
    00102   inline float
    00103   acos(float __x)
    00104   { return __builtin_acosf(__x); }
    00105
    00106   inline long double
    00107   acos(long double __x)
    00108   { return __builtin_acosl(__x); }
    00109
    00110   template<typename _Tp>
    00111     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00112                        double>::__type
    00113     acos(_Tp __x)
    00114     { return __builtin_acos(__x); }
    00115
    00116   using ::asin;
    00117
    00118   inline float
    00119   asin(float __x)
    00120   { return __builtin_asinf(__x); }
    00121
    00122   inline long double
    00123   asin(long double __x)
    00124   { return __builtin_asinl(__x); }
    00125
    00126   template<typename _Tp>
    00127   inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00128                      double>::__type
    00129     asin(_Tp __x)
    00130     { return __builtin_asin(__x); }
    00131
    00132   using ::atan;
    00133
    00134   inline float
    00135   atan(float __x)
    00136   { return __builtin_atanf(__x); }
    00137
    00138   inline long double
    00139   atan(long double __x)
    00140   { return __builtin_atanl(__x); }
    00141
    00142   template<typename _Tp>
    00143   inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00144                      double>::__type
    00145     atan(_Tp __x)
    00146     { return __builtin_atan(__x); }
    00147
    00148   using ::atan2;
    00149
    00150   inline float
    00151   atan2(float __y, float __x)
    00152   { return __builtin_atan2f(__y, __x); }
    00153
    00154   inline long double
    00155   atan2(long double __y, long double __x)
    00156   { return __builtin_atan2l(__y, __x); }
    00157
    00158   template<typename _Tp, typename _Up>
    00159     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value
    00160                            && __is_integer<_Up>::__value,
    00161                        double>::__type
    00162     atan2(_Tp __y, _Up __x)
    00163     { return __builtin_atan2(__y, __x); }
    00164
    00165   using ::ceil;
    00166
    00167   inline float
    00168   ceil(float __x)
    00169   { return __builtin_ceilf(__x); }
    00170
    00171   inline long double
    00172   ceil(long double __x)
    00173   { return __builtin_ceill(__x); }
    00174
    00175   template<typename _Tp>
    00176     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00177                        double>::__type
    00178     ceil(_Tp __x)
    00179     { return __builtin_ceil(__x); }
    00180
    00181   using ::cos;
    00182
    00183   inline float
    00184   cos(float __x)
    00185   { return __builtin_cosf(__x); }
    00186
    00187   inline long double
    00188   cos(long double __x)
    00189   { return __builtin_cosl(__x); }
    00190
    00191   template<typename _Tp>
    00192     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00193                        double>::__type
    00194     cos(_Tp __x)
    00195     { return __builtin_cos(__x); }
    00196
    00197   using ::cosh;
    00198
    00199   inline float
    00200   cosh(float __x)
    00201   { return __builtin_coshf(__x); }
    00202
    00203   inline long double
    00204   cosh(long double __x)
    00205   { return __builtin_coshl(__x); }
    00206
    00207   template<typename _Tp>
    00208     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00209                        double>::__type
    00210     cosh(_Tp __x)
    00211     { return __builtin_cosh(__x); }
    00212
    00213   using ::exp;
    00214
    00215   inline float
    00216   exp(float __x)
    00217   { return __builtin_expf(__x); }
    00218
    00219   inline long double
    00220   exp(long double __x)
    00221   { return __builtin_expl(__x); }
    00222
    00223   template<typename _Tp>
    00224     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00225                        double>::__type
    00226     exp(_Tp __x)
    00227     { return __builtin_exp(__x); }
    00228
    00229   using ::fabs;
    00230
    00231   inline float
    00232   fabs(float __x)
    00233   { return __builtin_fabsf(__x); }
    00234
    00235   inline long double
    00236   fabs(long double __x)
    00237   { return __builtin_fabsl(__x); }
    00238
    00239   template<typename _Tp>
    00240     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00241                        double>::__type
    00242     fabs(_Tp __x)
    00243     { return __builtin_fabs(__x); }
    00244
    00245   using ::floor;
    00246
    00247   inline float
    00248   floor(float __x)
    00249   { return __builtin_floorf(__x); }
    00250
    00251   inline long double
    00252   floor(long double __x)
    00253   { return __builtin_floorl(__x); }
    00254
    00255   template<typename _Tp>
    00256     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00257                        double>::__type
    00258     floor(_Tp __x)
    00259     { return __builtin_floor(__x); }
    00260
    00261   using ::fmod;
    00262
    00263   inline float
    00264   fmod(float __x, float __y)
    00265   { return __builtin_fmodf(__x, __y); }
    00266
    00267   inline long double
    00268   fmod(long double __x, long double __y)
    00269   { return __builtin_fmodl(__x, __y); }
    00270
    00271   using ::frexp;
    00272
    00273   inline float
    00274   frexp(float __x, int* __exp)
    00275   { return __builtin_frexpf(__x, __exp); }
    00276
    00277   inline long double
    00278   frexp(long double __x, int* __exp)
    00279   { return __builtin_frexpl(__x, __exp); }
    00280
    00281   template<typename _Tp>
    00282     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00283                        double>::__type
    00284     frexp(_Tp __x, int* __exp)
    00285     { return __builtin_frexp(__x, __exp); }
    00286
    00287   using ::ldexp;
    00288
    00289   inline float
    00290   ldexp(float __x, int __exp)
    00291   { return __builtin_ldexpf(__x, __exp); }
    00292
    00293   inline long double
    00294   ldexp(long double __x, int __exp)
    00295   { return __builtin_ldexpl(__x, __exp); }
    00296
    00297   template<typename _Tp>
    00298     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00299                        double>::__type
    00300   ldexp(_Tp __x, int __exp)
    00301   { return __builtin_ldexp(__x, __exp); }
    00302
    00303   using ::log;
    00304
    00305   inline float
    00306   log(float __x)
    00307   { return __builtin_logf(__x); }
    00308
    00309   inline long double
    00310   log(long double __x)
    00311   { return __builtin_logl(__x); }
    00312
    00313   template<typename _Tp>
    00314     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00315                        double>::__type
    00316     log(_Tp __x)
    00317     { return __builtin_log(__x); }
    00318
    00319   using ::log10;
    00320
    00321   inline float
    00322   log10(float __x)
    00323   { return __builtin_log10f(__x); }
    00324
    00325   inline long double
    00326   log10(long double __x)
    00327   { return __builtin_log10l(__x); }
    00328
    00329   template<typename _Tp>
    00330     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00331                        double>::__type
    00332     log10(_Tp __x)
    00333     { return __builtin_log10(__x); }
    00334
    00335   using ::modf;
    00336
    00337   inline float
    00338   modf(float __x, float* __iptr)
    00339   { return __builtin_modff(__x, __iptr); }
    00340
    00341   inline long double
    00342   modf(long double __x, long double* __iptr)
    00343   { return __builtin_modfl(__x, __iptr); }
    00344
    00345   template<typename _Tp>
    00346     inline _Tp
    00347     __pow_helper(_Tp __x, int __n)
    00348     {
    00349       return __n < 0
    00350         ? _Tp(1)/__cmath_power(__x, -__n)
    00351         : __cmath_power(__x, __n);
    00352     }
    00353
    00354   using ::pow;
    00355
    00356   inline float
    00357   pow(float __x, float __y)
    00358   { return __builtin_powf(__x, __y); }
    00359
    00360   inline long double
    00361   pow(long double __x, long double __y)
    00362   { return __builtin_powl(__x, __y); }
    00363
    00364   inline double
    00365   pow(double __x, int __i)
    00366   { return __builtin_powi(__x, __i); }
    00367
    00368   inline float
    00369   pow(float __x, int __n)
    00370   { return __builtin_powif(__x, __n); }
    00371
    00372   inline long double
    00373   pow(long double __x, int __n)
    00374   { return __builtin_powil(__x, __n); }
    00375
    00376   using ::sin;
    00377
    00378   inline float
    00379   sin(float __x)
    00380   { return __builtin_sinf(__x); }
    00381
    00382   inline long double
    00383   sin(long double __x)
    00384   { return __builtin_sinl(__x); }
    00385
    00386   template<typename _Tp>
    00387     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00388                        double>::__type
    00389     sin(_Tp __x)
    00390     { return __builtin_sin(__x); }
    00391
    00392   using ::sinh;
    00393
    00394   inline float
    00395   sinh(float __x)
    00396   { return __builtin_sinhf(__x); }
    00397
    00398   inline long double
    00399   sinh(long double __x)
    00400   { return __builtin_sinhl(__x); }
    00401
    00402   template<typename _Tp>
    00403     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00404                        double>::__type
    00405     sinh(_Tp __x)
    00406     { return __builtin_sinh(__x); }
    00407
    00408   using ::sqrt;
    00409
    00410   inline float
    00411   sqrt(float __x)
    00412   { return __builtin_sqrtf(__x); }
    00413
    00414   inline long double
    00415   sqrt(long double __x)
    00416   { return __builtin_sqrtl(__x); }
    00417
    00418   template<typename _Tp>
    00419     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00420                        double>::__type
    00421     sqrt(_Tp __x)
    00422     { return __builtin_sqrt(__x); }
    00423
    00424   using ::tan;
    00425
    00426   inline float
    00427   tan(float __x)
    00428   { return __builtin_tanf(__x); }
    00429
    00430   inline long double
    00431   tan(long double __x)
    00432   { return __builtin_tanl(__x); }
    00433
    00434   template<typename _Tp>
    00435     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00436                        double>::__type
    00437     tan(_Tp __x)
    00438     { return __builtin_tan(__x); }
    00439
    00440   using ::tanh;
    00441
    00442   inline float
    00443   tanh(float __x)
    00444   { return __builtin_tanhf(__x); }
    00445
    00446   inline long double
    00447   tanh(long double __x)
    00448   { return __builtin_tanhl(__x); }
    00449
    00450   template<typename _Tp>
    00451     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
    00452                        double>::__type
    00453     tanh(_Tp __x)
    00454     { return __builtin_tanh(__x); }
    00455
    00456 _GLIBCXX_END_NAMESPACE
    00457
    00458 #if _GLIBCXX_USE_C99_MATH
    00459 #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
    00460 // These are possible macros imported from C99-land. For strict
    00461 // conformance, remove possible C99-injected names from the global
    00462 // namespace, and sequester them in the __gnu_cxx extension namespace.
    00463
    00464 _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
    00465
    00466   template<typename _Tp>
    00467     inline int
    00468     __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
    00469
    00470   template<typename _Tp>
    00471     inline int
    00472     __capture_isfinite(_Tp __f) { return isfinite(__f); }
    00473
    00474   template<typename _Tp>
    00475     inline int
    00476     __capture_isinf(_Tp __f) { return isinf(__f); }
    00477
    00478   template<typename _Tp>
    00479     inline int
    00480     __capture_isnan(_Tp __f) { return isnan(__f); }
    00481
    00482   template<typename _Tp>
    00483     inline int
    00484     __capture_isnormal(_Tp __f) { return isnormal(__f); }
    00485
    00486   template<typename _Tp>
    00487     inline int
    00488     __capture_signbit(_Tp __f) { return signbit(__f); }
    00489
    00490   template<typename _Tp>
    00491     inline int
    00492     __capture_isgreater(_Tp __f1, _Tp __f2)
    00493     { return isgreater(__f1, __f2); }
    00494
    00495   template<typename _Tp>
    00496     inline int
    00497     __capture_isgreaterequal(_Tp __f1, _Tp __f2)
    00498     { return isgreaterequal(__f1, __f2); }
    00499
    00500   template<typename _Tp>
    00501     inline int
    00502     __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
    00503
    00504   template<typename _Tp>
    00505     inline int
    00506     __capture_islessequal(_Tp __f1, _Tp __f2)
    00507     { return islessequal(__f1, __f2); }
    00508
    00509   template<typename _Tp>
    00510     inline int
    00511     __capture_islessgreater(_Tp __f1, _Tp __f2)
    00512     { return islessgreater(__f1, __f2); }
    00513
    00514   template<typename _Tp>
    00515     inline int
    00516     __capture_isunordered(_Tp __f1, _Tp __f2)
    00517     { return isunordered(__f1, __f2); }
    00518
    00519 _GLIBCXX_END_NAMESPACE
    00520
    00521 // Only undefine the C99 FP macros, if actually captured for namespace movement
    00522 #undef fpclassify
    00523 #undef isfinite
    00524 #undef isinf
    00525 #undef isnan
    00526 #undef isnormal
    00527 #undef signbit
    00528 #undef isgreater
    00529 #undef isgreaterequal
    00530 #undef isless
    00531 #undef islessequal
    00532 #undef islessgreater
    00533 #undef isunordered
    00534
    00535 _GLIBCXX_BEGIN_NAMESPACE(std)
    00536
    00537   template<typename _Tp>
    00538     inline int
    00539     fpclassify(_Tp __f) { return ::__gnu_cxx::__capture_fpclassify(__f); }
    00540
    00541   template<typename _Tp>
    00542     inline int
    00543     isfinite(_Tp __f) { return ::__gnu_cxx::__capture_isfinite(__f); }
    00544
    00545   template<typename _Tp>
    00546     inline int
    00547     isinf(_Tp __f) { return ::__gnu_cxx::__capture_isinf(__f); }
    00548
    00549   template<typename _Tp>
    00550     inline int
    00551     isnan(_Tp __f) { return ::__gnu_cxx::__capture_isnan(__f); }
    00552
    00553   template<typename _Tp>
    00554     inline int
    00555     isnormal(_Tp __f) { return ::__gnu_cxx::__capture_isnormal(__f); }
    00556
    00557   template<typename _Tp>
    00558     inline int
    00559     signbit(_Tp __f) { return ::__gnu_cxx::__capture_signbit(__f); }
    00560
    00561   template<typename _Tp>
    00562     inline int
    00563     isgreater(_Tp __f1, _Tp __f2)
    00564     { return ::__gnu_cxx::__capture_isgreater(__f1, __f2); }
    00565
    00566   template<typename _Tp>
    00567     inline int
    00568     isgreaterequal(_Tp __f1, _Tp __f2)
    00569     { return ::__gnu_cxx::__capture_isgreaterequal(__f1, __f2); }
    00570
    00571   template<typename _Tp>
    00572     inline int
    00573     isless(_Tp __f1, _Tp __f2)
    00574     { return ::__gnu_cxx::__capture_isless(__f1, __f2); }
    00575
    00576   template<typename _Tp>
    00577     inline int
    00578     islessequal(_Tp __f1, _Tp __f2)
    00579     { return ::__gnu_cxx::__capture_islessequal(__f1, __f2); }
    00580
    00581   template<typename _Tp>
    00582     inline int
    00583     islessgreater(_Tp __f1, _Tp __f2)
    00584     { return ::__gnu_cxx::__capture_islessgreater(__f1, __f2); }
    00585
    00586   template<typename _Tp>
    00587     inline int
    00588     isunordered(_Tp __f1, _Tp __f2)
    00589     { return ::__gnu_cxx::__capture_isunordered(__f1, __f2); }
    00590
    00591 _GLIBCXX_END_NAMESPACE
    00592
    00593 #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
    00594 #endif
    00595
    00596 #ifndef _GLIBCXX_EXPORT_TEMPLATE
    00597 # include <bits/cmath.tcc>
    00598 #endif
    00599
    00600 #endif