home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / cwin / c.exe / $INSTDIR / include / c++ / cmath < prev    next >
Encoding:
Text File  |  2003-12-15  |  14.9 KB  |  658 lines
  1. // -*- C++ -*- C forwarding header.
  2.  
  3. // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
  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, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  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.
  42.  */
  43.  
  44. #ifndef _CPP_CMATH
  45. #define _CPP_CMATH 1
  46.  
  47. #pragma GCC system_header
  48.  
  49. #include <bits/c++config.h>
  50.  
  51. #include <math.h>
  52.  
  53. // Get rid of those macros defined in <math.h> in lieu of real functions.
  54. #undef abs
  55. #undef div
  56. #undef acos
  57. #undef asin
  58. #undef atan
  59. #undef atan2
  60. #undef ceil
  61. #undef cos
  62. #undef cosh
  63. #undef exp
  64. #undef fabs
  65. #undef floor
  66. #undef fmod
  67. #undef frexp
  68. #undef ldexp
  69. #undef log
  70. #undef log10
  71. #undef modf
  72. #undef pow
  73. #undef sin
  74. #undef sinh
  75. #undef sqrt
  76. #undef tan
  77. #undef tanh
  78.  
  79. namespace std 
  80. {
  81.   // Forward declaration of a helper function.  This really should be
  82.   // an `exported' forward declaration.
  83.   template<typename _Tp> _Tp __cmath_power(_Tp, unsigned int);
  84.  
  85.   inline double
  86.   abs(double __x)
  87.   { return __builtin_fabs(__x); }
  88.  
  89.   inline float
  90.   abs(float __x)
  91.   { return __builtin_fabsf(__x); }
  92.  
  93.   inline long double
  94.   abs(long double __x)
  95.   { return __builtin_fabsl(__x); }
  96.  
  97. #if _GLIBCPP_HAVE_ACOSF
  98.   inline float 
  99.   acos(float __x) { return ::acosf(__x); }
  100. #else
  101.   inline float 
  102.   acos(float __x) { return ::acos(static_cast<double>(__x)); }
  103. #endif
  104.  
  105.   using ::acos;
  106.   
  107. #if _GLIBCPP_HAVE_ACOSL
  108.   inline long double 
  109.   acos(long double __x) { return ::acosl(__x); }
  110. #else
  111.   inline long double 
  112.   acos(long double __x) { return ::acos(static_cast<double>(__x)); }
  113. #endif
  114.  
  115.   using ::asin;
  116.  
  117. #if _GLIBCPP_HAVE_ASINF
  118.   inline float 
  119.   asin(float __x) { return ::asinf(__x); }
  120. #else
  121.   inline float 
  122.   asin(float __x) { return ::asin(static_cast<double>(__x)); }
  123. #endif
  124.  
  125. #if _GLIBCPP_HAVE_ASINL
  126.   inline long double 
  127.   asin(long double __x) { return ::asinl(__x); }
  128. #else
  129.   inline long double 
  130.   asin(long double __x) { return ::asin(static_cast<double>(__x)); }
  131. #endif
  132.  
  133.   using ::atan;
  134.  
  135. #if _GLIBCPP_HAVE_ATANF
  136.   inline float 
  137.   atan(float __x) { return ::atanf(__x); }
  138. #else
  139.   inline float 
  140.   atan(float __x) { return ::atan(static_cast<double>(__x)); }
  141. #endif
  142.  
  143. #if _GLIBCPP_HAVE_ATANL
  144.   inline long double 
  145.   atan(long double __x) { return ::atanl(__x); }
  146. #else
  147.   inline long double 
  148.   atan(long double __x) { return ::atan(static_cast<double>(__x)); }
  149. #endif
  150.  
  151.   using ::atan2;
  152.  
  153. #if _GLIBCPP_HAVE_ATAN2F
  154.   inline float 
  155.   atan2(float __y, float __x) { return ::atan2f(__y, __x); }
  156. #else
  157.   inline float 
  158.   atan2(float __y, float __x)
  159.   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
  160. #endif
  161.  
  162. #if _GLIBCPP_HAVE_ATAN2L
  163.   inline long double 
  164.   atan2(long double __y, long double __x) { return ::atan2l(__y, __x); }
  165. #else
  166.   inline long double 
  167.   atan2(long double __y, long double __x) 
  168.   { return ::atan2(static_cast<double>(__y), static_cast<double>(__x)); }
  169. #endif
  170.  
  171.   using ::ceil;
  172.  
  173. #if _GLIBCPP_HAVE_CEILF
  174.   inline float 
  175.   ceil(float __x) { return ::ceilf(__x); }
  176. #else
  177.   inline float 
  178.   ceil(float __x) { return ::ceil(static_cast<double>(__x)); }
  179. #endif
  180.  
  181. #if _GLIBCPP_HAVE_CEILL
  182.   inline long double 
  183.   ceil(long double __x) { return ::ceill(__x); }
  184. #else
  185.   inline long double 
  186.   ceil(long double __x) { return ::ceil(static_cast<double>(__x)); }
  187. #endif
  188.  
  189.   using ::cos;
  190.  
  191.   inline float
  192.   cos(float __x)
  193.   { return __builtin_cosf(__x); }
  194.  
  195.   inline long double
  196.   cos(long double __x)
  197.   { return __builtin_cosl(__x); }
  198.  
  199.   using ::cosh;
  200.  
  201. #if _GLIBCPP_HAVE_COSHF
  202.   inline float 
  203.   cosh(float __x) { return ::coshf(__x); }
  204. #else
  205.   inline float 
  206.   cosh(float __x) { return ::cosh(static_cast<double>(__x)); }
  207. #endif
  208.  
  209. #if _GLIBCPP_HAVE_COSHL
  210.   inline long double 
  211.   cosh(long double __x) { return ::coshl(__x); }
  212. #else
  213.   inline long double 
  214.   cosh(long double __x) { return ::cosh(static_cast<double>(__x)); }
  215. #endif
  216.  
  217.   using ::exp;
  218.  
  219. #if _GLIBCPP_HAVE_EXPF
  220.   inline float 
  221.   exp(float __x) { return ::expf(__x); }
  222. #else
  223.   inline float 
  224.   exp(float __x) { return ::exp(static_cast<double>(__x)); }
  225. #endif
  226.  
  227. #if _GLIBCPP_HAVE_EXPL
  228.   inline long double 
  229.   exp(long double __x) { return ::expl(__x); }
  230. #else
  231.   inline long double 
  232.   exp(long double __x) { return ::exp(static_cast<double>(__x)); }
  233. #endif
  234.  
  235.   using ::fabs;
  236.  
  237.   inline float
  238.   fabs(float __x)
  239.   { return __builtin_fabsf(__x); }
  240.  
  241.   inline long double
  242.   fabs(long double __x)
  243.   { return __builtin_fabsl(__x); }
  244.  
  245.   using ::floor;
  246.  
  247. #if _GLIBCPP_HAVE_FLOORF
  248.   inline float 
  249.   floor(float __x) { return ::floorf(__x); }
  250. #else
  251.   inline float 
  252.   floor(float __x) { return ::floor(static_cast<double>(__x)); }
  253. #endif
  254.  
  255. #if _GLIBCPP_HAVE_FLOORL
  256.   inline long double 
  257.   floor(long double __x) { return ::floorl(__x); }
  258. #else
  259.   inline long double 
  260.   floor(long double __x) { return ::floor(static_cast<double>(__x)); }
  261. #endif
  262.  
  263.   using ::fmod;
  264.  
  265. #if _GLIBCPP_HAVE_FMODF
  266.   inline float 
  267.   fmod(float __x, float __y) { return ::fmodf(__x, __y); }
  268. #else
  269.   inline float 
  270.   fmod(float __x, float __y)
  271.   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
  272. #endif
  273.  
  274. #if _GLIBCPP_HAVE_FMODL
  275.   inline long double 
  276.   fmod(long double __x, long double __y) { return ::fmodl(__x, __y); }
  277. #else
  278.   inline long double 
  279.   fmod(long double __x, long double __y) 
  280.   { return ::fmod(static_cast<double>(__x), static_cast<double>(__y)); }
  281. #endif
  282.  
  283.   using ::frexp;
  284.  
  285. #if _GLIBCPP_HAVE_FREXPF
  286.   inline float 
  287.   frexp(float __x, int* __exp) { return ::frexpf(__x, __exp); }
  288. #else
  289.   inline float 
  290.   frexp(float __x, int* __exp) { return ::frexp(__x, __exp); }
  291. #endif
  292.  
  293. #if _GLIBCPP_HAVE_FREXPL
  294.   inline long double 
  295.   frexp(long double __x, int* __exp) { return ::frexpl(__x, __exp); }
  296. #else
  297.   inline long double 
  298.   frexp(long double __x, int* __exp) 
  299.   { return ::frexp(static_cast<double>(__x), __exp); }
  300. #endif
  301.  
  302.   using ::ldexp;
  303.  
  304. #if _GLIBCPP_HAVE_LDEXPF
  305.   inline float 
  306.   ldexp(float __x, int __exp) { return ::ldexpf(__x, __exp); }
  307. #else
  308.   inline float 
  309.   ldexp(float __x, int __exp)
  310.   { return ::ldexp(static_cast<double>(__x), __exp); }
  311. #endif
  312.  
  313. #if _GLIBCPP_HAVE_LDEXPL
  314.   inline long double 
  315.   ldexp(long double __x, int __exp) { return ::ldexpl(__x, __exp); }
  316. #else
  317.   inline long double 
  318.   ldexp(long double __x, int __exp) 
  319.   { return ::ldexp(static_cast<double>(__x), __exp); }
  320. #endif
  321.  
  322.   using ::log;
  323.  
  324. #if _GLIBCPP_HAVE_LOGF
  325.   inline float 
  326.   log(float __x) { return ::logf(__x); }
  327. #else
  328.   inline float log(float __x)
  329.   { return ::log(static_cast<double>(__x)); }
  330. #endif
  331.  
  332. #if _GLIBCPP_HAVE_LOGL
  333.   inline long double 
  334.   log(long double __x) { return ::logl(__x); }
  335. #else
  336.   inline long double 
  337.   log(long double __x) { return ::log(static_cast<double>(__x)); }
  338. #endif
  339.  
  340.   using ::log10;
  341.  
  342. #if _GLIBCPP_HAVE_LOG10F
  343.   inline float 
  344.   log10(float __x) { return ::log10f(__x); }
  345. #else
  346.   inline float 
  347.   log10(float __x) { return ::log10(static_cast<double>(__x)); }
  348. #endif
  349.  
  350. #if _GLIBCPP_HAVE_LOG10L
  351.   inline long double 
  352.   log10(long double __x) { return ::log10l(__x); }
  353. #else
  354.   inline long double 
  355.   log10(long double __x) { return ::log10(static_cast<double>(__x)); }
  356. #endif
  357.  
  358.   using ::modf;
  359.  
  360. #if _GLIBCPP_HAVE_MODFF
  361.   inline float 
  362.   modf(float __x, float* __iptr) { return ::modff(__x, __iptr); }
  363. #else
  364.   inline float 
  365.   modf(float __x, float* __iptr)
  366.   {
  367.     double __tmp;
  368.     double __res = ::modf(static_cast<double>(__x), &__tmp);
  369.     *__iptr = static_cast<float>(__tmp);
  370.     return __res;
  371.   }
  372. #endif
  373.  
  374. #if _GLIBCPP_HAVE_MODFL
  375.   inline long double 
  376.   modf(long double __x, long double* __iptr) { return ::modfl(__x, __iptr); }
  377. #else
  378.   inline long double 
  379.   modf(long double __x, long double* __iptr) 
  380.   { 
  381.     double __tmp;
  382.     double __res = ::modf(static_cast<double>(__x), &__tmp);
  383.     * __iptr = static_cast<long double>(__tmp);
  384.     return __res;
  385.   }
  386. #endif
  387.  
  388.   template<typename _Tp>
  389.     inline _Tp
  390.     __pow_helper(_Tp __x, int __n)
  391.     {
  392.       return __n < 0
  393.         ? _Tp(1)/__cmath_power(__x, -__n)
  394.         : __cmath_power(__x, __n);
  395.     }
  396.  
  397.   using ::pow;
  398.  
  399. #if _GLIBCPP_HAVE_POWF
  400.   inline float 
  401.   pow(float __x, float __y) { return ::powf(__x, __y); }
  402. #else
  403.   inline float 
  404.   pow(float __x, float __y)
  405.   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
  406. #endif
  407.  
  408. #if _GLIBCPP_HAVE_POWL
  409.   inline long double 
  410.   pow(long double __x, long double __y) { return ::powl(__x, __y); }
  411. #else
  412.   inline long double 
  413.   pow(long double __x, long double __y) 
  414.   { return ::pow(static_cast<double>(__x), static_cast<double>(__y)); }
  415. #endif
  416.  
  417.   inline double 
  418.   pow(double __x, int __i)
  419.   { return __pow_helper(__x, __i); }
  420.  
  421.   inline float 
  422.   pow(float __x, int __n)
  423.   { return __pow_helper(__x, __n); }
  424.  
  425.   inline long double 
  426.   pow(long double __x, int __n)
  427.   { return __pow_helper(__x, __n); }
  428.  
  429.   using ::sin;
  430.  
  431.   inline float
  432.   sin(float __x)
  433.   { return __builtin_sinf(__x); }
  434.  
  435.   inline long double
  436.   sin(long double __x)
  437.   { return __builtin_sinl(__x); }
  438.  
  439.   using ::sinh;
  440.  
  441. #if _GLIBCPP_HAVE_SINHF
  442.   inline float 
  443.   sinh(float __x) { return ::sinhf(__x); }
  444. #else
  445.   inline float 
  446.   sinh(float __x) { return ::sinh(static_cast<double>(__x)); }
  447. #endif
  448.  
  449. #if _GLIBCPP_HAVE_SINHL
  450.   inline long double 
  451.   sinh(long double __x) { return ::sinhl(__x); }
  452. #else
  453.   inline long double 
  454.   sinh(long double __x) { return ::sinh(static_cast<double>(__x)); }
  455. #endif
  456.  
  457.   using ::sqrt;
  458.  
  459.   inline float
  460.   sqrt(float __x)
  461.   { return __builtin_sqrtf(__x); }
  462.  
  463.   inline long double
  464.   sqrt(long double __x)
  465.   { return __builtin_sqrtl(__x); }
  466.  
  467.   using ::tan;
  468.  
  469. #if _GLIBCPP_HAVE_TANF
  470.   inline float 
  471.   tan(float __x) { return ::tanf(__x); }
  472. #else
  473.   inline float 
  474.   tan(float __x) { return ::tan(static_cast<double>(__x)); }
  475. #endif
  476.  
  477. #if _GLIBCPP_HAVE_TANL
  478.   inline long double 
  479.   tan(long double __x) { return ::tanl(__x); }
  480. #else
  481.   inline long double 
  482.   tan(long double __x) { return ::tan(static_cast<double>(__x)); }
  483. #endif
  484.  
  485.   using ::tanh;
  486.  
  487. #if _GLIBCPP_HAVE_TANHF
  488.   inline float 
  489.   tanh(float __x) { return ::tanhf(__x); }
  490. #else
  491.   inline float 
  492.   tanh(float __x) { return ::tanh(static_cast<double>(__x)); }
  493. #endif
  494.  
  495. #if _GLIBCPP_HAVE_TANHL
  496.   inline long double 
  497.   tanh(long double __x) { return ::tanhl(__x); }
  498. #else
  499.   inline long double 
  500.   tanh(long double __x) { return ::tanh(static_cast<double>(__x)); }
  501. #endif
  502. } 
  503.  
  504.  
  505. #if _GLIBCPP_USE_C99
  506. // These are possible macros imported from C99-land. For strict
  507. // conformance, remove possible C99-injected names from the global
  508. // namespace, and sequester them in the __gnu_cxx extension namespace. 
  509. namespace __gnu_cxx
  510. {
  511.   template<typename _Tp>
  512.     int 
  513.     __capture_fpclassify(_Tp __f) { return fpclassify(__f); }
  514.  
  515.   template<typename _Tp>
  516.     int 
  517.     __capture_isfinite(_Tp __f) { return isfinite(__f); }
  518.  
  519.   template<typename _Tp>
  520.     int 
  521.     __capture_isinf(_Tp __f) { return isinf(__f); }
  522.  
  523.   template<typename _Tp>
  524.     int 
  525.     __capture_isnan(_Tp __f) { return isnan(__f); }
  526.  
  527.   template<typename _Tp>
  528.     int 
  529.     __capture_isnormal(_Tp __f) { return isnormal(__f); }
  530.  
  531.   template<typename _Tp>
  532.     int 
  533.     __capture_signbit(_Tp __f) { return signbit(__f); }
  534.  
  535.   template<typename _Tp>
  536.     int 
  537.     __capture_isgreater(_Tp __f1, _Tp __f2)
  538.     { return isgreater(__f1, __f2); }
  539.  
  540.   template<typename _Tp>
  541.      int 
  542.      __capture_isgreaterequal(_Tp __f1, _Tp __f2) 
  543.      { return isgreaterequal(__f1, __f2); }
  544.  
  545.   template<typename _Tp>
  546.      int 
  547.      __capture_isless(_Tp __f1, _Tp __f2) { return isless(__f1, __f2); }
  548.  
  549.   template<typename _Tp>
  550.      int 
  551.      __capture_islessequal(_Tp __f1, _Tp __f2) 
  552.      { return islessequal(__f1, __f2); }
  553.  
  554.   template<typename _Tp>
  555.      int 
  556.      __capture_islessgreater(_Tp __f1, _Tp __f2) 
  557.      { return islessgreater(__f1, __f2); }
  558.  
  559.   template<typename _Tp>
  560.      int 
  561.      __capture_isunordered(_Tp __f1, _Tp __f2) 
  562.      { return isunordered(__f1, __f2); }
  563. } 
  564. #endif
  565.  
  566. #undef fpclassify
  567. #undef isfinite
  568. #undef isinf
  569. #undef isnan
  570. #undef isnormal
  571. #undef signbit
  572. #undef isgreater
  573. #undef isgreaterequal
  574. #undef isless
  575. #undef islessequal
  576. #undef islessgreater
  577. #undef isunordered
  578.  
  579. #if _GLIBCPP_USE_C99
  580. namespace __gnu_cxx
  581. {
  582.   template<typename _Tp>
  583.     int
  584.     fpclassify(_Tp __f) { return __capture_fpclassify(__f); }
  585.  
  586.   template<typename _Tp>
  587.     int
  588.     isfinite(_Tp __f) { return __capture_isfinite(__f); }
  589.  
  590.   template<typename _Tp>
  591.     int 
  592.     isinf(_Tp __f) { return __capture_isinf(__f); }
  593.  
  594.   template<typename _Tp>
  595.     int 
  596.     isnan(_Tp __f) { return __capture_isnan(__f); }
  597.  
  598.   template<typename _Tp>
  599.     int 
  600.     isnormal(_Tp __f) { return __capture_isnormal(__f); }
  601.  
  602.   template<typename _Tp>
  603.     int 
  604.     signbit(_Tp __f) { return __capture_signbit(__f); }
  605.  
  606.   template<typename _Tp>
  607.     int 
  608.     isgreater(_Tp __f1, _Tp __f2) { return __capture_isgreater(__f1, __f2); }
  609.  
  610.   template<typename _Tp>
  611.     int 
  612.     isgreaterequal(_Tp __f1, _Tp __f2) 
  613.     { return __capture_isgreaterequal(__f1, __f2); }
  614.  
  615.   template<typename _Tp>
  616.     int 
  617.     isless(_Tp __f1, _Tp __f2) { return __capture_isless(__f1, __f2); }
  618.  
  619.   template<typename _Tp>
  620.     int 
  621.     islessequal(_Tp __f1, _Tp __f2) 
  622.     { return __capture_islessequal(__f1, __f2); }
  623.  
  624.   template<typename _Tp>
  625.     int 
  626.     islessgreater(_Tp __f1, _Tp __f2) 
  627.     { return __capture_islessgreater(__f1, __f2); }
  628.  
  629.   template<typename _Tp>
  630.     int 
  631.     isunordered(_Tp __f1, _Tp __f2) 
  632.     { return __capture_isunordered(__f1, __f2); }
  633. }
  634.  
  635. namespace std
  636. {
  637.   using __gnu_cxx::fpclassify;
  638.   using __gnu_cxx::isfinite;
  639.   using __gnu_cxx::isinf;
  640.   using __gnu_cxx::isnan;
  641.   using __gnu_cxx::isnormal;
  642.   using __gnu_cxx::signbit;
  643.   using __gnu_cxx::isgreater;
  644.   using __gnu_cxx::isgreaterequal;
  645.   using __gnu_cxx::isless;
  646.   using __gnu_cxx::islessequal;
  647.   using __gnu_cxx::islessgreater;
  648.   using __gnu_cxx::isunordered;
  649. }
  650. #endif
  651.   
  652. #ifdef _GLIBCPP_NO_TEMPLATE_EXPORT
  653. #  define export
  654. #  include <bits/cmath.tcc>
  655. #endif
  656.  
  657. #endif
  658.