14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# Python test set -- math module 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# XXXX Should not do tests around zero only 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom test.test_support import run_unittest, verbose 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport unittest 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport math 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport os 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport sys 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport random 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport struct 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmeps = 1E-05 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmNAN = float('nan') 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmINF = float('inf') 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmNINF = float('-inf') 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# decorator for skipping tests on non-IEEE 754 platforms 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmrequires_IEEE_754 = unittest.skipUnless( 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__getformat__("double").startswith("IEEE"), 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test requires IEEE 754 doubles") 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# detect evidence of double-rounding: fsum is not always correctly 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# rounded on machines that suffer from double rounding. 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmx, y = 1e16, 2.9999 # use temporary values to defeat peephole optimizer 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmHAVE_DOUBLE_ROUNDING = (x + y == 1e16 + 4) 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# locate file with test values 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == '__main__': 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file = sys.argv[0] 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmelse: 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm file = __file__ 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtest_dir = os.path.dirname(file) or os.curdir 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmmath_testcases = os.path.join(test_dir, 'math_testcases.txt') 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtest_file = os.path.join(test_dir, 'cmath_testcases.txt') 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef to_ulps(x): 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Convert a non-NaN float x to an integer, in such a way that 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm adjacent floats are converted to adjacent integers. Then 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs(ulps(x) - ulps(y)) gives the difference in ulps between two 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm floats. 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm The results from this function will only make sense on platforms 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm where C doubles are represented in IEEE 754 binary64 format. 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """ 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = struct.unpack('<q', struct.pack('<d', x))[0] 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if n < 0: 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = ~(n+2**63) 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return n 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef ulps_check(expected, got, ulps=20): 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Given non-NaN floats `expected` and `got`, 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check that they're equal to within the given number of ulps. 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Returns None on success and an error message on failure.""" 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ulps_error = to_ulps(got) - to_ulps(expected) 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if abs(ulps_error) <= ulps: 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return None 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return "error = {} ulps; permitted error = {} ulps".format(ulps_error, 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ulps) 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef acc_check(expected, got, rel_err=2e-15, abs_err = 5e-323): 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Determine whether non-NaN floats a and b are equal to within a 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (small) rounding error. The default values for rel_err and 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs_err are chosen to be suitable for platforms where a float is 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm represented by an IEEE 754 double. They allow an error of between 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9 and 19 ulps.""" 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # need to special case infinities, since inf - inf gives nan 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if math.isinf(expected) and got == expected: 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return None 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm error = got - expected 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm permitted_error = max(abs_err, rel_err * abs(expected)) 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if abs(error) < permitted_error: 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return None 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return "error = {}; permitted error = {}".format(error, 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm permitted_error) 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef parse_mtestfile(fname): 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Parse a file with test values 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm -- starts a comment 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm blank lines, or lines containing only a comment, are ignored 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm other lines are expected to have the form 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id fn arg -> expected [flag]* 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """ 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with open(fname) as fp: 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for line in fp: 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # strip comments, and skip blank lines 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if '--' in line: 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = line[:line.index('--')] 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not line.strip(): 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lhs, rhs = line.split('->') 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id, fn, arg = lhs.split() 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rhs_pieces = rhs.split() 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exp = rhs_pieces[0] 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm flags = rhs_pieces[1:] 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield (id, fn, float(arg), float(exp), flags) 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef parse_testfile(fname): 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Parse a file with test values 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm Empty lines or lines starting with -- are ignored 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yields id, fn, arg_real, arg_imag, exp_real, exp_imag 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """ 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with open(fname) as fp: 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for line in fp: 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # skip comment lines and blank lines 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if line.startswith('--') or not line.strip(): 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lhs, rhs = line.split('->') 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm id, fn, arg_real, arg_imag = lhs.split() 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rhs_pieces = rhs.split() 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm exp_real, exp_imag = rhs_pieces[0], rhs_pieces[1] 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm flags = rhs_pieces[2:] 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm yield (id, fn, 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float(arg_real), float(arg_imag), 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float(exp_real), float(exp_imag), 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm flags 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass MathTests(unittest.TestCase): 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def ftest(self, name, value, expected): 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if abs(value-expected) > eps: 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Use %r instead of %f so the error message 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # displays full precision. Otherwise discrepancies 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # in the last few bits will lead to very confusing 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # error messages 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('%s returned %r, expected %r' % 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (name, value, expected)) 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testConstants(self): 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('pi', math.pi, 3.1415926) 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('e', math.e, 2.7182818) 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAcos(self): 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.acos) 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('acos(-1)', math.acos(-1), math.pi) 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('acos(0)', math.acos(0), math.pi/2) 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('acos(1)', math.acos(1), 0) 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.acos, INF) 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.acos, NINF) 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.acos(NAN))) 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAcosh(self): 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.acosh) 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('acosh(1)', math.acosh(1), 0) 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168) 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.acosh, 0) 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.acosh, -1) 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.acosh(INF), INF) 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.acosh, NINF) 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.acosh(NAN))) 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAsin(self): 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.asin) 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('asin(-1)', math.asin(-1), -math.pi/2) 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('asin(0)', math.asin(0), 0) 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('asin(1)', math.asin(1), math.pi/2) 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.asin, INF) 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.asin, NINF) 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.asin(NAN))) 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAsinh(self): 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.asinh) 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('asinh(0)', math.asinh(0), 0) 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305) 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305) 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.asinh(INF), INF) 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.asinh(NINF), NINF) 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.asinh(NAN))) 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAtan(self): 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.atan) 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan(-1)', math.atan(-1), -math.pi/4) 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan(0)', math.atan(0), 0) 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan(1)', math.atan(1), math.pi/4) 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan(inf)', math.atan(INF), math.pi/2) 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan(-inf)', math.atan(NINF), -math.pi/2) 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan(NAN))) 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAtanh(self): 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.atan) 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atanh(0)', math.atanh(0), 0) 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atanh(0.5)', math.atanh(0.5), 0.54930614433405489) 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atanh(-0.5)', math.atanh(-0.5), -0.54930614433405489) 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.atanh, 1) 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.atanh, -1) 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.atanh, INF) 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.atanh, NINF) 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atanh(NAN))) 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testAtan2(self): 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.atan2) 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-1, 0)', math.atan2(-1, 0), -math.pi/2) 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-1, 1)', math.atan2(-1, 1), -math.pi/4) 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(0, 1)', math.atan2(0, 1), 0) 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(1, 1)', math.atan2(1, 1), math.pi/4) 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(1, 0)', math.atan2(1, 0), math.pi/2) 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.atan2(0, x) 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(0., -inf)', math.atan2(0., NINF), math.pi) 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(0., -2.3)', math.atan2(0., -2.3), math.pi) 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(0., -0.)', math.atan2(0., -0.), math.pi) 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(0., 0.), 0.) 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(0., 2.3), 0.) 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(0., INF), 0.) 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(0., NAN))) 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.atan2(-0, x) 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-0., -inf)', math.atan2(-0., NINF), -math.pi) 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-0., -2.3)', math.atan2(-0., -2.3), -math.pi) 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-0., -0.)', math.atan2(-0., -0.), -math.pi) 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(-0., 0.), -0.) 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(-0., 2.3), -0.) 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(-0., INF), -0.) 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(-0., NAN))) 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.atan2(INF, x) 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(inf, -inf)', math.atan2(INF, NINF), math.pi*3/4) 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(inf, -2.3)', math.atan2(INF, -2.3), math.pi/2) 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(inf, -0.)', math.atan2(INF, -0.0), math.pi/2) 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(inf, 0.)', math.atan2(INF, 0.0), math.pi/2) 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(inf, 2.3)', math.atan2(INF, 2.3), math.pi/2) 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(inf, inf)', math.atan2(INF, INF), math.pi/4) 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(INF, NAN))) 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.atan2(NINF, x) 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-inf, -inf)', math.atan2(NINF, NINF), -math.pi*3/4) 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-inf, -2.3)', math.atan2(NINF, -2.3), -math.pi/2) 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-inf, -0.)', math.atan2(NINF, -0.0), -math.pi/2) 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-inf, 0.)', math.atan2(NINF, 0.0), -math.pi/2) 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-inf, 2.3)', math.atan2(NINF, 2.3), -math.pi/2) 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-inf, inf)', math.atan2(NINF, INF), -math.pi/4) 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NINF, NAN))) 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.atan2(+finite, x) 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(2.3, -inf)', math.atan2(2.3, NINF), math.pi) 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(2.3, -0.)', math.atan2(2.3, -0.), math.pi/2) 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(2.3, 0.)', math.atan2(2.3, 0.), math.pi/2) 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(2.3, INF), 0.) 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(2.3, NAN))) 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.atan2(-finite, x) 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-2.3, -inf)', math.atan2(-2.3, NINF), -math.pi) 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-2.3, -0.)', math.atan2(-2.3, -0.), -math.pi/2) 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('atan2(-2.3, 0.)', math.atan2(-2.3, 0.), -math.pi/2) 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(-2.3, INF), -0.) 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(-2.3, NAN))) 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.atan2(NAN, x) 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NAN, NINF))) 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NAN, -2.3))) 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NAN, -0.))) 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NAN, 0.))) 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NAN, 2.3))) 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NAN, INF))) 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.atan2(NAN, NAN))) 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testCeil(self): 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.ceil) 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # These types will be int in py3k. 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float, type(math.ceil(1))) 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float, type(math.ceil(1L))) 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float, type(math.ceil(1.0))) 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ceil(0.5)', math.ceil(0.5), 1) 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ceil(1.0)', math.ceil(1.0), 1) 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ceil(1.5)', math.ceil(1.5), 2) 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ceil(-0.5)', math.ceil(-0.5), 0) 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ceil(-1.0)', math.ceil(-1.0), -1) 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ceil(-1.5)', math.ceil(-1.5), -1) 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ceil(INF), INF) 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ceil(NINF), NINF) 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.ceil(NAN))) 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestCeil(object): 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 41.3 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestNoCeil(object): 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42) 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.ceil, TestNoCeil()) 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = TestNoCeil() 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t.__ceil__ = lambda *args: args 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.ceil, t) 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.ceil, t, 0) 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testCopysign(self): 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(1, 42), 1.0) 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(0., 42), 0.0) 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(1., -42), -1.0) 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(3, 0.), 3.0) 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(4., -0.), -4.0) 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.copysign) 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # copysign should let us distinguish signs of zeros 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(1., 0.), 1.) 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(1., -0.), -1.) 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(INF, 0.), INF) 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(INF, -0.), NINF) 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(NINF, 0.), INF) 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(NINF, -0.), NINF) 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # and of infinities 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(1., INF), 1.) 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(1., NINF), -1.) 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(INF, INF), INF) 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(INF, NINF), NINF) 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(NINF, INF), INF) 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(NINF, NINF), NINF) 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.copysign(NAN, 1.))) 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.copysign(NAN, INF))) 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.copysign(NAN, NINF))) 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.copysign(NAN, NAN))) 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # copysign(INF, NAN) may be INF or it may be NINF, since 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # we don't know whether the sign bit of NAN is set on any 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # given platform. 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isinf(math.copysign(INF, NAN))) 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # similarly, copysign(2., NAN) could be 2. or -2. 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(abs(math.copysign(2., NAN)), 2.) 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testCos(self): 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.cos) 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0) 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('cos(0)', math.cos(0), 1) 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('cos(pi/2)', math.cos(math.pi/2), 0) 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('cos(pi)', math.cos(math.pi), -1) 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.cos(INF))) 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.cos(NINF))) 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.cos, INF) 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.cos, NINF) 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.cos(NAN))) 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testCosh(self): 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.cosh) 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('cosh(0)', math.cosh(0), 1) 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.cosh(INF), INF) 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.cosh(NINF), INF) 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.cosh(NAN))) 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testDegrees(self): 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.degrees) 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('degrees(pi)', math.degrees(math.pi), 180.0) 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('degrees(pi/2)', math.degrees(math.pi/2), 90.0) 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('degrees(-pi/4)', math.degrees(-math.pi/4), -45.0) 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testExp(self): 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.exp) 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('exp(-1)', math.exp(-1), 1/math.e) 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('exp(0)', math.exp(0), 1) 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('exp(1)', math.exp(1), math.e) 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.exp(INF), INF) 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.exp(NINF), 0.) 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.exp(NAN))) 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFabs(self): 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.fabs) 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fabs(-1)', math.fabs(-1), 1) 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fabs(0)', math.fabs(0), 0) 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fabs(1)', math.fabs(1), 1) 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFactorial(self): 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def fact(n): 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = 1 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in range(1, int(n)+1): 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result *= i 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return result 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm values = range(10) + [50, 100, 500] 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm random.shuffle(values) 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in values: 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for cast in (int, long, float): 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.factorial(cast(x)), fact(x), (x, fact(x), math.factorial(x))) 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.factorial, -1) 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.factorial, math.pi) 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFloor(self): 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.floor) 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # These types will be int in py3k. 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float, type(math.floor(1))) 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float, type(math.floor(1L))) 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float, type(math.floor(1.0))) 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(0.5)', math.floor(0.5), 0) 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(1.0)', math.floor(1.0), 1) 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(1.5)', math.floor(1.5), 1) 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(-0.5)', math.floor(-0.5), -1) 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(-1.0)', math.floor(-1.0), -1) 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(-1.5)', math.floor(-1.5), -2) 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow() relies on floor() to check for integers 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # This fails on some platforms - so check it here 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167) 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167) 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ceil(INF), INF) 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ceil(NINF), NINF) 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.floor(NAN))) 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestFloor(object): 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42.3 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestNoFloor(object): 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42) 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.floor, TestNoFloor()) 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t = TestNoFloor() 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t.__floor__ = lambda *args: args 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.floor, t) 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.floor, t, 0) 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFmod(self): 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.fmod) 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fmod(10,1)', math.fmod(10,1), 0) 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fmod(10,0.5)', math.fmod(10,0.5), 0) 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fmod(10,1.5)', math.fmod(10,1.5), 1) 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fmod(-10,1)', math.fmod(-10,1), 0) 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fmod(-10,0.5)', math.fmod(-10,0.5), 0) 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('fmod(-10,1.5)', math.fmod(-10,1.5), -1) 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.fmod(NAN, 1.))) 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.fmod(1., NAN))) 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.fmod(NAN, NAN))) 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.fmod, 1., 0.) 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.fmod, INF, 1.) 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.fmod, NINF, 1.) 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.fmod, INF, 0.) 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.fmod(3.0, INF), 3.0) 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.fmod(-3.0, INF), -3.0) 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.fmod(3.0, NINF), 3.0) 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.fmod(-3.0, NINF), -3.0) 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.fmod(0.0, 3.0), 0.0) 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.fmod(0.0, NINF), 0.0) 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFrexp(self): 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.frexp) 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testfrexp(name, result, expected): 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (mant, exp), (emant, eexp) = result, expected 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if abs(mant-emant) > eps or exp != eexp: 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('%s returned %r, expected %r'%\ 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (name, (mant, exp), (emant,eexp))) 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm testfrexp('frexp(-1)', math.frexp(-1), (-0.5, 1)) 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm testfrexp('frexp(0)', math.frexp(0), (0, 0)) 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm testfrexp('frexp(1)', math.frexp(1), (0.5, 1)) 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm testfrexp('frexp(2)', math.frexp(2), (0.5, 2)) 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.frexp(INF)[0], INF) 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.frexp(NINF)[0], NINF) 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.frexp(NAN)[0])) 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipIf(HAVE_DOUBLE_ROUNDING, 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "fsum is not exact on machines with double rounding") 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testFsum(self): 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.fsum relies on exact rounding for correct operation. 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # There's a known problem with IA32 floating-point that causes 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # inexact rounding in some situations, and will cause the 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # math.fsum tests below to fail; see issue #2937. On non IEEE 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 754 platforms, and on IEEE 754 platforms that exhibit the 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # problem described in issue #2937, we simply skip the whole 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test. 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Python version of math.fsum, for comparison. Uses a 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # different algorithm based on frexp, ldexp and integer 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # arithmetic. 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from sys import float_info 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mant_dig = float_info.mant_dig 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm etiny = float_info.min_exp - mant_dig 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def msum(iterable): 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Full precision summation. Compute sum(iterable) without any 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm intermediate accumulation of error. Based on the 'lsum' function 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm at http://code.activestate.com/recipes/393090/ 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """ 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmant, texp = 0, 0 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in iterable: 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mant, exp = math.frexp(x) 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mant, exp = int(math.ldexp(mant, mant_dig)), exp - mant_dig 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if texp > exp: 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmant <<= texp-exp 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm texp = exp 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mant <<= exp-texp 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmant += mant 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Round tmant * 2**texp to a float. The original recipe 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # used float(str(tmant)) * 2.0**texp for this, but that's 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # a little unsafe because str -> float conversion can't be 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # relied upon to do correct rounding on all platforms. 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tail = max(len(bin(abs(tmant)))-2 - mant_dig, etiny - texp) 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if tail > 0: 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm h = 1 << (tail-1) 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm tmant = tmant // (2*h) + bool(tmant & h and tmant & 3*h-1) 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm texp += tail 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return math.ldexp(tmant, texp) 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_values = [ 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([], 0.0), 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([0.0], 0.0), 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([1e100, 1.0, -1e100, 1e-100, 1e50, -1.0, -1e50], 1e-100), 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([2.0**53, -0.5, -2.0**-54], 2.0**53-1.0), 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([2.0**53, 1.0, 2.0**-100], 2.0**53+2.0), 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([2.0**53+10.0, 1.0, 2.0**-100], 2.0**53+12.0), 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([2.0**53-4.0, 0.5, 2.0**-54], 2.0**53-3.0), 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([1./n for n in range(1, 1001)], 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.fromhex('0x1.df11f45f4e61ap+2')), 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([(-1.)**n/n for n in range(1, 1001)], 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.fromhex('-0x1.62a2af1bd3624p-1')), 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([1.7**(i+1)-1.7**i for i in range(1000)] + [-1.7**1000], -1.0), 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([1e16, 1., 1e-16], 10000000000000002.0), 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([1e16-2., 1.-2.**-53, -(1e16-2.), -(1.-2.**-53)], 0.0), 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # exercise code for resizing partials array 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ([2.**n - 2.**(n+50) + 2.**(n+52) for n in range(-1074, 972, 2)] + 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [-2.**1022], 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.fromhex('0x1.5555555555555p+970')), 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i, (vals, expected) in enumerate(test_values): 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm actual = math.fsum(vals) 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except OverflowError: 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("test %d failed: got OverflowError, expected %r " 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "for math.fsum(%.100r)" % (i, expected, vals)) 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("test %d failed: got ValueError, expected %r " 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "for math.fsum(%.100r)" % (i, expected, vals)) 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(actual, expected) 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from random import random, gauss, shuffle 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for j in xrange(1000): 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vals = [7, 1e100, -7, -1e100, -9e-20, 8e-20] * 10 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = 0 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(200): 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = gauss(0, random()) ** 7 - s 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s += v 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vals.append(v) 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm shuffle(vals) 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = msum(vals) 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(msum(vals), math.fsum(vals)) 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testHypot(self): 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.hypot) 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('hypot(0,0)', math.hypot(0,0), 0) 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('hypot(3,4)', math.hypot(3,4), 5) 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.hypot(NAN, INF), INF) 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.hypot(INF, NAN), INF) 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.hypot(NAN, NINF), INF) 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.hypot(NINF, NAN), INF) 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.hypot(1.0, NAN))) 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.hypot(NAN, -2.0))) 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testLdexp(self): 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.ldexp) 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ldexp(0,1)', math.ldexp(0,1), 0) 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ldexp(1,1)', math.ldexp(1,1), 2) 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ldexp(1,-1)', math.ldexp(1,-1), 0.5) 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2) 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, math.ldexp, 1., 1000000) 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, math.ldexp, -1., 1000000) 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(1., -1000000), 0.) 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(-1., -1000000), -0.) 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(INF, 30), INF) 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(NINF, -213), NINF) 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.ldexp(NAN, 0))) 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # large second argument 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]: 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(INF, -n), INF) 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(NINF, -n), NINF) 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(1., -n), 0.) 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(-1., -n), -0.) 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(0., -n), 0.) 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(-0., -n), -0.) 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.ldexp(NAN, -n))) 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, math.ldexp, 1., n) 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, math.ldexp, -1., n) 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(0., n), 0.) 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(-0., n), -0.) 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(INF, n), INF) 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.ldexp(NINF, n), NINF) 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.ldexp(NAN, n))) 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testLog(self): 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.log) 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log(1/e)', math.log(1/math.e), -1) 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log(1)', math.log(1), 0) 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log(e)', math.log(math.e), 1) 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log(32,2)', math.log(32,2), 5) 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log(10**40, 10)', math.log(10**40, 10), 40) 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2) 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.log(INF), INF) 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.log, NINF) 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.log(NAN))) 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testLog1p(self): 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.log1p) 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log1p(1/e -1)', math.log1p(1/math.e-1), -1) 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log1p(0)', math.log1p(0), 0) 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log1p(e-1)', math.log1p(math.e-1), 1) 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log1p(1)', math.log1p(1), math.log(2)) 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.log1p(INF), INF) 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.log1p, NINF) 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.log1p(NAN))) 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n= 2**90 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(math.log1p(n), 62.383246250395075) 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(math.log1p(n), math.log1p(float(n))) 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testLog10(self): 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.log10) 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log10(0.1)', math.log10(0.1), -1) 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log10(1)', math.log10(1), 0) 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('log10(10)', math.log10(10), 1) 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.log(INF), INF) 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.log10, NINF) 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.log10(NAN))) 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testModf(self): 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.modf) 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testmodf(name, result, expected): 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (v1, v2), (e1, e2) = result, expected 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if abs(v1-e1) > eps or abs(v2-e2): 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('%s returned %r, expected %r'%\ 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (name, (v1,v2), (e1,e2))) 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0)) 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0)) 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.modf(INF), (0.0, INF)) 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.modf(NINF), (-0.0, NINF)) 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm modf_nan = math.modf(NAN) 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(modf_nan[0])) 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(modf_nan[1])) 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testPow(self): 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.pow) 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('pow(0,1)', math.pow(0,1), 0) 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('pow(1,0)', math.pow(1,0), 1) 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('pow(2,1)', math.pow(2,1), 2) 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('pow(2,-1)', math.pow(2,-1), 0.5) 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, 1), INF) 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, 1), NINF) 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((math.pow(1, INF)), 1.) 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((math.pow(1, NINF)), 1.) 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(NAN, 1))) 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(2, NAN))) 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(0, NAN))) 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1, NAN), 1) 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(0., x) 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0., INF), 0.) 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0., 3.), 0.) 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0., 2.3), 0.) 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0., 2.), 0.) 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0., 0.), 1.) 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0., -0.), 1.) 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, 0., -2.) 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, 0., -2.3) 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, 0., -3.) 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, 0., NINF) 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(0., NAN))) 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(INF, x) 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, INF), INF) 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, 3.), INF) 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, 2.3), INF) 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, 2.), INF) 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, 0.), 1.) 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, -0.), 1.) 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, -2.), 0.) 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, -2.3), 0.) 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, -3.), 0.) 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(INF, NINF), 0.) 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(INF, NAN))) 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(-0., x) 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0., INF), 0.) 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0., 3.), -0.) 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0., 2.3), 0.) 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0., 2.), 0.) 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0., 0.), 1.) 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0., -0.), 1.) 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -0., -2.) 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -0., -2.3) 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -0., -3.) 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -0., NINF) 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(-0., NAN))) 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(NINF, x) 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, INF), INF) 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, 3.), NINF) 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, 2.3), INF) 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, 2.), INF) 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, 0.), 1.) 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, -0.), 1.) 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, -2.), 0.) 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, -2.3), 0.) 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, -3.), -0.) 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NINF, NINF), 0.) 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(NINF, NAN))) 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(-1, x) 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., INF), 1.) 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., 3.), -1.) 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -1., 2.3) 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., 2.), 1.) 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., 0.), 1.) 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., -0.), 1.) 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., -2.), 1.) 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -1., -2.3) 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., -3.), -1.) 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1., NINF), 1.) 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.pow(-1., NAN))) 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(1, x) 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., INF), 1.) 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., 3.), 1.) 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., 2.3), 1.) 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., 2.), 1.) 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., 0.), 1.) 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., -0.), 1.) 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., -2.), 1.) 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., -2.3), 1.) 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., -3.), 1.) 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., NINF), 1.) 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1., NAN), 1.) 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(x, 0) should be 1 for any x 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(2.3, 0.), 1.) 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-2.3, 0.), 1.) 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NAN, 0.), 1.) 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(2.3, -0.), 1.) 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-2.3, -0.), 1.) 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(NAN, -0.), 1.) 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(x, y) is invalid if x is negative and y is not integral 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -1., 2.3) 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -15., -3.1) 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(x, NINF) 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1.9, NINF), 0.) 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1.1, NINF), 0.) 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0.9, NINF), INF) 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0.1, NINF), INF) 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0.1, NINF), INF) 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0.9, NINF), INF) 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1.1, NINF), 0.) 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1.9, NINF), 0.) 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(x, INF) 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1.9, INF), INF) 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(1.1, INF), INF) 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0.9, INF), 0.) 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(0.1, INF), 0.) 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0.1, INF), 0.) 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-0.9, INF), 0.) 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1.1, INF), INF) 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.pow(-1.9, INF), INF) 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # pow(x, y) should work for x negative, y an integer 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**3.', math.pow(-2.0, 3.0), -8.0) 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**2.', math.pow(-2.0, 2.0), 4.0) 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**1.', math.pow(-2.0, 1.0), -2.0) 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**0.', math.pow(-2.0, 0.0), 1.0) 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**-0.', math.pow(-2.0, -0.0), 1.0) 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**-1.', math.pow(-2.0, -1.0), -0.5) 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**-2.', math.pow(-2.0, -2.0), 0.25) 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('(-2.)**-3.', math.pow(-2.0, -3.0), -0.125) 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -2.0, -0.5) 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.pow, -2.0, 0.5) 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the following tests have been commented out since they don't 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # really belong here: the implementation of ** for floats is 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # independent of the implementation of math.pow 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1**NAN, 1) 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1**INF, 1) 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1**NINF, 1) 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1**0, 1) 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1.**NAN, 1) 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1.**INF, 1) 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1.**NINF, 1) 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertEqual(1.**0, 1) 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testRadians(self): 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.radians) 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('radians(180)', math.radians(180), math.pi) 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('radians(90)', math.radians(90), math.pi/2) 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('radians(-45)', math.radians(-45), -math.pi/4) 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testSin(self): 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.sin) 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sin(0)', math.sin(0), 0) 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sin(pi/2)', math.sin(math.pi/2), 1) 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sin(-pi/2)', math.sin(-math.pi/2), -1) 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.sin(INF))) 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.sin(NINF))) 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.sin, INF) 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.sin, NINF) 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.sin(NAN))) 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testSinh(self): 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.sinh) 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sinh(0)', math.sinh(0), 0) 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1) 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0) 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.sinh(INF), INF) 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.sinh(NINF), NINF) 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.sinh(NAN))) 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testSqrt(self): 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.sqrt) 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sqrt(0)', math.sqrt(0), 0) 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sqrt(1)', math.sqrt(1), 1) 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('sqrt(4)', math.sqrt(4), 2) 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.sqrt(INF), INF) 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.sqrt, NINF) 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.sqrt(NAN))) 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testTan(self): 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.tan) 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('tan(0)', math.tan(0), 0) 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('tan(pi/4)', math.tan(math.pi/4), 1) 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('tan(-pi/4)', math.tan(-math.pi/4), -1) 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.tan(INF))) 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.tan(NINF))) 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except: 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.tan, INF) 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, math.tan, NINF) 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.tan(NAN))) 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testTanh(self): 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.tanh) 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('tanh(0)', math.tanh(0), 0) 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('tanh(1)+tanh(-1)', math.tanh(1)+math.tanh(-1), 0) 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('tanh(inf)', math.tanh(INF), 1) 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest('tanh(-inf)', math.tanh(NINF), -1) 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(math.tanh(NAN))) 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check that tanh(-0.) == -0. on IEEE 754 systems 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if float.__getformat__("double").startswith("IEEE"): 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.tanh(-0.), -0.) 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.copysign(1., math.tanh(-0.)), 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm math.copysign(1., -0.)) 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_trunc(self): 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(1), 1) 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(-1), -1) 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(math.trunc(1)), int) 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(math.trunc(1.5)), int) 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(1.5), 1) 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(-1.5), -1) 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(1.999999), 1) 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(-1.999999), -1) 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(-0.999999), -0) 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(-100.999), -100) 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestTrunc(object): 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __trunc__(self): 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 23 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class TestNoTrunc(object): 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.trunc(TestTrunc()), 23) 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.trunc) 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, math.trunc, 1, 2) 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises((AttributeError, TypeError), math.trunc, 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm TestNoTrunc()) 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testIsnan(self): 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(float("nan"))) 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(float("inf")* 0.)) 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(math.isnan(float("inf"))) 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(math.isnan(0.)) 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(math.isnan(1.)) 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def testIsinf(self): 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isinf(float("inf"))) 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isinf(float("-inf"))) 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isinf(1E400)) 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isinf(-1E400)) 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(math.isinf(float("nan"))) 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(math.isinf(0.)) 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(math.isinf(1.)) 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # RED_FLAG 16-Oct-2000 Tim 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # While 2.0 is more consistent about exceptions than previous releases, it 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # still fails this part of the test on some platforms. For now, we only 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # *run* test_exceptions() in verbose mode, so that this isn't normally 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # tested. 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if verbose: 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_exceptions(self): 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = math.exp(-1000000000) 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except: 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # mathmodule.c is failing to weed out underflows from libm, or 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # we've got an fp format with huge dynamic range 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("underflowing exp() should not have raised " 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "an exception") 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if x != 0: 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("underflowing exp() should have returned 0") 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # If this fails, probably using a strict IEEE-754 conforming libm, and x 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # is +Inf afterwards. But Python wants overflows detected by default. 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = math.exp(1000000000) 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except OverflowError: 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("overflowing exp() didn't trigger OverflowError") 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # If this fails, it could be a puzzle. One odd possibility is that 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # mathmodule.c's macros are getting confused while comparing 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Inf (HUGE_VAL) to a NaN, and artificially setting errno to ERANGE 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # as a result (and so raising OverflowError instead). 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = math.sqrt(-1.0) 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("sqrt(-1) didn't raise ValueError") 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_testfile(self): 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for id, fn, ar, ai, er, ei, flags in parse_testfile(test_file): 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Skip if either the input or result is complex, or if 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # flags is nonempty 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if ai != 0. or ei != 0. or flags: 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if fn in ['rect', 'polar']: 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # no real versions of rect, polar 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = getattr(math, fn) 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = func(ar) 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm message = ("Unexpected ValueError in " + 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test %s:%s(%r)\n" % (id, fn, ar)) 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail(message) 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except OverflowError: 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm message = ("Unexpected OverflowError in " + 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test %s:%s(%r)\n" % (id, fn, ar)) 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail(message) 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.ftest("%s:%s(%r)" % (id, fn, ar), result, er) 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test requires IEEE 754 doubles") 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_mtestfile(self): 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ALLOWED_ERROR = 20 # permitted error, in ulps 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fail_fmt = "{}:{}({!r}): expected {!r}, got {!r}" 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm failures = [] 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for id, fn, arg, expected, flags in parse_mtestfile(math_testcases): 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm func = getattr(math, fn) 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if 'invalid' in flags or 'divide-by-zero' in flags: 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expected = 'ValueError' 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif 'overflow' in flags: 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm expected = 'OverflowError' 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm got = func(arg) 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm got = 'ValueError' 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except OverflowError: 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm got = 'OverflowError' 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accuracy_failure = None 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isinstance(got, float) and isinstance(expected, float): 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if math.isnan(expected) and math.isnan(got): 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not math.isnan(expected) and not math.isnan(got): 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if fn == 'lgamma': 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # we use a weaker accuracy test for lgamma; 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # lgamma only achieves an absolute error of 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # a few multiples of the machine accuracy, in 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # general. 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accuracy_failure = acc_check(expected, got, 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm rel_err = 5e-15, 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm abs_err = 5e-15) 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif fn == 'erfc': 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # erfc has less-than-ideal accuracy for large 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # arguments (x ~ 25 or so), mainly due to the 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # error involved in computing exp(-x*x). 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # XXX Would be better to weaken this test only 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # for large x, instead of for all x. 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accuracy_failure = ulps_check(expected, got, 2000) 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm accuracy_failure = ulps_check(expected, got, 20) 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if accuracy_failure is None: 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isinstance(got, str) and isinstance(expected, str): 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if got == expected: 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fail_msg = fail_fmt.format(id, fn, arg, expected, got) 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if accuracy_failure is not None: 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fail_msg += ' ({})'.format(accuracy_failure) 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm failures.append(fail_msg) 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if failures: 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('Failures in test_mtestfile:\n ' + 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '\n '.join(failures)) 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef test_main(): 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm from doctest import DocFileSuite 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm suite = unittest.TestSuite() 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm suite.addTest(unittest.makeSuite(MathTests)) 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm suite.addTest(DocFileSuite("ieee754.txt")) 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm run_unittest(suite) 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == '__main__': 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_main() 1031