poly_laguerre.tcc: s/__alpha/__alpha1/g.

        * include/tr1/poly_laguerre.tcc: s/__alpha/__alpha1/g.
        * include/tr1/ell_integral.tcc: Likewise.

From-SVN: r123407

libstdc++-v3/ChangeLog

+2007-04-01  Richard Henderson  <rth@redhat.com>
+
+	* include/tr1/poly_laguerre.tcc: s/__alpha/__alpha1/g.
+	* include/tr1/ell_integral.tcc: Likewise.
+
 2007-03-31  Paolo Carlini  <pcarlini@suse.de>
 
 	* include/bits/stl_bvector.h (_M_fill_insert(iterator, size_type,

libstdc++-v3/include/tr1/ell_integral.tcc

@@ -627,9 +627,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
               const _Tp __znroot = std::sqrt(__zn);
               const _Tp __lambda = __xnroot * (__ynroot + __znroot)
                                  + __ynroot * __znroot;
-              const _Tp __alpha = __pn * (__xnroot + __ynroot + __znroot)
+              const _Tp __alpha1 = __pn * (__xnroot + __ynroot + __znroot)
                                 + __xnroot * __ynroot * __znroot;
-              const _Tp __alpha2 = __alpha * __alpha;
+              const _Tp __alpha2 = __alpha1 * __alpha1;
               const _Tp __beta = __pn * (__pn + __lambda)
                                       * (__pn + __lambda);
               __sigma += __power4 * __ellint_rc(__alpha2, __beta);

libstdc++-v3/include/tr1/poly_laguerre.tcc

@@ -80,11 +80,11 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
      */
     template<typename _Tpa, typename _Tp>
     _Tp
-    __poly_laguerre_large_n(const unsigned __n, const _Tpa __alpha,
+    __poly_laguerre_large_n(const unsigned __n, const _Tpa __alpha1,
                             const _Tp __x)
     {
       const _Tp __a = -_Tp(__n);
-      const _Tp __b = _Tp(__alpha) + _Tp(1);
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
       const _Tp __eta = _Tp(2) * __b - _Tp(4) * __a;
       const _Tp __cos2th = __x / __eta;
       const _Tp __sin2th = _Tp(1) - __cos2th;
@@ -135,9 +135,10 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
      */
     template<typename _Tpa, typename _Tp>
     _Tp
-    __poly_laguerre_hyperg(const unsigned int __n, const _Tpa __alpha, const _Tp __x)
+    __poly_laguerre_hyperg(const unsigned int __n, const _Tpa __alpha1,
+			   const _Tp __x)
     {
-      const _Tp __b = _Tp(__alpha) + _Tp(1);
+      const _Tp __b = _Tp(__alpha1) + _Tp(1);
       const _Tp __mx = -__x;
       const _Tp __tc_sgn = (__x < _Tp(0) ? _Tp(1)
                          : ((__n % 2 == 1) ? -_Tp(1) : _Tp(1)));
@@ -192,7 +193,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
     template<typename _Tpa, typename _Tp>
     _Tp
     __poly_laguerre_recursion(const unsigned int __n,
-                              const _Tpa __alpha, const _Tp __x)
+                              const _Tpa __alpha1, const _Tp __x)
     {
       //   Compute l_0.
       _Tp __l_0 = _Tp(1);
@@ -200,7 +201,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
         return __l_0;
 
       //  Compute l_1^alpha.
-      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha);
+      _Tp __l_1 = -__x + _Tp(1) + _Tp(__alpha1);
       if  (__n == 1)
         return __l_1;
 
@@ -210,9 +211,9 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       _Tp __l_n = _Tp(0);
       for  (unsigned int __nn = 2; __nn <= __n; ++__nn)
         {
-            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha) - __x)
+            __l_n = (_Tp(2 * __nn - 1) + _Tp(__alpha1) - __x)
                   * __l_n1 / _Tp(__nn)
-                  - (_Tp(__nn - 1) + _Tp(__alpha)) * __l_n2 / _Tp(__nn);
+                  - (_Tp(__nn - 1) + _Tp(__alpha1)) * __l_n2 / _Tp(__nn);
             __l_n2 = __l_n1;
             __l_n1 = __l_n;
         }
@@ -251,7 +252,7 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
      */
     template<typename _Tpa, typename _Tp>
     inline _Tp
-    __poly_laguerre(const unsigned int __n, const _Tpa __alpha,
+    __poly_laguerre(const unsigned int __n, const _Tpa __alpha1,
                     const _Tp __x)
     {
       if (__x < _Tp(0))
@@ -263,22 +264,22 @@ _GLIBCXX_BEGIN_NAMESPACE(_GLIBCXX_TR1)
       else if (__n == 0)
         return _Tp(1);
       else if (__n == 1)
-        return _Tp(1) + _Tp(__alpha) - __x;
+        return _Tp(1) + _Tp(__alpha1) - __x;
       else if (__x == _Tp(0))
         {
-          _Tp __prod = _Tp(__alpha) + _Tp(1);
+          _Tp __prod = _Tp(__alpha1) + _Tp(1);
           for (unsigned int __k = 2; __k <= __n; ++__k)
-            __prod *= (_Tp(__alpha) + _Tp(__k)) / _Tp(__k);
+            __prod *= (_Tp(__alpha1) + _Tp(__k)) / _Tp(__k);
           return __prod;
         }
-      else if (__n > 10000000 && _Tp(__alpha) > -_Tp(1)
-            && __x < _Tp(2) * (_Tp(__alpha) + _Tp(1)) + _Tp(4 * __n))
-        return __poly_laguerre_large_n(__n, __alpha, __x);
+      else if (__n > 10000000 && _Tp(__alpha1) > -_Tp(1)
+            && __x < _Tp(2) * (_Tp(__alpha1) + _Tp(1)) + _Tp(4 * __n))
+        return __poly_laguerre_large_n(__n, __alpha1, __x);
       else if (_Tp(__alpha) >= _Tp(0)
-           || (__x > _Tp(0) && _Tp(__alpha) < -_Tp(__n + 1)))
-        return __poly_laguerre_recursion(__n, __alpha, __x);
+           || (__x > _Tp(0) && _Tp(__alpha1) < -_Tp(__n + 1)))
+        return __poly_laguerre_recursion(__n, __alpha1, __x);
       else
-        return __poly_laguerre_hyperg(__n, __alpha, __x);
+        return __poly_laguerre_hyperg(__n, __alpha1, __x);
     }