API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 24th, 2017
253
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 15.81 KB | None | 0 0
raw download clone embed print report
  1. // -*- C++ -*- C forwarding header.
  2.  
  3. // Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
  4. // 2006, 2007, 2008, 2009
  5. // Free Software Foundation, Inc.
  6. //
  7. // This file is part of the GNU ISO C++ Library.  This library is free
  8. // software; you can redistribute it and/or modify it under the
  9. // terms of the GNU General Public License as published by the
  10. // Free Software Foundation; either version 3, or (at your option)
  11. // any later version.
  12.  
  13. // This library is distributed in the hope that it will be useful,
  14. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. // GNU General Public License for more details.
  17.  
  18. // Under Section 7 of GPL version 3, you are granted additional
  19. // permissions described in the GCC Runtime Library Exception, version
  20. // 3.1, as published by the Free Software Foundation.
  21.  
  22. // You should have received a copy of the GNU General Public License and
  23. // a copy of the GCC Runtime Library Exception along with this program;
  24. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  25. // <http://www.gnu.org/licenses/>.
  26.  
  27. /** @file include/cmath
  28.  *  This is a Standard C++ Library file.  You should @c #include this file
  29.  *  in your programs, rather than any of the "*.h" implementation files.
  30.  *
  31.  *  This is the C++ version of the Standard C Library header @c math.h,
  32.  *  and its contents are (mostly) the same as that header, but are all
  33.  *  contained in the namespace @c std (except for names which are defined
  34.  *  as macros in C).
  35.  */
  36.  
  37. //
  38. // ISO C++ 14882: 26.5  C library
  39. //
  40.  
  41. #pragma GCC system_header
  42.  
  43. #include <bits/c++config.h>
  44. #include <bits/cpp_type_traits.h>
  45. #include <ext/type_traits.h>
  46. #include <math.h>
  47.  
  48. #ifndef _GLIBCXX_CMATH
  49. #define _GLIBCXX_CMATH 1
  50.  
  51. // Get rid of those macros defined in <math.h> in lieu of real functions.
  52. #undef abs
  53. #undef div
  54. #undef acos
  55. #undef asin
  56. #undef atan
  57. #undef atan2
  58. #undef ceil
  59. #undef cos
  60. #undef cosh
  61. #undef exp
  62. #undef fabs
  63. #undef floor
  64. #undef fmod
  65. #undef frexp
  66. #undef ldexp
  67. #undef log
  68. #undef log10
  69. #undef modf
  70. #undef pow
  71. #undef sin
  72. #undef sinh
  73. #undef sqrt
  74. #undef tan
  75. #undef tanh
  76.  
  77. _GLIBCXX_BEGIN_NAMESPACE(std)
  78.  
  79.   // Forward declaration of a helper function.  This really should be
  80.   // an `exported' forward declaration.
  81.   template<typename _Tp>
  82.     _Tp __cmath_power(_Tp, unsigned int);
  83.  
  84.   template<typename _Tp>
  85.     inline _Tp
  86.     __pow_helper(_Tp __x, int __n)
  87.     {
  88.       return __n < 0
  89.         ? _Tp(1)/__cmath_power(__x, -__n)
  90.         : __cmath_power(__x, __n);
  91.     }
  92.  
  93.   inline double
  94.   abs(double __x)
  95.   { return __builtin_fabs(__x); }
  96.  
  97.   inline float
  98.   abs(float __x)
  99.   { return __builtin_fabsf(__x); }
  100.  
  101.   inline long double
  102.   abs(long double __x)
  103.   { return __builtin_fabsl(__x); }
  104.  
  105.   using ::acos;
  106.  
  107.   inline float
  108.   acos(float __x)
  109.   { return __builtin_acosf(__x); }
  110.  
  111.   inline long double
  112.   acos(long double __x)
  113.   { return __builtin_acosl(__x); }
  114.  
  115.   template<typename _Tp>
  116.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  117.                        double>::__type
  118.     acos(_Tp __x)
  119.     { return __builtin_acos(__x); }
  120.  
  121.   using ::asin;
  122.  
  123.   inline float
  124.   asin(float __x)
  125.   { return __builtin_asinf(__x); }
  126.  
  127.   inline long double
  128.   asin(long double __x)
  129.   { return __builtin_asinl(__x); }
  130.  
  131.   template<typename _Tp>
  132.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  133.                        double>::__type
  134.     asin(_Tp __x)
  135.     { return __builtin_asin(__x); }
  136.  
  137.   using ::atan;
  138.  
  139.   inline float
  140.   atan(float __x)
  141.   { return __builtin_atanf(__x); }
  142.  
  143.   inline long double
  144.   atan(long double __x)
  145.   { return __builtin_atanl(__x); }
  146.  
  147.   template<typename _Tp>
  148.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  149.                        double>::__type
  150.     atan(_Tp __x)
  151.     { return __builtin_atan(__x); }
  152.  
  153.   using ::atan2;
  154.  
  155.   inline float
  156.   atan2(float __y, float __x)
  157.   { return __builtin_atan2f(__y, __x); }
  158.  
  159.   inline long double
  160.   atan2(long double __y, long double __x)
  161.   { return __builtin_atan2l(__y, __x); }
  162.  
  163.   template<typename _Tp, typename _Up>
  164.     inline
  165.     typename __gnu_cxx::__promote_2<
  166.     typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
  167.                     && __is_arithmetic<_Up>::__value,
  168.                     _Tp>::__type, _Up>::__type
  169.     atan2(_Tp __y, _Up __x)
  170.     {
  171.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  172.       return atan2(__type(__y), __type(__x));
  173.     }
  174.  
  175.   using ::ceil;
  176.  
  177.   inline float
  178.   ceil(float __x)
  179.   { return __builtin_ceilf(__x); }
  180.  
  181.   inline long double
  182.   ceil(long double __x)
  183.   { return __builtin_ceill(__x); }
  184.  
  185.   template<typename _Tp>
  186.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  187.                        double>::__type
  188.     ceil(_Tp __x)
  189.     { return __builtin_ceil(__x); }
  190.  
  191.   using ::cos;
  192.  
  193.   inline float
  194.   cos(float __x)
  195.   { return __builtin_cosf(__x); }
  196.  
  197.   inline long double
  198.   cos(long double __x)
  199.   { return __builtin_cosl(__x); }
  200.  
  201.   template<typename _Tp>
  202.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  203.                        double>::__type
  204.     cos(_Tp __x)
  205.     { return __builtin_cos(__x); }
  206.  
  207.   using ::cosh;
  208.  
  209.   inline float
  210.   cosh(float __x)
  211.   { return __builtin_coshf(__x); }
  212.  
  213.   inline long double
  214.   cosh(long double __x)
  215.   { return __builtin_coshl(__x); }
  216.  
  217.   template<typename _Tp>
  218.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  219.                        double>::__type
  220.     cosh(_Tp __x)
  221.     { return __builtin_cosh(__x); }
  222.  
  223.   using ::exp;
  224.  
  225.   inline float
  226.   exp(float __x)
  227.   { return __builtin_expf(__x); }
  228.  
  229.   inline long double
  230.   exp(long double __x)
  231.   { return __builtin_expl(__x); }
  232.  
  233.   template<typename _Tp>
  234.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  235.                        double>::__type
  236.     exp(_Tp __x)
  237.     { return __builtin_exp(__x); }
  238.  
  239.   using ::fabs;
  240.  
  241.   inline float
  242.   fabs(float __x)
  243.   { return __builtin_fabsf(__x); }
  244.  
  245.   inline long double
  246.   fabs(long double __x)
  247.   { return __builtin_fabsl(__x); }
  248.  
  249.   template<typename _Tp>
  250.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  251.                        double>::__type
  252.     fabs(_Tp __x)
  253.     { return __builtin_fabs(__x); }
  254.  
  255.   using ::floor;
  256.  
  257.   inline float
  258.   floor(float __x)
  259.   { return __builtin_floorf(__x); }
  260.  
  261.   inline long double
  262.   floor(long double __x)
  263.   { return __builtin_floorl(__x); }
  264.  
  265.   template<typename _Tp>
  266.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  267.                        double>::__type
  268.     floor(_Tp __x)
  269.     { return __builtin_floor(__x); }
  270.  
  271.   using ::fmod;
  272.  
  273.   inline float
  274.   fmod(float __x, float __y)
  275.   { return __builtin_fmodf(__x, __y); }
  276.  
  277.   inline long double
  278.   fmod(long double __x, long double __y)
  279.   { return __builtin_fmodl(__x, __y); }
  280.  
  281.   using ::frexp;
  282.  
  283.   inline float
  284.   frexp(float __x, int* __exp)
  285.   { return __builtin_frexpf(__x, __exp); }
  286.  
  287.   inline long double
  288.   frexp(long double __x, int* __exp)
  289.   { return __builtin_frexpl(__x, __exp); }
  290.  
  291.   template<typename _Tp>
  292.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  293.                        double>::__type
  294.     frexp(_Tp __x, int* __exp)
  295.     { return __builtin_frexp(__x, __exp); }
  296.  
  297.   using ::ldexp;
  298.  
  299.   inline float
  300.   ldexp(float __x, int __exp)
  301.   { return __builtin_ldexpf(__x, __exp); }
  302.  
  303.   inline long double
  304.   ldexp(long double __x, int __exp)
  305.   { return __builtin_ldexpl(__x, __exp); }
  306.  
  307.   template<typename _Tp>
  308.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  309.                        double>::__type
  310.   ldexp(_Tp __x, int __exp)
  311.   { return __builtin_ldexp(__x, __exp); }
  312.  
  313.   using ::log;
  314.  
  315.   inline float
  316.   log(float __x)
  317.   { return __builtin_logf(__x); }
  318.  
  319.   inline long double
  320.   log(long double __x)
  321.   { return __builtin_logl(__x); }
  322.  
  323.   template<typename _Tp>
  324.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  325.                        double>::__type
  326.     log(_Tp __x)
  327.     { return __builtin_log(__x); }
  328.  
  329.   using ::log10;
  330.  
  331.   inline float
  332.   log10(float __x)
  333.   { return __builtin_log10f(__x); }
  334.  
  335.   inline long double
  336.   log10(long double __x)
  337.   { return __builtin_log10l(__x); }
  338.  
  339.   template<typename _Tp>
  340.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  341.                        double>::__type
  342.     log10(_Tp __x)
  343.     { return __builtin_log10(__x); }
  344.  
  345.   using ::modf;
  346.  
  347.   inline float
  348.   modf(float __x, float* __iptr)
  349.   { return __builtin_modff(__x, __iptr); }
  350.  
  351.   inline long double
  352.   modf(long double __x, long double* __iptr)
  353.   { return __builtin_modfl(__x, __iptr); }
  354.  
  355.   using ::pow;
  356.  
  357.   inline float
  358.   pow(float __x, float __y)
  359.   { return __builtin_powf(__x, __y); }
  360.  
  361.   inline long double
  362.   pow(long double __x, long double __y)
  363.   { return __builtin_powl(__x, __y); }
  364.  
  365. #ifndef __GXX_EXPERIMENTAL_CXX0X__
  366.   // _GLIBCXX_RESOLVE_LIB_DEFECTS
  367.   // DR 550. What should the return type of pow(float,int) be?
  368.   inline double
  369.   pow(double __x, int __i)
  370.   { return __builtin_powi(__x, __i); }
  371.  
  372.   inline float
  373.   pow(float __x, int __n)
  374.   { return __builtin_powif(__x, __n); }
  375.  
  376.   inline long double
  377.   pow(long double __x, int __n)
  378.   { return __builtin_powil(__x, __n); }
  379. #endif
  380.  
  381.   template<typename _Tp, typename _Up>
  382.     inline
  383.     typename __gnu_cxx::__promote_2<
  384.     typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value
  385.                     && __is_arithmetic<_Up>::__value,
  386.                     _Tp>::__type, _Up>::__type
  387.     pow(_Tp __x, _Up __y)
  388.     {
  389.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  390.       return pow(__type(__x), __type(__y));
  391.     }
  392.  
  393.   using ::sin;
  394.  
  395.   inline float
  396.   sin(float __x)
  397.   { return __builtin_sinf(__x); }
  398.  
  399.   inline long double
  400.   sin(long double __x)
  401.   { return __builtin_sinl(__x); }
  402.  
  403.   template<typename _Tp>
  404.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  405.                        double>::__type
  406.     sin(_Tp __x)
  407.     { return __builtin_sin(__x); }
  408.  
  409.   using ::sinh;
  410.  
  411.   inline float
  412.   sinh(float __x)
  413.   { return __builtin_sinhf(__x); }
  414.  
  415.   inline long double
  416.   sinh(long double __x)
  417.   { return __builtin_sinhl(__x); }
  418.  
  419.   template<typename _Tp>
  420.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  421.                        double>::__type
  422.     sinh(_Tp __x)
  423.     { return __builtin_sinh(__x); }
  424.  
  425.   using ::sqrt;
  426.  
  427.   inline float
  428.   sqrt(float __x)
  429.   { return __builtin_sqrtf(__x); }
  430.  
  431.   inline long double
  432.   sqrt(long double __x)
  433.   { return __builtin_sqrtl(__x); }
  434.  
  435.   template<typename _Tp>
  436.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  437.                        double>::__type
  438.     sqrt(_Tp __x)
  439.     { return __builtin_sqrt(__x); }
  440.  
  441.   using ::tan;
  442.  
  443.   inline float
  444.   tan(float __x)
  445.   { return __builtin_tanf(__x); }
  446.  
  447.   inline long double
  448.   tan(long double __x)
  449.   { return __builtin_tanl(__x); }
  450.  
  451.   template<typename _Tp>
  452.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  453.                        double>::__type
  454.     tan(_Tp __x)
  455.     { return __builtin_tan(__x); }
  456.  
  457.   using ::tanh;
  458.  
  459.   inline float
  460.   tanh(float __x)
  461.   { return __builtin_tanhf(__x); }
  462.  
  463.   inline long double
  464.   tanh(long double __x)
  465.   { return __builtin_tanhl(__x); }
  466.  
  467.   template<typename _Tp>
  468.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  469.                        double>::__type
  470.     tanh(_Tp __x)
  471.     { return __builtin_tanh(__x); }
  472.  
  473. _GLIBCXX_END_NAMESPACE
  474.  
  475. #if _GLIBCXX_USE_C99_MATH
  476. #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
  477.  
  478. // These are possible macros imported from C99-land.
  479. #undef fpclassify
  480. #undef isfinite
  481. #undef isinf
  482. #undef isnan
  483. #undef isnormal
  484. #undef signbit
  485. #undef isgreater
  486. #undef isgreaterequal
  487. #undef isless
  488. #undef islessequal
  489. #undef islessgreater
  490. #undef isunordered
  491.  
  492. _GLIBCXX_BEGIN_NAMESPACE(std)
  493.  
  494.   template<typename _Tp>
  495.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  496.                        int>::__type
  497.     fpclassify(_Tp __f)
  498.     {
  499.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  500.       return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
  501.                   FP_SUBNORMAL, FP_ZERO, __type(__f));
  502.     }
  503.  
  504.   template<typename _Tp>
  505.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  506.                        int>::__type
  507.     isfinite(_Tp __f)
  508.     {
  509.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  510.       return __builtin_isfinite(__type(__f));
  511.     }
  512.  
  513.   template<typename _Tp>
  514.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  515.                        int>::__type
  516.     isinf(_Tp __f)
  517.     {
  518.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  519.       return __builtin_isinf(__type(__f));
  520.     }
  521.  
  522.   template<typename _Tp>
  523.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  524.                        int>::__type
  525.     isnan(_Tp __f)
  526.     {
  527.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  528.       return __builtin_isnan(__type(__f));
  529.     }
  530.  
  531.   template<typename _Tp>
  532.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  533.                        int>::__type
  534.     isnormal(_Tp __f)
  535.     {
  536.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  537.       return __builtin_isnormal(__type(__f));
  538.     }
  539.  
  540.   template<typename _Tp>
  541.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  542.                        int>::__type
  543.     signbit(_Tp __f)
  544.     {
  545.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  546.       return __builtin_signbit(__type(__f));
  547.     }
  548.  
  549.   template<typename _Tp>
  550.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  551.                        int>::__type
  552.     isgreater(_Tp __f1, _Tp __f2)
  553.     {
  554.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  555.       return __builtin_isgreater(__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.     isgreaterequal(_Tp __f1, _Tp __f2)
  562.     {
  563.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  564.       return __builtin_isgreaterequal(__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.     isless(_Tp __f1, _Tp __f2)
  571.     {
  572.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  573.       return __builtin_isless(__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.     islessequal(_Tp __f1, _Tp __f2)
  580.     {
  581.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  582.       return __builtin_islessequal(__type(__f1), __type(__f2));
  583.     }
  584.  
  585.   template<typename _Tp>
  586.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  587.                        int>::__type
  588.     islessgreater(_Tp __f1, _Tp __f2)
  589.     {
  590.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  591.       return __builtin_islessgreater(__type(__f1), __type(__f2));
  592.     }
  593.  
  594.   template<typename _Tp>
  595.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  596.                        int>::__type
  597.     isunordered(_Tp __f1, _Tp __f2)
  598.     {
  599.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  600.       return __builtin_isunordered(__type(__f1), __type(__f2));
  601.     }
  602.  
  603. _GLIBCXX_END_NAMESPACE
  604.  
  605. #endif /* _GLIBCXX_USE_C99_FP_MACROS_DYNAMIC */
  606. #endif
  607.  
  608. #ifndef _GLIBCXX_EXPORT_TEMPLATE
  609. # include <bits/cmath.tcc>
  610. #endif
  611.  
  612. #ifdef __GXX_EXPERIMENTAL_CXX0X__
  613. #  if defined(_GLIBCXX_INCLUDE_AS_TR1)
  614. #    error C++0x header cannot be included from TR1 header
  615. #  endif
  616. #  if defined(_GLIBCXX_INCLUDE_AS_CXX0X)
  617. #    include <tr1_impl/cmath>
  618. #  else
  619. #    define _GLIBCXX_INCLUDE_AS_CXX0X
  620. #    define _GLIBCXX_BEGIN_NAMESPACE_TR1
  621. #    define _GLIBCXX_END_NAMESPACE_TR1
  622. #    define _GLIBCXX_TR1
  623. #    include <tr1_impl/cmath>
  624. #    undef _GLIBCXX_TR1
  625. #    undef _GLIBCXX_END_NAMESPACE_TR1
  626. #    undef _GLIBCXX_BEGIN_NAMESPACE_TR1
  627. #    undef _GLIBCXX_INCLUDE_AS_CXX0X
  628. #  endif
  629. #endif
  630.  
  631. #endif
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!