Rename testSum to testFsum and move it to proper place in test_math.py

1 files changed, 96 insertions, 97 deletions

diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py
index 9f5fdba..c82c775 100644
--- a/Lib/test/test_math.py
+++ b/Lib/test/test_math.py
@@ -364,6 +364,102 @@ class MathTests(unittest.TestCase):
         self.assertEquals(math.frexp(NINF)[0], NINF)
         self.assert_(math.isnan(math.frexp(NAN)[0]))
 
+    def testFsum(self):
+        # math.fsum relies on exact rounding for correct operation.
+        # There's a known problem with IA32 floating-point that causes
+        # inexact rounding in some situations, and will cause the
+        # math.fsum tests below to fail; see issue #2937.  On non IEEE
+        # 754 platforms, and on IEEE 754 platforms that exhibit the
+        # problem described in issue #2937, we simply skip the whole
+        # test.
+
+        if not float.__getformat__("double").startswith("IEEE"):
+            return
+
+        # on IEEE 754 compliant machines, both of the expressions
+        # below should round to 10000000000000002.0.
+        if 1e16+2.0 != 1e16+2.9999:
+            return
+
+        # Python version of math.fsum, for comparison.  Uses a
+        # different algorithm based on frexp, ldexp and integer
+        # arithmetic.
+        from sys import float_info
+        mant_dig = float_info.mant_dig
+        etiny = float_info.min_exp - mant_dig
+
+        def msum(iterable):
+            """Full precision summation.  Compute sum(iterable) without any
+            intermediate accumulation of error.  Based on the 'lsum' function
+            at http://code.activestate.com/recipes/393090/
+
+            """
+            tmant, texp = 0, 0
+            for x in iterable:
+                mant, exp = math.frexp(x)
+                mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig
+                if texp > exp:
+                    tmant <<= texp-exp
+                    texp = exp
+                else:
+                    mant <<= exp-texp
+                tmant += mant
+            # Round tmant * 2**texp to a float.  The original recipe
+            # used float(str(tmant)) * 2.0**texp for this, but that's
+            # a little unsafe because str -> float conversion can't be
+            # relied upon to do correct rounding on all platforms.
+            tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp)
+            if tail > 0:
+                h = 1 << (tail-1)
+                tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1)
+                texp += tail
+            return math.ldexp(tmant, texp)
+
+        test_values = [
+            ([], 0.0),
+            ([0.0], 0.0),
+            ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100),
+            ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0),
+            ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0),
+            ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0),
+            ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0),
+            ([1./n for n in range(1, 1001)],
+             float.fromhex('0x1.df11f45f4e61ap+2')),
+            ([(-1.)**n/n for n in range(1, 1001)],
+             float.fromhex('-0x1.62a2af1bd3624p-1')),
+            ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0),
+            ([1e16, 1., 1e-16], 10000000000000002.0),
+            ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0),
+            # exercise code for resizing partials array
+            ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] +
+             [-2.**1022],
+             float.fromhex('0x1.5555555555555p+970')),
+            ]
+
+        for i, (vals, expected) in enumerate(test_values):
+            try:
+                actual = math.fsum(vals)
+            except OverflowError:
+                self.fail("test %d failed: got OverflowError, expected %r "
+                          "for math.fsum(%.100r)" % (i, expected, vals))
+            except ValueError:
+                self.fail("test %d failed: got ValueError, expected %r "
+                          "for math.fsum(%.100r)" % (i, expected, vals))
+            self.assertEqual(actual, expected)
+
+        from random import random, gauss, shuffle
+        for j in xrange(1000):
+            vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10
+            s = 0
+            for i in xrange(200):
+                v = gauss(0, random()) ** 7 - s
+                s += v
+                vals.append(v)
+            shuffle(vals)
+
+            s = msum(vals)
+            self.assertEqual(msum(vals), math.fsum(vals))
+
     def testHypot(self):
         self.assertRaises(TypeError, math.hypot)
         self.ftest('hypot(0,0)', math.hypot(0,0), 0)
