1import unittest 2from test import test_support 3 4from random import random 5from math import atan2, isnan, copysign 6 7INF = float("inf") 8NAN = float("nan") 9# These tests ensure that complex math does the right thing 10 11# decorator for skipping tests on non-IEEE 754 platforms 12have_getformat = hasattr(float, "__getformat__") 13requires_IEEE_754 = unittest.skipUnless(have_getformat and 14 float.__getformat__("double").startswith("IEEE"), 15 "test requires IEEE 754 doubles") 16 17 18class ComplexTest(unittest.TestCase): 19 20 def assertAlmostEqual(self, a, b): 21 if isinstance(a, complex): 22 if isinstance(b, complex): 23 unittest.TestCase.assertAlmostEqual(self, a.real, b.real) 24 unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag) 25 else: 26 unittest.TestCase.assertAlmostEqual(self, a.real, b) 27 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.) 28 else: 29 if isinstance(b, complex): 30 unittest.TestCase.assertAlmostEqual(self, a, b.real) 31 unittest.TestCase.assertAlmostEqual(self, 0., b.imag) 32 else: 33 unittest.TestCase.assertAlmostEqual(self, a, b) 34 35 def assertCloseAbs(self, x, y, eps=1e-9): 36 """Return true iff floats x and y "are close".""" 37 # put the one with larger magnitude second 38 if abs(x) > abs(y): 39 x, y = y, x 40 if y == 0: 41 return abs(x) < eps 42 if x == 0: 43 return abs(y) < eps 44 # check that relative difference < eps 45 self.assertTrue(abs((x-y)/y) < eps) 46 47 def assertFloatsAreIdentical(self, x, y): 48 """assert that floats x and y are identical, in the sense that: 49 (1) both x and y are nans, or 50 (2) both x and y are infinities, with the same sign, or 51 (3) both x and y are zeros, with the same sign, or 52 (4) x and y are both finite and nonzero, and x == y 53 54 """ 55 msg = 'floats {!r} and {!r} are not identical' 56 57 if isnan(x) or isnan(y): 58 if isnan(x) and isnan(y): 59 return 60 elif x == y: 61 if x != 0.0: 62 return 63 # both zero; check that signs match 64 elif copysign(1.0, x) == copysign(1.0, y): 65 return 66 else: 67 msg += ': zeros have different signs' 68 self.fail(msg.format(x, y)) 69 70 def assertClose(self, x, y, eps=1e-9): 71 """Return true iff complexes x and y "are close".""" 72 self.assertCloseAbs(x.real, y.real, eps) 73 self.assertCloseAbs(x.imag, y.imag, eps) 74 75 def check_div(self, x, y): 76 """Compute complex z=x*y, and check that z/x==y and z/y==x.""" 77 z = x * y 78 if x != 0: 79 q = z / x 80 self.assertClose(q, y) 81 q = z.__div__(x) 82 self.assertClose(q, y) 83 q = z.__truediv__(x) 84 self.assertClose(q, y) 85 if y != 0: 86 q = z / y 87 self.assertClose(q, x) 88 q = z.__div__(y) 89 self.assertClose(q, x) 90 q = z.__truediv__(y) 91 self.assertClose(q, x) 92 93 def test_div(self): 94 simple_real = [float(i) for i in xrange(-5, 6)] 95 simple_complex = [complex(x, y) for x in simple_real for y in simple_real] 96 for x in simple_complex: 97 for y in simple_complex: 98 self.check_div(x, y) 99 100 # A naive complex division algorithm (such as in 2.0) is very prone to 101 # nonsense errors for these (overflows and underflows). 102 self.check_div(complex(1e200, 1e200), 1+0j) 103 self.check_div(complex(1e-200, 1e-200), 1+0j) 104 105 # Just for fun. 106 for i in xrange(100): 107 self.check_div(complex(random(), random()), 108 complex(random(), random())) 109 110 self.assertRaises(ZeroDivisionError, complex.__div__, 1+1j, 0+0j) 111 # FIXME: The following currently crashes on Alpha 112 # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j) 113 114 def test_truediv(self): 115 self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j) 116 self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j) 117 118 for denom_real, denom_imag in [(0, NAN), (NAN, 0), (NAN, NAN)]: 119 z = complex(0, 0) / complex(denom_real, denom_imag) 120 self.assertTrue(isnan(z.real)) 121 self.assertTrue(isnan(z.imag)) 122 123 def test_floordiv(self): 124 self.assertAlmostEqual(complex.__floordiv__(3+0j, 1.5+0j), 2) 125 self.assertRaises(ZeroDivisionError, complex.__floordiv__, 3+0j, 0+0j) 126 127 def test_coerce(self): 128 self.assertRaises(OverflowError, complex.__coerce__, 1+1j, 1L<<10000) 129 130 def test_no_implicit_coerce(self): 131 # Python 2.7 removed implicit coercion from the complex type 132 class A(object): 133 def __coerce__(self, other): 134 raise RuntimeError 135 __hash__ = None 136 def __cmp__(self, other): 137 return -1 138 139 a = A() 140 self.assertRaises(TypeError, lambda: a + 2.0j) 141 self.assertTrue(a < 2.0j) 142 143 def test_richcompare(self): 144 self.assertEqual(complex.__eq__(1+1j, 1L<<10000), False) 145 self.assertEqual(complex.__lt__(1+1j, None), NotImplemented) 146 self.assertIs(complex.__eq__(1+1j, 1+1j), True) 147 self.assertIs(complex.__eq__(1+1j, 2+2j), False) 148 self.assertIs(complex.__ne__(1+1j, 1+1j), False) 149 self.assertIs(complex.__ne__(1+1j, 2+2j), True) 150 self.assertRaises(TypeError, complex.__lt__, 1+1j, 2+2j) 151 self.assertRaises(TypeError, complex.__le__, 1+1j, 2+2j) 152 self.assertRaises(TypeError, complex.__gt__, 1+1j, 2+2j) 153 self.assertRaises(TypeError, complex.__ge__, 1+1j, 2+2j) 154 155 def test_richcompare_boundaries(self): 156 def check(n, deltas, is_equal, imag = 0.0): 157 for delta in deltas: 158 i = n + delta 159 z = complex(i, imag) 160 self.assertIs(complex.__eq__(z, i), is_equal(delta)) 161 self.assertIs(complex.__ne__(z, i), not is_equal(delta)) 162 # For IEEE-754 doubles the following should hold: 163 # x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0 164 # where the interval is representable, of course. 165 for i in range(1, 10): 166 pow = 52 + i 167 mult = 2 ** i 168 check(2 ** pow, range(1, 101), lambda delta: delta % mult == 0) 169 check(2 ** pow, range(1, 101), lambda delta: False, float(i)) 170 check(2 ** 53, range(-100, 0), lambda delta: True) 171 172 def test_mod(self): 173 self.assertRaises(ZeroDivisionError, (1+1j).__mod__, 0+0j) 174 175 a = 3.33+4.43j 176 try: 177 a % 0 178 except ZeroDivisionError: 179 pass 180 else: 181 self.fail("modulo parama can't be 0") 182 183 def test_divmod(self): 184 self.assertRaises(ZeroDivisionError, divmod, 1+1j, 0+0j) 185 186 def test_pow(self): 187 self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0) 188 self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0) 189 self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j) 190 self.assertAlmostEqual(pow(1j, -1), 1/1j) 191 self.assertAlmostEqual(pow(1j, 200), 1) 192 self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j) 193 194 a = 3.33+4.43j 195 self.assertEqual(a ** 0j, 1) 196 self.assertEqual(a ** 0.+0.j, 1) 197 198 self.assertEqual(3j ** 0j, 1) 199 self.assertEqual(3j ** 0, 1) 200 201 try: 202 0j ** a 203 except ZeroDivisionError: 204 pass 205 else: 206 self.fail("should fail 0.0 to negative or complex power") 207 208 try: 209 0j ** (3-2j) 210 except ZeroDivisionError: 211 pass 212 else: 213 self.fail("should fail 0.0 to negative or complex power") 214 215 # The following is used to exercise certain code paths 216 self.assertEqual(a ** 105, a ** 105) 217 self.assertEqual(a ** -105, a ** -105) 218 self.assertEqual(a ** -30, a ** -30) 219 220 self.assertEqual(0.0j ** 0, 1) 221 222 b = 5.1+2.3j 223 self.assertRaises(ValueError, pow, a, b, 0) 224 225 def test_boolcontext(self): 226 for i in xrange(100): 227 self.assertTrue(complex(random() + 1e-6, random() + 1e-6)) 228 self.assertTrue(not complex(0.0, 0.0)) 229 230 def test_conjugate(self): 231 self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j) 232 233 def test_constructor(self): 234 class OS: 235 def __init__(self, value): self.value = value 236 def __complex__(self): return self.value 237 class NS(object): 238 def __init__(self, value): self.value = value 239 def __complex__(self): return self.value 240 self.assertEqual(complex(OS(1+10j)), 1+10j) 241 self.assertEqual(complex(NS(1+10j)), 1+10j) 242 self.assertRaises(TypeError, complex, OS(None)) 243 self.assertRaises(TypeError, complex, NS(None)) 244 245 self.assertAlmostEqual(complex("1+10j"), 1+10j) 246 self.assertAlmostEqual(complex(10), 10+0j) 247 self.assertAlmostEqual(complex(10.0), 10+0j) 248 self.assertAlmostEqual(complex(10L), 10+0j) 249 self.assertAlmostEqual(complex(10+0j), 10+0j) 250 self.assertAlmostEqual(complex(1,10), 1+10j) 251 self.assertAlmostEqual(complex(1,10L), 1+10j) 252 self.assertAlmostEqual(complex(1,10.0), 1+10j) 253 self.assertAlmostEqual(complex(1L,10), 1+10j) 254 self.assertAlmostEqual(complex(1L,10L), 1+10j) 255 self.assertAlmostEqual(complex(1L,10.0), 1+10j) 256 self.assertAlmostEqual(complex(1.0,10), 1+10j) 257 self.assertAlmostEqual(complex(1.0,10L), 1+10j) 258 self.assertAlmostEqual(complex(1.0,10.0), 1+10j) 259 self.assertAlmostEqual(complex(3.14+0j), 3.14+0j) 260 self.assertAlmostEqual(complex(3.14), 3.14+0j) 261 self.assertAlmostEqual(complex(314), 314.0+0j) 262 self.assertAlmostEqual(complex(314L), 314.0+0j) 263 self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j) 264 self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j) 265 self.assertAlmostEqual(complex(314, 0), 314.0+0j) 266 self.assertAlmostEqual(complex(314L, 0L), 314.0+0j) 267 self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j) 268 self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j) 269 self.assertAlmostEqual(complex(0j, 3.14), 3.14j) 270 self.assertAlmostEqual(complex(0.0, 3.14), 3.14j) 271 self.assertAlmostEqual(complex("1"), 1+0j) 272 self.assertAlmostEqual(complex("1j"), 1j) 273 self.assertAlmostEqual(complex(), 0) 274 self.assertAlmostEqual(complex("-1"), -1) 275 self.assertAlmostEqual(complex("+1"), +1) 276 self.assertAlmostEqual(complex("(1+2j)"), 1+2j) 277 self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j) 278 self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j) 279 self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j) 280 self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j) 281 self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j) 282 self.assertAlmostEqual(complex("J"), 1j) 283 self.assertAlmostEqual(complex("( j )"), 1j) 284 self.assertAlmostEqual(complex("+J"), 1j) 285 self.assertAlmostEqual(complex("( -j)"), -1j) 286 self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j) 287 self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j) 288 self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j) 289 290 class complex2(complex): pass 291 self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j) 292 self.assertAlmostEqual(complex(real=17, imag=23), 17+23j) 293 self.assertAlmostEqual(complex(real=17+23j), 17+23j) 294 self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j) 295 self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j) 296 297 # check that the sign of a zero in the real or imaginary part 298 # is preserved when constructing from two floats. (These checks 299 # are harmless on systems without support for signed zeros.) 300 def split_zeros(x): 301 """Function that produces different results for 0. and -0.""" 302 return atan2(x, -1.) 303 304 self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.)) 305 self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.)) 306 self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.)) 307 self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.)) 308 309 c = 3.14 + 1j 310 self.assertTrue(complex(c) is c) 311 del c 312 313 self.assertRaises(TypeError, complex, "1", "1") 314 self.assertRaises(TypeError, complex, 1, "1") 315 316 if test_support.have_unicode: 317 self.assertEqual(complex(unicode(" 3.14+J ")), 3.14+1j) 318 319 # SF bug 543840: complex(string) accepts strings with \0 320 # Fixed in 2.3. 321 self.assertRaises(ValueError, complex, '1+1j\0j') 322 323 self.assertRaises(TypeError, int, 5+3j) 324 self.assertRaises(TypeError, long, 5+3j) 325 self.assertRaises(TypeError, float, 5+3j) 326 self.assertRaises(ValueError, complex, "") 327 self.assertRaises(TypeError, complex, None) 328 self.assertRaises(ValueError, complex, "\0") 329 self.assertRaises(ValueError, complex, "3\09") 330 self.assertRaises(TypeError, complex, "1", "2") 331 self.assertRaises(TypeError, complex, "1", 42) 332 self.assertRaises(TypeError, complex, 1, "2") 333 self.assertRaises(ValueError, complex, "1+") 334 self.assertRaises(ValueError, complex, "1+1j+1j") 335 self.assertRaises(ValueError, complex, "--") 336 self.assertRaises(ValueError, complex, "(1+2j") 337 self.assertRaises(ValueError, complex, "1+2j)") 338 self.assertRaises(ValueError, complex, "1+(2j)") 339 self.assertRaises(ValueError, complex, "(1+2j)123") 340 if test_support.have_unicode: 341 self.assertRaises(ValueError, complex, unicode("x")) 342 self.assertRaises(ValueError, complex, "1j+2") 343 self.assertRaises(ValueError, complex, "1e1ej") 344 self.assertRaises(ValueError, complex, "1e++1ej") 345 self.assertRaises(ValueError, complex, ")1+2j(") 346 # the following three are accepted by Python 2.6 347 self.assertRaises(ValueError, complex, "1..1j") 348 self.assertRaises(ValueError, complex, "1.11.1j") 349 self.assertRaises(ValueError, complex, "1e1.1j") 350 351 if test_support.have_unicode: 352 # check that complex accepts long unicode strings 353 self.assertEqual(type(complex(unicode("1"*500))), complex) 354 355 class EvilExc(Exception): 356 pass 357 358 class evilcomplex: 359 def __complex__(self): 360 raise EvilExc 361 362 self.assertRaises(EvilExc, complex, evilcomplex()) 363 364 class float2: 365 def __init__(self, value): 366 self.value = value 367 def __float__(self): 368 return self.value 369 370 self.assertAlmostEqual(complex(float2(42.)), 42) 371 self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j) 372 self.assertRaises(TypeError, complex, float2(None)) 373 374 class complex0(complex): 375 """Test usage of __complex__() when inheriting from 'complex'""" 376 def __complex__(self): 377 return 42j 378 379 class complex1(complex): 380 """Test usage of __complex__() with a __new__() method""" 381 def __new__(self, value=0j): 382 return complex.__new__(self, 2*value) 383 def __complex__(self): 384 return self 385 386 class complex2(complex): 387 """Make sure that __complex__() calls fail if anything other than a 388 complex is returned""" 389 def __complex__(self): 390 return None 391 392 self.assertAlmostEqual(complex(complex0(1j)), 42j) 393 self.assertAlmostEqual(complex(complex1(1j)), 2j) 394 self.assertRaises(TypeError, complex, complex2(1j)) 395 396 def test_subclass(self): 397 class xcomplex(complex): 398 def __add__(self,other): 399 return xcomplex(complex(self) + other) 400 __radd__ = __add__ 401 402 def __sub__(self,other): 403 return xcomplex(complex(self) + other) 404 __rsub__ = __sub__ 405 406 def __mul__(self,other): 407 return xcomplex(complex(self) * other) 408 __rmul__ = __mul__ 409 410 def __div__(self,other): 411 return xcomplex(complex(self) / other) 412 413 def __rdiv__(self,other): 414 return xcomplex(other / complex(self)) 415 416 __truediv__ = __div__ 417 __rtruediv__ = __rdiv__ 418 419 def __floordiv__(self,other): 420 return xcomplex(complex(self) // other) 421 422 def __rfloordiv__(self,other): 423 return xcomplex(other // complex(self)) 424 425 def __pow__(self,other): 426 return xcomplex(complex(self) ** other) 427 428 def __rpow__(self,other): 429 return xcomplex(other ** complex(self) ) 430 431 def __mod__(self,other): 432 return xcomplex(complex(self) % other) 433 434 def __rmod__(self,other): 435 return xcomplex(other % complex(self)) 436 437 infix_binops = ('+', '-', '*', '**', '%', '//', '/') 438 xcomplex_values = (xcomplex(1), xcomplex(123.0), 439 xcomplex(-10+2j), xcomplex(3+187j), 440 xcomplex(3-78j)) 441 test_values = (1, 123.0, 10-19j, xcomplex(1+2j), 442 xcomplex(1+87j), xcomplex(10+90j)) 443 444 for op in infix_binops: 445 for x in xcomplex_values: 446 for y in test_values: 447 a = 'x %s y' % op 448 b = 'y %s x' % op 449 self.assertTrue(type(eval(a)) is type(eval(b)) is xcomplex) 450 451 @requires_IEEE_754 452 def test_constructor_special_numbers(self): 453 class complex2(complex): 454 pass 455 for x in 0.0, -0.0, INF, -INF, NAN: 456 for y in 0.0, -0.0, INF, -INF, NAN: 457 z = complex(x, y) 458 self.assertFloatsAreIdentical(z.real, x) 459 self.assertFloatsAreIdentical(z.imag, y) 460 z = complex2(x, y) 461 self.assertIs(type(z), complex2) 462 self.assertFloatsAreIdentical(z.real, x) 463 self.assertFloatsAreIdentical(z.imag, y) 464 z = complex(complex2(x, y)) 465 self.assertIs(type(z), complex) 466 self.assertFloatsAreIdentical(z.real, x) 467 self.assertFloatsAreIdentical(z.imag, y) 468 z = complex2(complex(x, y)) 469 self.assertIs(type(z), complex2) 470 self.assertFloatsAreIdentical(z.real, x) 471 self.assertFloatsAreIdentical(z.imag, y) 472 473 def test_hash(self): 474 for x in xrange(-30, 30): 475 self.assertEqual(hash(x), hash(complex(x, 0))) 476 x /= 3.0 # now check against floating point 477 self.assertEqual(hash(x), hash(complex(x, 0.))) 478 479 def test_abs(self): 480 nums = [complex(x/3., y/7.) for x in xrange(-9,9) for y in xrange(-9,9)] 481 for num in nums: 482 self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num)) 483 484 def test_repr(self): 485 self.assertEqual(repr(1+6j), '(1+6j)') 486 self.assertEqual(repr(1-6j), '(1-6j)') 487 488 self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)') 489 490 self.assertEqual(1-6j,complex(repr(1-6j))) 491 self.assertEqual(1+6j,complex(repr(1+6j))) 492 self.assertEqual(-6j,complex(repr(-6j))) 493 self.assertEqual(6j,complex(repr(6j))) 494 495 self.assertEqual(repr(complex(1., INF)), "(1+infj)") 496 self.assertEqual(repr(complex(1., -INF)), "(1-infj)") 497 self.assertEqual(repr(complex(INF, 1)), "(inf+1j)") 498 self.assertEqual(repr(complex(-INF, INF)), "(-inf+infj)") 499 self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)") 500 self.assertEqual(repr(complex(1, NAN)), "(1+nanj)") 501 self.assertEqual(repr(complex(NAN, NAN)), "(nan+nanj)") 502 503 self.assertEqual(repr(complex(0, INF)), "infj") 504 self.assertEqual(repr(complex(0, -INF)), "-infj") 505 self.assertEqual(repr(complex(0, NAN)), "nanj") 506 507 def test_neg(self): 508 self.assertEqual(-(1+6j), -1-6j) 509 510 def test_file(self): 511 a = 3.33+4.43j 512 b = 5.1+2.3j 513 514 fo = None 515 try: 516 fo = open(test_support.TESTFN, "wb") 517 print >>fo, a, b 518 fo.close() 519 fo = open(test_support.TESTFN, "rb") 520 self.assertEqual(fo.read(), "%s %s\n" % (a, b)) 521 finally: 522 if (fo is not None) and (not fo.closed): 523 fo.close() 524 test_support.unlink(test_support.TESTFN) 525 526 def test_getnewargs(self): 527 self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0)) 528 self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0)) 529 self.assertEqual((2j).__getnewargs__(), (0.0, 2.0)) 530 self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0)) 531 self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF)) 532 self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0)) 533 534 if float.__getformat__("double").startswith("IEEE"): 535 def test_plus_minus_0j(self): 536 # test that -0j and 0j literals are not identified 537 z1, z2 = 0j, -0j 538 self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.)) 539 self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.)) 540 541 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 542 "test requires IEEE 754 doubles") 543 def test_overflow(self): 544 self.assertEqual(complex("1e500"), complex(INF, 0.0)) 545 self.assertEqual(complex("-1e500j"), complex(0.0, -INF)) 546 self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF)) 547 548 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), 549 "test requires IEEE 754 doubles") 550 def test_repr_roundtrip(self): 551 vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN] 552 vals += [-v for v in vals] 553 554 # complex(repr(z)) should recover z exactly, even for complex 555 # numbers involving an infinity, nan, or negative zero 556 for x in vals: 557 for y in vals: 558 z = complex(x, y) 559 roundtrip = complex(repr(z)) 560 self.assertFloatsAreIdentical(z.real, roundtrip.real) 561 self.assertFloatsAreIdentical(z.imag, roundtrip.imag) 562 563 # if we predefine some constants, then eval(repr(z)) should 564 # also work, except that it might change the sign of zeros 565 inf, nan = float('inf'), float('nan') 566 infj, nanj = complex(0.0, inf), complex(0.0, nan) 567 for x in vals: 568 for y in vals: 569 z = complex(x, y) 570 roundtrip = eval(repr(z)) 571 # adding 0.0 has no effect beside changing -0.0 to 0.0 572 self.assertFloatsAreIdentical(0.0 + z.real, 573 0.0 + roundtrip.real) 574 self.assertFloatsAreIdentical(0.0 + z.imag, 575 0.0 + roundtrip.imag) 576 577 def test_format(self): 578 # empty format string is same as str() 579 self.assertEqual(format(1+3j, ''), str(1+3j)) 580 self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j)) 581 self.assertEqual(format(3j, ''), str(3j)) 582 self.assertEqual(format(3.2j, ''), str(3.2j)) 583 self.assertEqual(format(3+0j, ''), str(3+0j)) 584 self.assertEqual(format(3.2+0j, ''), str(3.2+0j)) 585 586 # empty presentation type should still be analogous to str, 587 # even when format string is nonempty (issue #5920). 588 self.assertEqual(format(3.2+0j, '-'), str(3.2+0j)) 589 self.assertEqual(format(3.2+0j, '<'), str(3.2+0j)) 590 z = 4/7. - 100j/7. 591 self.assertEqual(format(z, ''), str(z)) 592 self.assertEqual(format(z, '-'), str(z)) 593 self.assertEqual(format(z, '<'), str(z)) 594 self.assertEqual(format(z, '10'), str(z)) 595 z = complex(0.0, 3.0) 596 self.assertEqual(format(z, ''), str(z)) 597 self.assertEqual(format(z, '-'), str(z)) 598 self.assertEqual(format(z, '<'), str(z)) 599 self.assertEqual(format(z, '2'), str(z)) 600 z = complex(-0.0, 2.0) 601 self.assertEqual(format(z, ''), str(z)) 602 self.assertEqual(format(z, '-'), str(z)) 603 self.assertEqual(format(z, '<'), str(z)) 604 self.assertEqual(format(z, '3'), str(z)) 605 606 self.assertEqual(format(1+3j, 'g'), '1+3j') 607 self.assertEqual(format(3j, 'g'), '0+3j') 608 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j') 609 610 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j') 611 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j') 612 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j') 613 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j') 614 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j') 615 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j') 616 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j') 617 618 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j') 619 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j') 620 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j') 621 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j') 622 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j') 623 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j') 624 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j') 625 626 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ') 627 self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************') 628 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j') 629 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ') 630 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ') 631 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)') 632 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ') 633 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ') 634 635 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j') 636 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j') 637 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ') 638 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j') 639 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j') 640 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ') 641 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ') 642 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j') 643 644 # alternate is invalid 645 self.assertRaises(ValueError, (1.5+0.5j).__format__, '#f') 646 647 # zero padding is invalid 648 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f') 649 650 # '=' alignment is invalid 651 self.assertRaises(ValueError, (1.5+3j).__format__, '=20') 652 653 # integer presentation types are an error 654 for t in 'bcdoxX': 655 self.assertRaises(ValueError, (1.5+0.5j).__format__, t) 656 657 # make sure everything works in ''.format() 658 self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*') 659 660 # issue 3382: 'f' and 'F' with inf's and nan's 661 self.assertEqual('{0:f}'.format(INF+0j), 'inf+0.000000j') 662 self.assertEqual('{0:F}'.format(INF+0j), 'INF+0.000000j') 663 self.assertEqual('{0:f}'.format(-INF+0j), '-inf+0.000000j') 664 self.assertEqual('{0:F}'.format(-INF+0j), '-INF+0.000000j') 665 self.assertEqual('{0:f}'.format(complex(INF, INF)), 'inf+infj') 666 self.assertEqual('{0:F}'.format(complex(INF, INF)), 'INF+INFj') 667 self.assertEqual('{0:f}'.format(complex(INF, -INF)), 'inf-infj') 668 self.assertEqual('{0:F}'.format(complex(INF, -INF)), 'INF-INFj') 669 self.assertEqual('{0:f}'.format(complex(-INF, INF)), '-inf+infj') 670 self.assertEqual('{0:F}'.format(complex(-INF, INF)), '-INF+INFj') 671 self.assertEqual('{0:f}'.format(complex(-INF, -INF)), '-inf-infj') 672 self.assertEqual('{0:F}'.format(complex(-INF, -INF)), '-INF-INFj') 673 674 self.assertEqual('{0:f}'.format(complex(NAN, 0)), 'nan+0.000000j') 675 self.assertEqual('{0:F}'.format(complex(NAN, 0)), 'NAN+0.000000j') 676 self.assertEqual('{0:f}'.format(complex(NAN, NAN)), 'nan+nanj') 677 self.assertEqual('{0:F}'.format(complex(NAN, NAN)), 'NAN+NANj') 678 679def test_main(): 680 with test_support.check_warnings(("complex divmod.., // and % are " 681 "deprecated", DeprecationWarning)): 682 test_support.run_unittest(ComplexTest) 683 684if __name__ == "__main__": 685 test_main() 686