Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. // TR1 cmath -*- C++ -*-
  2.  
  3. // Copyright (C) 2006-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 tr1/cmath
  26.  *  This is a TR1 C++ Library header.
  27.  */
  28.  
  29. #ifndef _GLIBCXX_TR1_CMATH
  30. #define _GLIBCXX_TR1_CMATH 1
  31.  
  32. #pragma GCC system_header
  33.  
  34. #include <cmath>
  35.  
  36. #ifdef _GLIBCXX_USE_C99_MATH_TR1
  37.  
  38. #undef acosh
  39. #undef acoshf
  40. #undef acoshl
  41. #undef asinh
  42. #undef asinhf
  43. #undef asinhl
  44. #undef atanh
  45. #undef atanhf
  46. #undef atanhl
  47. #undef cbrt
  48. #undef cbrtf
  49. #undef cbrtl
  50. #undef copysign
  51. #undef copysignf
  52. #undef copysignl
  53. #undef erf
  54. #undef erff
  55. #undef erfl
  56. #undef erfc
  57. #undef erfcf
  58. #undef erfcl
  59. #undef exp2
  60. #undef exp2f
  61. #undef exp2l
  62. #undef expm1
  63. #undef expm1f
  64. #undef expm1l
  65. #undef fdim
  66. #undef fdimf
  67. #undef fdiml
  68. #undef fma
  69. #undef fmaf
  70. #undef fmal
  71. #undef fmax
  72. #undef fmaxf
  73. #undef fmaxl
  74. #undef fmin
  75. #undef fminf
  76. #undef fminl
  77. #undef hypot
  78. #undef hypotf
  79. #undef hypotl
  80. #undef ilogb
  81. #undef ilogbf
  82. #undef ilogbl
  83. #undef lgamma
  84. #undef lgammaf
  85. #undef lgammal
  86. #undef llrint
  87. #undef llrintf
  88. #undef llrintl
  89. #undef llround
  90. #undef llroundf
  91. #undef llroundl
  92. #undef log1p
  93. #undef log1pf
  94. #undef log1pl
  95. #undef log2
  96. #undef log2f
  97. #undef log2l
  98. #undef logb
  99. #undef logbf
  100. #undef logbl
  101. #undef lrint
  102. #undef lrintf
  103. #undef lrintl
  104. #undef lround
  105. #undef lroundf
  106. #undef lroundl
  107. #undef nan
  108. #undef nanf
  109. #undef nanl
  110. #undef nearbyint
  111. #undef nearbyintf
  112. #undef nearbyintl
  113. #undef nextafter
  114. #undef nextafterf
  115. #undef nextafterl
  116. #undef nexttoward
  117. #undef nexttowardf
  118. #undef nexttowardl
  119. #undef remainder
  120. #undef remainderf
  121. #undef remainderl
  122. #undef remquo
  123. #undef remquof
  124. #undef remquol
  125. #undef rint
  126. #undef rintf
  127. #undef rintl
  128. #undef round
  129. #undef roundf
  130. #undef roundl
  131. #undef scalbln
  132. #undef scalblnf
  133. #undef scalblnl
  134. #undef scalbn
  135. #undef scalbnf
  136. #undef scalbnl
  137. #undef tgamma
  138. #undef tgammaf
  139. #undef tgammal
  140. #undef trunc
  141. #undef truncf
  142. #undef truncl
  143.  
  144. #endif
  145.  
  146. namespace std _GLIBCXX_VISIBILITY(default)
  147. {
  148. namespace tr1
  149. {
  150. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  151.  
  152. #if _GLIBCXX_USE_C99_MATH_TR1
  153.  
  154.   // types
  155.   using ::double_t;
  156.   using ::float_t;
  157.  
  158.   // functions
  159.   using ::acosh;
  160.   using ::acoshf;
  161.   using ::acoshl;
  162.  
  163.   using ::asinh;
  164.   using ::asinhf;
  165.   using ::asinhl;
  166.  
  167.   using ::atanh;
  168.   using ::atanhf;
  169.   using ::atanhl;
  170.  
  171.   using ::cbrt;
  172.   using ::cbrtf;
  173.   using ::cbrtl;
  174.  
  175.   using ::copysign;
  176.   using ::copysignf;
  177.   using ::copysignl;
  178.  
  179.   using ::erf;
  180.   using ::erff;
  181.   using ::erfl;
  182.  
  183.   using ::erfc;
  184.   using ::erfcf;
  185.   using ::erfcl;
  186.  
  187.   using ::exp2;
  188.   using ::exp2f;
  189.   using ::exp2l;
  190.  
  191.   using ::expm1;
  192.   using ::expm1f;
  193.   using ::expm1l;
  194.  
  195.   using ::fdim;
  196.   using ::fdimf;
  197.   using ::fdiml;
  198.  
  199.   using ::fma;
  200.   using ::fmaf;
  201.   using ::fmal;
  202.  
  203.   using ::fmax;
  204.   using ::fmaxf;
  205.   using ::fmaxl;
  206.  
  207.   using ::fmin;
  208.   using ::fminf;
  209.   using ::fminl;
  210.  
  211.   using ::hypot;
  212.   using ::hypotf;
  213.   using ::hypotl;
  214.  
  215.   using ::ilogb;
  216.   using ::ilogbf;
  217.   using ::ilogbl;
  218.  
  219.   using ::lgamma;
  220.   using ::lgammaf;
  221.   using ::lgammal;
  222.  
  223.   using ::llrint;
  224.   using ::llrintf;
  225.   using ::llrintl;
  226.  
  227.   using ::llround;
  228.   using ::llroundf;
  229.   using ::llroundl;
  230.  
  231.   using ::log1p;
  232.   using ::log1pf;
  233.   using ::log1pl;
  234.  
  235.   using ::log2;
  236.   using ::log2f;
  237.   using ::log2l;
  238.  
  239.   using ::logb;
  240.   using ::logbf;
  241.   using ::logbl;
  242.  
  243.   using ::lrint;
  244.   using ::lrintf;
  245.   using ::lrintl;
  246.  
  247.   using ::lround;
  248.   using ::lroundf;
  249.   using ::lroundl;
  250.  
  251.   using ::nan;
  252.   using ::nanf;
  253.   using ::nanl;
  254.  
  255.   using ::nearbyint;
  256.   using ::nearbyintf;
  257.   using ::nearbyintl;
  258.  
  259.   using ::nextafter;
  260.   using ::nextafterf;
  261.   using ::nextafterl;
  262.  
  263.   using ::nexttoward;
  264.   using ::nexttowardf;
  265.   using ::nexttowardl;
  266.  
  267.   using ::remainder;
  268.   using ::remainderf;
  269.   using ::remainderl;
  270.  
  271.   using ::remquo;
  272.   using ::remquof;
  273.   using ::remquol;
  274.  
  275.   using ::rint;
  276.   using ::rintf;
  277.   using ::rintl;
  278.  
  279.   using ::round;
  280.   using ::roundf;
  281.   using ::roundl;
  282.  
  283.   using ::scalbln;
  284.   using ::scalblnf;
  285.   using ::scalblnl;
  286.  
  287.   using ::scalbn;
  288.   using ::scalbnf;
  289.   using ::scalbnl;
  290.  
  291.   using ::tgamma;
  292.   using ::tgammaf;
  293.   using ::tgammal;
  294.  
  295.   using ::trunc;
  296.   using ::truncf;
  297.   using ::truncl;
  298.  
  299. #endif
  300.  
  301. #if _GLIBCXX_USE_C99_MATH
  302. #if !_GLIBCXX_USE_C99_FP_MACROS_DYNAMIC
  303.  
  304.   /// Function template definitions [8.16.3].
  305.   template<typename _Tp>
  306.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  307.                                            int>::__type
  308.     fpclassify(_Tp __f)
  309.     {
  310.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  311.       return __builtin_fpclassify(FP_NAN, FP_INFINITE, FP_NORMAL,
  312.                                   FP_SUBNORMAL, FP_ZERO, __type(__f));
  313.     }
  314.  
  315.   template<typename _Tp>
  316.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  317.                                            int>::__type
  318.     isfinite(_Tp __f)
  319.     {
  320.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  321.       return __builtin_isfinite(__type(__f));
  322.     }
  323.  
  324.   template<typename _Tp>
  325.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  326.                                            int>::__type
  327.     isinf(_Tp __f)
  328.     {
  329.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  330.       return __builtin_isinf(__type(__f));
  331.     }
  332.  
  333.   template<typename _Tp>
  334.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  335.                                            int>::__type
  336.     isnan(_Tp __f)
  337.     {
  338.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  339.       return __builtin_isnan(__type(__f));
  340.     }
  341.  
  342.   template<typename _Tp>
  343.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  344.                                            int>::__type
  345.     isnormal(_Tp __f)
  346.     {
  347.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  348.       return __builtin_isnormal(__type(__f));
  349.     }
  350.  
  351.   template<typename _Tp>
  352.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  353.                                            int>::__type
  354.     signbit(_Tp __f)
  355.     {
  356.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  357.       return __builtin_signbit(__type(__f));
  358.     }
  359.  
  360.   template<typename _Tp>
  361.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  362.                                            int>::__type
  363.     isgreater(_Tp __f1, _Tp __f2)
  364.     {
  365.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  366.       return __builtin_isgreater(__type(__f1), __type(__f2));
  367.     }
  368.  
  369.   template<typename _Tp>
  370.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  371.                                            int>::__type
  372.     isgreaterequal(_Tp __f1, _Tp __f2)
  373.     {
  374.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  375.       return __builtin_isgreaterequal(__type(__f1), __type(__f2));
  376.     }
  377.  
  378.   template<typename _Tp>
  379.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  380.                                            int>::__type
  381.     isless(_Tp __f1, _Tp __f2)
  382.     {
  383.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  384.       return __builtin_isless(__type(__f1), __type(__f2));
  385.     }
  386.  
  387.   template<typename _Tp>
  388.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  389.                                            int>::__type
  390.     islessequal(_Tp __f1, _Tp __f2)
  391.     {
  392.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  393.       return __builtin_islessequal(__type(__f1), __type(__f2));
  394.     }
  395.  
  396.   template<typename _Tp>
  397.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  398.                                            int>::__type
  399.     islessgreater(_Tp __f1, _Tp __f2)
  400.     {
  401.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  402.       return __builtin_islessgreater(__type(__f1), __type(__f2));
  403.     }
  404.  
  405.   template<typename _Tp>
  406.     inline typename __gnu_cxx::__enable_if<__is_arithmetic<_Tp>::__value,
  407.                                            int>::__type
  408.     isunordered(_Tp __f1, _Tp __f2)
  409.     {
  410.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  411.       return __builtin_isunordered(__type(__f1), __type(__f2));
  412.     }
  413.  
  414. #endif
  415. #endif
  416.  
  417. #if _GLIBCXX_USE_C99_MATH_TR1
  418.  
  419.   /// Additional overloads [8.16.4].
  420.   using std::acos;
  421.  
  422. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  423.   inline float
  424.   acosh(float __x)
  425.   { return __builtin_acoshf(__x); }
  426.  
  427.   inline long double
  428.   acosh(long double __x)
  429.   { return __builtin_acoshl(__x); }
  430. #endif
  431.  
  432.   template<typename _Tp>
  433.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  434.                                            double>::__type
  435.     acosh(_Tp __x)
  436.     { return __builtin_acosh(__x); }
  437.  
  438.   using std::asin;
  439.  
  440. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  441.   inline float
  442.   asinh(float __x)
  443.   { return __builtin_asinhf(__x); }
  444.  
  445.   inline long double
  446.   asinh(long double __x)
  447.   { return __builtin_asinhl(__x); }
  448. #endif
  449.  
  450.   template<typename _Tp>
  451.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  452.                                            double>::__type
  453.     asinh(_Tp __x)
  454.     { return __builtin_asinh(__x); }
  455.  
  456.   using std::atan;
  457.   using std::atan2;
  458.  
  459. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  460.   inline float
  461.   atanh(float __x)
  462.   { return __builtin_atanhf(__x); }
  463.  
  464.   inline long double
  465.   atanh(long double __x)
  466.   { return __builtin_atanhl(__x); }
  467. #endif
  468.  
  469.   template<typename _Tp>
  470.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  471.                                            double>::__type
  472.     atanh(_Tp __x)
  473.     { return __builtin_atanh(__x); }
  474.  
  475. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  476.   inline float
  477.   cbrt(float __x)
  478.   { return __builtin_cbrtf(__x); }
  479.  
  480.   inline long double
  481.   cbrt(long double __x)
  482.   { return __builtin_cbrtl(__x); }
  483. #endif
  484.  
  485.   template<typename _Tp>
  486.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  487.                                            double>::__type
  488.     cbrt(_Tp __x)
  489.     { return __builtin_cbrt(__x); }
  490.  
  491.   using std::ceil;
  492.  
  493. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  494.   inline float
  495.   copysign(float __x, float __y)
  496.   { return __builtin_copysignf(__x, __y); }
  497.  
  498.   inline long double
  499.   copysign(long double __x, long double __y)
  500.   { return __builtin_copysignl(__x, __y); }
  501. #endif
  502.  
  503.   template<typename _Tp, typename _Up>
  504.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  505.     copysign(_Tp __x, _Up __y)
  506.     {
  507.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  508.       return copysign(__type(__x), __type(__y));
  509.     }
  510.  
  511.   using std::cos;
  512.   using std::cosh;  
  513.  
  514. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  515.   inline float
  516.   erf(float __x)
  517.   { return __builtin_erff(__x); }
  518.  
  519.   inline long double
  520.   erf(long double __x)
  521.   { return __builtin_erfl(__x); }
  522. #endif
  523.  
  524.   template<typename _Tp>
  525.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  526.                                            double>::__type
  527.     erf(_Tp __x)
  528.     { return __builtin_erf(__x); }
  529.  
  530. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  531.   inline float
  532.   erfc(float __x)
  533.   { return __builtin_erfcf(__x); }
  534.  
  535.   inline long double
  536.   erfc(long double __x)
  537.   { return __builtin_erfcl(__x); }
  538. #endif
  539.  
  540.   template<typename _Tp>
  541.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  542.                                            double>::__type
  543.     erfc(_Tp __x)
  544.     { return __builtin_erfc(__x); }
  545.  
  546.   using std::exp;
  547.  
  548. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  549.   inline float
  550.   exp2(float __x)
  551.   { return __builtin_exp2f(__x); }
  552.  
  553.   inline long double
  554.   exp2(long double __x)
  555.   { return __builtin_exp2l(__x); }
  556. #endif
  557.  
  558.   template<typename _Tp>
  559.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  560.                                            double>::__type
  561.     exp2(_Tp __x)
  562.     { return __builtin_exp2(__x); }
  563.  
  564. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  565.   inline float
  566.   expm1(float __x)
  567.   { return __builtin_expm1f(__x); }
  568.  
  569.   inline long double
  570.   expm1(long double __x)
  571.   { return __builtin_expm1l(__x); }
  572. #endif
  573.  
  574.   template<typename _Tp>
  575.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  576.                                            double>::__type
  577.     expm1(_Tp __x)
  578.     { return __builtin_expm1(__x); }
  579.  
  580.   // Note: we deal with fabs in a special way, because an using std::fabs
  581.   // would bring in also the overloads for complex types, which in C++0x
  582.   // mode have a different return type.
  583.   // With __CORRECT_ISO_CPP_MATH_H_PROTO, math.h imports std::fabs in the
  584.   // global namespace after the declarations of the float / double / long
  585.   // double overloads but before the std::complex overloads.
  586.   using ::fabs;
  587.  
  588. #ifndef __CORRECT_ISO_CPP_MATH_H_PROTO
  589. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  590.   inline float
  591.   fabs(float __x)
  592.   { return __builtin_fabsf(__x); }
  593.  
  594.   inline long double
  595.   fabs(long double __x)
  596.   { return __builtin_fabsl(__x); }
  597. #endif
  598.  
  599.   template<typename _Tp>
  600.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  601.                                            double>::__type
  602.     fabs(_Tp __x)
  603.     { return __builtin_fabs(__x); }
  604. #endif
  605.  
  606. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  607.   inline float
  608.   fdim(float __x, float __y)
  609.   { return __builtin_fdimf(__x, __y); }
  610.  
  611.   inline long double
  612.   fdim(long double __x, long double __y)
  613.   { return __builtin_fdiml(__x, __y); }
  614. #endif
  615.  
  616.   template<typename _Tp, typename _Up>
  617.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  618.     fdim(_Tp __x, _Up __y)
  619.     {
  620.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  621.       return fdim(__type(__x), __type(__y));
  622.     }
  623.  
  624.   using std::floor;
  625.  
  626. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  627.   inline float
  628.   fma(float __x, float __y, float __z)
  629.   { return __builtin_fmaf(__x, __y, __z); }
  630.  
  631.   inline long double
  632.   fma(long double __x, long double __y, long double __z)
  633.   { return __builtin_fmal(__x, __y, __z); }
  634. #endif
  635.  
  636.   template<typename _Tp, typename _Up, typename _Vp>
  637.     inline typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type
  638.     fma(_Tp __x, _Up __y, _Vp __z)
  639.     {
  640.       typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type;
  641.       return fma(__type(__x), __type(__y), __type(__z));
  642.     }
  643.  
  644. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  645.   inline float
  646.   fmax(float __x, float __y)
  647.   { return __builtin_fmaxf(__x, __y); }
  648.  
  649.   inline long double
  650.   fmax(long double __x, long double __y)
  651.   { return __builtin_fmaxl(__x, __y); }
  652. #endif
  653.  
  654.   template<typename _Tp, typename _Up>
  655.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  656.     fmax(_Tp __x, _Up __y)
  657.     {
  658.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  659.       return fmax(__type(__x), __type(__y));
  660.     }
  661.  
  662. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  663.   inline float
  664.   fmin(float __x, float __y)
  665.   { return __builtin_fminf(__x, __y); }
  666.  
  667.   inline long double
  668.   fmin(long double __x, long double __y)
  669.   { return __builtin_fminl(__x, __y); }
  670. #endif
  671.  
  672.   template<typename _Tp, typename _Up>
  673.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  674.     fmin(_Tp __x, _Up __y)
  675.     {
  676.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  677.       return fmin(__type(__x), __type(__y));
  678.     }
  679.  
  680.   using std::fmod;
  681.   using std::frexp;
  682.  
  683. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  684.   inline float
  685.   hypot(float __x, float __y)
  686.   { return __builtin_hypotf(__x, __y); }
  687.  
  688.   inline long double
  689.   hypot(long double __x, long double __y)
  690.   { return __builtin_hypotl(__x, __y); }
  691. #endif
  692.  
  693.   template<typename _Tp, typename _Up>
  694.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  695.     hypot(_Tp __y, _Up __x)
  696.     {
  697.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  698.       return hypot(__type(__y), __type(__x));
  699.     }
  700.  
  701. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  702.   inline int
  703.   ilogb(float __x)
  704.   { return __builtin_ilogbf(__x); }
  705.  
  706.   inline int
  707.   ilogb(long double __x)
  708.   { return __builtin_ilogbl(__x); }
  709. #endif
  710.  
  711.   template<typename _Tp>
  712.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  713.                                            int>::__type
  714.     ilogb(_Tp __x)
  715.     { return __builtin_ilogb(__x); }
  716.  
  717.   using std::ldexp;
  718.  
  719. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  720.   inline float
  721.   lgamma(float __x)
  722.   { return __builtin_lgammaf(__x); }
  723.  
  724.   inline long double
  725.   lgamma(long double __x)
  726.   { return __builtin_lgammal(__x); }
  727. #endif
  728.  
  729.   template<typename _Tp>
  730.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  731.                                            double>::__type
  732.     lgamma(_Tp __x)
  733.     { return __builtin_lgamma(__x); }
  734.  
  735. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  736.   inline long long
  737.   llrint(float __x)
  738.   { return __builtin_llrintf(__x); }
  739.  
  740.   inline long long
  741.   llrint(long double __x)
  742.   { return __builtin_llrintl(__x); }
  743. #endif
  744.  
  745.   template<typename _Tp>
  746.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  747.                                            long long>::__type
  748.     llrint(_Tp __x)
  749.     { return __builtin_llrint(__x); }
  750.  
  751. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  752.   inline long long
  753.   llround(float __x)
  754.   { return __builtin_llroundf(__x); }
  755.  
  756.   inline long long
  757.   llround(long double __x)
  758.   { return __builtin_llroundl(__x); }
  759. #endif
  760.  
  761.   template<typename _Tp>
  762.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  763.                                            long long>::__type
  764.     llround(_Tp __x)
  765.     { return __builtin_llround(__x); }
  766.  
  767.   using std::log;
  768.   using std::log10;
  769.  
  770. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  771.   inline float
  772.   log1p(float __x)
  773.   { return __builtin_log1pf(__x); }
  774.  
  775.   inline long double
  776.   log1p(long double __x)
  777.   { return __builtin_log1pl(__x); }
  778. #endif
  779.  
  780.   template<typename _Tp>
  781.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  782.                                            double>::__type
  783.     log1p(_Tp __x)
  784.     { return __builtin_log1p(__x); }
  785.  
  786.   // DR 568.
  787. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  788.   inline float
  789.   log2(float __x)
  790.   { return __builtin_log2f(__x); }
  791.  
  792.   inline long double
  793.   log2(long double __x)
  794.   { return __builtin_log2l(__x); }
  795. #endif
  796.  
  797.   template<typename _Tp>
  798.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  799.                                            double>::__type
  800.     log2(_Tp __x)
  801.     { return __builtin_log2(__x); }
  802.  
  803. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  804.   inline float
  805.   logb(float __x)
  806.   { return __builtin_logbf(__x); }
  807.  
  808.   inline long double
  809.   logb(long double __x)
  810.   { return __builtin_logbl(__x); }
  811. #endif
  812.  
  813.   template<typename _Tp>
  814.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  815.                                            double>::__type
  816.     logb(_Tp __x)
  817.     {
  818.       return __builtin_logb(__x);
  819.     }
  820.  
  821. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  822.   inline long
  823.   lrint(float __x)
  824.   { return __builtin_lrintf(__x); }
  825.  
  826.   inline long
  827.   lrint(long double __x)
  828.   { return __builtin_lrintl(__x); }
  829. #endif
  830.  
  831.   template<typename _Tp>
  832.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  833.                                            long>::__type
  834.     lrint(_Tp __x)
  835.     { return __builtin_lrint(__x); }
  836.  
  837. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  838.   inline long
  839.   lround(float __x)
  840.   { return __builtin_lroundf(__x); }
  841.  
  842.   inline long
  843.   lround(long double __x)
  844.   { return __builtin_lroundl(__x); }
  845. #endif
  846.  
  847.   template<typename _Tp>
  848.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  849.                                            long>::__type
  850.     lround(_Tp __x)
  851.     { return __builtin_lround(__x); }
  852.  
  853. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  854.   inline float
  855.   nearbyint(float __x)
  856.   { return __builtin_nearbyintf(__x); }
  857.  
  858.   inline long double
  859.   nearbyint(long double __x)
  860.   { return __builtin_nearbyintl(__x); }
  861. #endif
  862.  
  863.   template<typename _Tp>
  864.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  865.                                            double>::__type
  866.     nearbyint(_Tp __x)
  867.     { return __builtin_nearbyint(__x); }
  868.  
  869. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  870.   inline float
  871.   nextafter(float __x, float __y)
  872.   { return __builtin_nextafterf(__x, __y); }
  873.  
  874.   inline long double
  875.   nextafter(long double __x, long double __y)
  876.   { return __builtin_nextafterl(__x, __y); }
  877. #endif
  878.  
  879.   template<typename _Tp, typename _Up>
  880.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  881.     nextafter(_Tp __x, _Up __y)
  882.     {
  883.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  884.       return nextafter(__type(__x), __type(__y));
  885.     }
  886.  
  887. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  888.   inline float
  889.   nexttoward(float __x, long double __y)
  890.   { return __builtin_nexttowardf(__x, __y); }
  891.  
  892.   inline long double
  893.   nexttoward(long double __x, long double __y)
  894.   { return __builtin_nexttowardl(__x, __y); }
  895. #endif
  896.  
  897.   template<typename _Tp>
  898.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  899.                                            double>::__type
  900.     nexttoward(_Tp __x, long double __y)
  901.     { return __builtin_nexttoward(__x, __y); }
  902.  
  903. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  904.   inline float
  905.   remainder(float __x, float __y)
  906.   { return __builtin_remainderf(__x, __y); }
  907.  
  908.   inline long double
  909.   remainder(long double __x, long double __y)
  910.   { return __builtin_remainderl(__x, __y); }
  911. #endif
  912.  
  913.   template<typename _Tp, typename _Up>
  914.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  915.     remainder(_Tp __x, _Up __y)
  916.     {
  917.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  918.       return remainder(__type(__x), __type(__y));
  919.     }
  920.  
  921. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  922.   inline float
  923.   remquo(float __x, float __y, int* __pquo)
  924.   { return __builtin_remquof(__x, __y, __pquo); }
  925.  
  926.   inline long double
  927.   remquo(long double __x, long double __y, int* __pquo)
  928.   { return __builtin_remquol(__x, __y, __pquo); }
  929. #endif
  930.  
  931.   template<typename _Tp, typename _Up>
  932.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  933.     remquo(_Tp __x, _Up __y, int* __pquo)
  934.     {
  935.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  936.       return remquo(__type(__x), __type(__y), __pquo);
  937.     }
  938.  
  939. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  940.   inline float
  941.   rint(float __x)
  942.   { return __builtin_rintf(__x); }
  943.  
  944.   inline long double
  945.   rint(long double __x)
  946.   { return __builtin_rintl(__x); }
  947. #endif
  948.  
  949.   template<typename _Tp>
  950.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  951.                                            double>::__type
  952.     rint(_Tp __x)
  953.     { return __builtin_rint(__x); }
  954.  
  955. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  956.   inline float
  957.   round(float __x)
  958.   { return __builtin_roundf(__x); }
  959.  
  960.   inline long double
  961.   round(long double __x)
  962.   { return __builtin_roundl(__x); }
  963. #endif
  964.  
  965.   template<typename _Tp>
  966.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  967.                                            double>::__type
  968.     round(_Tp __x)
  969.     { return __builtin_round(__x); }
  970.  
  971. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  972.   inline float
  973.   scalbln(float __x, long __ex)
  974.   { return __builtin_scalblnf(__x, __ex); }
  975.  
  976.   inline long double
  977.   scalbln(long double __x, long __ex)
  978.   { return __builtin_scalblnl(__x, __ex); }
  979. #endif
  980.  
  981.   template<typename _Tp>
  982.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  983.                                            double>::__type
  984.     scalbln(_Tp __x, long __ex)
  985.     { return __builtin_scalbln(__x, __ex); }
  986.  
  987. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  988.   inline float
  989.   scalbn(float __x, int __ex)
  990.   { return __builtin_scalbnf(__x, __ex); }
  991.  
  992.   inline long double
  993.   scalbn(long double __x, int __ex)
  994.   { return __builtin_scalbnl(__x, __ex); }
  995. #endif
  996.  
  997.   template<typename _Tp>
  998.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  999.                                            double>::__type
  1000.     scalbn(_Tp __x, int __ex)
  1001.     { return __builtin_scalbn(__x, __ex); }
  1002.  
  1003.   using std::sin;
  1004.   using std::sinh;
  1005.   using std::sqrt;
  1006.   using std::tan;
  1007.   using std::tanh;
  1008.  
  1009. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  1010.   inline float
  1011.   tgamma(float __x)
  1012.   { return __builtin_tgammaf(__x); }
  1013.  
  1014.   inline long double
  1015.   tgamma(long double __x)
  1016.   { return __builtin_tgammal(__x); }
  1017. #endif
  1018.  
  1019.   template<typename _Tp>
  1020.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  1021.                                            double>::__type
  1022.     tgamma(_Tp __x)
  1023.     { return __builtin_tgamma(__x); }
  1024.  
  1025. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  1026.   inline float
  1027.   trunc(float __x)
  1028.   { return __builtin_truncf(__x); }
  1029.  
  1030.   inline long double
  1031.   trunc(long double __x)
  1032.   { return __builtin_truncl(__x); }
  1033. #endif
  1034.  
  1035.   template<typename _Tp>
  1036.     inline typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value,
  1037.                                            double>::__type
  1038.     trunc(_Tp __x)
  1039.     { return __builtin_trunc(__x); }
  1040.  
  1041. #endif
  1042. _GLIBCXX_END_NAMESPACE_VERSION
  1043. }
  1044. }
  1045.  
  1046. namespace std _GLIBCXX_VISIBILITY(default)
  1047. {
  1048. namespace tr1
  1049. {
  1050. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  1051.  
  1052.   // DR 550. What should the return type of pow(float,int) be?
  1053.   // NB: C++0x and TR1 != C++03.
  1054.  
  1055.   // The std::tr1::pow(double, double) overload cannot be provided
  1056.   // here, because it would clash with ::pow(double,double) declared
  1057.   // in <math.h>, if <tr1/math.h> is included at the same time (raised
  1058.   // by the fix of PR c++/54537). It is not possible either to use the
  1059.   // using-declaration 'using ::pow;' here, because if the user code
  1060.   // has a 'using std::pow;', it would bring the pow(*,int) averloads
  1061.   // in the tr1 namespace, which is undesirable. Consequently, the
  1062.   // solution is to forward std::tr1::pow(double,double) to
  1063.   // std::pow(double,double) via the templatized version below. See
  1064.   // the discussion about this issue here:
  1065.   // http://gcc.gnu.org/ml/gcc-patches/2012-09/msg01278.html
  1066.  
  1067. #ifndef __CORRECT_ISO_CPP11_MATH_H_PROTO
  1068.   inline float
  1069.   pow(float __x, float __y)
  1070.   { return std::pow(__x, __y); }
  1071.  
  1072.   inline long double
  1073.   pow(long double __x, long double __y)
  1074.   { return std::pow(__x, __y); }
  1075. #endif
  1076.  
  1077.   template<typename _Tp, typename _Up>
  1078.     inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type
  1079.     pow(_Tp __x, _Up __y)
  1080.     {
  1081.       typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type;
  1082.       return std::pow(__type(__x), __type(__y));
  1083.     }
  1084.  
  1085. _GLIBCXX_END_NAMESPACE_VERSION
  1086. }
  1087. }
  1088.  
  1089. #include <bits/stl_algobase.h>
  1090. #include <limits>
  1091. #include <tr1/type_traits>
  1092.  
  1093. #include <tr1/gamma.tcc>
  1094. #include <tr1/bessel_function.tcc>
  1095. #include <tr1/beta_function.tcc>
  1096. #include <tr1/ell_integral.tcc>
  1097. #include <tr1/exp_integral.tcc>
  1098. #include <tr1/hypergeometric.tcc>
  1099. #include <tr1/legendre_function.tcc>
  1100. #include <tr1/modified_bessel_func.tcc>
  1101. #include <tr1/poly_hermite.tcc>
  1102. #include <tr1/poly_laguerre.tcc>
  1103. #include <tr1/riemann_zeta.tcc>
  1104.  
  1105. namespace std _GLIBCXX_VISIBILITY(default)
  1106. {
  1107. namespace tr1
  1108. {
  1109. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  1110.  
  1111.   /**
  1112.    * @defgroup tr1_math_spec_func Mathematical Special Functions
  1113.    * @ingroup numerics
  1114.    *
  1115.    * A collection of advanced mathematical special functions.
  1116.    * @{
  1117.    */
  1118.  
  1119.   inline float
  1120.   assoc_laguerref(unsigned int __n, unsigned int __m, float __x)
  1121.   { return __detail::__assoc_laguerre<float>(__n, __m, __x); }
  1122.  
  1123.   inline long double
  1124.   assoc_laguerrel(unsigned int __n, unsigned int __m, long double __x)
  1125.   {
  1126.     return __detail::__assoc_laguerre<long double>(__n, __m, __x);
  1127.   }
  1128.  
  1129.   ///  5.2.1.1  Associated Laguerre polynomials.
  1130.   template<typename _Tp>
  1131.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1132.     assoc_laguerre(unsigned int __n, unsigned int __m, _Tp __x)
  1133.     {
  1134.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1135.       return __detail::__assoc_laguerre<__type>(__n, __m, __x);
  1136.     }
  1137.  
  1138.   inline float
  1139.   assoc_legendref(unsigned int __l, unsigned int __m, float __x)
  1140.   { return __detail::__assoc_legendre_p<float>(__l, __m, __x); }
  1141.  
  1142.   inline long double
  1143.   assoc_legendrel(unsigned int __l, unsigned int __m, long double __x)
  1144.   { return __detail::__assoc_legendre_p<long double>(__l, __m, __x); }
  1145.  
  1146.   ///  5.2.1.2  Associated Legendre functions.
  1147.   template<typename _Tp>
  1148.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1149.     assoc_legendre(unsigned int __l, unsigned int __m, _Tp __x)
  1150.     {
  1151.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1152.       return __detail::__assoc_legendre_p<__type>(__l, __m, __x);
  1153.     }
  1154.  
  1155.   inline float
  1156.   betaf(float __x, float __y)
  1157.   { return __detail::__beta<float>(__x, __y); }
  1158.  
  1159.   inline long double
  1160.   betal(long double __x, long double __y)
  1161.   { return __detail::__beta<long double>(__x, __y); }
  1162.  
  1163.   ///  5.2.1.3  Beta functions.
  1164.   template<typename _Tpx, typename _Tpy>
  1165.     inline typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type
  1166.     beta(_Tpx __x, _Tpy __y)
  1167.     {
  1168.       typedef typename __gnu_cxx::__promote_2<_Tpx, _Tpy>::__type __type;
  1169.       return __detail::__beta<__type>(__x, __y);
  1170.     }
  1171.  
  1172.   inline float
  1173.   comp_ellint_1f(float __k)
  1174.   { return __detail::__comp_ellint_1<float>(__k); }
  1175.  
  1176.   inline long double
  1177.   comp_ellint_1l(long double __k)
  1178.   { return __detail::__comp_ellint_1<long double>(__k); }
  1179.  
  1180.   ///  5.2.1.4  Complete elliptic integrals of the first kind.
  1181.   template<typename _Tp>
  1182.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1183.     comp_ellint_1(_Tp __k)
  1184.     {
  1185.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1186.       return __detail::__comp_ellint_1<__type>(__k);
  1187.     }
  1188.  
  1189.   inline float
  1190.   comp_ellint_2f(float __k)
  1191.   { return __detail::__comp_ellint_2<float>(__k); }
  1192.  
  1193.   inline long double
  1194.   comp_ellint_2l(long double __k)
  1195.   { return __detail::__comp_ellint_2<long double>(__k); }
  1196.  
  1197.   ///  5.2.1.5  Complete elliptic integrals of the second kind.
  1198.   template<typename _Tp>
  1199.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1200.     comp_ellint_2(_Tp __k)
  1201.     {
  1202.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1203.       return __detail::__comp_ellint_2<__type>(__k);
  1204.     }
  1205.  
  1206.   inline float
  1207.   comp_ellint_3f(float __k, float __nu)
  1208.   { return __detail::__comp_ellint_3<float>(__k, __nu); }
  1209.  
  1210.   inline long double
  1211.   comp_ellint_3l(long double __k, long double __nu)
  1212.   { return __detail::__comp_ellint_3<long double>(__k, __nu); }
  1213.  
  1214.   ///  5.2.1.6  Complete elliptic integrals of the third kind.
  1215.   template<typename _Tp, typename _Tpn>
  1216.     inline typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type
  1217.     comp_ellint_3(_Tp __k, _Tpn __nu)
  1218.     {
  1219.       typedef typename __gnu_cxx::__promote_2<_Tp, _Tpn>::__type __type;
  1220.       return __detail::__comp_ellint_3<__type>(__k, __nu);
  1221.     }
  1222.  
  1223.   inline float
  1224.   conf_hypergf(float __a, float __c, float __x)
  1225.   { return __detail::__conf_hyperg<float>(__a, __c, __x); }
  1226.  
  1227.   inline long double
  1228.   conf_hypergl(long double __a, long double __c, long double __x)
  1229.   { return __detail::__conf_hyperg<long double>(__a, __c, __x); }
  1230.  
  1231.   ///  5.2.1.7  Confluent hypergeometric functions.
  1232.   template<typename _Tpa, typename _Tpc, typename _Tp>
  1233.     inline typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type
  1234.     conf_hyperg(_Tpa __a, _Tpc __c, _Tp __x)
  1235.     {
  1236.       typedef typename __gnu_cxx::__promote_3<_Tpa, _Tpc, _Tp>::__type __type;
  1237.       return __detail::__conf_hyperg<__type>(__a, __c, __x);
  1238.     }
  1239.  
  1240.   inline float
  1241.   cyl_bessel_if(float __nu, float __x)
  1242.   { return __detail::__cyl_bessel_i<float>(__nu, __x); }
  1243.  
  1244.   inline long double
  1245.   cyl_bessel_il(long double __nu, long double __x)
  1246.   { return __detail::__cyl_bessel_i<long double>(__nu, __x); }
  1247.  
  1248.   ///  5.2.1.8  Regular modified cylindrical Bessel functions.
  1249.   template<typename _Tpnu, typename _Tp>
  1250.     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
  1251.     cyl_bessel_i(_Tpnu __nu, _Tp __x)
  1252.     {
  1253.       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
  1254.       return __detail::__cyl_bessel_i<__type>(__nu, __x);
  1255.     }
  1256.  
  1257.   inline float
  1258.   cyl_bessel_jf(float __nu, float __x)
  1259.   { return __detail::__cyl_bessel_j<float>(__nu, __x); }
  1260.  
  1261.   inline long double
  1262.   cyl_bessel_jl(long double __nu, long double __x)
  1263.   { return __detail::__cyl_bessel_j<long double>(__nu, __x); }
  1264.  
  1265.   ///  5.2.1.9  Cylindrical Bessel functions (of the first kind).
  1266.   template<typename _Tpnu, typename _Tp>
  1267.     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
  1268.     cyl_bessel_j(_Tpnu __nu, _Tp __x)
  1269.     {
  1270.       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
  1271.       return __detail::__cyl_bessel_j<__type>(__nu, __x);
  1272.     }
  1273.  
  1274.   inline float
  1275.   cyl_bessel_kf(float __nu, float __x)
  1276.   { return __detail::__cyl_bessel_k<float>(__nu, __x); }
  1277.  
  1278.   inline long double
  1279.   cyl_bessel_kl(long double __nu, long double __x)
  1280.   { return __detail::__cyl_bessel_k<long double>(__nu, __x); }
  1281.  
  1282.   ///  5.2.1.10  Irregular modified cylindrical Bessel functions.
  1283.   template<typename _Tpnu, typename _Tp>
  1284.     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
  1285.     cyl_bessel_k(_Tpnu __nu, _Tp __x)
  1286.     {
  1287.       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
  1288.       return __detail::__cyl_bessel_k<__type>(__nu, __x);
  1289.     }
  1290.  
  1291.   inline float
  1292.   cyl_neumannf(float __nu, float __x)
  1293.   { return __detail::__cyl_neumann_n<float>(__nu, __x); }
  1294.  
  1295.   inline long double
  1296.   cyl_neumannl(long double __nu, long double __x)
  1297.   { return __detail::__cyl_neumann_n<long double>(__nu, __x); }
  1298.  
  1299.   ///  5.2.1.11  Cylindrical Neumann functions.
  1300.   template<typename _Tpnu, typename _Tp>
  1301.     inline typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type
  1302.     cyl_neumann(_Tpnu __nu, _Tp __x)
  1303.     {
  1304.       typedef typename __gnu_cxx::__promote_2<_Tpnu, _Tp>::__type __type;
  1305.       return __detail::__cyl_neumann_n<__type>(__nu, __x);
  1306.     }
  1307.  
  1308.   inline float
  1309.   ellint_1f(float __k, float __phi)
  1310.   { return __detail::__ellint_1<float>(__k, __phi); }
  1311.  
  1312.   inline long double
  1313.   ellint_1l(long double __k, long double __phi)
  1314.   { return __detail::__ellint_1<long double>(__k, __phi); }
  1315.  
  1316.   ///  5.2.1.12  Incomplete elliptic integrals of the first kind.
  1317.   template<typename _Tp, typename _Tpp>
  1318.     inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
  1319.     ellint_1(_Tp __k, _Tpp __phi)
  1320.     {
  1321.       typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
  1322.       return __detail::__ellint_1<__type>(__k, __phi);
  1323.     }
  1324.  
  1325.   inline float
  1326.   ellint_2f(float __k, float __phi)
  1327.   { return __detail::__ellint_2<float>(__k, __phi); }
  1328.  
  1329.   inline long double
  1330.   ellint_2l(long double __k, long double __phi)
  1331.   { return __detail::__ellint_2<long double>(__k, __phi); }
  1332.  
  1333.   ///  5.2.1.13  Incomplete elliptic integrals of the second kind.
  1334.   template<typename _Tp, typename _Tpp>
  1335.     inline typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type
  1336.     ellint_2(_Tp __k, _Tpp __phi)
  1337.     {
  1338.       typedef typename __gnu_cxx::__promote_2<_Tp, _Tpp>::__type __type;
  1339.       return __detail::__ellint_2<__type>(__k, __phi);
  1340.     }
  1341.  
  1342.   inline float
  1343.   ellint_3f(float __k, float __nu, float __phi)
  1344.   { return __detail::__ellint_3<float>(__k, __nu, __phi); }
  1345.  
  1346.   inline long double
  1347.   ellint_3l(long double __k, long double __nu, long double __phi)
  1348.   { return __detail::__ellint_3<long double>(__k, __nu, __phi); }
  1349.  
  1350.   ///  5.2.1.14  Incomplete elliptic integrals of the third kind.
  1351.   template<typename _Tp, typename _Tpn, typename _Tpp>
  1352.     inline typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type
  1353.     ellint_3(_Tp __k, _Tpn __nu, _Tpp __phi)
  1354.     {
  1355.       typedef typename __gnu_cxx::__promote_3<_Tp, _Tpn, _Tpp>::__type __type;
  1356.       return __detail::__ellint_3<__type>(__k, __nu, __phi);
  1357.     }
  1358.  
  1359.   inline float
  1360.   expintf(float __x)
  1361.   { return __detail::__expint<float>(__x); }
  1362.  
  1363.   inline long double
  1364.   expintl(long double __x)
  1365.   { return __detail::__expint<long double>(__x); }
  1366.  
  1367.   ///  5.2.1.15  Exponential integrals.
  1368.   template<typename _Tp>
  1369.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1370.     expint(_Tp __x)
  1371.     {
  1372.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1373.       return __detail::__expint<__type>(__x);
  1374.     }
  1375.  
  1376.   inline float
  1377.   hermitef(unsigned int __n, float __x)
  1378.   { return __detail::__poly_hermite<float>(__n, __x); }
  1379.  
  1380.   inline long double
  1381.   hermitel(unsigned int __n, long double __x)
  1382.   { return __detail::__poly_hermite<long double>(__n, __x); }
  1383.  
  1384.   ///  5.2.1.16  Hermite polynomials.
  1385.   template<typename _Tp>
  1386.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1387.     hermite(unsigned int __n, _Tp __x)
  1388.     {
  1389.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1390.       return __detail::__poly_hermite<__type>(__n, __x);
  1391.     }
  1392.  
  1393.   inline float
  1394.   hypergf(float __a, float __b, float __c, float __x)
  1395.   { return __detail::__hyperg<float>(__a, __b, __c, __x); }
  1396.  
  1397.   inline long double
  1398.   hypergl(long double __a, long double __b, long double __c, long double __x)
  1399.   { return __detail::__hyperg<long double>(__a, __b, __c, __x); }
  1400.  
  1401.   ///  5.2.1.17  Hypergeometric functions.
  1402.   template<typename _Tpa, typename _Tpb, typename _Tpc, typename _Tp>
  1403.     inline typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type
  1404.     hyperg(_Tpa __a, _Tpb __b, _Tpc __c, _Tp __x)
  1405.     {
  1406.       typedef typename __gnu_cxx::__promote_4<_Tpa, _Tpb, _Tpc, _Tp>::__type __type;
  1407.       return __detail::__hyperg<__type>(__a, __b, __c, __x);
  1408.     }
  1409.  
  1410.   inline float
  1411.   laguerref(unsigned int __n, float __x)
  1412.   { return __detail::__laguerre<float>(__n, __x); }
  1413.  
  1414.   inline long double
  1415.   laguerrel(unsigned int __n, long double __x)
  1416.   { return __detail::__laguerre<long double>(__n, __x); }
  1417.  
  1418.   ///  5.2.1.18  Laguerre polynomials.
  1419.   template<typename _Tp>
  1420.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1421.     laguerre(unsigned int __n, _Tp __x)
  1422.     {
  1423.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1424.       return __detail::__laguerre<__type>(__n, __x);
  1425.     }
  1426.  
  1427.   inline float
  1428.   legendref(unsigned int __n, float __x)
  1429.   { return __detail::__poly_legendre_p<float>(__n, __x); }
  1430.  
  1431.   inline long double
  1432.   legendrel(unsigned int __n, long double __x)
  1433.   { return __detail::__poly_legendre_p<long double>(__n, __x); }
  1434.  
  1435.   ///  5.2.1.19  Legendre polynomials.
  1436.   template<typename _Tp>
  1437.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1438.     legendre(unsigned int __n, _Tp __x)
  1439.     {
  1440.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1441.       return __detail::__poly_legendre_p<__type>(__n, __x);
  1442.     }
  1443.  
  1444.   inline float
  1445.   riemann_zetaf(float __x)
  1446.   { return __detail::__riemann_zeta<float>(__x); }
  1447.  
  1448.   inline long double
  1449.   riemann_zetal(long double __x)
  1450.   { return __detail::__riemann_zeta<long double>(__x); }
  1451.  
  1452.   ///  5.2.1.20  Riemann zeta function.
  1453.   template<typename _Tp>
  1454.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1455.     riemann_zeta(_Tp __x)
  1456.     {
  1457.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1458.       return __detail::__riemann_zeta<__type>(__x);
  1459.     }
  1460.  
  1461.   inline float
  1462.   sph_besself(unsigned int __n, float __x)
  1463.   { return __detail::__sph_bessel<float>(__n, __x); }
  1464.  
  1465.   inline long double
  1466.   sph_bessell(unsigned int __n, long double __x)
  1467.   { return __detail::__sph_bessel<long double>(__n, __x); }
  1468.  
  1469.   ///  5.2.1.21  Spherical Bessel functions.
  1470.   template<typename _Tp>
  1471.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1472.     sph_bessel(unsigned int __n, _Tp __x)
  1473.     {
  1474.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1475.       return __detail::__sph_bessel<__type>(__n, __x);
  1476.     }
  1477.  
  1478.   inline float
  1479.   sph_legendref(unsigned int __l, unsigned int __m, float __theta)
  1480.   { return __detail::__sph_legendre<float>(__l, __m, __theta); }
  1481.  
  1482.   inline long double
  1483.   sph_legendrel(unsigned int __l, unsigned int __m, long double __theta)
  1484.   { return __detail::__sph_legendre<long double>(__l, __m, __theta); }
  1485.  
  1486.   ///  5.2.1.22  Spherical associated Legendre functions.
  1487.   template<typename _Tp>
  1488.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1489.     sph_legendre(unsigned int __l, unsigned int __m, _Tp __theta)
  1490.     {
  1491.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1492.       return __detail::__sph_legendre<__type>(__l, __m, __theta);
  1493.     }
  1494.  
  1495.   inline float
  1496.   sph_neumannf(unsigned int __n, float __x)
  1497.   { return __detail::__sph_neumann<float>(__n, __x); }
  1498.  
  1499.   inline long double
  1500.   sph_neumannl(unsigned int __n, long double __x)
  1501.   { return __detail::__sph_neumann<long double>(__n, __x); }
  1502.  
  1503.   ///  5.2.1.23  Spherical Neumann functions.
  1504.   template<typename _Tp>
  1505.     inline typename __gnu_cxx::__promote<_Tp>::__type
  1506.     sph_neumann(unsigned int __n, _Tp __x)
  1507.     {
  1508.       typedef typename __gnu_cxx::__promote<_Tp>::__type __type;
  1509.       return __detail::__sph_neumann<__type>(__n, __x);
  1510.     }
  1511.  
  1512.   /* @} */ // tr1_math_spec_func
  1513. _GLIBCXX_END_NAMESPACE_VERSION
  1514. }
  1515. }
  1516.  
  1517. #endif // _GLIBCXX_TR1_CMATH
  1518.