@@ -645,103 +741,6 @@ class MathTests(unittest.TestCase):
         self.assertRaises(ValueError, math.sqrt, NINF)
         self.assert_(math.isnan(math.sqrt(NAN)))
 
-    def testSum(self):
-        # math.fsum relies on exact rounding for correct operation.
-        # There's a known problem with IA32 floating-point that causes
-        # inexact rounding in some situations, and will cause the
-        # math.fsum tests below to fail; see issue #2937.  On non IEEE
-        # 754 platforms, and on IEEE 754 platforms that exhibit the
-        # problem described in issue #2937, we simply skip the whole
-        # test.
-
-        if not float.__getformat__("double").startswith("IEEE"):
-            return
-
-        # on IEEE 754 compliant machines, both of the expressions
-        # below should round to 10000000000000002.0.
-        if 1e16+2.0 != 1e16+2.9999:
-            return
-
-        # Python version of math.fsum, for comparison.  Uses a
-        # different algorithm based on frexp, ldexp and integer
-        # arithmetic.
-        from sys import float_info
-        mant_dig = float_info.mant_dig
-        etiny = float_info.min_exp - mant_dig
-
-        def msum(iterable):
-            """Full precision summation.  Compute sum(iterable) without any
-            intermediate accumulation of error.  Based on the 'lsum' function
-            at http://code.activestate.com/recipes/393090/
-
-            """
-            tmant, texp = 0, 0
-            for x in iterable:
-                mant, exp = math.frexp(x)
-                mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig
-                if texp > exp:
-                    tmant <<= texp-exp
-                    texp = exp
-                else:
-                    mant <<= exp-texp
-                tmant += mant
-            # Round tmant * 2**texp to a float.  The original recipe
-            # used float(str(tmant)) * 2.0**texp for this, but that's
-            # a little unsafe because str -> float conversion can't be
-            # relied upon to do correct rounding on all platforms.
-            tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp)
-            if tail > 0:
-                h = 1 << (tail-1)
-                tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1)
-                texp += tail
-            return math.ldexp(tmant, texp)
-
-        test_values = [
-            ([], 0.0),
-            ([0.0], 0.0),
-            ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100),
-            ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0),
-            ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0),
-            ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0),
-            ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0),
-            ([1./n for n in range(1, 1001)],
-             float.fromhex('0x1.df11f45f4e61ap+2')),
-            ([(-1.)**n/n for n in range(1, 1001)],
-             float.fromhex('-0x1.62a2af1bd3624p-1')),
-            ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0),
-            ([1e16, 1., 1e-16], 10000000000000002.0),
-            ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0),
-            # exercise code for resizing partials array
-            ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] +
-             [-2.**1022],
-             float.fromhex('0x1.5555555555555p+970')),
-            ]
-
-        for i, (vals, expected) in enumerate(test_values):
-            try:
-                actual = math.fsum(vals)
-            except OverflowError:
-                self.fail("test %d failed: got OverflowError, expected %r "
-                          "for math.fsum(%.100r)" % (i, expected, vals))
-            except ValueError:
-                self.fail("test %d failed: got ValueError, expected %r "
-                          "for math.fsum(%.100r)" % (i, expected, vals))
-            self.assertEqual(actual, expected)
-
-        from random import random, gauss, shuffle
-        for j in xrange(1000):
-            vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10
-            s = 0
-            for i in xrange(200):
-                v = gauss(0, random()) ** 7 - s
-                s += v
-                vals.append(v)
-            shuffle(vals)
-
-            s = msum(vals)
-            self.assertEqual(msum(vals), math.fsum(vals))
-
-
     def testTan(self):
         self.assertRaises(TypeError, math.tan)
         self.ftest('tan(0)', math.tan(0), 0)