mirror of
https://github.com/python/cpython.git
synced 2025-08-30 21:48:47 +00:00
Merged revisions 62380,62382-62383 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk ........ r62380 | christian.heimes | 2008-04-19 01:13:07 +0200 (Sat, 19 Apr 2008) | 3 lines I finally got the time to update and merge Mark's and my trunk-math branch. The patch is collaborated work of Mark Dickinson and me. It was mostly done a few months ago. The patch fixes a lot of loose ends and edge cases related to operations with NaN, INF, very small values and complex math. The patch also adds acosh, asinh, atanh, log1p and copysign to all platforms. Finally it fixes differences between platforms like different results or exceptions for edge cases. Have fun :) ........ r62382 | christian.heimes | 2008-04-19 01:40:40 +0200 (Sat, 19 Apr 2008) | 2 lines Added new files to Windows project files More Windows related fixes are coming soon ........ r62383 | christian.heimes | 2008-04-19 01:49:11 +0200 (Sat, 19 Apr 2008) | 1 line Stupid me. Py_RETURN_NAN should actually return something ... ........
This commit is contained in:
Christian Heimes
parent
dc3e06ce3a
commit
53876d9cd8
27 changed files with 5101 additions and 1167 deletions
|
|
@ -4,9 +4,45 @@
|
|||
from test.test_support import run_unittest, verbose
|
||||
import unittest
|
||||
import math
|
||||
import os
|
||||
import sys
|
||||
|
||||
seps='1e-05'
|
||||
eps = eval(seps)
|
||||
eps = 1E-05
|
||||
NAN = float('nan')
|
||||
INF = float('inf')
|
||||
NINF = float('-inf')
|
||||
|
||||
# locate file with test values
|
||||
if __name__ == '__main__':
|
||||
file = sys.argv[0]
|
||||
else:
|
||||
file = __file__
|
||||
test_dir = os.path.dirname(file) or os.curdir
|
||||
test_file = os.path.join(test_dir, 'cmath_testcases.txt')
|
||||
|
||||
def parse_testfile(fname):
|
||||
"""Parse a file with test values
|
||||
|
||||
Empty lines or lines starting with -- are ignored
|
||||
yields id, fn, arg_real, arg_imag, exp_real, exp_imag
|
||||
"""
|
||||
with open(fname) as fp:
|
||||
for line in fp:
|
||||
# skip comment lines and blank lines
|
||||
if line.startswith('--') or not line.strip():
|
||||
continue
|
||||
|
||||
lhs, rhs = line.split('->')
|
||||
id, fn, arg_real, arg_imag = lhs.split()
|
||||
rhs_pieces = rhs.split()
|
||||
exp_real, exp_imag = rhs_pieces[0], rhs_pieces[1]
|
||||
flags = rhs_pieces[2:]
|
||||
|
||||
yield (id, fn,
|
||||
float(arg_real), float(arg_imag),
|
||||
float(exp_real), float(exp_imag),
|
||||
flags
|
||||
)
|
||||
|
||||
class MathTests(unittest.TestCase):
|
||||
|
||||
|
|
@ -28,18 +64,57 @@ class MathTests(unittest.TestCase):
|
|||
self.ftest('acos(-1)', math.acos(-1), math.pi)
|
||||
self.ftest('acos(0)', math.acos(0), math.pi/2)
|
||||
self.ftest('acos(1)', math.acos(1), 0)
|
||||
self.assertRaises(ValueError, math.acos, INF)
|
||||
self.assertRaises(ValueError, math.acos, NINF)
|
||||
self.assert_(math.isnan(math.acos(NAN)))
|
||||
|
||||
def testAcosh(self):
|
||||
self.assertRaises(TypeError, math.acosh)
|
||||
self.ftest('acosh(1)', math.acosh(1), 0)
|
||||
self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168)
|
||||
self.assertRaises(ValueError, math.acosh, 0)
|
||||
self.assertRaises(ValueError, math.acosh, -1)
|
||||
self.assertEquals(math.acosh(INF), INF)
|
||||
self.assertRaises(ValueError, math.acosh, NINF)
|
||||
self.assert_(math.isnan(math.acosh(NAN)))
|
||||
|
||||
def testAsin(self):
|
||||
self.assertRaises(TypeError, math.asin)
|
||||
self.ftest('asin(-1)', math.asin(-1), -math.pi/2)
|
||||
self.ftest('asin(0)', math.asin(0), 0)
|
||||
self.ftest('asin(1)', math.asin(1), math.pi/2)
|
||||
self.assertRaises(ValueError, math.asin, INF)
|
||||
self.assertRaises(ValueError, math.asin, NINF)
|
||||
self.assert_(math.isnan(math.asin(NAN)))
|
||||
|
||||
def testAsinh(self):
|
||||
self.assertRaises(TypeError, math.asinh)
|
||||
self.ftest('asinh(0)', math.asinh(0), 0)
|
||||
self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305)
|
||||
self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305)
|
||||
self.assertEquals(math.asinh(INF), INF)
|
||||
self.assertEquals(math.asinh(NINF), NINF)
|
||||
self.assert_(math.isnan(math.asinh(NAN)))
|
||||
|
||||
def testAtan(self):
|
||||
self.assertRaises(TypeError, math.atan)
|
||||
self.ftest('atan(-1)', math.atan(-1), -math.pi/4)
|
||||
self.ftest('atan(0)', math.atan(0), 0)
|
||||
self.ftest('atan(1)', math.atan(1), math.pi/4)
|
||||
self.ftest('atan(inf)', math.atan(INF), math.pi/2)
|
||||
self.ftest('atan(-inf)', math.atan(-INF), -math.pi/2)
|
||||
self.assert_(math.isnan(math.atan(NAN)))
|
||||
|
||||
def testAtanh(self):
|
||||
self.assertRaises(TypeError, math.atan)
|
||||
self.ftest('atanh(0)', math.atanh(0), 0)
|
||||
self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489)
|
||||
self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489)
|
||||
self.assertRaises(ValueError, math.atanh, 1)
|
||||
self.assertRaises(ValueError, math.atanh, -1)
|
||||
self.assertRaises(ValueError, math.atanh, INF)
|
||||
self.assertRaises(ValueError, math.atanh, NINF)
|
||||
self.assert_(math.isnan(math.atanh(NAN)))
|
||||
|
||||
def testAtan2(self):
|
||||
self.assertRaises(TypeError, math.atan2)
|
||||
|
|
@ -58,6 +133,9 @@ class MathTests(unittest.TestCase):
|
|||
self.ftest('ceil(-0.5)', math.ceil(-0.5), 0)
|
||||
self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)
|
||||
self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)
|
||||
#self.assertEquals(math.ceil(INF), INF)
|
||||
#self.assertEquals(math.ceil(NINF), NINF)
|
||||
#self.assert_(math.isnan(math.ceil(NAN)))
|
||||
|
||||
class TestCeil:
|
||||
def __ceil__(self):
|
||||
|
|
@ -72,17 +150,55 @@ class MathTests(unittest.TestCase):
|
|||
self.assertRaises(TypeError, math.ceil, t)
|
||||
self.assertRaises(TypeError, math.ceil, t, 0)
|
||||
|
||||
if float.__getformat__("double").startswith("IEEE"):
|
||||
def testCopysign(self):
|
||||
self.assertRaises(TypeError, math.copysign)
|
||||
# copysign should let us distinguish signs of zeros
|
||||
self.assertEquals(copysign(1., 0.), 1.)
|
||||
self.assertEquals(copysign(1., -0.), -1.)
|
||||
self.assertEquals(copysign(INF, 0.), INF)
|
||||
self.assertEquals(copysign(INF, -0.), NINF)
|
||||
self.assertEquals(copysign(NINF, 0.), INF)
|
||||
self.assertEquals(copysign(NINF, -0.), NINF)
|
||||
# and of infinities
|
||||
self.assertEquals(copysign(1., INF), 1.)
|
||||
self.assertEquals(copysign(1., NINF), -1.)
|
||||
self.assertEquals(copysign(INF, INF), INF)
|
||||
self.assertEquals(copysign(INF, NINF), NINF)
|
||||
self.assertEquals(copysign(NINF, INF), INF)
|
||||
self.assertEquals(copysign(NINF, NINF), NINF)
|
||||
self.assert_(math.isnan(copysign(NAN, 1.)))
|
||||
self.assert_(math.isnan(copysign(NAN, INF)))
|
||||
self.assert_(math.isnan(copysign(NAN, NINF)))
|
||||
self.assert_(math.isnan(copysign(NAN, NAN)))
|
||||
# copysign(INF, NAN) may be INF or it may be NINF, since
|
||||
# we don't know whether the sign bit of NAN is set on any
|
||||
# given platform.
|
||||
self.assert_(math.isinf(copysign(INF, NAN)))
|
||||
# similarly, copysign(2., NAN) could be 2. or -2.
|
||||
self.assertEquals(abs(copysign(2., NAN)), 2.)
|
||||
|
||||
def testCos(self):
|
||||
self.assertRaises(TypeError, math.cos)
|
||||
self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0)
|
||||
self.ftest('cos(0)', math.cos(0), 1)
|
||||
self.ftest('cos(pi/2)', math.cos(math.pi/2), 0)
|
||||
self.ftest('cos(pi)', math.cos(math.pi), -1)
|
||||
try:
|
||||
self.assert_(math.isnan(math.cos(INF)))
|
||||
self.assert_(math.isnan(math.cos(NINF)))
|
||||
except ValueError:
|
||||
self.assertRaises(ValueError, math.cos, INF)
|
||||
self.assertRaises(ValueError, math.cos, NINF)
|
||||
self.assert_(math.isnan(math.cos(NAN)))
|
||||
|
||||
def testCosh(self):
|
||||
self.assertRaises(TypeError, math.cosh)
|
||||
self.ftest('cosh(0)', math.cosh(0), 1)
|
||||
self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert
|
||||
self.assertEquals(math.cosh(INF), INF)
|
||||
self.assertEquals(math.cosh(NINF), INF)
|
||||
self.assert_(math.isnan(math.cosh(NAN)))
|
||||
|
||||
def testDegrees(self):
|
||||
self.assertRaises(TypeError, math.degrees)
|
||||
|
|
@ -95,6 +211,9 @@ class MathTests(unittest.TestCase):
|
|||
self.ftest('exp(-1)', math.exp(-1), 1/math.e)
|
||||
self.ftest('exp(0)', math.exp(0), 1)
|
||||
self.ftest('exp(1)', math.exp(1), math.e)
|
||||
self.assertEquals(math.exp(INF), INF)
|
||||
self.assertEquals(math.exp(NINF), 0.)
|
||||
self.assert_(math.isnan(math.exp(NAN)))
|
||||
|
||||
def testFabs(self):
|
||||
self.assertRaises(TypeError, math.fabs)
|
||||
|
|
@ -115,6 +234,9 @@ class MathTests(unittest.TestCase):
|
|||
# This fails on some platforms - so check it here
|
||||
self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)
|
||||
self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)
|
||||
#self.assertEquals(math.ceil(INF), INF)
|
||||
#self.assertEquals(math.ceil(NINF), NINF)
|
||||
#self.assert_(math.isnan(math.floor(NAN)))
|
||||
|
||||
class TestFloor:
|
||||
def __floor__(self):
|
||||
|
|
@ -137,6 +259,19 @@ class MathTests(unittest.TestCase):
|
|||
self.ftest('fmod(-10,1)', math.fmod(-10,1), 0)
|
||||
self.ftest('fmod(-10,0.5)', math.fmod(-10,0.5), 0)
|
||||
self.ftest('fmod(-10,1.5)', math.fmod(-10,1.5), -1)
|
||||
self.assert_(math.isnan(math.fmod(NAN, 1.)))
|
||||
self.assert_(math.isnan(math.fmod(1., NAN)))
|
||||
self.assert_(math.isnan(math.fmod(NAN, NAN)))
|
||||
self.assertRaises(ValueError, math.fmod, 1., 0.)
|
||||
self.assertRaises(ValueError, math.fmod, INF, 1.)
|
||||
self.assertRaises(ValueError, math.fmod, NINF, 1.)
|
||||
self.assertRaises(ValueError, math.fmod, INF, 0.)
|
||||
self.assertEquals(math.fmod(3.0, INF), 3.0)
|
||||
self.assertEquals(math.fmod(-3.0, INF), -3.0)
|
||||
self.assertEquals(math.fmod(3.0, NINF), 3.0)
|
||||
self.assertEquals(math.fmod(-3.0, NINF), -3.0)
|
||||
self.assertEquals(math.fmod(0.0, 3.0), 0.0)
|
||||
self.assertEquals(math.fmod(0.0, NINF), 0.0)
|
||||
|
||||
def testFrexp(self):
|
||||
self.assertRaises(TypeError, math.frexp)
|
||||
|
|
@ -152,10 +287,20 @@ class MathTests(unittest.TestCase):
|
|||
testfrexp('frexp(1)', math.frexp(1), (0.5, 1))
|
||||
testfrexp('frexp(2)', math.frexp(2), (0.5, 2))
|
||||
|
||||
self.assertEquals(math.frexp(INF)[0], INF)
|
||||
self.assertEquals(math.frexp(NINF)[0], NINF)
|
||||
self.assert_(math.isnan(math.frexp(NAN)[0]))
|
||||
|
||||
def testHypot(self):
|
||||
self.assertRaises(TypeError, math.hypot)
|
||||
self.ftest('hypot(0,0)', math.hypot(0,0), 0)
|
||||
self.ftest('hypot(3,4)', math.hypot(3,4), 5)
|
||||
self.assertEqual(math.hypot(NAN, INF), INF)
|
||||
self.assertEqual(math.hypot(INF, NAN), INF)
|
||||
self.assertEqual(math.hypot(NAN, NINF), INF)
|
||||
self.assertEqual(math.hypot(NINF, NAN), INF)
|
||||
self.assert_(math.isnan(math.hypot(1.0, NAN)))
|
||||
self.assert_(math.isnan(math.hypot(NAN, -2.0)))
|
||||
|
||||
def testLdexp(self):
|
||||
self.assertRaises(TypeError, math.ldexp)
|
||||
|
|
@ -163,6 +308,13 @@ class MathTests(unittest.TestCase):
|
|||
self.ftest('ldexp(1,1)', math.ldexp(1,1), 2)
|
||||
self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5)
|
||||
self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2)
|
||||
self.assertRaises(OverflowError, math.ldexp, 1., 1000000)
|
||||
self.assertRaises(OverflowError, math.ldexp, -1., 1000000)
|
||||
self.assertEquals(math.ldexp(1., -1000000), 0.)
|
||||
self.assertEquals(math.ldexp(-1., -1000000), -0.)
|
||||
self.assertEquals(math.ldexp(INF, 30), INF)
|
||||
self.assertEquals(math.ldexp(NINF, -213), NINF)
|
||||
self.assert_(math.isnan(math.ldexp(NAN, 0)))
|
||||
|
||||
def testLog(self):
|
||||
self.assertRaises(TypeError, math.log)
|
||||
|
|
@ -172,12 +324,31 @@ class MathTests(unittest.TestCase):
|
|||
self.ftest('log(32,2)', math.log(32,2), 5)
|
||||
self.ftest('log(10**40, 10)', math.log(10**40, 10), 40)
|
||||
self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2)
|
||||
self.assertEquals(math.log(INF), INF)
|
||||
self.assertRaises(ValueError, math.log, NINF)
|
||||
self.assert_(math.isnan(math.log(NAN)))
|
||||
|
||||
def testLog1p(self):
|
||||
self.assertRaises(TypeError, math.log1p)
|
||||
self.ftest('log1p(1/e -1)', math.log1p(1/math.e-1), -1)
|
||||
self.ftest('log1p(0)', math.log1p(0), 0)
|
||||
self.ftest('log1p(e-1)', math.log1p(math.e-1), 1)
|
||||
self.ftest('log1p(1)', math.log1p(1), math.log(2))
|
||||
self.assertEquals(math.log1p(INF), INF)
|
||||
self.assertRaises(ValueError, math.log1p, NINF)
|
||||
self.assert_(math.isnan(math.log1p(NAN)))
|
||||
n= 2**90
|
||||
self.assertAlmostEquals(math.log1p(n), 62.383246250395075)
|
||||
self.assertAlmostEquals(math.log1p(n), math.log1p(float(n)))
|
||||
|
||||
def testLog10(self):
|
||||
self.assertRaises(TypeError, math.log10)
|
||||
self.ftest('log10(0.1)', math.log10(0.1), -1)
|
||||
self.ftest('log10(1)', math.log10(1), 0)
|
||||
self.ftest('log10(10)', math.log10(10), 1)
|
||||
self.assertEquals(math.log(INF), INF)
|
||||
self.assertRaises(ValueError, math.log10, NINF)
|
||||
self.assert_(math.isnan(math.log10(NAN)))
|
||||
|
||||
def testModf(self):
|
||||
self.assertRaises(TypeError, math.modf)
|
||||
|
|
@ -191,12 +362,35 @@ class MathTests(unittest.TestCase):
|
|||
testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0))
|
||||
testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0))
|
||||
|
||||
self.assertEquals(math.modf(INF), (0.0, INF))
|
||||
self.assertEquals(math.modf(NINF), (-0.0, NINF))
|
||||
|
||||
modf_nan = math.modf(NAN)
|
||||
self.assert_(math.isnan(modf_nan[0]))
|
||||
self.assert_(math.isnan(modf_nan[1]))
|
||||
|
||||
def testPow(self):
|
||||
self.assertRaises(TypeError, math.pow)
|
||||
self.ftest('pow(0,1)', math.pow(0,1), 0)
|
||||
self.ftest('pow(1,0)', math.pow(1,0), 1)
|
||||
self.ftest('pow(2,1)', math.pow(2,1), 2)
|
||||
self.ftest('pow(2,-1)', math.pow(2,-1), 0.5)
|
||||
self.assertEqual(math.pow(INF, 1), INF)
|
||||
self.assertEqual(math.pow(NINF, 1), NINF)
|
||||
self.assertEqual((math.pow(1, INF)), 1.)
|
||||
self.assertEqual((math.pow(1, NINF)), 1.)
|
||||
self.assert_(math.isnan(math.pow(NAN, 1)))
|
||||
self.assert_(math.isnan(math.pow(2, NAN)))
|
||||
self.assert_(math.isnan(math.pow(0, NAN)))
|
||||
self.assertEqual(math.pow(1, NAN), 1)
|
||||
self.assertEqual(1**NAN, 1)
|
||||
self.assertEqual(1**INF, 1)
|
||||
self.assertEqual(1**NINF, 1)
|
||||
self.assertEqual(1**0, 1)
|
||||
self.assertEqual(1.**NAN, 1)
|
||||
self.assertEqual(1.**INF, 1)
|
||||
self.assertEqual(1.**NINF, 1)
|
||||
self.assertEqual(1.**0, 1)
|
||||
|
||||
def testRadians(self):
|
||||
self.assertRaises(TypeError, math.radians)
|
||||
|
|
@ -209,29 +403,52 @@ class MathTests(unittest.TestCase):
|
|||
self.ftest('sin(0)', math.sin(0), 0)
|
||||
self.ftest('sin(pi/2)', math.sin(math.pi/2), 1)
|
||||
self.ftest('sin(-pi/2)', math.sin(-math.pi/2), -1)
|
||||
try:
|
||||
self.assert_(math.isnan(math.sin(INF)))
|
||||
self.assert_(math.isnan(math.sin(NINF)))
|
||||
except ValueError:
|
||||
self.assertRaises(ValueError, math.sin, INF)
|
||||
self.assertRaises(ValueError, math.sin, NINF)
|
||||
self.assert_(math.isnan(math.sin(NAN)))
|
||||
|
||||
def testSinh(self):
|
||||
self.assertRaises(TypeError, math.sinh)
|
||||
self.ftest('sinh(0)', math.sinh(0), 0)
|
||||
self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1)
|
||||
self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0)
|
||||
self.assertEquals(math.sinh(INF), INF)
|
||||
self.assertEquals(math.sinh(-INF), -INF)
|
||||
self.assert_(math.isnan(math.sinh(NAN)))
|
||||
|
||||
def testSqrt(self):
|
||||
self.assertRaises(TypeError, math.sqrt)
|
||||
self.ftest('sqrt(0)', math.sqrt(0), 0)
|
||||
self.ftest('sqrt(1)', math.sqrt(1), 1)
|
||||
self.ftest('sqrt(4)', math.sqrt(4), 2)
|
||||
self.assertEquals(math.sqrt(INF), INF)
|
||||
self.assertRaises(ValueError, math.sqrt, NINF)
|
||||
self.assert_(math.isnan(math.sqrt(NAN)))
|
||||
|
||||
def testTan(self):
|
||||
self.assertRaises(TypeError, math.tan)
|
||||
self.ftest('tan(0)', math.tan(0), 0)
|
||||
self.ftest('tan(pi/4)', math.tan(math.pi/4), 1)
|
||||
self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1)
|
||||
try:
|
||||
self.assert_(math.isnan(math.tan(INF)))
|
||||
self.assert_(math.isnan(math.tan(NINF)))
|
||||
except:
|
||||
self.assertRaises(ValueError, math.tan, INF)
|
||||
self.assertRaises(ValueError, math.tan, NINF)
|
||||
self.assert_(math.isnan(math.tan(NAN)))
|
||||
|
||||
def testTanh(self):
|
||||
self.assertRaises(TypeError, math.tanh)
|
||||
self.ftest('tanh(0)', math.tanh(0), 0)
|
||||
self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0)
|
||||
self.ftest('tanh(inf)', math.tanh(INF), 1)
|
||||
self.ftest('tanh(-inf)', math.tanh(NINF), -1)
|
||||
self.assert_(math.isnan(math.tanh(NAN)))
|
||||
|
||||
def test_trunc(self):
|
||||
self.assertEqual(math.trunc(1), 1)
|
||||
|
|
@ -326,9 +543,27 @@ class MathTests(unittest.TestCase):
|
|||
else:
|
||||
self.fail("sqrt(-1) didn't raise ValueError")
|
||||
|
||||
def test_testfile(self):
|
||||
if not float.__getformat__("double").startswith("IEEE"):
|
||||
return
|
||||
for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file):
|
||||
# Skip if either the input or result is complex, or if
|
||||
# flags is nonempty
|
||||
if ai != 0. or ei != 0. or flags:
|
||||
continue
|
||||
if fn in ['rect', 'polar']:
|
||||
# no real versions of rect, polar
|
||||
continue
|
||||
func = getattr(math, fn)
|
||||
result = func(ar)
|
||||
self.ftest("%s:%s(%r)" % (id, fn, ar), result, er)
|
||||
|
||||
def test_main():
|
||||
run_unittest(MathTests)
|
||||
from doctest import DocFileSuite
|
||||
suite = unittest.TestSuite()
|
||||
suite.addTest(unittest.makeSuite(MathTests))
|
||||
suite.addTest(DocFileSuite("ieee754.txt"))
|
||||
run_unittest(suite)
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_main()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue