14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport unittest, struct 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport os 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom test import test_support 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport math 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom math import isinf, isnan, copysign, ldexp 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport operator 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport random 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport fractions 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport sys 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmINF = float("inf") 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmNAN = float("nan") 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmhave_getformat = hasattr(float, "__getformat__") 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmrequires_getformat = unittest.skipUnless(have_getformat, 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "requires __getformat__") 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmrequires_setformat = unittest.skipUnless(hasattr(float, "__setformat__"), 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "requires __setformat__") 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# decorator for skipping tests on non-IEEE 754 platforms 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmrequires_IEEE_754 = unittest.skipUnless(have_getformat and 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__getformat__("double").startswith("IEEE"), 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test requires IEEE 754 doubles") 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm#locate file with float format test values 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtest_dir = os.path.dirname(__file__) or os.curdir 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmformat_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt') 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass GeneralFloatCases(unittest.TestCase): 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_float(self): 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(3.14), 3.14) 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(314), 314.0) 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(314L), 314.0) 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(" 3.14 "), 3.14) 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " 0x3.1 ") 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " -0x3.p-1 ") 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " +0x3.p-1 ") 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "++3.14") 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "+-3.14") 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "-+3.14") 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "--3.14") 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check that we don't accept alternate exponent markers 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "-1.7d29") 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "3D-14") 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if test_support.have_unicode: 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(unicode(" 3.14 ")), 3.14) 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(unicode(" \u0663.\u0661\u0664 ",'raw-unicode-escape')), 3.14) 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # extra long strings should no longer be a problem 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (in 2.6, long unicode inputs to float raised ValueError) 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float('.' + '1'*1000) 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float(unicode('.' + '1'*1000)) 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def check_conversion_to_int(self, x): 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Check that int(x) has the correct value and type, for a float x.""" 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n = int(x) 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if x >= 0.0: 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x >= 0 and n = int(x) ==> n <= x < n + 1 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertLessEqual(n, x) 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertLess(x, n + 1) 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x < 0 and n = int(x) ==> n >= x > n - 1 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertGreaterEqual(n, x) 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertGreater(x, n - 1) 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Result should be an int if within range, else a long. 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if -sys.maxint-1 <= n <= sys.maxint: 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(n), int) 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(n), long) 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Double check. 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(int(n)), type(n)) 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_conversion_to_int(self): 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check that floats within the range of an int convert to type 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # int, not long. (issue #11144.) 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm boundary = float(sys.maxint + 1) 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm epsilon = 2**-sys.float_info.mant_dig * boundary 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # These 2 floats are either side of the positive int/long boundary on 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # both 32-bit and 64-bit systems. 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_conversion_to_int(boundary - epsilon) 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_conversion_to_int(boundary) 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # These floats are either side of the negative long/int boundary on 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 64-bit systems... 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_conversion_to_int(-boundary - 2*epsilon) 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_conversion_to_int(-boundary) 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # ... and these ones are either side of the negative long/int 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # boundary on 32-bit systems. 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_conversion_to_int(-boundary - 1.0) 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_conversion_to_int(-boundary - 1.0 + 2*epsilon) 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @test_support.run_with_locale('LC_NUMERIC', 'fr_FR', 'de_DE') 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_float_with_comma(self): 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # set locale to something that doesn't use '.' for the decimal point 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # float must not accept the locale specific decimal point but 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # it still has to accept the normal python syntax 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import locale 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not locale.localeconv()['decimal_point'] == ',': 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(" 3.14 "), 3.14) 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float("+3.14 "), 3.14) 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float("-3.14 "), -3.14) 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(".14 "), .14) 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float("3. "), 3.0) 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float("3.e3 "), 3000.0) 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float("3.2e3 "), 3200.0) 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float("2.5e-1 "), 0.25) 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float("5e-1"), 0.5) 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " 3,14 ") 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " +3,14 ") 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " -3,14 ") 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " 0x3.1 ") 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " -0x3.p-1 ") 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, " +0x3.p-1 ") 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(" 25.e-1 "), 2.5) 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(test_support.fcmp(float(" .25e-1 "), .025), 0) 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_floatconversion(self): 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Make sure that calls to __float__() work properly 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo0: 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42. 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo1(object): 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42. 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo2(float): 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42. 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo3(float): 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __new__(cls, value=0.): 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return float.__new__(cls, 2*value) 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class Foo4(float): 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Issue 5759: __float__ not called on str subclasses (though it is on 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # unicode subclasses). 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class FooStr(str): 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return float(str(self)) + 1 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class FooUnicode(unicode): 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return float(unicode(self)) + 1 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(float(Foo0()), 42.) 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(float(Foo1()), 42.) 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(float(Foo2()), 42.) 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(float(Foo3(21)), 42.) 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, float, Foo4(42)) 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(float(FooUnicode('8')), 9.) 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(float(FooStr('8')), 9.) 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_floatasratio(self): 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for f, ratio in [ 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (0.875, (7, 8)), 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (-0.875, (-7, 8)), 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (0.0, (0, 1)), 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (11.5, (23, 2)), 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ]: 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(f.as_integer_ratio(), ratio) 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in range(10000): 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f = random.random() 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm f *= 10 ** random.randint(-100, 100) 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm n, d = f.as_integer_ratio() 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(float(n).__truediv__(d), f) 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm R = fractions.Fraction 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(R(0, 1), 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm R(*float(0.0).as_integer_ratio())) 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(R(5, 2), 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm R(*float(2.5).as_integer_ratio())) 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(R(1, 2), 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm R(*float(0.5).as_integer_ratio())) 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(R(4728779608739021, 2251799813685248), 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm R(*float(2.1).as_integer_ratio())) 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(R(-4728779608739021, 2251799813685248), 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm R(*float(-2.1).as_integer_ratio())) 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(R(-2100, 1), 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm R(*float(-2100.0).as_integer_ratio())) 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, float('inf').as_integer_ratio) 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, float('-inf').as_integer_ratio) 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float('nan').as_integer_ratio) 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def assertEqualAndEqualSign(self, a, b): 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # fail unless a == b and a and b have the same sign bit; 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the only difference from assertEqual is that this test 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # distinguishes -0.0 and 0.0. 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b))) 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_float_mod(self): 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Check behaviour of % operator for IEEE 754 special cases. 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # In particular, check signs of zeros. 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mod = operator.mod 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(-1.0, 1.0), 0.0) 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(-1e-100, 1.0), 1.0) 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(-0.0, 1.0), 0.0) 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(0.0, 1.0), 0.0) 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(1e-100, 1.0), 1e-100) 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(1.0, 1.0), 0.0) 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(-1.0, -1.0), -0.0) 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(-1e-100, -1.0), -1e-100) 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(-0.0, -1.0), -0.0) 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(0.0, -1.0), -0.0) 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(1e-100, -1.0), -1.0) 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(mod(1.0, -1.0), -0.0) 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_float_pow(self): 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test builtin pow and ** operator for IEEE 754 special cases. 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Special cases taken from section F.9.4.4 of the C99 specification 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for pow_op in pow, operator.pow: 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x**NAN is NAN for any x except 1 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(-INF, NAN))) 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(-2.0, NAN))) 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(-1.0, NAN))) 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(-0.5, NAN))) 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(-0.0, NAN))) 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(0.0, NAN))) 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(0.5, NAN))) 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(2.0, NAN))) 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(INF, NAN))) 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, NAN))) 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # NAN**y is NAN for any y except +-0 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, -INF))) 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, -2.0))) 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, -1.0))) 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, -0.5))) 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, 0.5))) 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, 1.0))) 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, 2.0))) 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(pow_op(NAN, INF))) 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (+-0)**y raises ZeroDivisionError for y a negative odd integer 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, pow_op, -0.0, -1.0) 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, pow_op, 0.0, -1.0) 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (+-0)**y raises ZeroDivisionError for y finite and negative 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # but not an odd integer 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, pow_op, -0.0, -2.0) 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, pow_op, -0.0, -0.5) 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, pow_op, 0.0, -2.0) 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, pow_op, 0.0, -0.5) 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (+-0)**y is +-0 for y a positive odd integer 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.0, 1.0), -0.0) 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.0, 1.0), 0.0) 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (+-0)**y is 0 for y finite and positive but not an odd integer 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.0, 0.5), 0.0) 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.0, 2.0), 0.0) 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.0, 0.5), 0.0) 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.0, 2.0), 0.0) 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (-1)**+-inf is 1 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, -INF), 1.0) 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, INF), 1.0) 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 1**y is 1 for any y, even if y is an infinity or nan 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, -INF), 1.0) 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, -2.0), 1.0) 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, -1.0), 1.0) 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, -0.5), 1.0) 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0) 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0) 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, 0.5), 1.0) 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, 1.0), 1.0) 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, 2.0), 1.0) 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, INF), 1.0) 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, NAN), 1.0) 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x**+-0 is 1 for any x, even if x is a zero, infinity, or nan 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, 0.0), 1.0) 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0) 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0) 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.5, 0.0), 1.0) 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.0, 0.0), 1.0) 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.0, 0.0), 1.0) 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.5, 0.0), 1.0) 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, 0.0), 1.0) 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0) 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, 0.0), 1.0) 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(NAN, 0.0), 1.0) 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, -0.0), 1.0) 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0) 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0) 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.5, -0.0), 1.0) 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.0, -0.0), 1.0) 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.0, -0.0), 1.0) 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.5, -0.0), 1.0) 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, -0.0), 1.0) 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0) 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, -0.0), 1.0) 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(NAN, -0.0), 1.0) 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x**y raises ValueError for finite negative x and non-integral y 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -2.0, -0.5) 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -2.0, 0.5) 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -1.0, -0.5) 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -1.0, 0.5) 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -0.5, -0.5) 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -0.5, 0.5) 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x**-INF is INF for abs(x) < 1 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.5, -INF), INF) 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.0, -INF), INF) 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.0, -INF), INF) 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.5, -INF), INF) 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x**-INF is 0 for abs(x) > 1 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, -INF), 0.0) 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, -INF), 0.0) 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -INF), 0.0) 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, -INF), 0.0) 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x**INF is 0 for abs(x) < 1 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.5, INF), 0.0) 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.0, INF), 0.0) 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.0, INF), 0.0) 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.5, INF), 0.0) 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x**INF is INF for abs(x) > 1 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, INF), INF) 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, INF), INF) 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, INF), INF) 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, INF), INF) 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (-INF)**y is -0.0 for y a negative odd integer 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, -1.0), -0.0) 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (-INF)**y is 0.0 for y negative but not an odd integer 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, -0.5), 0.0) 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, -2.0), 0.0) 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (-INF)**y is -INF for y a positive odd integer 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, 1.0), -INF) 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (-INF)**y is INF for y positive but not an odd integer 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, 0.5), INF) 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-INF, 2.0), INF) 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # INF**y is INF for y positive 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, 0.5), INF) 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, 1.0), INF) 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, 2.0), INF) 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # INF**y is 0.0 for y negative 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, -2.0), 0.0) 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, -1.0), 0.0) 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(INF, -0.5), 0.0) 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # basic checks not covered by the special cases above 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, -2.0), 0.25) 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, -1.0), -0.5) 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, -0.0), 1.0) 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, 0.0), 1.0) 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, 1.0), -2.0) 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, 2.0), 4.0) 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, -2.0), 1.0) 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, -1.0), -1.0) 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, -0.0), 1.0) 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, 0.0), 1.0) 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, 1.0), -1.0) 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, 2.0), 1.0) 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -2.0), 0.25) 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -1.0), 0.5) 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -0.0), 1.0) 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, 0.0), 1.0) 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, 1.0), 2.0) 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, 2.0), 4.0) 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 1 ** large and -1 ** large; some libms apparently 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # have problems with these 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, -1e100), 1.0) 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(1.0, 1e100), 1.0) 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, -1e100), 1.0) 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-1.0, 1e100), 1.0) 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check sign for results that underflow to 0 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, -2000.0), 0.0) 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -2.0, -2000.5) 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-2.0, -2001.0), -0.0) 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -2000.0), 0.0) 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -2000.5), 0.0) 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(2.0, -2001.0), 0.0) 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.5, 2000.0), 0.0) 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow_op, -0.5, 2000.5) 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(-0.5, 2001.0), -0.0) 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.5, 2000.0), 0.0) 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.5, 2000.5), 0.0) 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqualAndEqualSign(pow_op(0.5, 2001.0), 0.0) 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check we don't raise an exception for subnormal results, 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # and validate signs. Tests currently disabled, since 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # they fail on systems where a subnormal result from pow 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # is flushed to zero (e.g. Debian/ia64.) 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 < pow_op(0.5, 1048) < 1e-315) 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 < pow_op(-0.5, 1048) < 1e-315) 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 < pow_op(0.5, 1047) < 1e-315) 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 > pow_op(-0.5, 1047) > -1e-315) 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 < pow_op(2.0, -1048) < 1e-315) 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 < pow_op(-2.0, -1048) < 1e-315) 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 < pow_op(2.0, -1047) < 1e-315) 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm #self.assertTrue(0.0 > pow_op(-2.0, -1047) > -1e-315) 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm@requires_setformat 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass FormatFunctionsTestCase(unittest.TestCase): 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def setUp(self): 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.save_formats = {'double':float.__getformat__('double'), 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'float':float.__getformat__('float')} 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def tearDown(self): 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__setformat__('double', self.save_formats['double']) 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__setformat__('float', self.save_formats['float']) 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_getformat(self): 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(float.__getformat__('double'), 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ['unknown', 'IEEE, big-endian', 'IEEE, little-endian']) 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIn(float.__getformat__('float'), 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ['unknown', 'IEEE, big-endian', 'IEEE, little-endian']) 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float.__getformat__, 'chicken') 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, float.__getformat__, 1) 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_setformat(self): 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for t in 'double', 'float': 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__setformat__(t, 'unknown') 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if self.save_formats[t] == 'IEEE, big-endian': 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float.__setformat__, 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t, 'IEEE, little-endian') 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif self.save_formats[t] == 'IEEE, little-endian': 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float.__setformat__, 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t, 'IEEE, big-endian') 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float.__setformat__, 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t, 'IEEE, big-endian') 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float.__setformat__, 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t, 'IEEE, little-endian') 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float.__setformat__, 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm t, 'chicken') 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float.__setformat__, 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'chicken', 'unknown') 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmBE_DOUBLE_INF = '\x7f\xf0\x00\x00\x00\x00\x00\x00' 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmLE_DOUBLE_INF = ''.join(reversed(BE_DOUBLE_INF)) 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmBE_DOUBLE_NAN = '\x7f\xf8\x00\x00\x00\x00\x00\x00' 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmLE_DOUBLE_NAN = ''.join(reversed(BE_DOUBLE_NAN)) 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmBE_FLOAT_INF = '\x7f\x80\x00\x00' 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmLE_FLOAT_INF = ''.join(reversed(BE_FLOAT_INF)) 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmBE_FLOAT_NAN = '\x7f\xc0\x00\x00' 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmLE_FLOAT_NAN = ''.join(reversed(BE_FLOAT_NAN)) 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# on non-IEEE platforms, attempting to unpack a bit pattern 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# representing an infinity or a NaN should raise an exception. 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm@requires_setformat 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass UnknownFormatTestCase(unittest.TestCase): 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def setUp(self): 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.save_formats = {'double':float.__getformat__('double'), 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'float':float.__getformat__('float')} 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__setformat__('double', 'unknown') 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__setformat__('float', 'unknown') 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def tearDown(self): 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__setformat__('double', self.save_formats['double']) 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm float.__setformat__('float', self.save_formats['float']) 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_double_specials_dont_unpack(self): 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for fmt, data in [('>d', BE_DOUBLE_INF), 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('>d', BE_DOUBLE_NAN), 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<d', LE_DOUBLE_INF), 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<d', LE_DOUBLE_NAN)]: 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, struct.unpack, fmt, data) 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_float_specials_dont_unpack(self): 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for fmt, data in [('>f', BE_FLOAT_INF), 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('>f', BE_FLOAT_NAN), 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<f', LE_FLOAT_INF), 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<f', LE_FLOAT_NAN)]: 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, struct.unpack, fmt, data) 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# on an IEEE platform, all we guarantee is that bit patterns 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# representing infinities or NaNs do not raise an exception; all else 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# is accident (today). 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# let's also try to guarantee that -0.0 and 0.0 don't get confused. 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass IEEEFormatTestCase(unittest.TestCase): 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_double_specials_do_unpack(self): 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for fmt, data in [('>d', BE_DOUBLE_INF), 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('>d', BE_DOUBLE_NAN), 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<d', LE_DOUBLE_INF), 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<d', LE_DOUBLE_NAN)]: 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm struct.unpack(fmt, data) 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_float_specials_do_unpack(self): 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for fmt, data in [('>f', BE_FLOAT_INF), 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('>f', BE_FLOAT_NAN), 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<f', LE_FLOAT_INF), 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('<f', LE_FLOAT_NAN)]: 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm struct.unpack(fmt, data) 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_negative_zero(self): 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def pos_pos(): 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0.0, math.atan2(0.0, -1) 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def pos_neg(): 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 0.0, math.atan2(-0.0, -1) 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def neg_pos(): 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -0.0, math.atan2(0.0, -1) 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def neg_neg(): 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -0.0, math.atan2(-0.0, -1) 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pos_pos(), neg_pos()) 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(pos_neg(), neg_neg()) 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_underflow_sign(self): 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check that -1e-1000 gives -0.0, not 0.0 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(-1e-1000, -1), math.atan2(-0.0, -1)) 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(math.atan2(float('-1e-1000'), -1), 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm math.atan2(-0.0, -1)) 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_format(self): 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # these should be rewritten to use both format(x, spec) and 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x.__format__(spec) 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(0.0, 'f'), '0.000000') 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the default is 'g', except for empty format spec 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(0.0, ''), '0.0') 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(0.01, ''), '0.01') 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(0.01, 'g'), '0.01') 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # empty presentation type should format in the same way as str 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (issue 5920) 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = 100/7. 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(x, ''), str(x)) 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(x, '-'), str(x)) 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(x, '>'), str(x)) 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(x, '2'), str(x)) 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.0, 'f'), '1.000000') 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.0, 'f'), '-1.000000') 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format( 1.0, ' f'), ' 1.000000') 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.0, ' f'), '-1.000000') 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format( 1.0, '+f'), '+1.000000') 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.0, '+f'), '-1.000000') 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # % formatting 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.0, '%'), '-100.000000%') 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # conversion to string should fail 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, 3.0, "s") 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # other format specifiers shouldn't work on floats, 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # in particular int specifiers 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] + 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm [chr(x) for x in range(ord('A'), ord('Z')+1)]): 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not format_spec in 'eEfFgGn%': 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, 0.0, format_spec) 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, 1.0, format_spec) 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, -1.0, format_spec) 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, 1e100, format_spec) 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, -1e100, format_spec) 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, 1e-100, format_spec) 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, format, -1e-100, format_spec) 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # issue 3382: 'f' and 'F' with inf's and nan's 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(INF), 'inf') 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(INF), 'INF') 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(-INF), '-inf') 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(-INF), '-INF') 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(NAN), 'nan') 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(NAN), 'NAN') 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_format_testfile(self): 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with open(format_testfile) as testfile: 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for line in open(format_testfile): 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if line.startswith('--'): 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = line.strip() 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not line: 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm lhs, rhs = map(str.strip, line.split('->')) 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fmt, arg = lhs.split() 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm arg = float(arg) 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fmt % arg, rhs) 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not math.isnan(arg) and copysign(1.0, arg) > 0.0: 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fmt % -arg, '-' + rhs) 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_issue5864(self): 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(123.456, '.4'), '123.5') 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1234.56, '.4'), '1.235e+03') 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(12345.6, '.4'), '1.235e+04') 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass ReprTestCase(unittest.TestCase): 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repr(self): 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm floats_file = open(os.path.join(os.path.split(__file__)[0], 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'floating_points.txt')) 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for line in floats_file: 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm line = line.strip() 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not line or line.startswith('#'): 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm continue 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm v = eval(line) 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(v, eval(repr(v))) 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm floats_file.close() 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short', 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "applies only when using short float repr style") 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_short_repr(self): 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test short float repr introduced in Python 3.1. One aspect 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # of this repr is that we get some degree of str -> float -> 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # str roundtripping. In particular, for any numeric string 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # containing 15 or fewer significant digits, those exact same 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # digits (modulo trailing zeros) should appear in the output. 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # No more repr(0.03) -> "0.029999999999999999"! 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_strings = [ 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # output always includes *either* a decimal point and at 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # least one digit after that point, or an exponent. 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.0', 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '1.0', 6524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.01', 6534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.02', 6544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.03', 6554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.04', 6564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.05', 6574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '1.23456789', 6584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '10.0', 6594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '100.0', 6604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # values >= 1e16 get an exponent... 6614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '1000000000000000.0', 6624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '9999999999999990.0', 6634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '1e+16', 6644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '1e+17', 6654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # ... and so do values < 1e-4 6664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.001', 6674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.001001', 6684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.00010000000000001', 6694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0.0001', 6704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '9.999999999999e-05', 6714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '1e-05', 6724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # values designed to provoke failure if the FPU rounding 6734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # precision isn't set correctly 6744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '8.72293771110361e+25', 6754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '7.47005307342313e+26', 6764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '2.86438000439698e+28', 6774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '8.89142905246179e+28', 6784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '3.08578087079232e+35', 6794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 6804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for s in test_strings: 6824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm negs = '-'+s 6834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(s, repr(float(s))) 6844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(negs, repr(float(negs))) 6854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm@requires_IEEE_754 6884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass RoundTestCase(unittest.TestCase): 6894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_second_argument_type(self): 6904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # any type with an __index__ method should be permitted as 6914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # a second argument 6924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(12.34, True), 12.3) 6934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class MyIndex(object): 6954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __index__(self): return 4 6964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.123456, MyIndex()), -0.1235) 6974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # but floats should be illegal 6984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, 3.14159, 2.0) 6994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_inf_nan(self): 7014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # rounding an infinity or nan returns the same number; 7024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # (in py3k, rounding an infinity or nan raises an error, 7034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # since the result can't be represented as a long). 7044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(INF), INF) 7054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-INF), -INF) 7064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(round(NAN))) 7074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in range(-5, 5): 7084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(INF, n), INF) 7094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-INF, n), -INF) 7104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(math.isnan(round(NAN, n))) 7114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, INF, 0.0) 7134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, -INF, 1.0) 7144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, NAN, "ceci n'est pas un integer") 7154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, round, -0.0, 1j) 7164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_large_n(self): 7184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in [324, 325, 400, 2**31-1, 2**31, 2**32, 2**100]: 7194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(123.456, n), 123.456) 7204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-123.456, n), -123.456) 7214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e300, n), 1e300) 7224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e-320, n), 1e-320) 7234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e150, 300), 1e150) 7244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e300, 307), 1e300) 7254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-3.1415, 308), -3.1415) 7264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e150, 309), 1e150) 7274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1.4e-315, 315), 1e-315) 7284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_small_n(self): 7304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for n in [-308, -309, -400, 1-2**31, -2**31, -2**31-1, -2**100]: 7314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(123.456, n), 0.0) 7324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-123.456, n), -0.0) 7334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e300, n), 0.0) 7344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1e-320, n), 0.0) 7354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_overflow(self): 7374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, round, 1.6e308, -308) 7384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, round, -1.7e308, -308) 7394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short', 7414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test applies only when using short float repr style") 7424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_previous_round_bugs(self): 7434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # particular cases that have occurred in bug reports 7444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(562949953421312.5, 1), 7454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 562949953421312.5) 7464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(56294995342131.5, 3), 7474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 56294995342131.5) 7484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipUnless(getattr(sys, 'float_repr_style', '') == 'short', 7504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test applies only when using short float repr style") 7514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_halfway_cases(self): 7524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Halfway cases need special attention, since the current 7534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # implementation has to deal with them specially. Note that 7544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 2.x rounds halfway values up (i.e., away from zero) while 7554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # 3.x does round-half-to-even. 7564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.125, 2), 0.13) 7574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.375, 2), 0.38) 7584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.625, 2), 0.63) 7594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.875, 2), 0.88) 7604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.125, 2), -0.13) 7614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.375, 2), -0.38) 7624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.625, 2), -0.63) 7634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.875, 2), -0.88) 7644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.25, 1), 0.3) 7664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.75, 1), 0.8) 7674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.25, 1), -0.3) 7684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.75, 1), -0.8) 7694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-6.5, 0), -7.0) 7714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-5.5, 0), -6.0) 7724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-1.5, 0), -2.0) 7734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-0.5, 0), -1.0) 7744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(0.5, 0), 1.0) 7754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1.5, 0), 2.0) 7764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(2.5, 0), 3.0) 7774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(3.5, 0), 4.0) 7784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(4.5, 0), 5.0) 7794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5.5, 0), 6.0) 7804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(6.5, 0), 7.0) 7814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # same but without an explicit second argument; in 3.x these 7834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # will give integers 7844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-6.5), -7.0) 7854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-5.5), -6.0) 7864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-1.5), -2.0) 7874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-0.5), -1.0) 7884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(0.5), 1.0) 7894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(1.5), 2.0) 7904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(2.5), 3.0) 7914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(3.5), 4.0) 7924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(4.5), 5.0) 7934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5.5), 6.0) 7944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(6.5), 7.0) 7954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 7964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-25.0, -1), -30.0) 7974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-15.0, -1), -20.0) 7984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(-5.0, -1), -10.0) 7994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(5.0, -1), 10.0) 8004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(15.0, -1), 20.0) 8014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(25.0, -1), 30.0) 8024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(35.0, -1), 40.0) 8034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(45.0, -1), 50.0) 8044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(55.0, -1), 60.0) 8054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(65.0, -1), 70.0) 8064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(75.0, -1), 80.0) 8074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(85.0, -1), 90.0) 8084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(95.0, -1), 100.0) 8094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(12325.0, -1), 12330.0) 8104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(350.0, -2), 400.0) 8124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(round(450.0, -2), 500.0) 8134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.5e21, -21), 1e21) 8154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(1.5e21, -21), 2e21) 8164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(2.5e21, -21), 3e21) 8174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(5.5e21, -21), 6e21) 8184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(8.5e21, -21), 9e21) 8194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-1.5e22, -22), -2e22) 8214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(-0.5e22, -22), -1e22) 8224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(0.5e22, -22), 1e22) 8234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(round(1.5e22, -22), 2e22) 8244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @requires_IEEE_754 8274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_format_specials(self): 8284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test formatting of nans and infs. 8294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test(fmt, value, expected): 8314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Test with both % and format(). 8324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fmt % value, expected, fmt) 8334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if not '#' in fmt: 8344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Until issue 7094 is implemented, format() for floats doesn't 8354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # support '#' formatting 8364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fmt = fmt[1:] # strip off the % 8374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(value, fmt), expected, fmt) 8384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for fmt in ['%e', '%f', '%g', '%.0e', '%.6f', '%.20g', 8404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '%#e', '%#f', '%#g', '%#.20e', '%#.15f', '%#.3g']: 8414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pfmt = '%+' + fmt[1:] 8424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm sfmt = '% ' + fmt[1:] 8434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(fmt, INF, 'inf') 8444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(fmt, -INF, '-inf') 8454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(fmt, NAN, 'nan') 8464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(fmt, -NAN, 'nan') 8474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # When asking for a sign, it's always provided. nans are 8484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # always positive. 8494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(pfmt, INF, '+inf') 8504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(pfmt, -INF, '-inf') 8514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(pfmt, NAN, '+nan') 8524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(pfmt, -NAN, '+nan') 8534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # When using ' ' for a sign code, only infs can be negative. 8544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Others have a space. 8554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(sfmt, INF, ' inf') 8564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(sfmt, -INF, '-inf') 8574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(sfmt, NAN, ' nan') 8584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test(sfmt, -NAN, ' nan') 8594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# Beginning with Python 2.6 float has cross platform compatible 8624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# ways to create and represent inf and nan 8634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass InfNanTest(unittest.TestCase): 8644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_inf_from_str(self): 8654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinf(float("inf"))) 8664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinf(float("+inf"))) 8674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinf(float("-inf"))) 8684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinf(float("infinity"))) 8694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinf(float("+infinity"))) 8704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isinf(float("-infinity"))) 8714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("inf")), "inf") 8734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("+inf")), "inf") 8744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("-inf")), "-inf") 8754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("infinity")), "inf") 8764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("+infinity")), "inf") 8774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("-infinity")), "-inf") 8784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("INF")), "inf") 8804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("+Inf")), "inf") 8814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("-iNF")), "-inf") 8824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("Infinity")), "inf") 8834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("+iNfInItY")), "inf") 8844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("-INFINITY")), "-inf") 8854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("inf")), "inf") 8874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("+inf")), "inf") 8884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("-inf")), "-inf") 8894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("infinity")), "inf") 8904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("+infinity")), "inf") 8914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("-infinity")), "-inf") 8924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 8934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "info") 8944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "+info") 8954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "-info") 8964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "in") 8974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "+in") 8984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "-in") 8994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "infinit") 9004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "+Infin") 9014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "-INFI") 9024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "infinitys") 9034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_inf_as_str(self): 9054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(1e300 * 1e300), "inf") 9064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(-1e300 * 1e300), "-inf") 9074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(1e300 * 1e300), "inf") 9094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(-1e300 * 1e300), "-inf") 9104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_nan_from_str(self): 9124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(float("nan"))) 9134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(float("+nan"))) 9144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(isnan(float("-nan"))) 9154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("nan")), "nan") 9174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("+nan")), "nan") 9184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("-nan")), "nan") 9194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("NAN")), "nan") 9214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("+NAn")), "nan") 9224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(float("-NaN")), "nan") 9234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("nan")), "nan") 9254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("+nan")), "nan") 9264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(float("-nan")), "nan") 9274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "nana") 9294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "+nana") 9304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "-nana") 9314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "na") 9324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "+na") 9334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, float, "-na") 9344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_nan_as_str(self): 9364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(1e300 * 1e300 * 0), "nan") 9374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(-1e300 * 1e300 * 0), "nan") 9384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(1e300 * 1e300 * 0), "nan") 9404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(str(-1e300 * 1e300 * 0), "nan") 9414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def notest_float_nan(self): 9434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(NAN.is_nan()) 9444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(INF.is_nan()) 9454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse((0.).is_nan()) 9464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def notest_float_inf(self): 9484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(INF.is_inf()) 9494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse(NAN.is_inf()) 9504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFalse((0.).is_inf()) 9514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_hash_inf(self): 9534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the actual values here should be regarded as an 9544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # implementation detail, but they need to be 9554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # identical to those used in the Decimal module. 9564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(float('inf')), 314159) 9574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(float('-inf')), -271828) 9584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(float('nan')), 0) 9594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfromHex = float.fromhex 9624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmtoHex = float.hex 9634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass HexFloatTestCase(unittest.TestCase): 9644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MAX = fromHex('0x.fffffffffffff8p+1024') # max normal 9654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MIN = fromHex('0x1p-1022') # min normal 9664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm TINY = fromHex('0x0.0000000000001p-1022') # min subnormal 9674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm EPS = fromHex('0x0.0000000000001p0') # diff between 1.0 and next float up 9684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def identical(self, x, y): 9704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check that floats x and y are identical, or that both 9714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # are NaNs 9724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isnan(x) or isnan(y): 9734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isnan(x) == isnan(y): 9744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 9754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif x == y and (x != 0.0 or copysign(1.0, x) == copysign(1.0, y)): 9764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 9774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('%r not identical to %r' % (x, y)) 9784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_ends(self): 9804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(self.MIN, ldexp(1.0, -1022)) 9814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(self.TINY, ldexp(1.0, -1074)) 9824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(self.EPS, ldexp(1.0, -52)) 9834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(self.MAX, 2.*(ldexp(1.0, 1023) - ldexp(1.0, 970))) 9844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 9854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_invalid_inputs(self): 9864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm invalid_inputs = [ 9874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'infi', # misspelt infinities and nans 9884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '-Infinit', 9894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '++inf', 9904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '-+Inf', 9914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '--nan', 9924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '+-NaN', 9934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'snan', 9944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'NaNs', 9954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'nna', 9964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'an', 9974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'nf', 9984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'nfinity', 9994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'inity', 10004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'iinity', 10014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0xnan', 10024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '', 10034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ' ', 10044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'x1.0p0', 10054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0xX1.0p0', 10064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '+ 0x1.0p0', # internal whitespace 10074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '- 0x1.0p0', 10084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0 x1.0p0', 10094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x 1.0p0', 10104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1 2.0p0', 10114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '+0x1 .0p0', 10124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1. 0p0', 10134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '-0x1.0 1p0', 10144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '-0x1.0 p0', 10154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '+0x1.0p +0', 10164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1.0p -0', 10174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1.0p 0', 10184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '+0x1.0p+ 0', 10194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '-0x1.0p- 0', 10204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '++0x1.0p-0', # double signs 10214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '--0x1.0p0', 10224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '+-0x1.0p+0', 10234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '-+0x1.0p0', 10244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1.0p++0', 10254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '+0x1.0p+-0', 10264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '-0x1.0p-+0', 10274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1.0p--0', 10284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1.0.p0', 10294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x.p0', # no hex digits before or after point 10304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1,p0', # wrong decimal point character 10314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1pa', 10324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u'0x1p\uff10', # fullwidth Unicode digits 10334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u'\uff10x1p0', 10344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u'0x\uff11p0', 10354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm u'0x1.\uff10p0', 10364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1p0 \n 0x2p0', 10374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '0x1p0\0 0x1p0', # embedded null byte is not end of string 10384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 10394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in invalid_inputs: 10404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 10414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm result = fromHex(x) 10424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ValueError: 10434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 10444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 10454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail('Expected float.fromhex(%r) to raise ValueError; ' 10464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 'got %r instead' % (x, result)) 10474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_whitespace(self): 10504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm value_pairs = [ 10514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('inf', INF), 10524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('-Infinity', -INF), 10534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('nan', NAN), 10544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('1.0', 1.0), 10554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('-0x.2', -0.125), 10564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ('-0.0', -0.0) 10574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 10584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm whitespace = [ 10594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '', 10604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ' ', 10614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '\t', 10624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '\n', 10634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '\n \t', 10644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '\f', 10654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '\v', 10664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm '\r' 10674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ] 10684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for inp, expected in value_pairs: 10694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for lead in whitespace: 10704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for trail in whitespace: 10714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm got = fromHex(lead + inp + trail) 10724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(got, expected) 10734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_from_hex(self): 10764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MIN = self.MIN; 10774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm MAX = self.MAX; 10784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm TINY = self.TINY; 10794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm EPS = self.EPS; 10804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # two spellings of infinity, with optional signs; case-insensitive 10824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('inf'), INF) 10834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('+Inf'), INF) 10844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-INF'), -INF) 10854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('iNf'), INF) 10864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('Infinity'), INF) 10874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('+INFINITY'), INF) 10884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-infinity'), -INF) 10894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-iNFiNitY'), -INF) 10904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # nans with optional sign; case insensitive 10924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('nan'), NAN) 10934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('+NaN'), NAN) 10944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-NaN'), NAN) 10954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-nAN'), NAN) 10964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 10974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # variations in input format 10984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('1'), 1.0) 10994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('+1'), 1.0) 11004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('1.'), 1.0) 11014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('1.0'), 1.0) 11024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('1.0p0'), 1.0) 11034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('01'), 1.0) 11044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('01.'), 1.0) 11054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1'), 1.0) 11064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.'), 1.0) 11074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0'), 1.0) 11084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('+0x1.0'), 1.0) 11094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1p0'), 1.0) 11104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1p0'), 1.0) 11114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1P0'), 1.0) 11124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1P0'), 1.0) 11134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.p0'), 1.0) 11144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0p0'), 1.0) 11154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.1p4'), 1.0) 11164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.1p04'), 1.0) 11174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.1p004'), 1.0) 11184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1p+0'), 1.0) 11194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1P-0'), 1.0) 11204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('+0x1p0'), 1.0) 11214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x01p0'), 1.0) 11224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1p00'), 1.0) 11234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex(u'0x1p0'), 1.0) 11244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex(' 0x1p0 '), 1.0) 11254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('\n 0x1p0'), 1.0) 11264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1p0 \t'), 1.0) 11274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xap0'), 10.0) 11284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xAp0'), 10.0) 11294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xaP0'), 10.0) 11304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xAP0'), 10.0) 11314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xbep0'), 190.0) 11324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xBep0'), 190.0) 11334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xbEp0'), 190.0) 11344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0XBE0P-4'), 190.0) 11354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xBEp0'), 190.0) 11364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xB.Ep4'), 190.0) 11374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.BEp8'), 190.0) 11384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.0BEp12'), 190.0) 11394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # moving the point around 11414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pi = fromHex('0x1.921fb54442d18p1') 11424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.006487ed5110b46p11'), pi) 11434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.00c90fdaa22168cp10'), pi) 11444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.01921fb54442d18p9'), pi) 11454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.03243f6a8885a3p8'), pi) 11464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.06487ed5110b46p7'), pi) 11474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.0c90fdaa22168cp6'), pi) 11484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.1921fb54442d18p5'), pi) 11494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.3243f6a8885a3p4'), pi) 11504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.6487ed5110b46p3'), pi) 11514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x.c90fdaa22168cp2'), pi) 11524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.921fb54442d18p1'), pi) 11534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x3.243f6a8885a3p0'), pi) 11544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x6.487ed5110b46p-1'), pi) 11554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xc.90fdaa22168cp-2'), pi) 11564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x19.21fb54442d18p-3'), pi) 11574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x32.43f6a8885a3p-4'), pi) 11584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x64.87ed5110b46p-5'), pi) 11594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xc9.0fdaa22168cp-6'), pi) 11604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x192.1fb54442d18p-7'), pi) 11614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x324.3f6a8885a3p-8'), pi) 11624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x648.7ed5110b46p-9'), pi) 11634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xc90.fdaa22168cp-10'), pi) 11644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1921.fb54442d18p-11'), pi) 11654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # ... 11664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1921fb54442d1.8p-47'), pi) 11674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x3243f6a8885a3p-48'), pi) 11684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x6487ed5110b46p-49'), pi) 11694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xc90fdaa22168cp-50'), pi) 11704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1921fb54442d18p-51'), pi) 11714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x3243f6a8885a30p-52'), pi) 11724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x6487ed5110b460p-53'), pi) 11734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xc90fdaa22168c0p-54'), pi) 11744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1921fb54442d180p-55'), pi) 11754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # results that should overflow... 11784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '-0x1p1024') 11794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0x1p+1025') 11804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '+0X1p1030') 11814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '-0x1p+1100') 11824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0X1p123456789123456789') 11834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '+0X.8p+1025') 11844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '+0x0.8p1025') 11854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '-0x0.4p1026') 11864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0X2p+1023') 11874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0x2.p1023') 11884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '-0x2.0p+1023') 11894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '+0X4p+1022') 11904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0x1.ffffffffffffffp+1023') 11914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '-0X1.fffffffffffff9p1023') 11924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0X1.fffffffffffff8p1023') 11934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '+0x3.fffffffffffffp1022') 11944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0x3fffffffffffffp+970') 11954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '0x10000000000000000p960') 11964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, fromHex, '-0Xffffffffffffffffp960') 11974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 11984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # ...and those that round to +-max float 11994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('+0x1.fffffffffffffp+1023'), MAX) 12004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X1.fffffffffffff7p1023'), -MAX) 12014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.fffffffffffff7fffffffffffffp1023'), MAX) 12024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # zeros 12044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0p0'), 0.0) 12054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0p1000'), 0.0) 12064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x0p1023'), -0.0) 12074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0p1024'), 0.0) 12084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x0p1025'), -0.0) 12094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0p2000'), 0.0) 12104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0p123456789123456789'), 0.0) 12114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X0p-0'), -0.0) 12124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X0p-1000'), -0.0) 12134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0p-1023'), 0.0) 12144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X0p-1024'), -0.0) 12154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x0p-1025'), -0.0) 12164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x0p-1072'), -0.0) 12174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0p-1073'), 0.0) 12184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x0p-1074'), -0.0) 12194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0p-1075'), 0.0) 12204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0p-1076'), 0.0) 12214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X0p-2000'), -0.0) 12224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x0p-123456789123456789'), -0.0) 12234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # values that should underflow to 0 12254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1p-1075'), 0.0) 12264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X1p-1075'), -0.0) 12274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x1p-123456789123456789'), -0.0) 12284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000000001p-1075'), TINY) 12294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x1.1p-1075'), -TINY) 12304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.fffffffffffffffffp-1075'), TINY) 12314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check round-half-even is working correctly near 0 ... 12334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1p-1076'), 0.0) 12344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X2p-1076'), 0.0) 12354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X3p-1076'), TINY) 12364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x4p-1076'), TINY) 12374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X5p-1076'), TINY) 12384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X6p-1076'), 2*TINY) 12394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x7p-1076'), 2*TINY) 12404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X8p-1076'), 2*TINY) 12414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X9p-1076'), 2*TINY) 12424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xap-1076'), 2*TINY) 12434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0Xbp-1076'), 3*TINY) 12444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xcp-1076'), 3*TINY) 12454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0Xdp-1076'), 3*TINY) 12464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0Xep-1076'), 4*TINY) 12474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0xfp-1076'), 4*TINY) 12484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x10p-1076'), 4*TINY) 12494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x1p-1076'), -0.0) 12504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X2p-1076'), -0.0) 12514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x3p-1076'), -TINY) 12524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X4p-1076'), -TINY) 12534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x5p-1076'), -TINY) 12544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0x6p-1076'), -2*TINY) 12554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X7p-1076'), -2*TINY) 12564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X8p-1076'), -2*TINY) 12574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X9p-1076'), -2*TINY) 12584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0Xap-1076'), -2*TINY) 12594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0xbp-1076'), -3*TINY) 12604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0xcp-1076'), -3*TINY) 12614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0Xdp-1076'), -3*TINY) 12624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0xep-1076'), -4*TINY) 12634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0Xfp-1076'), -4*TINY) 12644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('-0X10p-1076'), -4*TINY) 12654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 12664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # ... and near MIN ... 12674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffd6p-1022'), MIN-3*TINY) 12684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffd8p-1022'), MIN-2*TINY) 12694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffdap-1022'), MIN-2*TINY) 12704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffdcp-1022'), MIN-2*TINY) 12714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffdep-1022'), MIN-2*TINY) 12724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffe0p-1022'), MIN-2*TINY) 12734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffe2p-1022'), MIN-2*TINY) 12744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffe4p-1022'), MIN-2*TINY) 12754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffe6p-1022'), MIN-2*TINY) 12764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffe8p-1022'), MIN-2*TINY) 12774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffeap-1022'), MIN-TINY) 12784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffecp-1022'), MIN-TINY) 12794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffeep-1022'), MIN-TINY) 12804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff0p-1022'), MIN-TINY) 12814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff2p-1022'), MIN-TINY) 12824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff4p-1022'), MIN-TINY) 12834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff6p-1022'), MIN-TINY) 12844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff8p-1022'), MIN) 12854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffffap-1022'), MIN) 12864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffffcp-1022'), MIN) 12874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffffep-1022'), MIN) 12884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000000p-1022'), MIN) 12894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000002p-1022'), MIN) 12904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000004p-1022'), MIN) 12914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000006p-1022'), MIN) 12924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000008p-1022'), MIN) 12934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000000ap-1022'), MIN+TINY) 12944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000000cp-1022'), MIN+TINY) 12954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000000ep-1022'), MIN+TINY) 12964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000010p-1022'), MIN+TINY) 12974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000012p-1022'), MIN+TINY) 12984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000014p-1022'), MIN+TINY) 12994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000016p-1022'), MIN+TINY) 13004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000018p-1022'), MIN+2*TINY) 13014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # ... and near 1.0. 13034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff0p0'), 1.0-EPS) 13044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff1p0'), 1.0-EPS) 13054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffff2p0'), 1.0-EPS) 13064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff3p0'), 1.0-EPS) 13074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffff4p0'), 1.0-EPS) 13084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffff5p0'), 1.0-EPS/2) 13094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffff6p0'), 1.0-EPS/2) 13104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff7p0'), 1.0-EPS/2) 13114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffff8p0'), 1.0-EPS/2) 13124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffff9p0'), 1.0-EPS/2) 13134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffffap0'), 1.0-EPS/2) 13144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffffbp0'), 1.0-EPS/2) 13154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffffcp0'), 1.0) 13164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.fffffffffffffdp0'), 1.0) 13174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X0.fffffffffffffep0'), 1.0) 13184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x0.ffffffffffffffp0'), 1.0) 13194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000000p0'), 1.0) 13204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000001p0'), 1.0) 13214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000002p0'), 1.0) 13224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000003p0'), 1.0) 13234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000004p0'), 1.0) 13244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000005p0'), 1.0) 13254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000006p0'), 1.0) 13264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000007p0'), 1.0) 13274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000007ffffffffffffffffffffp0'), 13284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1.0) 13294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000008p0'), 1.0) 13304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000008000000000000000001p0'), 13314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1+EPS) 13324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000009p0'), 1.0+EPS) 13334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000000ap0'), 1.0+EPS) 13344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000000bp0'), 1.0+EPS) 13354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.0000000000000cp0'), 1.0+EPS) 13364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000000dp0'), 1.0+EPS) 13374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000000ep0'), 1.0+EPS) 13384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.0000000000000fp0'), 1.0+EPS) 13394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000010p0'), 1.0+EPS) 13404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000011p0'), 1.0+EPS) 13414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000012p0'), 1.0+EPS) 13424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000013p0'), 1.0+EPS) 13434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000014p0'), 1.0+EPS) 13444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000015p0'), 1.0+EPS) 13454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000016p0'), 1.0+EPS) 13464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000017p0'), 1.0+EPS) 13474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000017ffffffffffffffffffffp0'), 13484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1.0+EPS) 13494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000018p0'), 1.0+2*EPS) 13504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.00000000000018000000000000000001p0'), 13514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1.0+2*EPS) 13524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000019p0'), 1.0+2*EPS) 13534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.0000000000001ap0'), 1.0+2*EPS) 13544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.0000000000001bp0'), 1.0+2*EPS) 13554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000001cp0'), 1.0+2*EPS) 13564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000001dp0'), 1.0+2*EPS) 13574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.0000000000001ep0'), 1.0+2*EPS) 13584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0X1.0000000000001fp0'), 1.0+2*EPS) 13594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(fromHex('0x1.00000000000020p0'), 1.0+2*EPS) 13604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_roundtrip(self): 13624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def roundtrip(x): 13634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return fromHex(toHex(x)) 13644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in [NAN, INF, self.MAX, self.MIN, self.MIN-self.TINY, self.TINY, 0.0]: 13664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(x, roundtrip(x)) 13674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(-x, roundtrip(-x)) 13684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # fromHex(toHex(x)) should exactly recover x, for any non-NaN float x. 13704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm import random 13714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(10000): 13724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm e = random.randrange(-1200, 1200) 13734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm m = random.random() 13744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm s = random.choice([1.0, -1.0]) 13754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 13764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x = s*ldexp(m, e) 13774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except OverflowError: 13784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 13794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 13804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.identical(x, fromHex(toHex(x))) 13814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef test_main(): 13844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_support.run_unittest( 13854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm GeneralFloatCases, 13864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm FormatFunctionsTestCase, 13874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm UnknownFormatTestCase, 13884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm IEEEFormatTestCase, 13894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ReprTestCase, 13904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm RoundTestCase, 13914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm InfNanTest, 13924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm HexFloatTestCase, 13934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm ) 13944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 13954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == '__main__': 13964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_main() 1397