1a44153c1a57202fb538659eb50706e60454d6273Andreas Huber# Python test set -- math module 2a44153c1a57202fb538659eb50706e60454d6273Andreas Huber# XXXX Should not do tests around zero only 3a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 4a44153c1a57202fb538659eb50706e60454d6273Andreas Huberfrom test.test_support import run_unittest, verbose 5a44153c1a57202fb538659eb50706e60454d6273Andreas Huberimport unittest 6a44153c1a57202fb538659eb50706e60454d6273Andreas Huberimport math 7a44153c1a57202fb538659eb50706e60454d6273Andreas Huberimport os 8a44153c1a57202fb538659eb50706e60454d6273Andreas Huberimport sys 9a44153c1a57202fb538659eb50706e60454d6273Andreas Huberimport random 10a44153c1a57202fb538659eb50706e60454d6273Andreas Huberimport struct 11a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 12a44153c1a57202fb538659eb50706e60454d6273Andreas Hubereps = 1E-05 13a44153c1a57202fb538659eb50706e60454d6273Andreas HuberNAN = float('nan') 14a44153c1a57202fb538659eb50706e60454d6273Andreas HuberINF = float('inf') 15a44153c1a57202fb538659eb50706e60454d6273Andreas HuberNINF = float('-inf') 16a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 17a44153c1a57202fb538659eb50706e60454d6273Andreas Huber# decorator for skipping tests on non-IEEE 754 platforms 18a44153c1a57202fb538659eb50706e60454d6273Andreas Huberrequires_IEEE_754 = unittest.skipUnless( 19a44153c1a57202fb538659eb50706e60454d6273Andreas Huber float.__getformat__("double").startswith("IEEE"), 20a44153c1a57202fb538659eb50706e60454d6273Andreas Huber "test requires IEEE 754 doubles") 2114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 22a44153c1a57202fb538659eb50706e60454d6273Andreas Huber# detect evidence of double-rounding: fsum is not always correctly 2314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber# rounded on machines that suffer from double rounding. 2414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huberx, y = 1e16, 2.9999 # use temporary values to defeat peephole optimizer 25a44153c1a57202fb538659eb50706e60454d6273Andreas HuberHAVE_DOUBLE_ROUNDING = (x + y == 1e16 + 4) 261156dc913a5ba7b2bc86489468d4914430f03d14Andreas Huber 2714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber# locate file with test values 28a44153c1a57202fb538659eb50706e60454d6273Andreas Huberif __name__ == '__main__': 29a44153c1a57202fb538659eb50706e60454d6273Andreas Huber file = sys.argv[0] 301b86fe063badb5f28c467ade39be0f4008688947Andreas Huberelse: 311b86fe063badb5f28c467ade39be0f4008688947Andreas Huber file = __file__ 32a44153c1a57202fb538659eb50706e60454d6273Andreas Hubertest_dir = os.path.dirname(file) or os.curdir 33a44153c1a57202fb538659eb50706e60454d6273Andreas Hubermath_testcases = os.path.join(test_dir, 'math_testcases.txt') 34a44153c1a57202fb538659eb50706e60454d6273Andreas Hubertest_file = os.path.join(test_dir, 'cmath_testcases.txt') 35a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 36a44153c1a57202fb538659eb50706e60454d6273Andreas Huberdef to_ulps(x): 37a44153c1a57202fb538659eb50706e60454d6273Andreas Huber """Convert a non-NaN float x to an integer, in such a way that 38a44153c1a57202fb538659eb50706e60454d6273Andreas Huber adjacent floats are converted to adjacent integers. Then 391b86fe063badb5f28c467ade39be0f4008688947Andreas Huber abs(ulps(x) - ulps(y)) gives the difference in ulps between two 4014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber floats. 4114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 42a44153c1a57202fb538659eb50706e60454d6273Andreas Huber The results from this function will only make sense on platforms 431543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih where C doubles are represented in IEEE 754 binary64 format. 441543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 45a44153c1a57202fb538659eb50706e60454d6273Andreas Huber """ 46b4a7a2df4c28c3f32b5d877b54831d2cc5d78f81Colin Cross n = struct.unpack('<q', struct.pack('<d', x))[0] 47a44153c1a57202fb538659eb50706e60454d6273Andreas Huber if n < 0: 487e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber n = ~(n+2**63) 49a44153c1a57202fb538659eb50706e60454d6273Andreas Huber return n 50a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 51a44153c1a57202fb538659eb50706e60454d6273Andreas Huberdef ulps_check(expected, got, ulps=20): 520df36ec3303c2c6bf9b42c07945ac8bd234153f3Andreas Huber """Given non-NaN floats `expected` and `got`, 531b86fe063badb5f28c467ade39be0f4008688947Andreas Huber check that they're equal to within the given number of ulps. 5481e68448f3361eaf8618930471fdc3c21bdf5cbcAndreas Huber 550df36ec3303c2c6bf9b42c07945ac8bd234153f3Andreas Huber Returns None on success and an error message on failure.""" 560df36ec3303c2c6bf9b42c07945ac8bd234153f3Andreas Huber 571b86fe063badb5f28c467ade39be0f4008688947Andreas Huber ulps_error = to_ulps(got) - to_ulps(expected) 580df36ec3303c2c6bf9b42c07945ac8bd234153f3Andreas Huber if abs(ulps_error) <= ulps: 591b86fe063badb5f28c467ade39be0f4008688947Andreas Huber return None 60a44153c1a57202fb538659eb50706e60454d6273Andreas Huber return "error = {} ulps; permitted error = {} ulps".format(ulps_error, 6114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ulps) 621543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 631543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shihdef acc_check(expected, got, rel_err=2e-15, abs_err = 5e-323): 6414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber """Determine whether non-NaN floats a and b are equal to within a 651543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih (small) rounding error. The default values for rel_err and 6614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber abs_err are chosen to be suitable for platforms where a float is 67dcb89b3b505522efde173c105a851c412f947178Chong Zhang represented by an IEEE 754 double. They allow an error of between 6814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 9 and 19 ulps.""" 691543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 705ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih # need to special case infinities, since inf - inf gives nan 715ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih if math.isinf(expected) and got == expected: 7214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber return None 738ca002eedc747dd854b61cbe364b52c06869273fRobert Shih 748ca002eedc747dd854b61cbe364b52c06869273fRobert Shih error = got - expected 75e4f25c280a8f1655c31a745978e0fcbc61f91deeRobert Shih 7614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber permitted_error = max(abs_err, rel_err * abs(expected)) 778ca002eedc747dd854b61cbe364b52c06869273fRobert Shih if abs(error) < permitted_error: 788ca002eedc747dd854b61cbe364b52c06869273fRobert Shih return None 791543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih return "error = {}; permitted error = {}".format(error, 808ca002eedc747dd854b61cbe364b52c06869273fRobert Shih permitted_error) 81a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 82a44153c1a57202fb538659eb50706e60454d6273Andreas Huberdef parse_mtestfile(fname): 83a44153c1a57202fb538659eb50706e60454d6273Andreas Huber """Parse a file with test values 84a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 85a44153c1a57202fb538659eb50706e60454d6273Andreas Huber -- starts a comment 861543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih blank lines, or lines containing only a comment, are ignored 871543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih other lines are expected to have the form 881543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih id fn arg -> expected [flag]* 891543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 901543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih """ 911543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih with open(fname) as fp: 921543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih for line in fp: 931543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # strip comments, and skip blank lines 941543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih if '--' in line: 951543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih line = line[:line.index('--')] 961543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih if not line.strip(): 971543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih continue 981543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 991543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih lhs, rhs = line.split('->') 1001543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih id, fn, arg = lhs.split() 1011543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih rhs_pieces = rhs.split() 1021543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih exp = rhs_pieces[0] 1031543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih flags = rhs_pieces[1:] 10414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 10514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber yield (id, fn, float(arg), float(exp), flags) 10614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 1071543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shihdef parse_testfile(fname): 1081543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih """Parse a file with test values 1091543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 11014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber Empty lines or lines starting with -- are ignored 11114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber yields id, fn, arg_real, arg_imag, exp_real, exp_imag 11214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber """ 11314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber with open(fname) as fp: 11414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber for line in fp: 11514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # skip comment lines and blank lines 11614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if line.startswith('--') or not line.strip(): 11714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber continue 11814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 11914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber lhs, rhs = line.split('->') 12014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber id, fn, arg_real, arg_imag = lhs.split() 12114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber rhs_pieces = rhs.split() 12214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber exp_real, exp_imag = rhs_pieces[0], rhs_pieces[1] 12314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber flags = rhs_pieces[2:] 12414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 12514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber yield (id, fn, 12614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber float(arg_real), float(arg_imag), 12714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber float(exp_real), float(exp_imag), 12814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber flags 12914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ) 13014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 13114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huberclass MathTests(unittest.TestCase): 13214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 13314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def ftest(self, name, value, expected): 13414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if abs(value-expected) > eps: 13514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # Use %r instead of %f so the error message 13614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # displays full precision. Otherwise discrepancies 13714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # in the last few bits will lead to very confusing 13814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # error messages 13914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.fail('%s returned %r, expected %r' % 14014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber (name, value, expected)) 14114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 14214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testConstants(self): 14314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('pi', math.pi, 3.1415926) 14414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('e', math.e, 2.7182818) 14514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 14614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testAcos(self): 14714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.acos) 14814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('acos(-1)', math.acos(-1), math.pi) 1491543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('acos(0)', math.acos(0), math.pi/2) 1501543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('acos(1)', math.acos(1), 0) 1511543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(ValueError, math.acos, INF) 1521543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(ValueError, math.acos, NINF) 1531543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertTrue(math.isnan(math.acos(NAN))) 1541543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 1551543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih def testAcosh(self): 1561543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(TypeError, math.acosh) 1571543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('acosh(1)', math.acosh(1), 0) 1581543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168) 1591543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(ValueError, math.acosh, 0) 1601543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(ValueError, math.acosh, -1) 1611543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(math.acosh(INF), INF) 1621543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(ValueError, math.acosh, NINF) 1631543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertTrue(math.isnan(math.acosh(NAN))) 1641543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 1651543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih def testAsin(self): 1661543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(TypeError, math.asin) 1671543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('asin(-1)', math.asin(-1), -math.pi/2) 16814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('asin(0)', math.asin(0), 0) 169dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.ftest('asin(1)', math.asin(1), math.pi/2) 170dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertRaises(ValueError, math.asin, INF) 171dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertRaises(ValueError, math.asin, NINF) 172b4a7a2df4c28c3f32b5d877b54831d2cc5d78f81Colin Cross self.assertTrue(math.isnan(math.asin(NAN))) 173dcb89b3b505522efde173c105a851c412f947178Chong Zhang 174dcb89b3b505522efde173c105a851c412f947178Chong Zhang def testAsinh(self): 175dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertRaises(TypeError, math.asinh) 176dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.ftest('asinh(0)', math.asinh(0), 0) 177dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305) 178dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305) 179dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertEqual(math.asinh(INF), INF) 180dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertEqual(math.asinh(NINF), NINF) 18114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.asinh(NAN))) 18214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 18314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testAtan(self): 18414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.atan) 18514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan(-1)', math.atan(-1), -math.pi/4) 18614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan(0)', math.atan(0), 0) 18714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan(1)', math.atan(1), math.pi/4) 18814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan(inf)', math.atan(INF), math.pi/2) 1891543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2) 19014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan(NAN))) 19114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 19214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testAtanh(self): 19314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.atan) 19414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atanh(0)', math.atanh(0), 0) 19514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489) 19614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489) 19714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.atanh, 1) 19814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.atanh, -1) 19914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.atanh, INF) 20014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.atanh, NINF) 20114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atanh(NAN))) 20214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 203a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def testAtan2(self): 204a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(TypeError, math.atan2) 20514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2) 206ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4) 207a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(0, 1)', math.atan2(0, 1), 0) 208a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4) 209ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2) 210ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber 211ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber # math.atan2(0, x) 212ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi) 213ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi) 214ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi) 215ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber self.assertEqual(math.atan2(0., 0.), 0.) 216a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.atan2(0., 2.3), 0.) 217a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.atan2(0., INF), 0.) 218a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.atan2(0., NAN))) 21914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # math.atan2(-0, x) 22014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi) 221ab8a0badb8fb1e294dacf2eb6a891439f348aff9Andreas Huber self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi) 22214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi) 22314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.atan2(-0., 0.), -0.) 224ab8a0badb8fb1e294dacf2eb6a891439f348aff9Andreas Huber self.assertEqual(math.atan2(-0., 2.3), -0.) 22514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.atan2(-0., INF), -0.) 226a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.atan2(-0., NAN))) 227a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # math.atan2(INF, x) 22814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4) 229a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2) 230a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2) 231a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2) 23214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2) 23314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4) 23414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(INF, NAN))) 2355ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih # math.atan2(NINF, x) 2365ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4) 2375ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2) 2385ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2) 23914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2) 240a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2) 241a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4) 242a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.atan2(NINF, NAN))) 243a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # math.atan2(+finite, x) 244a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi) 24514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2) 246a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2) 247a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.atan2(2.3, INF), 0.) 24814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(2.3, NAN))) 249a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # math.atan2(-finite, x) 250a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi) 25114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2) 25214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2) 25314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.atan2(-2.3, INF), -0.) 25414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(-2.3, NAN))) 25514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # math.atan2(NAN, x) 25614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(NAN, NINF))) 25714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(NAN, -2.3))) 25814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(NAN, -0.))) 259a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.atan2(NAN, 0.))) 26014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(NAN, 2.3))) 261a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.atan2(NAN, INF))) 26214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.atan2(NAN, NAN))) 26314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 2645ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih def testCeil(self): 26514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.ceil) 26614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # These types will be int in py3k. 26714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(float, type(math.ceil(1))) 2685ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.assertEqual(float, type(math.ceil(1L))) 2695ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.assertEqual(float, type(math.ceil(1.0))) 27014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ceil(0.5)', math.ceil(0.5), 1) 27114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ceil(1.0)', math.ceil(1.0), 1) 27214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ceil(1.5)', math.ceil(1.5), 2) 27314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ceil(-0.5)', math.ceil(-0.5), 0) 27414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ceil(-1.0)', math.ceil(-1.0), -1) 27514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ceil(-1.5)', math.ceil(-1.5), -1) 27614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ceil(INF), INF) 27714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ceil(NINF), NINF) 27814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.ceil(NAN))) 27914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 28014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber class TestCeil(object): 28114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def __float__(self): 28214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber return 41.3 28314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber class TestNoCeil(object): 28414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber pass 28514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42) 28614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.ceil, TestNoCeil()) 2871543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 2881543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih t = TestNoCeil() 2891543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih t.__ceil__ = lambda *args: args 2901543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(TypeError, math.ceil, t) 2911543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(TypeError, math.ceil, t, 0) 2921543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 29314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber @requires_IEEE_754 29414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testCopysign(self): 29514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(1, 42), 1.0) 29614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(0., 42), 0.0) 29714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(1., -42), -1.0) 29814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(3, 0.), 3.0) 2995ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.assertEqual(math.copysign(4., -0.), -4.0) 3005ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih 3015ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.assertRaises(TypeError, math.copysign) 3025ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih # copysign should let us distinguish signs of zeros 3035ce50c1931e1e3d8f113394bbe2c9f99354f4c5fRobert Shih self.assertEqual(math.copysign(1., 0.), 1.) 30414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(1., -0.), -1.) 30514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(INF, 0.), INF) 30614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(INF, -0.), NINF) 30714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(NINF, 0.), INF) 30814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(NINF, -0.), NINF) 30914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # and of infinities 31014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(1., INF), 1.) 31114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(1., NINF), -1.) 31214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(INF, INF), INF) 31314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(INF, NINF), NINF) 31414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(NINF, INF), INF) 31514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.copysign(NINF, NINF), NINF) 31614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.copysign(NAN, 1.))) 31714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.copysign(NAN, INF))) 31814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.copysign(NAN, NINF))) 31914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.copysign(NAN, NAN))) 32014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # copysign(INF, NAN) may be INF or it may be NINF, since 32114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # we don't know whether the sign bit of NAN is set on any 32214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # given platform. 32314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isinf(math.copysign(INF, NAN))) 32414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # similarly, copysign(2., NAN) could be 2. or -2. 32514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(abs(math.copysign(2., NAN)), 2.) 32614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 32714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testCos(self): 32814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.cos) 32914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0) 33014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('cos(0)', math.cos(0), 1) 33114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('cos(pi/2)', math.cos(math.pi/2), 0) 33214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('cos(pi)', math.cos(math.pi), -1) 3331543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih try: 3341543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertTrue(math.isnan(math.cos(INF))) 33514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.cos(NINF))) 33614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber except ValueError: 33714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.cos, INF) 33814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.cos, NINF) 33914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.cos(NAN))) 34014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 34114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testCosh(self): 34214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.cosh) 34314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('cosh(0)', math.cosh(0), 1) 34414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert 34514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.cosh(INF), INF) 34614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.cosh(NINF), INF) 34714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.cosh(NAN))) 34814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 34914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testDegrees(self): 35014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.degrees) 35114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('degrees(pi)', math.degrees(math.pi), 180.0) 35214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('degrees(pi/2)', math.degrees(math.pi/2), 90.0) 35314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('degrees(-pi/4)', math.degrees(-math.pi/4), -45.0) 35414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 35514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testExp(self): 35614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.exp) 35714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('exp(-1)', math.exp(-1), 1/math.e) 35814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('exp(0)', math.exp(0), 1) 35914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('exp(1)', math.exp(1), math.e) 36014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.exp(INF), INF) 36114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.exp(NINF), 0.) 36214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.exp(NAN))) 36314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 36414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testFabs(self): 36514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.fabs) 36614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fabs(-1)', math.fabs(-1), 1) 36714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fabs(0)', math.fabs(0), 0) 36814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fabs(1)', math.fabs(1), 1) 36914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 37014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testFactorial(self): 37114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def fact(n): 37214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber result = 1 3731543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih for i in range(1, int(n)+1): 3741543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih result *= i 3751543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih return result 3761543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih values = range(10) + [50, 100, 500] 3771543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih random.shuffle(values) 3781543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih for x in values: 3791543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih for cast in (int, long, float): 3801543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(math.factorial(cast(x)), fact(x), (x, fact(x), math.factorial(x))) 3811543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(ValueError, math.factorial, -1) 3821543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(ValueError, math.factorial, math.pi) 3831543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 3841543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih def testFloor(self): 3851543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(TypeError, math.floor) 3861543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # These types will be int in py3k. 3871543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(float, type(math.floor(1))) 3881543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(float, type(math.floor(1L))) 3891543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(float, type(math.floor(1.0))) 3901543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('floor(0.5)', math.floor(0.5), 0) 3911543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('floor(1.0)', math.floor(1.0), 1) 3921543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('floor(1.5)', math.floor(1.5), 1) 3931543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('floor(-0.5)', math.floor(-0.5), -1) 39414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('floor(-1.0)', math.floor(-1.0), -1) 39514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('floor(-1.5)', math.floor(-1.5), -2) 39614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # pow() relies on floor() to check for integers 39714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # This fails on some platforms - so check it here 39814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167) 39914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167) 40014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ceil(INF), INF) 40114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ceil(NINF), NINF) 402a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.floor(NAN))) 403a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 404a44153c1a57202fb538659eb50706e60454d6273Andreas Huber class TestFloor(object): 405a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def __float__(self): 40614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber return 42.3 407a44153c1a57202fb538659eb50706e60454d6273Andreas Huber class TestNoFloor(object): 408a44153c1a57202fb538659eb50706e60454d6273Andreas Huber pass 409a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42) 41014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.floor, TestNoFloor()) 411a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 412a44153c1a57202fb538659eb50706e60454d6273Andreas Huber t = TestNoFloor() 413a44153c1a57202fb538659eb50706e60454d6273Andreas Huber t.__floor__ = lambda *args: args 414dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertRaises(TypeError, math.floor, t) 415dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertRaises(TypeError, math.floor, t, 0) 416dcb89b3b505522efde173c105a851c412f947178Chong Zhang 417dcb89b3b505522efde173c105a851c412f947178Chong Zhang def testFmod(self): 418dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.assertRaises(TypeError, math.fmod) 419dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.ftest('fmod(10,1)', math.fmod(10,1), 0) 42014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fmod(10,0.5)', math.fmod(10,0.5), 0) 42114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fmod(10,1.5)', math.fmod(10,1.5), 1) 42214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fmod(-10,1)', math.fmod(-10,1), 0) 42314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fmod(-10,0.5)', math.fmod(-10,0.5), 0) 42414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('fmod(-10,1.5)', math.fmod(-10,1.5), -1) 42514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.fmod(NAN, 1.))) 42614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.fmod(1., NAN))) 42714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.fmod(NAN, NAN))) 42814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.fmod, 1., 0.) 42914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.fmod, INF, 1.) 43014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.fmod, NINF, 1.) 43114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.fmod, INF, 0.) 43214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.fmod(3.0, INF), 3.0) 43314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.fmod(-3.0, INF), -3.0) 43414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.fmod(3.0, NINF), 3.0) 435a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.fmod(-3.0, NINF), -3.0) 43614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.fmod(0.0, 3.0), 0.0) 437a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.fmod(0.0, NINF), 0.0) 4381543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 4391543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih def testFrexp(self): 4401543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertRaises(TypeError, math.frexp) 4411543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 4421543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih def testfrexp(name, result, expected): 443a44153c1a57202fb538659eb50706e60454d6273Andreas Huber (mant, exp), (emant, eexp) = result, expected 444a44153c1a57202fb538659eb50706e60454d6273Andreas Huber if abs(mant-emant) > eps or exp != eexp: 445a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.fail('%s returned %r, expected %r'%\ 446a44153c1a57202fb538659eb50706e60454d6273Andreas Huber (name, (mant, exp), (emant,eexp))) 447a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 448a44153c1a57202fb538659eb50706e60454d6273Andreas Huber testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1)) 449a44153c1a57202fb538659eb50706e60454d6273Andreas Huber testfrexp('frexp(0)', math.frexp(0), (0, 0)) 450a44153c1a57202fb538659eb50706e60454d6273Andreas Huber testfrexp('frexp(1)', math.frexp(1), (0.5, 1)) 451a44153c1a57202fb538659eb50706e60454d6273Andreas Huber testfrexp('frexp(2)', math.frexp(2), (0.5, 2)) 452a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 453a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.frexp(INF)[0], INF) 454a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.frexp(NINF)[0], NINF) 455a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.frexp(NAN)[0])) 456a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 457a44153c1a57202fb538659eb50706e60454d6273Andreas Huber @requires_IEEE_754 458a44153c1a57202fb538659eb50706e60454d6273Andreas Huber @unittest.skipIf(HAVE_DOUBLE_ROUNDING, 459a44153c1a57202fb538659eb50706e60454d6273Andreas Huber "fsum is not exact on machines with double rounding") 4608ca002eedc747dd854b61cbe364b52c06869273fRobert Shih def testFsum(self): 4618ca002eedc747dd854b61cbe364b52c06869273fRobert Shih # math.fsum relies on exact rounding for correct operation. 4628ca002eedc747dd854b61cbe364b52c06869273fRobert Shih # There's a known problem with IA32 floating-point that causes 4638ca002eedc747dd854b61cbe364b52c06869273fRobert Shih # inexact rounding in some situations, and will cause the 4648ca002eedc747dd854b61cbe364b52c06869273fRobert Shih # math.fsum tests below to fail; see issue #2937. On non IEEE 4658ca002eedc747dd854b61cbe364b52c06869273fRobert Shih # 754 platforms, and on IEEE 754 platforms that exhibit the 466a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # problem described in issue #2937, we simply skip the whole 467a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # test. 468a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 469a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # Python version of math.fsum, for comparison. Uses a 470ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber # different algorithm based on frexp, ldexp and integer 471ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber # arithmetic. 472ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber from sys import float_info 473ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber mant_dig = float_info.mant_dig 474ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber etiny = float_info.min_exp - mant_dig 475ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber 476ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber def msum(iterable): 477ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber """Full precision summation. Compute sum(iterable) without any 478ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber intermediate accumulation of error. Based on the 'lsum' function 479ad0d9c9c39a24b7fbd94e935a5855c9025341929Andreas Huber at http://code.activestate.com/recipes/393090/ 480a1df816c0677185534babba6ffc29970b048e52eLajos Molnar 481a1df816c0677185534babba6ffc29970b048e52eLajos Molnar """ 482a44153c1a57202fb538659eb50706e60454d6273Andreas Huber tmant, texp = 0, 0 483a44153c1a57202fb538659eb50706e60454d6273Andreas Huber for x in iterable: 484a44153c1a57202fb538659eb50706e60454d6273Andreas Huber mant, exp = math.frexp(x) 4857e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig 48614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if texp > exp: 487ab8a0badb8fb1e294dacf2eb6a891439f348aff9Andreas Huber tmant <<= texp-exp 48814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber texp = exp 489a1df816c0677185534babba6ffc29970b048e52eLajos Molnar else: 490ab8a0badb8fb1e294dacf2eb6a891439f348aff9Andreas Huber mant <<= exp-texp 49114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber tmant += mant 492ab8a0badb8fb1e294dacf2eb6a891439f348aff9Andreas Huber # Round tmant * 2**texp to a float. The original recipe 493ab8a0badb8fb1e294dacf2eb6a891439f348aff9Andreas Huber # used float(str(tmant)) * 2.0**texp for this, but that's 494a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # a little unsafe because str -> float conversion can't be 49514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # relied upon to do correct rounding on all platforms. 49614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp) 49714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if tail > 0: 49814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber h = 1 << (tail-1) 49914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1) 50014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber texp += tail 50114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber return math.ldexp(tmant, texp) 50214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 50314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber test_values = [ 50414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([], 0.0), 505a44153c1a57202fb538659eb50706e60454d6273Andreas Huber ([0.0], 0.0), 506a44153c1a57202fb538659eb50706e60454d6273Andreas Huber ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100), 50714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0), 50814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0), 509a44153c1a57202fb538659eb50706e60454d6273Andreas Huber ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0), 51014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0), 51114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([1./n for n in range(1, 1001)], 512a44153c1a57202fb538659eb50706e60454d6273Andreas Huber float.fromhex('0x1.df11f45f4e61ap+2')), 513a44153c1a57202fb538659eb50706e60454d6273Andreas Huber ([(-1.)**n/n for n in range(1, 1001)], 514a44153c1a57202fb538659eb50706e60454d6273Andreas Huber float.fromhex('-0x1.62a2af1bd3624p-1')), 515a44153c1a57202fb538659eb50706e60454d6273Andreas Huber ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0), 51614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([1e16, 1., 1e-16], 10000000000000002.0), 51714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0), 51814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # exercise code for resizing partials array 51914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] + 520a44153c1a57202fb538659eb50706e60454d6273Andreas Huber [-2.**1022], 521a44153c1a57202fb538659eb50706e60454d6273Andreas Huber float.fromhex('0x1.5555555555555p+970')), 522a44153c1a57202fb538659eb50706e60454d6273Andreas Huber ] 523a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 524a44153c1a57202fb538659eb50706e60454d6273Andreas Huber for i, (vals, expected) in enumerate(test_values): 525a44153c1a57202fb538659eb50706e60454d6273Andreas Huber try: 52614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber actual = math.fsum(vals) 52714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber except OverflowError: 52814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.fail("test %d failed: got OverflowError, expected %r " 52914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber "for math.fsum(%.100r)" % (i, expected, vals)) 53014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber except ValueError: 53114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.fail("test %d failed: got ValueError, expected %r " 53214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber "for math.fsum(%.100r)" % (i, expected, vals)) 53314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(actual, expected) 53414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 53514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber from random import random, gauss, shuffle 53614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber for j in xrange(1000): 53714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10 53814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber s = 0 539a44153c1a57202fb538659eb50706e60454d6273Andreas Huber for i in xrange(200): 540a44153c1a57202fb538659eb50706e60454d6273Andreas Huber v = gauss(0, random()) ** 7 - s 541dcb89b3b505522efde173c105a851c412f947178Chong Zhang s += v 542dcb89b3b505522efde173c105a851c412f947178Chong Zhang vals.append(v) 543a44153c1a57202fb538659eb50706e60454d6273Andreas Huber shuffle(vals) 544a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 54514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber s = msum(vals) 54614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(msum(vals), math.fsum(vals)) 54714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 54814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testHypot(self): 54914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.hypot) 5501543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('hypot(0,0)', math.hypot(0,0), 0) 5511543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('hypot(3,4)', math.hypot(3,4), 5) 5521543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(math.hypot(NAN, INF), INF) 5531543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(math.hypot(INF, NAN), INF) 55414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.hypot(NAN, NINF), INF) 55514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.hypot(NINF, NAN), INF) 55614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.hypot(1.0, NAN))) 55714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.hypot(NAN, -2.0))) 55814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 559a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def testLdexp(self): 56014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.ldexp) 56114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ldexp(0,1)', math.ldexp(0,1), 0) 562ab8a0badb8fb1e294dacf2eb6a891439f348aff9Andreas Huber self.ftest('ldexp(1,1)', math.ldexp(1,1), 2) 56314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5) 56414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2) 56514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(OverflowError, math.ldexp, 1., 1000000) 56614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(OverflowError, math.ldexp, -1., 1000000) 56714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(1., -1000000), 0.) 56814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(-1., -1000000), -0.) 56914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(INF, 30), INF) 57014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(NINF, -213), NINF) 57114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.ldexp(NAN, 0))) 57214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 57314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # large second argument 57414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]: 57514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(INF, -n), INF) 57614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(NINF, -n), NINF) 57714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(1., -n), 0.) 57814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(-1., -n), -0.) 57914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(0., -n), 0.) 58014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(-0., -n), -0.) 58114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.ldexp(NAN, -n))) 58214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 58314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(OverflowError, math.ldexp, 1., n) 58414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(OverflowError, math.ldexp, -1., n) 58514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(0., n), 0.) 58614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(-0., n), -0.) 58714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(INF, n), INF) 58814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.ldexp(NINF, n), NINF) 58914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.ldexp(NAN, n))) 59014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 59114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testLog(self): 59214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.log) 5931543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest('log(1/e)', math.log(1/math.e), -1) 59414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('log(1)', math.log(1), 0) 59514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('log(e)', math.log(math.e), 1) 59614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('log(32,2)', math.log(32,2), 5) 59714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('log(10**40, 10)', math.log(10**40, 10), 40) 59814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2) 5991543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.assertEqual(math.log(INF), INF) 60014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.log, NINF) 60114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.log(NAN))) 60214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 60314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testLog1p(self): 60414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.log1p) 605a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('log1p(1/e -1)', math.log1p(1/math.e-1), -1) 606a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('log1p(0)', math.log1p(0), 0) 6078dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('log1p(e-1)', math.log1p(math.e-1), 1) 6088dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('log1p(1)', math.log1p(1), math.log(2)) 6098dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.log1p(INF), INF) 6108dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertRaises(ValueError, math.log1p, NINF) 6118dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertTrue(math.isnan(math.log1p(NAN))) 6128dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih n= 2**90 6138dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertAlmostEqual(math.log1p(n), 62.383246250395075) 6148dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertAlmostEqual(math.log1p(n), math.log1p(float(n))) 6158dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih 6168dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih def testLog10(self): 6178dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertRaises(TypeError, math.log10) 6188dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('log10(0.1)', math.log10(0.1), -1) 6198dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('log10(1)', math.log10(1), 0) 6208dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('log10(10)', math.log10(10), 1) 6218dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.log(INF), INF) 6228dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertRaises(ValueError, math.log10, NINF) 62343ca783effd99bba0e6e2dd6fe177a8888578ef8Robert Shih self.assertTrue(math.isnan(math.log10(NAN))) 6242aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber 6258dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih def testModf(self): 6268dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertRaises(TypeError, math.modf) 62797194cdf8d67f362ef8c6dfdf607298c7e102b3bMarco Nelissen 628784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo def testmodf(name, result, expected): 6298dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih (v1, v2), (e1, e2) = result, expected 6308dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih if abs(v1-e1) > eps or abs(v2-e2): 6318dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.fail('%s returned %r, expected %r'%\ 6328dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih (name, (v1,v2), (e1,e2))) 6338dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih 634a44153c1a57202fb538659eb50706e60454d6273Andreas Huber testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0)) 6358dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0)) 6368dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih 6378dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.modf(INF), (0.0, INF)) 6388dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.modf(NINF), (-0.0, NINF)) 6398dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih 6408dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih modf_nan = math.modf(NAN) 6418dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertTrue(math.isnan(modf_nan[0])) 6428dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertTrue(math.isnan(modf_nan[1])) 6438dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih 6448dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih def testPow(self): 6458dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertRaises(TypeError, math.pow) 6468dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('pow(0,1)', math.pow(0,1), 0) 6478dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('pow(1,0)', math.pow(1,0), 1) 6488dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('pow(2,1)', math.pow(2,1), 2) 6498dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.ftest('pow(2,-1)', math.pow(2,-1), 0.5) 6508dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(INF, 1), INF) 6518dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(NINF, 1), NINF) 6528dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual((math.pow(1, INF)), 1.) 6538dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual((math.pow(1, NINF)), 1.) 6548dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertTrue(math.isnan(math.pow(NAN, 1))) 655a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.pow(2, NAN))) 6568dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertTrue(math.isnan(math.pow(0, NAN))) 6578dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(1, NAN), 1) 6588dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih 659a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # pow(0., x) 6608dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(0., INF), 0.) 661a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(0., 3.), 0.) 662a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(0., 2.3), 0.) 663a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(0., 2.), 0.) 6648dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(0., 0.), 1.) 6658dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(0., -0.), 1.) 666a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, 0., -2.) 667a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, 0., -2.3) 668a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, 0., -3.) 6698dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertRaises(ValueError, math.pow, 0., NINF) 6708dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertTrue(math.isnan(math.pow(0., NAN))) 6718dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih 6728dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih # pow(INF, x) 673a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(INF, INF), INF) 67443ca783effd99bba0e6e2dd6fe177a8888578ef8Robert Shih self.assertEqual(math.pow(INF, 3.), INF) 6758dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(INF, 2.3), INF) 676b4a7a2df4c28c3f32b5d877b54831d2cc5d78f81Colin Cross self.assertEqual(math.pow(INF, 2.), INF) 6778dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(INF, 0.), 1.) 6788dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(INF, -0.), 1.) 679a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(INF, -2.), 0.) 6808dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(INF, -2.3), 0.) 681a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(INF, -3.), 0.) 6828dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(INF, NINF), 0.) 683a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.pow(INF, NAN))) 684a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 685b4a7a2df4c28c3f32b5d877b54831d2cc5d78f81Colin Cross # pow(-0., x) 686a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-0., INF), 0.) 687a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-0., 3.), -0.) 688a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-0., 2.3), 0.) 689a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-0., 2.), 0.) 690a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-0., 0.), 1.) 691a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-0., -0.), 1.) 692a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, -0., -2.) 693a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, -0., -2.3) 694a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, -0., -3.) 6952aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertRaises(ValueError, math.pow, -0., NINF) 6962aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertTrue(math.isnan(math.pow(-0., NAN))) 6972aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber 698b4a7a2df4c28c3f32b5d877b54831d2cc5d78f81Colin Cross # pow(NINF, x) 6992aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, INF), INF) 7002aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, 3.), NINF) 7012aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, 2.3), INF) 7022aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, 2.), INF) 7032aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, 0.), 1.) 7042aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, -0.), 1.) 7052aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, -2.), 0.) 7062aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber self.assertEqual(math.pow(NINF, -2.3), 0.) 7078dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(NINF, -3.), -0.) 7088dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertEqual(math.pow(NINF, NINF), 0.) 7098dd1c202aea703ed8beacaaa0dad5ae9c76a0863Robert Shih self.assertTrue(math.isnan(math.pow(NINF, NAN))) 710a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 7112aa4cc04154d82f6658fb86f394f13bb488b0468Andreas Huber # pow(-1, x) 712a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., INF), 1.) 713a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., 3.), -1.) 71420ad3a341a96e7746015ccb7369fa567897e11f6Andreas Huber self.assertRaises(ValueError, math.pow, -1., 2.3) 715a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., 2.), 1.) 716a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., 0.), 1.) 717a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., -0.), 1.) 718a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., -2.), 1.) 719a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, -1., -2.3) 720a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., -3.), -1.) 721a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-1., NINF), 1.) 72243ca783effd99bba0e6e2dd6fe177a8888578ef8Robert Shih self.assertTrue(math.isnan(math.pow(-1., NAN))) 723a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 724a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # pow(1, x) 725a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(1., INF), 1.) 726784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo self.assertEqual(math.pow(1., 3.), 1.) 72797194cdf8d67f362ef8c6dfdf607298c7e102b3bMarco Nelissen self.assertEqual(math.pow(1., 2.3), 1.) 728784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo self.assertEqual(math.pow(1., 2.), 1.) 729784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo self.assertEqual(math.pow(1., 0.), 1.) 730784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo self.assertEqual(math.pow(1., -0.), 1.) 731784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo self.assertEqual(math.pow(1., -2.), 1.) 732a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(1., -2.3), 1.) 73343ca783effd99bba0e6e2dd6fe177a8888578ef8Robert Shih self.assertEqual(math.pow(1., -3.), 1.) 734a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(1., NINF), 1.) 735a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(1., NAN), 1.) 73614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 73714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # pow(x, 0) should be 1 for any x 738b7c8e91880463ff4981e3e53e98e45d68e2fe374Andreas Huber self.assertEqual(math.pow(2.3, 0.), 1.) 739b7c8e91880463ff4981e3e53e98e45d68e2fe374Andreas Huber self.assertEqual(math.pow(-2.3, 0.), 1.) 7407e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(NAN, 0.), 1.) 7417e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(2.3, -0.), 1.) 742a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.pow(-2.3, -0.), 1.) 743784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo self.assertEqual(math.pow(NAN, -0.), 1.) 74443ca783effd99bba0e6e2dd6fe177a8888578ef8Robert Shih 745a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # pow(x, y) is invalid if x is negative and y is not integral 74643ca783effd99bba0e6e2dd6fe177a8888578ef8Robert Shih self.assertRaises(ValueError, math.pow, -1., 2.3) 747a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.pow, -15., -3.1) 748a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 749a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # pow(x, NINF) 7507e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(1.9, NINF), 0.) 7517e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(1.1, NINF), 0.) 7527e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(0.9, NINF), INF) 7537e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(0.1, NINF), INF) 7547e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-0.1, NINF), INF) 7557e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-0.9, NINF), INF) 7567e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-1.1, NINF), 0.) 7577e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-1.9, NINF), 0.) 7587e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber 7597e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber # pow(x, INF) 7607e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(1.9, INF), INF) 7617e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(1.1, INF), INF) 76214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.pow(0.9, INF), 0.) 7637e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(0.1, INF), 0.) 7647e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-0.1, INF), 0.) 7657e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-0.9, INF), 0.) 7667e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-1.1, INF), INF) 7677e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.assertEqual(math.pow(-1.9, INF), INF) 7687e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber 76914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # pow(x, y) should work for x negative, y an integer 77014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('(-2.)**3.', math.pow(-2.0, 3.0), -8.0) 77114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('(-2.)**2.', math.pow(-2.0, 2.0), 4.0) 7727e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.ftest('(-2.)**1.', math.pow(-2.0, 1.0), -2.0) 7737e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber self.ftest('(-2.)**0.', math.pow(-2.0, 0.0), 1.0) 774a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('(-2.)**-0.', math.pow(-2.0, -0.0), 1.0) 775784faaf1d76902be6b36d3af01fb5325f0d45a04Martin Storsjo self.ftest('(-2.)**-1.', math.pow(-2.0, -1.0), -0.5) 776a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('(-2.)**-2.', math.pow(-2.0, -2.0), 0.25) 777a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('(-2.)**-3.', math.pow(-2.0, -3.0), -0.125) 77829357bc2c0dd7c43ad3bd0c8e3efa4e6fd9bfd47Steve Block self.assertRaises(ValueError, math.pow, -2.0, -0.5) 7799067e30b3ccb3a07e41b61af22c036378053a9a3Andreas Huber self.assertRaises(ValueError, math.pow, -2.0, 0.5) 780a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 781a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # the following tests have been commented out since they don't 782a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # really belong here: the implementation of ** for floats is 783a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # independent of the implementation of math.pow 784a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1**NAN, 1) 785a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1**INF, 1) 786a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1**NINF, 1) 787a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1**0, 1) 788a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1.**NAN, 1) 789a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1.**INF, 1) 790a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1.**NINF, 1) 791a44153c1a57202fb538659eb50706e60454d6273Andreas Huber #self.assertEqual(1.**0, 1) 792a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 793a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def testRadians(self): 794a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(TypeError, math.radians) 795a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('radians(180)', math.radians(180), math.pi) 796a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('radians(90)', math.radians(90), math.pi/2) 797673158582c9589cee1d5e4d7c79622609938b8f8Andreas Huber self.ftest('radians(-45)', math.radians(-45), -math.pi/4) 79814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 799a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def testSin(self): 80014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.sin) 80114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sin(0)', math.sin(0), 0) 80214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sin(pi/2)', math.sin(math.pi/2), 1) 80314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sin(-pi/2)', math.sin(-math.pi/2), -1) 80414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber try: 805a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.sin(INF))) 806a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.sin(NINF))) 807a44153c1a57202fb538659eb50706e60454d6273Andreas Huber except ValueError: 80814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.sin, INF) 80914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.sin, NINF) 81014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.sin(NAN))) 81114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 81214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testSinh(self): 81314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.sinh) 81414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sinh(0)', math.sinh(0), 0) 81514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1) 81614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0) 817a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.sinh(INF), INF) 81814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.sinh(NINF), NINF) 81914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.sinh(NAN))) 82014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 82114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testSqrt(self): 82214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.sqrt) 82314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sqrt(0)', math.sqrt(0), 0) 82414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sqrt(1)', math.sqrt(1), 1) 82514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('sqrt(4)', math.sqrt(4), 2) 82614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.sqrt(INF), INF) 82714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.sqrt, NINF) 82814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.sqrt(NAN))) 829a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 83014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testTan(self): 83114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.tan) 83214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('tan(0)', math.tan(0), 0) 83314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('tan(pi/4)', math.tan(math.pi/4), 1) 83414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1) 83514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber try: 83614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.tan(INF))) 83714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(math.tan(NINF))) 83814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber except: 83914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(ValueError, math.tan, INF) 840a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(ValueError, math.tan, NINF) 841a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.tan(NAN))) 842a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 843a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def testTanh(self): 844a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertRaises(TypeError, math.tanh) 845a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('tanh(0)', math.tanh(0), 0) 846a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0) 847a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('tanh(inf)', math.tanh(INF), 1) 848a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.ftest('tanh(-inf)', math.tanh(NINF), -1) 849a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isnan(math.tanh(NAN))) 85014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # check that tanh(-0.) == -0. on IEEE 754 systems 85114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if float.__getformat__("double").startswith("IEEE"): 852a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.tanh(-0.), -0.) 853a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.copysign(1., math.tanh(-0.)), 854a44153c1a57202fb538659eb50706e60454d6273Andreas Huber math.copysign(1., -0.)) 855a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 856a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def test_trunc(self): 857a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.trunc(1), 1) 858a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.trunc(-1), -1) 859a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(type(math.trunc(1)), int) 860a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(type(math.trunc(1.5)), int) 861a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.trunc(1.5), 1) 862a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.trunc(-1.5), -1) 86314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.trunc(1.999999), 1) 864a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.trunc(-1.999999), -1) 865a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.trunc(-0.999999), -0) 866a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertEqual(math.trunc(-100.999), -100) 867a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 868a44153c1a57202fb538659eb50706e60454d6273Andreas Huber class TestTrunc(object): 869a44153c1a57202fb538659eb50706e60454d6273Andreas Huber def __trunc__(self): 870a44153c1a57202fb538659eb50706e60454d6273Andreas Huber return 23 87114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 87214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber class TestNoTrunc(object): 87314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber pass 87414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 87514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertEqual(math.trunc(TestTrunc()), 23) 87614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 87714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.trunc) 87814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises(TypeError, math.trunc, 1, 2) 87914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertRaises((AttributeError, TypeError), math.trunc, 88014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber TestNoTrunc()) 88114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 88214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testIsnan(self): 88314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(float("nan"))) 88414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isnan(float("inf")* 0.)) 885a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertFalse(math.isnan(float("inf"))) 886a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertFalse(math.isnan(0.)) 887a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertFalse(math.isnan(1.)) 888a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 88914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def testIsinf(self): 89014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertTrue(math.isinf(float("inf"))) 891a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isinf(float("-inf"))) 892a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isinf(1E400)) 893a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.assertTrue(math.isinf(-1E400)) 89414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertFalse(math.isinf(float("nan"))) 89514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertFalse(math.isinf(0.)) 89614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.assertFalse(math.isinf(1.)) 8977e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber 89814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # RED_FLAG 16-Oct-2000 Tim 89914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # While 2.0 is more consistent about exceptions than previous releases, it 9007e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber # still fails this part of the test on some platforms. For now, we only 9017e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber # *run* test_exceptions() in verbose mode, so that this isn't normally 90214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # tested. 9037e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber 9047e43a5a2dcfa9bc64ef477472a33c87a84695c09Andreas Huber if verbose: 90514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def test_exceptions(self): 90614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber try: 90714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber x = math.exp(-1000000000) 90814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber except: 909b7c8e91880463ff4981e3e53e98e45d68e2fe374Andreas Huber # mathmodule.c is failing to weed out underflows from libm, or 91014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # we've got an fp format with huge dynamic range 91114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.fail("underflowing exp() should not have raised " 912a44153c1a57202fb538659eb50706e60454d6273Andreas Huber "an exception") 913a44153c1a57202fb538659eb50706e60454d6273Andreas Huber if x != 0: 914a44153c1a57202fb538659eb50706e60454d6273Andreas Huber self.fail("underflowing exp() should have returned 0") 91514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 916a44153c1a57202fb538659eb50706e60454d6273Andreas Huber # If this fails, probably using a strict IEEE-754 conforming libm, and x 91714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # is +Inf afterwards. But Python wants overflows detected by default. 91814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber try: 9190f30bd90272c818aa37c0bb22d22eaa7d3689879Andreas Huber x = math.exp(1000000000) 92014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber except OverflowError: 92114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber pass 92214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber else: 92314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber self.fail("overflowing exp() didn't trigger OverflowError") 9240f30bd90272c818aa37c0bb22d22eaa7d3689879Andreas Huber 92514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # If this fails, it could be a puzzle. One odd possibility is that 92614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # mathmodule.c's macros are getting confused while comparing 92714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE 9280f30bd90272c818aa37c0bb22d22eaa7d3689879Andreas Huber # as a result (and so raising OverflowError instead). 929dcb89b3b505522efde173c105a851c412f947178Chong Zhang try: 930dcb89b3b505522efde173c105a851c412f947178Chong Zhang x = math.sqrt(-1.0) 931dcb89b3b505522efde173c105a851c412f947178Chong Zhang except ValueError: 932dcb89b3b505522efde173c105a851c412f947178Chong Zhang pass 933dcb89b3b505522efde173c105a851c412f947178Chong Zhang else: 934dcb89b3b505522efde173c105a851c412f947178Chong Zhang self.fail("sqrt(-1) didn't raise ValueError") 935dcb89b3b505522efde173c105a851c412f947178Chong Zhang 936dcb89b3b505522efde173c105a851c412f947178Chong Zhang @requires_IEEE_754 937dcb89b3b505522efde173c105a851c412f947178Chong Zhang def test_testfile(self): 938dcb89b3b505522efde173c105a851c412f947178Chong Zhang for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file): 939dcb89b3b505522efde173c105a851c412f947178Chong Zhang # Skip if either the input or result is complex, or if 940dcb89b3b505522efde173c105a851c412f947178Chong Zhang # flags is nonempty 9411543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih if ai != 0. or ei != 0. or flags: 9421543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih continue 9431543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih if fn in ['rect', 'polar']: 9441543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # no real versions of rect, polar 9451543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih continue 9461543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih func = getattr(math, fn) 9471543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih try: 9481543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih result = func(ar) 9491543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih except ValueError: 9501543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih message = ("Unexpected ValueError in " + 9511543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih "test %s:%s(%r)\n" % (id, fn, ar)) 9521543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.fail(message) 9531543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih except OverflowError: 954dcb89b3b505522efde173c105a851c412f947178Chong Zhang message = ("Unexpected OverflowError in " + 955dcb89b3b505522efde173c105a851c412f947178Chong Zhang "test %s:%s(%r)\n" % (id, fn, ar)) 9561543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.fail(message) 9571543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.ftest("%s:%s(%r)" % (id, fn, ar), result, er) 9581543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 9591543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 96014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber "test requires IEEE 754 doubles") 96114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber def test_mtestfile(self): 962a44153c1a57202fb538659eb50706e60454d6273Andreas Huber ALLOWED_ERROR = 20 # permitted error, in ulps 96314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber fail_fmt = "{}:{}({!r}): expected {!r}, got {!r}" 96443c3e6ce02215ca99d506458f596cb1211639f29Andreas Huber 965b4a7a2df4c28c3f32b5d877b54831d2cc5d78f81Colin Cross failures = [] 966dcb89b3b505522efde173c105a851c412f947178Chong Zhang for id, fn, arg, expected, flags in parse_mtestfile(math_testcases): 96743c3e6ce02215ca99d506458f596cb1211639f29Andreas Huber func = getattr(math, fn) 968dcb89b3b505522efde173c105a851c412f947178Chong Zhang 969dcb89b3b505522efde173c105a851c412f947178Chong Zhang if 'invalid' in flags or 'divide-by-zero' in flags: 970dcb89b3b505522efde173c105a851c412f947178Chong Zhang expected = 'ValueError' 97143c3e6ce02215ca99d506458f596cb1211639f29Andreas Huber elif 'overflow' in flags: 97214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber expected = 'OverflowError' 97314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 974a44153c1a57202fb538659eb50706e60454d6273Andreas Huber try: 9751543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih got = func(arg) 9761543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih except ValueError: 977a44153c1a57202fb538659eb50706e60454d6273Andreas Huber got = 'ValueError' 9788ca002eedc747dd854b61cbe364b52c06869273fRobert Shih except OverflowError: 9798ca002eedc747dd854b61cbe364b52c06869273fRobert Shih got = 'OverflowError' 9808ca002eedc747dd854b61cbe364b52c06869273fRobert Shih 9818ca002eedc747dd854b61cbe364b52c06869273fRobert Shih accuracy_failure = None 9828ca002eedc747dd854b61cbe364b52c06869273fRobert Shih if isinstance(got, float) and isinstance(expected, float): 98314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if math.isnan(expected) and math.isnan(got): 984aea5aff45a1af14e249ac311f0a128a621a7d13eAndreas Huber continue 98514f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if not math.isnan(expected) and not math.isnan(got): 98614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if fn == 'lgamma': 98714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # we use a weaker accuracy test for lgamma; 98814f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # lgamma only achieves an absolute error of 989aea5aff45a1af14e249ac311f0a128a621a7d13eAndreas Huber # a few multiples of the machine accuracy, in 99014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber # general. 991aea5aff45a1af14e249ac311f0a128a621a7d13eAndreas Huber accuracy_failure = acc_check(expected, got, 99214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber rel_err = 5e-15, 99314f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber abs_err = 5e-15) 9941543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih elif fn == 'erfc': 9951543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # erfc has less-than-ideal accuracy for large 9961543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # arguments (x ~ 25 or so), mainly due to the 9978ca002eedc747dd854b61cbe364b52c06869273fRobert Shih # error involved in computing exp(-x*x). 9981543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # 9991543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # XXX Would be better to weaken this test only 10001543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih # for large x, instead of for all x. 10011543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih accuracy_failure = ulps_check(expected, got, 2000) 10028ca002eedc747dd854b61cbe364b52c06869273fRobert Shih 10036801b4dbd00b485ecdcd31b517ed885a8fa21c63Andreas Huber else: 100414f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber accuracy_failure = ulps_check(expected, got, 20) 1005a44153c1a57202fb538659eb50706e60454d6273Andreas Huber if accuracy_failure is None: 100614f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber continue 100714f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 10086801b4dbd00b485ecdcd31b517ed885a8fa21c63Andreas Huber if isinstance(got, str) and isinstance(expected, str): 100914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber if got == expected: 10106801b4dbd00b485ecdcd31b517ed885a8fa21c63Andreas Huber continue 1011a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 1012a44153c1a57202fb538659eb50706e60454d6273Andreas Huber fail_msg = fail_fmt.format(id, fn, arg, expected, got) 10131543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih if accuracy_failure is not None: 10141543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih fail_msg += ' ({})'.format(accuracy_failure) 10151543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih failures.append(fail_msg) 10161543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 10171543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih if failures: 10181543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih self.fail('Failures in test_mtestfile:\n ' + 10191543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih '\n '.join(failures)) 102014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber 10211543d3c735a5ba4ddfcf8ab644575df13c7e30a9Robert Shih 102214f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huberdef test_main(): 10238ca002eedc747dd854b61cbe364b52c06869273fRobert Shih from doctest import DocFileSuite 10248ca002eedc747dd854b61cbe364b52c06869273fRobert Shih suite = unittest.TestSuite() 10258ca002eedc747dd854b61cbe364b52c06869273fRobert Shih suite.addTest(unittest.makeSuite(MathTests)) 10268ca002eedc747dd854b61cbe364b52c06869273fRobert Shih suite.addTest(DocFileSuite("ieee754.txt")) 10276e6b1cae2bac1b78205cefab8e4e9e9538982965Andreas Huber run_unittest(suite) 1028a44153c1a57202fb538659eb50706e60454d6273Andreas Huber 102914f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huberif __name__ == '__main__': 103014f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber test_main() 103114f7672b5d450ed26a06fd3bb3ce045ea78b11b2Andreas Huber