Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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