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