14710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmimport unittest 24710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom test import test_support 34710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 44710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom random import random 54710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmfrom math import atan2, isnan, copysign 64710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 74710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmINF = float("inf") 84710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmNAN = float("nan") 94710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm# These tests ensure that complex math does the right thing 104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmclass ComplexTest(unittest.TestCase): 124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def assertAlmostEqual(self, a, b): 144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isinstance(a, complex): 154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isinstance(b, complex): 164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unittest.TestCase.assertAlmostEqual(self, a.real, b.real) 174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag) 184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unittest.TestCase.assertAlmostEqual(self, a.real, b) 204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unittest.TestCase.assertAlmostEqual(self, a.imag, 0.) 214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isinstance(b, complex): 234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unittest.TestCase.assertAlmostEqual(self, a, b.real) 244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unittest.TestCase.assertAlmostEqual(self, 0., b.imag) 254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm unittest.TestCase.assertAlmostEqual(self, a, b) 274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def assertCloseAbs(self, x, y, eps=1e-9): 294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Return true iff floats x and y "are close\"""" 304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # put the one with larger magnitude second 314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if abs(x) > abs(y): 324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x, y = y, x 334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if y == 0: 344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return abs(x) < eps 354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if x == 0: 364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return abs(y) < eps 374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check that relative difference < eps 384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(abs((x-y)/y) < eps) 394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def assertFloatsAreIdentical(self, x, y): 414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """assert that floats x and y are identical, in the sense that: 424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (1) both x and y are nans, or 434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (2) both x and y are infinities, with the same sign, or 444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (3) both x and y are zeros, with the same sign, or 454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm (4) x and y are both finite and nonzero, and x == y 464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """ 484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg = 'floats {!r} and {!r} are not identical' 494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isnan(x) or isnan(y): 514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if isnan(x) and isnan(y): 524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif x == y: 544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if x != 0.0: 554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # both zero; check that signs match 574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm elif copysign(1.0, x) == copysign(1.0, y): 584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm msg += ': zeros have different signs' 614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail(msg.format(x, y)) 624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def assertClose(self, x, y, eps=1e-9): 644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Return true iff complexes x and y "are close\"""" 654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertCloseAbs(x.real, y.real, eps) 664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertCloseAbs(x.imag, y.imag, eps) 674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def check_div(self, x, y): 694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Compute complex z=x*y, and check that z/x==y and z/y==x.""" 704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = x * y 714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if x != 0: 724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = z / x 734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertClose(q, y) 744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = z.__div__(x) 754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertClose(q, y) 764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = z.__truediv__(x) 774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertClose(q, y) 784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if y != 0: 794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = z / y 804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertClose(q, x) 814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = z.__div__(y) 824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertClose(q, x) 834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm q = z.__truediv__(y) 844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertClose(q, x) 854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_div(self): 874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm simple_real = [float(i) for i in xrange(-5, 6)] 884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm simple_complex = [complex(x, y) for x in simple_real for y in simple_real] 894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in simple_complex: 904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for y in simple_complex: 914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_div(x, y) 924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # A naive complex division algorithm (such as in 2.0) is very prone to 944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # nonsense errors for these (overflows and underflows). 954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_div(complex(1e200, 1e200), 1+0j) 964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_div(complex(1e-200, 1e-200), 1+0j) 974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Just for fun. 994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(100): 1004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.check_div(complex(random(), random()), 1014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm complex(random(), random())) 1024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j) 1044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # FIXME: The following currently crashes on Alpha 1054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j) 1064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_truediv(self): 1084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j) 1094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j) 1104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_floordiv(self): 1124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex.__floordiv__(3+0j, 1.5+0j), 2) 1134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j) 1144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_coerce(self): 1164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000) 1174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_no_implicit_coerce(self): 1194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Python 2.7 removed implicit coercion from the complex type 1204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class A(object): 1214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __coerce__(self, other): 1224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise RuntimeError 1234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __hash__ = None 1244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __cmp__(self, other): 1254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return -1 1264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = A() 1284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, lambda: a + 2.0j) 1294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(a < 2.0j) 1304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_richcompare(self): 1324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex.__eq__(1+1j, 1L<<10000), False) 1334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex.__lt__(1+1j, None), NotImplemented) 1344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIs(complex.__eq__(1+1j, 1+1j), True) 1354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIs(complex.__eq__(1+1j, 2+2j), False) 1364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIs(complex.__ne__(1+1j, 1+1j), False) 1374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIs(complex.__ne__(1+1j, 2+2j), True) 1384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j) 1394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j) 1404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j) 1414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j) 1424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_richcompare_boundaries(self): 1444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def check(n, deltas, is_equal, imag = 0.0): 1454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for delta in deltas: 1464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm i = n + delta 1474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = complex(i, imag) 1484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIs(complex.__eq__(z, i), is_equal(delta)) 1494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertIs(complex.__ne__(z, i), not is_equal(delta)) 1504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # For IEEE-754 doubles the following should hold: 1514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0 1524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # where the interval is representable, of course. 1534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in range(1, 10): 1544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pow = 52 + i 1554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm mult = 2 ** i 1564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check(2 ** pow, range(1, 101), lambda delta: delta % mult == 0) 1574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check(2 ** pow, range(1, 101), lambda delta: False, float(i)) 1584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm check(2 ** 53, range(-100, 0), lambda delta: True) 1594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_mod(self): 1614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j) 1624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = 3.33+4.43j 1644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 1654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a % 0 1664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ZeroDivisionError: 1674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 1684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 1694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("modulo parama can't be 0") 1704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_divmod(self): 1724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, divmod, 1+1j, 0+0j) 1734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_pow(self): 1754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0) 1764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0) 1774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j) 1784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(1j, -1), 1/1j) 1794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(pow(1j, 200), 1) 1804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j) 1814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = 3.33+4.43j 1834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a ** 0j, 1) 1844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a ** 0.+0.j, 1) 1854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3j ** 0j, 1) 1874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(3j ** 0, 1) 1884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 1904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0j ** a 1914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ZeroDivisionError: 1924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 1934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 1944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("should fail 0.0 to negative or complex power") 1954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 1964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 1974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0j ** (3-2j) 1984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm except ZeroDivisionError: 1994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 2004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm else: 2014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.fail("should fail 0.0 to negative or complex power") 2024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # The following is used to exercise certain code paths 2044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a ** 105, a ** 105) 2054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a ** -105, a ** -105) 2064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(a ** -30, a ** -30) 2074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(0.0j ** 0, 1) 2094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = 5.1+2.3j 2114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, pow, a, b, 0) 2124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_boolcontext(self): 2144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for i in xrange(100): 2154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(complex(random() + 1e-6, random() + 1e-6)) 2164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(not complex(0.0, 0.0)) 2174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_conjugate(self): 2194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j) 2204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_constructor(self): 2224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class OS: 2234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, value): self.value = value 2244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __complex__(self): return self.value 2254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class NS(object): 2264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, value): self.value = value 2274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __complex__(self): return self.value 2284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex(OS(1+10j)), 1+10j) 2294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex(NS(1+10j)), 1+10j) 2304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, OS(None)) 2314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, NS(None)) 2324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("1+10j"), 1+10j) 2344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(10), 10+0j) 2354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(10.0), 10+0j) 2364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(10L), 10+0j) 2374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(10+0j), 10+0j) 2384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1,10), 1+10j) 2394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1,10L), 1+10j) 2404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1,10.0), 1+10j) 2414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1L,10), 1+10j) 2424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1L,10L), 1+10j) 2434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1L,10.0), 1+10j) 2444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1.0,10), 1+10j) 2454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1.0,10L), 1+10j) 2464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(1.0,10.0), 1+10j) 2474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(3.14+0j), 3.14+0j) 2484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(3.14), 3.14+0j) 2494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(314), 314.0+0j) 2504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(314L), 314.0+0j) 2514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j) 2524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j) 2534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(314, 0), 314.0+0j) 2544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(314L, 0L), 314.0+0j) 2554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j) 2564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j) 2574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(0j, 3.14), 3.14j) 2584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(0.0, 3.14), 3.14j) 2594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("1"), 1+0j) 2604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("1j"), 1j) 2614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(), 0) 2624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("-1"), -1) 2634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("+1"), +1) 2644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("(1+2j)"), 1+2j) 2654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j) 2664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j) 2674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j) 2684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j) 2694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j) 2704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("J"), 1j) 2714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("( j )"), 1j) 2724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("+J"), 1j) 2734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex("( -j)"), -1j) 2744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j) 2754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j) 2764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j) 2774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class complex2(complex): pass 2794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j) 2804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(real=17, imag=23), 17+23j) 2814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(real=17+23j), 17+23j) 2824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j) 2834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j) 2844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check that the sign of a zero in the real or imaginary part 2864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # is preserved when constructing from two floats. (These checks 2874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # are harmless on systems without support for signed zeros.) 2884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def split_zeros(x): 2894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Function that produces different results for 0. and -0.""" 2904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return atan2(x, -1.) 2914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.)) 2934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.)) 2944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.)) 2954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.)) 2964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 2974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm c = 3.14 + 1j 2984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(complex(c) is c) 2994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm del c 3004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, "1", "1") 3024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, 1, "1") 3034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if test_support.have_unicode: 3054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j) 3064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # SF bug 543840: complex(string) accepts strings with \0 3084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # Fixed in 2.3. 3094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, '1+1j\0j') 3104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, int, 5+3j) 3124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, long, 5+3j) 3134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, float, 5+3j) 3144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "") 3154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, None) 3164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "\0") 3174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "3\09") 3184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, "1", "2") 3194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, "1", 42) 3204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, 1, "2") 3214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1+") 3224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1+1j+1j") 3234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "--") 3244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "(1+2j") 3254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1+2j)") 3264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1+(2j)") 3274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "(1+2j)123") 3284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if test_support.have_unicode: 3294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, unicode("x")) 3304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1j+2") 3314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1e1ej") 3324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1e++1ej") 3334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, ")1+2j(") 3344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # the following three are accepted by Python 2.6 3354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1..1j") 3364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1.11.1j") 3374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, complex, "1e1.1j") 3384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if test_support.have_unicode: 3404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # check that complex accepts long unicode strings 3414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(type(complex(unicode("1"*500))), complex) 3424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class EvilExc(Exception): 3444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm pass 3454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class evilcomplex: 3474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __complex__(self): 3484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm raise EvilExc 3494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(EvilExc, complex, evilcomplex()) 3514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class float2: 3534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __init__(self, value): 3544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.value = value 3554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __float__(self): 3564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self.value 3574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(float2(42.)), 42) 3594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j) 3604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, float2(None)) 3614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class complex0(complex): 3634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Test usage of __complex__() when inheriting from 'complex'""" 3644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __complex__(self): 3654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return 42j 3664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class complex1(complex): 3684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Test usage of __complex__() with a __new__() method""" 3694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __new__(self, value=0j): 3704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return complex.__new__(self, 2*value) 3714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __complex__(self): 3724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return self 3734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class complex2(complex): 3754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm """Make sure that __complex__() calls fail if anything other than a 3764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm complex is returned""" 3774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __complex__(self): 3784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return None 3794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(complex0(1j)), 42j) 3814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual(complex(complex1(1j)), 2j) 3824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(TypeError, complex, complex2(1j)) 3834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_subclass(self): 3854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm class xcomplex(complex): 3864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __add__(self,other): 3874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(complex(self) + other) 3884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __radd__ = __add__ 3894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __sub__(self,other): 3914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(complex(self) + other) 3924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __rsub__ = __sub__ 3934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __mul__(self,other): 3954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(complex(self) * other) 3964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __rmul__ = __mul__ 3974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 3984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __div__(self,other): 3994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(complex(self) / other) 4004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __rdiv__(self,other): 4024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(other / complex(self)) 4034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __truediv__ = __div__ 4054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm __rtruediv__ = __rdiv__ 4064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __floordiv__(self,other): 4084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(complex(self) // other) 4094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __rfloordiv__(self,other): 4114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(other // complex(self)) 4124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __pow__(self,other): 4144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(complex(self) ** other) 4154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __rpow__(self,other): 4174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(other ** complex(self) ) 4184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __mod__(self,other): 4204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(complex(self) % other) 4214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def __rmod__(self,other): 4234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm return xcomplex(other % complex(self)) 4244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm infix_binops = ('+', '-', '*', '**', '%', '//', '/') 4264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm xcomplex_values = (xcomplex(1), xcomplex(123.0), 4274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm xcomplex(-10+2j), xcomplex(3+187j), 4284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm xcomplex(3-78j)) 4294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_values = (1, 123.0, 10-19j, xcomplex(1+2j), 4304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm xcomplex(1+87j), xcomplex(10+90j)) 4314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for op in infix_binops: 4334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in xcomplex_values: 4344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for y in test_values: 4354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = 'x %s y' % op 4364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = 'y %s x' % op 4374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertTrue(type(eval(a)) is type(eval(b)) is xcomplex) 4384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_hash(self): 4404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in xrange(-30, 30): 4414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(x), hash(complex(x, 0))) 4424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm x /= 3.0 # now check against floating point 4434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(hash(x), hash(complex(x, 0.))) 4444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_abs(self): 4464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)] 4474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for num in nums: 4484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num)) 4494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repr(self): 4514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(1+6j), '(1+6j)') 4524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(1-6j), '(1-6j)') 4534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)') 4554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(1-6j,complex(repr(1-6j))) 4574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(1+6j,complex(repr(1+6j))) 4584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(-6j,complex(repr(-6j))) 4594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(6j,complex(repr(6j))) 4604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(1., INF)), "(1+infj)") 4624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(1., -INF)), "(1-infj)") 4634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(INF, 1)), "(inf+1j)") 4644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(-INF, INF)), "(-inf+infj)") 4654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)") 4664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(1, NAN)), "(1+nanj)") 4674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(NAN, NAN)), "(nan+nanj)") 4684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(0, INF)), "infj") 4704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(0, -INF)), "-infj") 4714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(repr(complex(0, NAN)), "nanj") 4724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_neg(self): 4744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(-(1+6j), -1-6j) 4754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_file(self): 4774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm a = 3.33+4.43j 4784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm b = 5.1+2.3j 4794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fo = None 4814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm try: 4824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fo = open(test_support.TESTFN, "wb") 4834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm print >>fo, a, b 4844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fo.close() 4854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fo = open(test_support.TESTFN, "rb") 4864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(fo.read(), "%s %s\n" % (a, b)) 4874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm finally: 4884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if (fo is not None) and (not fo.closed): 4894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm fo.close() 4904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_support.unlink(test_support.TESTFN) 4914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 4924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_getnewargs(self): 4934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0)) 4944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0)) 4954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((2j).__getnewargs__(), (0.0, 2.0)) 4964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0)) 4974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF)) 4984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0)) 4994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm if float.__getformat__("double").startswith("IEEE"): 5014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_plus_minus_0j(self): 5024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # test that -0j and 0j literals are not identified 5034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z1, z2 = 0j, -0j 5044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.)) 5054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.)) 5064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 5084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test requires IEEE 754 doubles") 5094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_overflow(self): 5104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex("1e500"), complex(INF, 0.0)) 5114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex("-1e500j"), complex(0.0, -INF)) 5124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF)) 5134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 5154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "test requires IEEE 754 doubles") 5164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_repr_roundtrip(self): 5174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN] 5184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm vals += [-v for v in vals] 5194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # complex(repr(z)) should recover z exactly, even for complex 5214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # numbers involving an infinity, nan, or negative zero 5224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in vals: 5234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for y in vals: 5244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = complex(x, y) 5254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm roundtrip = complex(repr(z)) 5264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFloatsAreIdentical(z.real, roundtrip.real) 5274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFloatsAreIdentical(z.imag, roundtrip.imag) 5284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # if we predefine some constants, then eval(repr(z)) should 5304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # also work, except that it might change the sign of zeros 5314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm inf, nan = float('inf'), float('nan') 5324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm infj, nanj = complex(0.0, inf), complex(0.0, nan) 5334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for x in vals: 5344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for y in vals: 5354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = complex(x, y) 5364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm roundtrip = eval(repr(z)) 5374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # adding 0.0 has no effect beside changing -0.0 to 0.0 5384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFloatsAreIdentical(0.0 + z.real, 5394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0.0 + roundtrip.real) 5404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertFloatsAreIdentical(0.0 + z.imag, 5414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 0.0 + roundtrip.imag) 5424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm def test_format(self): 5444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # empty format string is same as str() 5454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1+3j, ''), str(1+3j)) 5464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j)) 5474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3j, ''), str(3j)) 5484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3.2j, ''), str(3.2j)) 5494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3+0j, ''), str(3+0j)) 5504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3.2+0j, ''), str(3.2+0j)) 5514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5524710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # empty presentation type should still be analogous to str, 5534710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # even when format string is nonempty (issue #5920). 5544710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3.2+0j, '-'), str(3.2+0j)) 5554710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3.2+0j, '<'), str(3.2+0j)) 5564710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = 4/7. - 100j/7. 5574710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, ''), str(z)) 5584710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '-'), str(z)) 5594710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '<'), str(z)) 5604710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '10'), str(z)) 5614710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = complex(0.0, 3.0) 5624710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, ''), str(z)) 5634710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '-'), str(z)) 5644710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '<'), str(z)) 5654710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '2'), str(z)) 5664710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm z = complex(-0.0, 2.0) 5674710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, ''), str(z)) 5684710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '-'), str(z)) 5694710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '<'), str(z)) 5704710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(z, '3'), str(z)) 5714710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5724710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1+3j, 'g'), '1+3j') 5734710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(3j, 'g'), '0+3j') 5744710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j') 5754710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5764710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j') 5774710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j') 5784710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j') 5794710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j') 5804710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j') 5814710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j') 5824710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j') 5834710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5844710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j') 5854710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j') 5864710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j') 5874710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j') 5884710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j') 5894710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j') 5904710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j') 5914710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 5924710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ') 5934710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************') 5944710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j') 5954710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ') 5964710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ') 5974710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)') 5984710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ') 5994710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ') 6004710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6014710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j') 6024710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j') 6034710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ') 6044710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j') 6054710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j') 6064710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ') 6074710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ') 6084710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j') 6094710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6104710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # alternate is invalid 6114710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, (1.5+0.5j).__format__, '#f') 6124710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6134710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # zero padding is invalid 6144710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f') 6154710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6164710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # '=' alignment is invalid 6174710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, (1.5+3j).__format__, '=20') 6184710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6194710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # integer presentation types are an error 6204710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm for t in 'bcdoxX': 6214710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertRaises(ValueError, (1.5+0.5j).__format__, t) 6224710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6234710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # make sure everything works in ''.format() 6244710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*') 6254710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6264710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm # issue 3382: 'f' and 'F' with inf's and nan's 6274710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(INF+0j), 'inf+0.000000j') 6284710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(INF+0j), 'INF+0.000000j') 6294710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(-INF+0j), '-inf+0.000000j') 6304710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(-INF+0j), '-INF+0.000000j') 6314710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(complex(INF, INF)), 'inf+infj') 6324710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(complex(INF, INF)), 'INF+INFj') 6334710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(complex(INF, -INF)), 'inf-infj') 6344710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(complex(INF, -INF)), 'INF-INFj') 6354710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(complex(-INF, INF)), '-inf+infj') 6364710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(complex(-INF, INF)), '-INF+INFj') 6374710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(complex(-INF, -INF)), '-inf-infj') 6384710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(complex(-INF, -INF)), '-INF-INFj') 6394710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6404710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(complex(NAN, 0)), 'nan+0.000000j') 6414710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(complex(NAN, 0)), 'NAN+0.000000j') 6424710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:f}'.format(complex(NAN, NAN)), 'nan+nanj') 6434710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm self.assertEqual('{0:F}'.format(complex(NAN, NAN)), 'NAN+NANj') 6444710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6454710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmdef test_main(): 6464710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm with test_support.check_warnings(("complex divmod.., // and % are " 6474710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm "deprecated", DeprecationWarning)): 6484710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_support.run_unittest(ComplexTest) 6494710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm 6504710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylmif __name__ == "__main__": 6514710c53dcad1ebf3755f3efb9e80ac24bd72a9b2darylm test_main() 652