Subversion Repositories Kolibri OS

Rev

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

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