[Python-checkins] r65326 - python/trunk/Lib/test/test_math.py
mark.dickinson
python-checkins at python.org
Thu Jul 31 16:48:32 CEST 2008
Author: mark.dickinson
Date: Thu Jul 31 16:48:32 2008
New Revision: 65326
Log:
Rename testSum to testFsum and move it to proper place in test_math.py
Modified:
python/trunk/Lib/test/test_math.py
Modified: python/trunk/Lib/test/test_math.py
==============================================================================
--- python/trunk/Lib/test/test_math.py (original)
+++ python/trunk/Lib/test/test_math.py Thu Jul 31 16:48:32 2008
@@ -364,6 +364,102 @@
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 @@
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)
More information about the Python-checkins
mailing list